@gjsify/readline 0.2.0 → 0.3.1

package/lib/esm/index.js

@@ -1,10 +1,18 @@
 import { EventEmitter } from "node:events";
+import { StringDecoder } from "node:string_decoder";
+const LINE_END = /\r\n|\r|\n/;
 class Interface extends EventEmitter {
   terminal;
   line = "";
   cursor = 0;
   _input;
   _output;
+  get input() {
+    return this._input;
+  }
+  get output() {
+    return this._output;
+  }
   _prompt;
   _closed = false;
   _paused = false;
@@ -13,6 +21,12 @@ class Interface extends EventEmitter {
   _crlfDelay;
   _lineBuffer = "";
   _questionCallback = null;
+  // Per-listener refs so close() removes only our listeners, not the keypress
+  // parser's 'data' listener — which must survive across sequential prompts.
+  _boundOnData = null;
+  _boundOnEnd = null;
+  _boundOnError = null;
+  _boundOnKeypress = null;
   constructor(input, output) {
     super();
     let opts;
@@ -29,21 +43,45 @@ class Interface extends EventEmitter {
     this.history = [];
     this._crlfDelay = opts.crlfDelay ?? 100;
     if (this._input) {
-      this._input.on("data", (chunk) => this._onData(chunk));
-      this._input.on("end", () => this._onEnd());
-      this._input.on("error", (err) => this.emit("error", err));
+      this._boundOnData = (chunk) => this._onData(chunk);
+      this._boundOnEnd = () => this._onEnd();
+      this._boundOnError = (err) => this.emit("error", err);
+      this._input.on("data", this._boundOnData);
+      this._input.on("end", this._boundOnEnd);
+      this._input.on("error", this._boundOnError);
       if ("setEncoding" in this._input && typeof this._input.setEncoding === "function") {
         this._input.setEncoding("utf8");
       }
+      if (this.terminal) {
+        emitKeypressEvents(this._input, this);
+        if ("setRawMode" in this._input && typeof this._input.setRawMode === "function") {
+          if (!this._input.isRaw) this._input.setRawMode(true);
+        }
+        if ("resume" in this._input && typeof this._input.resume === "function") {
+          this._input.resume();
+        }
+        this._boundOnKeypress = (str, key) => {
+          if (!key) return;
+          if (key.name === "backspace" || key.name === "delete") {
+            if (this.cursor > 0) {
+              this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
+              this.cursor--;
+            }
+          } else if (str && str.length === 1 && !key.ctrl && !key.meta && key.name !== "return" && key.name !== "enter" && key.name !== "escape") {
+            this.line = this.line.slice(0, this.cursor) + str + this.line.slice(this.cursor);
+            this.cursor++;
+          }
+        };
+        this._input.on("keypress", this._boundOnKeypress);
+      }
     }
   }
   _onData(chunk) {
     if (this._closed || this._paused) return;
     const str = typeof chunk === "string" ? chunk : chunk.toString("utf8");
     this._lineBuffer += str;
-    const lineEnd = /\r\n|\r|\n/;
     let m;
-    while ((m = lineEnd.exec(this._lineBuffer)) !== null) {
+    while ((m = LINE_END.exec(this._lineBuffer)) !== null) {
       const line = this._lineBuffer.substring(0, m.index);
       this._lineBuffer = this._lineBuffer.substring(m.index + m[0].length);
       this._onLine(line);
@@ -53,9 +91,7 @@ class Interface extends EventEmitter {
     if (line.length > 0 && this._historySize > 0) {
       if (this.history.length === 0 || this.history[0] !== line) {
         this.history.unshift(line);
-        if (this.history.length > this._historySize) {
-          this.history.pop();
-        }
+        if (this.history.length > this._historySize) this.history.pop();
       }
     }
     if (this._questionCallback) {
@@ -72,53 +108,64 @@ class Interface extends EventEmitter {
     }
     this.close();
   }
-  /** Set the prompt string. */
   setPrompt(prompt) {
     this._prompt = prompt;
   }
-  /** Get the current prompt string. */
   getPrompt() {
     return this._prompt;
   }
-  /** Write the prompt to the output stream. */
-  prompt(preserveCursor) {
-    if (this._closed) {
-      throw new Error("readline was closed");
-    }
-    if (this._output) {
-      this._output.write(this._prompt);
-    }
+  prompt(_preserveCursor) {
+    if (this._closed) throw new Error("readline was closed");
+    this._output?.write(this._prompt);
   }
   question(query, optionsOrCallback, callback) {
-    if (this._closed) {
-      throw new Error("readline was closed");
-    }
+    if (this._closed) throw new Error("readline was closed");
     const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
     this._questionCallback = cb;
-    if (this._output) {
-      this._output.write(query);
-    }
+    this._output?.write(query);
+  }
+  clearLine(_dir, callback) {
+    this.line = "";
+    this.cursor = 0;
+    if (callback) callback();
+    return true;
   }
-  /** Write data to the output stream. */
   write(data, key) {
     if (this._closed) return;
+    if (key) {
+      if (this._input) this._input.emit("keypress", data ?? "", key);
+      return;
+    }
     if (data !== null && data !== void 0) {
-      if (this._output) {
-        this._output.write(data);
+      const str = typeof data === "string" ? data : data.toString("utf8");
+      if (str) {
+        this.line = this.line.slice(0, this.cursor) + str + this.line.slice(this.cursor);
+        this.cursor += str.length;
       }
+      this._output?.write(data);
     }
   }
-  /** Close the interface. */
   close() {
     if (this._closed) return;
     this._closed = true;
     if (this._input) {
-      this._input.removeAllListeners("data");
-      this._input.removeAllListeners("end");
+      if (this._boundOnData) this._input.removeListener("data", this._boundOnData);
+      if (this._boundOnEnd) this._input.removeListener("end", this._boundOnEnd);
+      if (this._boundOnError) this._input.removeListener("error", this._boundOnError);
+      if (this._boundOnKeypress) this._input.removeListener("keypress", this._boundOnKeypress);
+      this._boundOnData = null;
+      this._boundOnEnd = null;
+      this._boundOnError = null;
+      this._boundOnKeypress = null;
+      if (this.terminal && this._input.isRaw && "setRawMode" in this._input && typeof this._input.setRawMode === "function") {
+        this._input.setRawMode(false);
+      }
+      if ("pause" in this._input && typeof this._input.pause === "function") {
+        this._input.pause();
+      }
     }
     this.emit("close");
   }
-  /** Pause the input stream. */
   pause() {
     if (this._closed) return this;
     this._paused = true;
@@ -128,7 +175,6 @@ class Interface extends EventEmitter {
     this.emit("pause");
     return this;
   }
-  /** Resume the input stream. */
   resume() {
     if (this._closed) return this;
     this._paused = false;
@@ -138,15 +184,16 @@ class Interface extends EventEmitter {
     this.emit("resume");
     return this;
   }
-  /** Get the current line content. */
   getCursorPos() {
-    return { rows: 0, cols: this.cursor };
+    const columns = this._output?.columns ?? 80;
+    const len = this._prompt.length + this.cursor;
+    return { rows: Math.floor(len / columns), cols: len % columns };
   }
   [Symbol.asyncIterator]() {
     const lines = [];
     let resolve = null;
     let done = false;
-    this.on("line", (line) => {
+    const onLine = (line) => {
       if (resolve) {
         const r = resolve;
         resolve = null;
@@ -154,29 +201,29 @@ class Interface extends EventEmitter {
       } else {
         lines.push(line);
       }
-    });
-    this.on("close", () => {
+    };
+    const onClose = () => {
       done = true;
       if (resolve) {
         const r = resolve;
         resolve = null;
         r({ value: void 0, done: true });
       }
-    });
+    };
+    this.on("line", onLine);
+    this.on("close", onClose);
     return {
-      next() {
-        if (lines.length > 0) {
-          return Promise.resolve({ value: lines.shift(), done: false });
-        }
-        if (done) {
-          return Promise.resolve({ value: void 0, done: true });
-        }
+      next: () => {
+        if (lines.length > 0) return Promise.resolve({ value: lines.shift(), done: false });
+        if (done) return Promise.resolve({ value: void 0, done: true });
         return new Promise((r) => {
           resolve = r;
         });
       },
-      return() {
+      return: () => {
         done = true;
+        this.removeListener("line", onLine);
+        this.removeListener("close", onClose);
         return Promise.resolve({ value: void 0, done: true });
       },
       [Symbol.asyncIterator]() {
@@ -229,13 +276,339 @@ function moveCursor(stream, dx, dy, callback) {
   else if (dx < 0) code += `\x1B[${-dx}D`;
   if (dy > 0) code += `\x1B[${dy}B`;
   else if (dy < 0) code += `\x1B[${-dy}A`;
-  if (code) {
-    return stream.write(code, callback);
-  }
+  if (code) return stream.write(code, callback);
   if (callback) callback();
   return true;
 }
-function emitKeypressEvents(_stream, _interface) {
+const ESCAPE_CODE_TIMEOUT = 500;
+function* emitKeys(stream) {
+  while (true) {
+    let ch = yield;
+    let s = ch;
+    let escaped = false;
+    const key = { sequence: "", name: void 0, ctrl: false, meta: false, shift: false };
+    if (ch === "\x1B") {
+      escaped = true;
+      s += ch = yield;
+      if (ch === "\x1B") s += ch = yield;
+    }
+    if (escaped && (ch === "O" || ch === "[")) {
+      let code = ch;
+      let modifier = 0;
+      if (ch === "O") {
+        s += ch = yield;
+        if (ch >= "0" && ch <= "9") {
+          modifier = ch.charCodeAt(0) - 1;
+          s += ch = yield;
+        }
+        code += ch;
+      } else if (ch === "[") {
+        s += ch = yield;
+        if (ch === "[") {
+          code += ch;
+          s += ch = yield;
+        }
+        const cmdStart = s.length - 1;
+        if (ch >= "0" && ch <= "9") {
+          s += ch = yield;
+          if (ch >= "0" && ch <= "9") {
+            s += ch = yield;
+            if (ch >= "0" && ch <= "9") s += ch = yield;
+          }
+        }
+        if (ch === ";") {
+          s += ch = yield;
+          if (ch >= "0" && ch <= "9") s += yield;
+        }
+        const cmd = s.slice(cmdStart);
+        let match;
+        if (match = /^(?:(\d\d?)(?:;(\d))?([~^$])|(\d{3}~))$/.exec(cmd)) {
+          if (match[4]) {
+            code += match[4];
+          } else {
+            code += match[1] + match[3];
+            modifier = (parseInt(match[2] ?? "1", 10) || 1) - 1;
+          }
+        } else if (match = /^((\d;)?(\d))?([A-Za-z])$/.exec(cmd)) {
+          code += match[4];
+          modifier = (parseInt(match[3] ?? "1", 10) || 1) - 1;
+        } else {
+          code += cmd;
+        }
+      }
+      key.ctrl = !!(modifier & 4);
+      key.meta = !!(modifier & 10);
+      key.shift = !!(modifier & 1);
+      key.code = code;
+      switch (code) {
+        case "[P":
+        case "OP":
+        case "[11~":
+        case "[[A":
+          key.name = "f1";
+          break;
+        case "[Q":
+        case "OQ":
+        case "[12~":
+        case "[[B":
+          key.name = "f2";
+          break;
+        case "[R":
+        case "OR":
+        case "[13~":
+        case "[[C":
+          key.name = "f3";
+          break;
+        case "[S":
+        case "OS":
+        case "[14~":
+        case "[[D":
+          key.name = "f4";
+          break;
+        case "[15~":
+        case "[[E":
+          key.name = "f5";
+          break;
+        case "[17~":
+          key.name = "f6";
+          break;
+        case "[18~":
+          key.name = "f7";
+          break;
+        case "[19~":
+          key.name = "f8";
+          break;
+        case "[20~":
+          key.name = "f9";
+          break;
+        case "[21~":
+          key.name = "f10";
+          break;
+        case "[23~":
+          key.name = "f11";
+          break;
+        case "[24~":
+          key.name = "f12";
+          break;
+        case "[200~":
+          key.name = "paste-start";
+          break;
+        case "[201~":
+          key.name = "paste-end";
+          break;
+        case "[A":
+        case "OA":
+          key.name = "up";
+          break;
+        case "[B":
+        case "OB":
+          key.name = "down";
+          break;
+        case "[C":
+        case "OC":
+          key.name = "right";
+          break;
+        case "[D":
+        case "OD":
+          key.name = "left";
+          break;
+        case "[E":
+        case "OE":
+          key.name = "clear";
+          break;
+        case "[F":
+        case "OF":
+          key.name = "end";
+          break;
+        case "[H":
+        case "OH":
+          key.name = "home";
+          break;
+        case "[1~":
+          key.name = "home";
+          break;
+        case "[2~":
+          key.name = "insert";
+          break;
+        case "[3~":
+          key.name = "delete";
+          break;
+        case "[4~":
+          key.name = "end";
+          break;
+        case "[5~":
+        case "[[5~":
+          key.name = "pageup";
+          break;
+        case "[6~":
+        case "[[6~":
+          key.name = "pagedown";
+          break;
+        case "[7~":
+          key.name = "home";
+          break;
+        case "[8~":
+          key.name = "end";
+          break;
+        case "[a":
+          key.name = "up";
+          key.shift = true;
+          break;
+        case "[b":
+          key.name = "down";
+          key.shift = true;
+          break;
+        case "[c":
+          key.name = "right";
+          key.shift = true;
+          break;
+        case "[d":
+          key.name = "left";
+          key.shift = true;
+          break;
+        case "[2$":
+          key.name = "insert";
+          key.shift = true;
+          break;
+        case "[3$":
+          key.name = "delete";
+          key.shift = true;
+          break;
+        case "[5$":
+          key.name = "pageup";
+          key.shift = true;
+          break;
+        case "[6$":
+          key.name = "pagedown";
+          key.shift = true;
+          break;
+        case "[7$":
+          key.name = "home";
+          key.shift = true;
+          break;
+        case "[8$":
+          key.name = "end";
+          key.shift = true;
+          break;
+        case "Oa":
+          key.name = "up";
+          key.ctrl = true;
+          break;
+        case "Ob":
+          key.name = "down";
+          key.ctrl = true;
+          break;
+        case "Oc":
+          key.name = "right";
+          key.ctrl = true;
+          break;
+        case "Od":
+          key.name = "left";
+          key.ctrl = true;
+          break;
+        case "[2^":
+          key.name = "insert";
+          key.ctrl = true;
+          break;
+        case "[3^":
+          key.name = "delete";
+          key.ctrl = true;
+          break;
+        case "[5^":
+          key.name = "pageup";
+          key.ctrl = true;
+          break;
+        case "[6^":
+          key.name = "pagedown";
+          key.ctrl = true;
+          break;
+        case "[7^":
+          key.name = "home";
+          key.ctrl = true;
+          break;
+        case "[8^":
+          key.name = "end";
+          key.ctrl = true;
+          break;
+        case "[Z":
+          key.name = "tab";
+          key.shift = true;
+          break;
+        default:
+          key.name = "undefined";
+          break;
+      }
+    } else if (ch === "\r") {
+      key.name = "return";
+      key.meta = escaped;
+    } else if (ch === "\n") {
+      key.name = "enter";
+      key.meta = escaped;
+    } else if (ch === "	") {
+      key.name = "tab";
+      key.meta = escaped;
+    } else if (ch === "\b" || ch === "\x7F") {
+      key.name = "backspace";
+      key.meta = escaped;
+    } else if (ch === "\x1B") {
+      key.name = "escape";
+      key.meta = escaped;
+    } else if (ch === " ") {
+      key.name = "space";
+      key.meta = escaped;
+    } else if (!escaped && ch <= "") {
+      key.name = String.fromCharCode(ch.charCodeAt(0) + "a".charCodeAt(0) - 1);
+      key.ctrl = true;
+    } else if (/^[0-9A-Za-z]$/.test(ch)) {
+      key.name = ch.toLowerCase();
+      key.shift = /^[A-Z]$/.test(ch);
+      key.meta = escaped;
+    } else if (escaped) {
+      key.name = ch.length ? void 0 : "escape";
+      key.meta = true;
+    }
+    key.sequence = s;
+    if (s.length !== 0 && (key.name !== void 0 || escaped)) {
+      stream.emit("keypress", escaped ? void 0 : s, key);
+    } else if (s.length === 1) {
+      stream.emit("keypress", s, key);
+    }
+  }
+}
+const _KEYPRESS_DECODER = /* @__PURE__ */ Symbol("keypress-decoder");
+const _ESCAPE_DECODER = /* @__PURE__ */ Symbol("escape-decoder");
+function emitKeypressEvents(stream, iface = {}) {
+  if (stream[_KEYPRESS_DECODER]) return;
+  stream[_KEYPRESS_DECODER] = new StringDecoder("utf8");
+  stream[_ESCAPE_DECODER] = emitKeys(stream);
+  stream[_ESCAPE_DECODER].next();
+  const escTimeout = iface.escapeCodeTimeout ?? ESCAPE_CODE_TIMEOUT;
+  let timeoutId;
+  const triggerEscape = () => stream[_ESCAPE_DECODER].next("");
+  function onData(input) {
+    if (stream.listenerCount("keypress") > 0) {
+      const str = stream[_KEYPRESS_DECODER].write(
+        typeof input === "string" ? Buffer.from(input) : input
+      );
+      if (str) {
+        clearTimeout(timeoutId);
+        for (const ch of str) {
+          try {
+            stream[_ESCAPE_DECODER].next(ch);
+            if (ch === "\x1B") timeoutId = setTimeout(triggerEscape, escTimeout);
+          } catch {
+            stream[_ESCAPE_DECODER] = emitKeys(stream);
+            stream[_ESCAPE_DECODER].next();
+          }
+        }
+      }
+    } else {
+      stream.removeListener("data", onData);
+      delete stream[_KEYPRESS_DECODER];
+      delete stream[_ESCAPE_DECODER];
+    }
+  }
+  stream.on("data", onData);
 }
 var index_default = {
   Interface,

package/lib/types/index.d.ts

@@ -12,15 +12,14 @@ export interface InterfaceOptions {
     escapeCodeTimeout?: number;
     tabSize?: number;
 }
-/**
- * readline.Interface — reads lines from a Readable stream.
- */
 export declare class Interface extends EventEmitter {
     terminal: boolean;
     line: string;
     cursor: number;
     private _input;
     private _output;
+    get input(): Readable | null;
+    get output(): Writable | null;
     private _prompt;
     private _closed;
     private _paused;
@@ -29,67 +28,51 @@ export declare class Interface extends EventEmitter {
     private _crlfDelay;
     private _lineBuffer;
     private _questionCallback;
+    private _boundOnData;
+    private _boundOnEnd;
+    private _boundOnError;
+    private _boundOnKeypress;
     constructor(input?: Readable | InterfaceOptions, output?: Writable);
     private _onData;
     private _onLine;
     private _onEnd;
-    /** Set the prompt string. */
     setPrompt(prompt: string): void;
-    /** Get the current prompt string. */
     getPrompt(): string;
-    /** Write the prompt to the output stream. */
-    prompt(preserveCursor?: boolean): void;
-    /**
-     * Display the query and wait for user input.
-     */
+    prompt(_preserveCursor?: boolean): void;
     question(query: string, callback: (answer: string) => void): void;
     question(query: string, options: Record<string, unknown>, callback: (answer: string) => void): void;
-    /** Write data to the output stream. */
+    clearLine(_dir: number, callback?: () => void): boolean;
     write(data: string | Buffer | null, key?: {
         ctrl?: boolean;
         meta?: boolean;
         shift?: boolean;
         name?: string;
     }): void;
-    /** Close the interface. */
     close(): void;
-    /** Pause the input stream. */
     pause(): this;
-    /** Resume the input stream. */
     resume(): this;
-    /** Get the current line content. */
     getCursorPos(): {
         rows: number;
         cols: number;
     };
     [Symbol.asyncIterator](): AsyncIterableIterator<string>;
 }
-/**
- * Create a readline Interface.
- */
 export declare function createInterface(input?: Readable | InterfaceOptions, output?: Writable, completer?: InterfaceOptions['completer'], terminal?: boolean): Interface;
-/**
- * Clear the current line of a TTY stream.
- * dir: -1 = to the left, 1 = to the right, 0 = entire line
- */
 export declare function clearLine(stream: Writable, dir: number, callback?: () => void): boolean;
-/**
- * Clear from cursor to end of screen.
- */
 export declare function clearScreenDown(stream: Writable, callback?: () => void): boolean;
-/**
- * Move cursor to the specified position.
- */
 export declare function cursorTo(stream: Writable, x: number, y?: number | (() => void), callback?: () => void): boolean;
-/**
- * Move cursor relative to its current position.
- */
 export declare function moveCursor(stream: Writable, dx: number, dy: number, callback?: () => void): boolean;
-/**
- * Enable keypress events on a stream (no-op in GJS — full implementation
- * requires raw terminal mode which depends on the input stream type).
- */
-export declare function emitKeypressEvents(_stream: Readable, _interface?: Interface): void;
+export interface Key {
+    sequence: string;
+    name: string | undefined;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    code?: string;
+}
+export declare function emitKeypressEvents(stream: Readable & Record<symbol, unknown>, iface?: {
+    escapeCodeTimeout?: number;
+}): void;
 declare const _default: {
     Interface: typeof Interface;
     createInterface: typeof createInterface;