import { ERR_INVALID_ARG_VALUE, ERR_USE_AFTER_CLOSE } from "../errors.ts";import { validateAbortSignal, validateArray, validateString, validateUint32,} from "../validators.mjs";import { getStringWidth, stripVTControlCharacters,} from "../util/inspect.mjs";import EventEmitter from "../../events.ts";import { emitKeypressEvents } from "./emitKeypressEvents.mjs";import { charLengthAt, charLengthLeft, commonPrefix, kSubstringSearch,} from "./utils.mjs";import { clearScreenDown, cursorTo, moveCursor } from "./callbacks.mjs";import { Readable } from "../../_stream.mjs";
import { StringDecoder } from "../../string_decoder.ts";import { kAddHistory, kDecoder, kDeleteLeft, kDeleteLineLeft, kDeleteLineRight, kDeleteRight, kDeleteWordLeft, kDeleteWordRight, kGetDisplayPos, kHistoryNext, kHistoryPrev, kInsertString, kLine, kLine_buffer, kMoveCursor, kNormalWrite, kOldPrompt, kOnLine, kPreviousKey, kPrompt, kQuestionCallback, kRefreshLine, kSawKeyPress, kSawReturnAt, kSetRawMode, kTabComplete, kTabCompleter, kTtyWrite, kWordLeft, kWordRight, kWriteToOutput,} from "./symbols.mjs";
const kHistorySize = 30;const kMincrlfDelay = 100;const lineEnding = /\r?\n|\r(?!\n)/;
const kLineObjectStream = Symbol("line object stream");export const kQuestionCancel = Symbol("kQuestionCancel");export const kQuestion = Symbol("kQuestion");
const ESCAPE_CODE_TIMEOUT = 500;
export { kAddHistory, kDecoder, kDeleteLeft, kDeleteLineLeft, kDeleteLineRight, kDeleteRight, kDeleteWordLeft, kDeleteWordRight, kGetDisplayPos, kHistoryNext, kHistoryPrev, kInsertString, kLine, kLine_buffer, kMoveCursor, kNormalWrite, kOldPrompt, kOnLine, kPreviousKey, kPrompt, kQuestionCallback, kRefreshLine, kSawKeyPress, kSawReturnAt, kSetRawMode, kTabComplete, kTabCompleter, kTtyWrite, kWordLeft, kWordRight, kWriteToOutput,};
export function InterfaceConstructor(input, output, completer, terminal) { this[kSawReturnAt] = 0; this.isCompletionEnabled = true; this[kSawKeyPress] = false; this[kPreviousKey] = null; this.escapeCodeTimeout = ESCAPE_CODE_TIMEOUT; this.tabSize = 8; Function.prototype.call(EventEmitter, this);
let history; let historySize; let removeHistoryDuplicates = false; let crlfDelay; let prompt = "> "; let signal;
if (input?.input) { output = input.output; completer = input.completer; terminal = input.terminal; history = input.history; historySize = input.historySize; signal = input.signal; if (input.tabSize !== undefined) { validateUint32(input.tabSize, "tabSize", true); this.tabSize = input.tabSize; } removeHistoryDuplicates = input.removeHistoryDuplicates; if (input.prompt !== undefined) { prompt = input.prompt; } if (input.escapeCodeTimeout !== undefined) { if (Number.isFinite(input.escapeCodeTimeout)) { this.escapeCodeTimeout = input.escapeCodeTimeout; } else { throw new ERR_INVALID_ARG_VALUE( "input.escapeCodeTimeout", this.escapeCodeTimeout, ); } }
if (signal) { validateAbortSignal(signal, "options.signal"); }
crlfDelay = input.crlfDelay; input = input.input; }
if (completer !== undefined && typeof completer !== "function") { throw new ERR_INVALID_ARG_VALUE("completer", completer); }
if (history === undefined) { history = []; } else { validateArray(history, "history"); }
if (historySize === undefined) { historySize = kHistorySize; }
if ( typeof historySize !== "number" || Number.isNaN(historySize) || historySize < 0 ) { throw new ERR_INVALID_ARG_VALUE.RangeError("historySize", historySize); }
if (terminal === undefined && !(output === null || output === undefined)) { terminal = !!output.isTTY; }
const self = this;
this.line = ""; this[kSubstringSearch] = null; this.output = output; this.input = input; this.history = history; this.historySize = historySize; this.removeHistoryDuplicates = !!removeHistoryDuplicates; this.crlfDelay = crlfDelay ? Math.max(kMincrlfDelay, crlfDelay) : kMincrlfDelay; this.completer = completer;
this.setPrompt(prompt);
this.terminal = !!terminal;
function onerror(err) { self.emit("error", err); }
function ondata(data) { self[kNormalWrite](data); }
function onend() { if ( typeof self[kLine_buffer] === "string" && self[kLine_buffer].length > 0 ) { self.emit("line", self[kLine_buffer]); } self.close(); }
function ontermend() { if (typeof self.line === "string" && self.line.length > 0) { self.emit("line", self.line); } self.close(); }
function onkeypress(s, key) { self[kTtyWrite](s, key); if (key && key.sequence) { const ch = key.sequence.codePointAt(0); if (ch >= 0xd800 && ch <= 0xdfff) self[kRefreshLine](); } }
function onresize() { self[kRefreshLine](); }
this[kLineObjectStream] = undefined;
input.on("error", onerror);
if (!this.terminal) { function onSelfCloseWithoutTerminal() { input.removeListener("data", ondata); input.removeListener("error", onerror); input.removeListener("end", onend); }
input.on("data", ondata); input.on("end", onend); self.once("close", onSelfCloseWithoutTerminal); this[kDecoder] = new StringDecoder("utf8"); } else { function onSelfCloseWithTerminal() { input.removeListener("keypress", onkeypress); input.removeListener("error", onerror); input.removeListener("end", ontermend); if (output !== null && output !== undefined) { output.removeListener("resize", onresize); } }
emitKeypressEvents(input, this);
input.on("keypress", onkeypress); input.on("end", ontermend);
this[kSetRawMode](true); this.terminal = true;
this.cursor = 0;
this.historyIndex = -1;
if (output !== null && output !== undefined) { output.on("resize", onresize); }
self.once("close", onSelfCloseWithTerminal); }
if (signal) { const onAborted = () => self.close(); if (signal.aborted) { process.nextTick(onAborted); } else { signal.addEventListener("abort", onAborted, { once: true }); self.once("close", () => signal.removeEventListener("abort", onAborted)); } }
this.line = "";
input.resume();}
Object.setPrototypeOf(InterfaceConstructor.prototype, EventEmitter.prototype);Object.setPrototypeOf(InterfaceConstructor, EventEmitter);
export class Interface extends InterfaceConstructor { constructor(input, output, completer, terminal) { super(input, output, completer, terminal); } get columns() { if (this.output && this.output.columns) return this.output.columns; return Infinity; }
setPrompt(prompt) { this[kPrompt] = prompt; }
getPrompt() { return this[kPrompt]; }
[kSetRawMode](mode) { const wasInRawMode = this.input.isRaw;
if (typeof this.input.setRawMode === "function") { this.input.setRawMode(mode); }
return wasInRawMode; }
prompt(preserveCursor) { if (this.paused) this.resume(); if (this.terminal && process.env.TERM !== "dumb") { if (!preserveCursor) this.cursor = 0; this[kRefreshLine](); } else { this[kWriteToOutput](this[kPrompt]); } }
[kQuestion](query, cb) { if (this.closed) { throw new ERR_USE_AFTER_CLOSE("readline"); } if (this[kQuestionCallback]) { this.prompt(); } else { this[kOldPrompt] = this[kPrompt]; this.setPrompt(query); this[kQuestionCallback] = cb; this.prompt(); } }
[kOnLine](line) { if (this[kQuestionCallback]) { const cb = this[kQuestionCallback]; this[kQuestionCallback] = null; this.setPrompt(this[kOldPrompt]); cb(line); } else { this.emit("line", line); } }
[kQuestionCancel]() { if (this[kQuestionCallback]) { this[kQuestionCallback] = null; this.setPrompt(this[kOldPrompt]); this.clearLine(); } }
[kWriteToOutput](stringToWrite) { validateString(stringToWrite, "stringToWrite");
if (this.output !== null && this.output !== undefined) { this.output.write(stringToWrite); } }
[kAddHistory]() { if (this.line.length === 0) return "";
if (this.historySize === 0) return this.line;
if (this.line.trim().length === 0) return this.line;
if (this.history.length === 0 || this.history[0] !== this.line) { if (this.removeHistoryDuplicates) { const dupIndex = this.history.indexOf(this.line); if (dupIndex !== -1) this.history.splice(dupIndex, 1); }
this.history.unshift(this.line);
if (this.history.length > this.historySize) { this.history.pop(); } }
this.historyIndex = -1;
const line = this.history[0];
this.emit("history", this.history);
return line; }
[kRefreshLine]() { const line = this[kPrompt] + this.line; const dispPos = this[kGetDisplayPos](line); const lineCols = dispPos.cols; const lineRows = dispPos.rows;
const cursorPos = this.getCursorPos();
const prevRows = this.prevRows || 0; if (prevRows > 0) { moveCursor(this.output, 0, -prevRows); }
cursorTo(this.output, 0); clearScreenDown(this.output);
this[kWriteToOutput](line);
if (lineCols === 0) { this[kWriteToOutput](" "); }
cursorTo(this.output, cursorPos.cols);
const diff = lineRows - cursorPos.rows; if (diff > 0) { moveCursor(this.output, 0, -diff); }
this.prevRows = cursorPos.rows; }
close() { if (this.closed) return; this.pause(); if (this.terminal) { this[kSetRawMode](false); } this.closed = true; this.emit("close"); }
pause() { if (this.paused) return; this.input.pause(); this.paused = true; this.emit("pause"); return this; }
resume() { if (!this.paused) return; this.input.resume(); this.paused = false; this.emit("resume"); return this; }
write(d, key) { if (this.paused) this.resume(); if (this.terminal) { this[kTtyWrite](d, key); } else { this[kNormalWrite](d); } }
[kNormalWrite](b) { if (b === undefined) { return; } let string = this[kDecoder].write(b); if ( this[kSawReturnAt] && Date.now() - this[kSawReturnAt] <= this.crlfDelay ) { string = string.replace(/^\n/, ""); this[kSawReturnAt] = 0; }
const newPartContainsEnding = lineEnding.test(string);
if (this[kLine_buffer]) { string = this[kLine_buffer] + string; this[kLine_buffer] = null; } if (newPartContainsEnding) { this[kSawReturnAt] = string.endsWith("\r") ? Date.now() : 0;
const lines = string.split(lineEnding); string = lines.pop(); this[kLine_buffer] = string; for (let n = 0; n < lines.length; n++) this[kOnLine](lines[n]); } else if (string) { this[kLine_buffer] = string; } }
[kInsertString](c) { if (this.cursor < this.line.length) { const beg = this.line.slice(0, this.cursor); const end = this.line.slice( this.cursor, this.line.length, ); this.line = beg + c + end; this.cursor += c.length; this[kRefreshLine](); } else { this.line += c; this.cursor += c.length;
if (this.getCursorPos().cols === 0) { this[kRefreshLine](); } else { this[kWriteToOutput](c); } } }
async [kTabComplete](lastKeypressWasTab) { this.pause(); const string = this.line.slice(0, this.cursor); let value; try { value = await this.completer(string); } catch (err) { this[kWriteToOutput](`Tab completion error: ${err}`); return; } finally { this.resume(); } this[kTabCompleter](lastKeypressWasTab, value); }
[kTabCompleter](lastKeypressWasTab, { 0: completions, 1: completeOn }) {
if (!completions || completions.length === 0) { return; }
const prefix = commonPrefix( completions.filter((e) => e !== ""), ); if ( prefix.startsWith(completeOn) && prefix.length > completeOn.length ) { this[kInsertString](prefix.slice(completeOn.length)); return; } else if (!completeOn.startsWith(prefix)) { this.line = this.line.slice(0, this.cursor - completeOn.length) + prefix + this.line.slice(this.cursor, this.line.length); this.cursor = this.cursor - completeOn.length + prefix.length; this._refreshLine(); return; }
if (!lastKeypressWasTab) { return; }
const completionsWidth = completions.map( (e) => getStringWidth(e), ); const width = Math.max.apply(completionsWidth) + 2; let maxColumns = Math.floor(this.columns / width) || 1; if (maxColumns === Infinity) { maxColumns = 1; } let output = "\r\n"; let lineIndex = 0; let whitespace = 0; for (let i = 0; i < completions.length; i++) { const completion = completions[i]; if (completion === "" || lineIndex === maxColumns) { output += "\r\n"; lineIndex = 0; whitespace = 0; } else { output += " ".repeat(whitespace); } if (completion !== "") { output += completion; whitespace = width - completionsWidth[i]; lineIndex++; } else { output += "\r\n"; } } if (lineIndex !== 0) { output += "\r\n\r\n"; } this[kWriteToOutput](output); this[kRefreshLine](); }
[kWordLeft]() { if (this.cursor > 0) { const leading = this.line.slice(0, this.cursor); const reversed = Array.from(leading).reverse().join(""); const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/); this[kMoveCursor](-match[0].length); } }
[kWordRight]() { if (this.cursor < this.line.length) { const trailing = this.line.slice(this.cursor); const match = trailing.match(/^(?:\s+|[^\w\s]+|\w+)\s*/); this[kMoveCursor](match[0].length); } }
[kDeleteLeft]() { if (this.cursor > 0 && this.line.length > 0) { const charSize = charLengthLeft(this.line, this.cursor); this.line = this.line.slice(0, this.cursor - charSize) + this.line.slice(this.cursor, this.line.length);
this.cursor -= charSize; this[kRefreshLine](); } }
[kDeleteRight]() { if (this.cursor < this.line.length) { const charSize = charLengthAt(this.line, this.cursor); this.line = this.line.slice(0, this.cursor) + this.line.slice( this.cursor + charSize, this.line.length, ); this[kRefreshLine](); } }
[kDeleteWordLeft]() { if (this.cursor > 0) { let leading = this.line.slice(0, this.cursor); const reversed = Array.from(leading).reverse().join(""); const match = reversed.match(/^\s*(?:[^\w\s]+|\w+)?/); leading = leading.slice( 0, leading.length - match[0].length, ); this.line = leading + this.line.slice(this.cursor, this.line.length); this.cursor = leading.length; this[kRefreshLine](); } }
[kDeleteWordRight]() { if (this.cursor < this.line.length) { const trailing = this.line.slice(this.cursor); const match = trailing.match(/^(?:\s+|\W+|\w+)\s*/); this.line = this.line.slice(0, this.cursor) + trailing.slice(match[0].length); this[kRefreshLine](); } }
[kDeleteLineLeft]() { this.line = this.line.slice(this.cursor); this.cursor = 0; this[kRefreshLine](); }
[kDeleteLineRight]() { this.line = this.line.slice(0, this.cursor); this[kRefreshLine](); }
clearLine() { this[kMoveCursor](+Infinity); this[kWriteToOutput]("\r\n"); this.line = ""; this.cursor = 0; this.prevRows = 0; }
[kLine]() { const line = this[kAddHistory](); this.clearLine(); this[kOnLine](line); }
[kHistoryNext]() { if (this.historyIndex >= 0) { const search = this[kSubstringSearch] || ""; let index = this.historyIndex - 1; while ( index >= 0 && (!this.history[index].startsWith(search) || this.line === this.history[index]) ) { index--; } if (index === -1) { this.line = search; } else { this.line = this.history[index]; } this.historyIndex = index; this.cursor = this.line.length; this[kRefreshLine](); } }
[kHistoryPrev]() { if (this.historyIndex < this.history.length && this.history.length) { const search = this[kSubstringSearch] || ""; let index = this.historyIndex + 1; while ( index < this.history.length && (!this.history[index].startsWith(search) || this.line === this.history[index]) ) { index++; } if (index === this.history.length) { this.line = search; } else { this.line = this.history[index]; } this.historyIndex = index; this.cursor = this.line.length; this[kRefreshLine](); } }
[kGetDisplayPos](str) { let offset = 0; const col = this.columns; let rows = 0; str = stripVTControlCharacters(str); for (const char of str[Symbol.iterator]()) { if (char === "\n") { rows += Math.ceil(offset / col) || 1; offset = 0; continue; } if (char === "\t") { offset += this.tabSize - (offset % this.tabSize); continue; } const width = getStringWidth(char); if (width === 0 || width === 1) { offset += width; } else { if ((offset + 1) % col === 0) { offset++; } offset += 2; } } const cols = offset % col; rows += (offset - cols) / col; return { cols, rows }; }
getCursorPos() { const strBeforeCursor = this[kPrompt] + this.line.slice(0, this.cursor); return this[kGetDisplayPos](strBeforeCursor); }
[kMoveCursor](dx) { if (dx === 0) { return; } const oldPos = this.getCursorPos(); this.cursor += dx;
if (this.cursor < 0) { this.cursor = 0; } else if (this.cursor > this.line.length) { this.cursor = this.line.length; }
const newPos = this.getCursorPos();
if (oldPos.rows === newPos.rows) { const diffWidth = newPos.cols - oldPos.cols; moveCursor(this.output, diffWidth, 0); } else { this[kRefreshLine](); } }
[kTtyWrite](s, key) { const previousKey = this[kPreviousKey]; key = key || {}; this[kPreviousKey] = key;
if ( (key.name === "up" || key.name === "down") && !key.ctrl && !key.meta && !key.shift ) { if (this[kSubstringSearch] === null) { this[kSubstringSearch] = this.line.slice( 0, this.cursor, ); } } else if (this[kSubstringSearch] !== null) { this[kSubstringSearch] = null; if (this.history.length === this.historyIndex) { this.historyIndex = -1; } }
if (key.name === "escape") return;
if (key.ctrl && key.shift) { switch (key.name) { case "backspace": this[kDeleteLineLeft](); break;
case "delete": this[kDeleteLineRight](); break; } } else if (key.ctrl) {
switch (key.name) { case "c": if (this.listenerCount("SIGINT") > 0) { this.emit("SIGINT"); } else { this.close(); } break;
case "h": this[kDeleteLeft](); break;
case "d": if (this.cursor === 0 && this.line.length === 0) { this.close(); } else if (this.cursor < this.line.length) { this[kDeleteRight](); } break;
case "u": this[kDeleteLineLeft](); break;
case "k": this[kDeleteLineRight](); break;
case "a": this[kMoveCursor](-Infinity); break;
case "e": this[kMoveCursor](+Infinity); break;
case "b": this[kMoveCursor](-charLengthLeft(this.line, this.cursor)); break;
case "f": this[kMoveCursor](+charLengthAt(this.line, this.cursor)); break;
case "l": cursorTo(this.output, 0, 0); clearScreenDown(this.output); this[kRefreshLine](); break;
case "n": this[kHistoryNext](); break;
case "p": this[kHistoryPrev](); break;
case "z": if (process.platform === "win32") break; if (this.listenerCount("SIGTSTP") > 0) { this.emit("SIGTSTP"); } else { process.once("SIGCONT", () => { if (!this.paused) { this.pause(); this.emit("SIGCONT"); } this[kSetRawMode](true); this[kRefreshLine](); }); this[kSetRawMode](false); process.kill(process.pid, "SIGTSTP"); } break;
case "w": case "backspace": this[kDeleteWordLeft](); break;
case "delete": this[kDeleteWordRight](); break;
case "left": this[kWordLeft](); break;
case "right": this[kWordRight](); break; } } else if (key.meta) {
switch (key.name) { case "b": this[kWordLeft](); break;
case "f": this[kWordRight](); break;
case "d": case "delete": this[kDeleteWordRight](); break;
case "backspace": this[kDeleteWordLeft](); break; } } else {
if (this[kSawReturnAt] && key.name !== "enter") this[kSawReturnAt] = 0;
switch (key.name) { case "return": this[kSawReturnAt] = Date.now(); this[kLine](); break;
case "enter": if ( this[kSawReturnAt] === 0 || Date.now() - this[kSawReturnAt] > this.crlfDelay ) { this[kLine](); } this[kSawReturnAt] = 0; break;
case "backspace": this[kDeleteLeft](); break;
case "delete": this[kDeleteRight](); break;
case "left": this[kMoveCursor](-charLengthLeft(this.line, this.cursor)); break;
case "right": this[kMoveCursor](+charLengthAt(this.line, this.cursor)); break;
case "home": this[kMoveCursor](-Infinity); break;
case "end": this[kMoveCursor](+Infinity); break;
case "up": this[kHistoryPrev](); break;
case "down": this[kHistoryNext](); break;
case "tab": if ( typeof this.completer === "function" && this.isCompletionEnabled ) { const lastKeypressWasTab = previousKey && previousKey.name === "tab"; this[kTabComplete](lastKeypressWasTab); break; } default: if (typeof s === "string" && s) { const lines = s.split(/\r\n|\n|\r/); for (let i = 0, len = lines.length; i < len; i++) { if (i > 0) { this[kLine](); } this[kInsertString](lines[i]); } } } } }
[Symbol.asyncIterator]() { if (this[kLineObjectStream] === undefined) { const readable = new Readable({ objectMode: true, read: () => { this.resume(); }, destroy: (err, cb) => { this.off("line", lineListener); this.off("close", closeListener); this.close(); cb(err); }, }); const lineListener = (input) => { if (!readable.push(input)) { this.pause(); } }; const closeListener = () => { readable.push(null); }; const errorListener = (err) => { readable.destroy(err); }; this.on("error", errorListener); this.on("line", lineListener); this.on("close", closeListener); this[kLineObjectStream] = readable; }
return this[kLineObjectStream][Symbol.asyncIterator](); }}