@gjsify/readline 0.3.21 → 0.4.3

package/src/index.ts

@@ -1,544 +0,0 @@
-// Reference: Node.js lib/readline.js
-// Reimplemented for GJS without Node.js primordials.
-
-import { EventEmitter } from 'node:events';
-import { StringDecoder } from 'node:string_decoder';
-import type { Readable, Writable } from 'node:stream';
-
-export interface InterfaceOptions {
-  input?: Readable;
-  output?: Writable;
-  prompt?: string;
-  terminal?: boolean;
-  historySize?: number;
-  completer?: (line: string, callback: (err: Error | null, result: [string[], string]) => void) => void;
-  crlfDelay?: number;
-  removeHistoryDuplicates?: boolean;
-  escapeCodeTimeout?: number;
-  tabSize?: number;
-}
-
-const LINE_END = /\r\n|\r|\n/;
-
-export class Interface extends EventEmitter {
-  terminal: boolean;
-  line = '';
-  cursor = 0;
-
-  private _input: Readable | null;
-  private _output: Writable | null;
-
-  get input(): Readable | null { return this._input; }
-  get output(): Writable | null { return this._output; }
-
-  private _prompt: string;
-  private _closed = false;
-  private _paused = false;
-  history: string[];
-  private _historySize: number;
-  private _crlfDelay: number;
-  private _lineBuffer = '';
-  private _questionCallback: ((answer: string) => void) | null = null;
-  // Per-listener refs so close() removes only our listeners, not the keypress
-  // parser's 'data' listener — which must survive across sequential prompts.
-  private _boundOnData: ((chunk: Buffer | string) => void) | null = null;
-  private _boundOnEnd: (() => void) | null = null;
-  private _boundOnError: ((err: Error) => void) | null = null;
-  private _boundOnKeypress: ((str: string | undefined, key: Key) => void) | null = null;
-
-  constructor(input?: Readable | InterfaceOptions, output?: Writable) {
-    super();
-
-    let opts: InterfaceOptions;
-    if (input && typeof input === 'object' && !('read' in input && typeof input.read === 'function')) {
-      opts = input as InterfaceOptions;
-    } else {
-      opts = { input: input as Readable, output };
-    }
-
-    this._input = opts.input || null;
-    this._output = opts.output || null;
-    this._prompt = opts.prompt || '> ';
-    this.terminal = opts.terminal ?? (this._output !== null);
-    this._historySize = opts.historySize ?? 30;
-    this.history = [];
-    this._crlfDelay = opts.crlfDelay ?? 100;
-
-    if (this._input) {
-      this._boundOnData = (chunk: Buffer | string) => this._onData(chunk);
-      this._boundOnEnd = () => this._onEnd();
-      this._boundOnError = (err: Error) => 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 as Readable & Record<symbol, unknown>, this as any);
-        if ('setRawMode' in this._input && typeof (this._input as any).setRawMode === 'function') {
-          if (!(this._input as any).isRaw) (this._input as any).setRawMode(true);
-        }
-        if ('resume' in this._input && typeof (this._input as any).resume === 'function') {
-          (this._input as any).resume();
-        }
-
-        this._boundOnKeypress = (str: string | undefined, key: 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 as (...args: unknown[]) => void);
-      }
-    }
-  }
-
-  private _onData(chunk: Buffer | string): void {
-    if (this._closed || this._paused) return;
-    const str = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-    this._lineBuffer += str;
-    let m: RegExpExecArray | 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);
-    }
-  }
-
-  private _onLine(line: string): void {
-    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._questionCallback) {
-      const cb = this._questionCallback;
-      this._questionCallback = null;
-      cb(line);
-    }
-    this.emit('line', line);
-  }
-
-  private _onEnd(): void {
-    if (this._lineBuffer.length > 0) {
-      this._onLine(this._lineBuffer);
-      this._lineBuffer = '';
-    }
-    this.close();
-  }
-
-  setPrompt(prompt: string): void {
-    this._prompt = prompt;
-  }
-
-  getPrompt(): string {
-    return this._prompt;
-  }
-
-  prompt(_preserveCursor?: boolean): void {
-    if (this._closed) throw new Error('readline was closed');
-    this._output?.write(this._prompt);
-  }
-
-  question(query: string, callback: (answer: string) => void): void;
-  question(query: string, options: Record<string, unknown>, callback: (answer: string) => void): void;
-  question(
-    query: string,
-    optionsOrCallback: Record<string, unknown> | ((answer: string) => void),
-    callback?: (answer: string) => void,
-  ): void {
-    if (this._closed) throw new Error('readline was closed');
-    const cb = typeof optionsOrCallback === 'function' ? optionsOrCallback : callback!;
-    this._questionCallback = cb;
-    this._output?.write(query);
-  }
-
-  clearLine(_dir: number, callback?: () => void): boolean {
-    this.line = '';
-    this.cursor = 0;
-    if (callback) callback();
-    return true;
-  }
-
-  write(data: string | Buffer | null, key?: { ctrl?: boolean; meta?: boolean; shift?: boolean; name?: string }): void {
-    if (this._closed) return;
-    if (key) {
-      if (this._input) (this._input as any).emit('keypress', data ?? '', key);
-      return;
-    }
-    if (data !== null && data !== undefined) {
-      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(): void {
-    if (this._closed) return;
-    this._closed = true;
-
-    if (this._input) {
-      // Remove only our own listeners — removeAllListeners would also strip the
-      // keypress parser's 'data' listener. The _KEYPRESS_DECODER Symbol idempotency
-      // guard would then prevent emitKeypressEvents from re-installing for the next
-      // prompt, silencing all keypress events.
-      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 as (...args: unknown[]) => void);
-      this._boundOnData = null;
-      this._boundOnEnd = null;
-      this._boundOnError = null;
-      this._boundOnKeypress = null;
-
-      if (this.terminal && (this._input as any).isRaw &&
-          'setRawMode' in this._input && typeof (this._input as any).setRawMode === 'function') {
-        (this._input as any).setRawMode(false);
-      }
-
-      // Pause stdin so ProcessReadStream releases the GLib main loop via
-      // quitMainLoop(). Mirrors Node.js readline: close() pauses the stream
-      // so the event loop can drain and the process exits when no more prompts follow.
-      if ('pause' in this._input && typeof (this._input as any).pause === 'function') {
-        (this._input as any).pause();
-      }
-    }
-
-    this.emit('close');
-  }
-
-  pause(): this {
-    if (this._closed) return this;
-    this._paused = true;
-    if (this._input && 'pause' in this._input && typeof this._input.pause === 'function') {
-      this._input.pause();
-    }
-    this.emit('pause');
-    return this;
-  }
-
-  resume(): this {
-    if (this._closed) return this;
-    this._paused = false;
-    if (this._input && 'resume' in this._input && typeof this._input.resume === 'function') {
-      this._input.resume();
-    }
-    this.emit('resume');
-    return this;
-  }
-
-  getCursorPos(): { rows: number; cols: number } {
-    const columns = (this._output as any)?.columns ?? 80;
-    const len = this._prompt.length + this.cursor;
-    return { rows: Math.floor(len / columns), cols: len % columns };
-  }
-
-  [Symbol.asyncIterator](): AsyncIterableIterator<string> {
-    const lines: string[] = [];
-    let resolve: ((value: IteratorResult<string, undefined>) => void) | null = null;
-    let done = false;
-
-    const onLine = (line: string) => {
-      if (resolve) {
-        const r = resolve;
-        resolve = null;
-        r({ value: line, done: false });
-      } else {
-        lines.push(line);
-      }
-    };
-    const onClose = () => {
-      done = true;
-      if (resolve) {
-        const r = resolve;
-        resolve = null;
-        r({ value: undefined, done: true });
-      }
-    };
-
-    this.on('line', onLine);
-    this.on('close', onClose);
-
-    return {
-      next: (): Promise<IteratorResult<string, undefined>> => {
-        if (lines.length > 0) return Promise.resolve({ value: lines.shift()!, done: false });
-        if (done) return Promise.resolve({ value: undefined, done: true });
-        return new Promise<IteratorResult<string, undefined>>((r) => { resolve = r; });
-      },
-      return: (): Promise<IteratorResult<string, undefined>> => {
-        done = true;
-        this.removeListener('line', onLine);
-        this.removeListener('close', onClose);
-        return Promise.resolve({ value: undefined, done: true });
-      },
-      [Symbol.asyncIterator]() { return this; },
-    };
-  }
-}
-
-export function createInterface(
-  input?: Readable | InterfaceOptions,
-  output?: Writable,
-  completer?: InterfaceOptions['completer'],
-  terminal?: boolean,
-): Interface {
-  if (typeof input === 'object' && input !== null && !('read' in input && typeof input.read === 'function')) {
-    return new Interface(input);
-  }
-  return new Interface({ input: input as Readable, output, completer, terminal });
-}
-
-export function clearLine(stream: Writable, dir: number, callback?: () => void): boolean {
-  if (!stream || typeof stream.write !== 'function') {
-    if (callback) callback();
-    return true;
-  }
-  const code = dir < 0 ? '\x1b[1K' : dir > 0 ? '\x1b[0K' : '\x1b[2K';
-  return stream.write(code, callback);
-}
-
-export function clearScreenDown(stream: Writable, callback?: () => void): boolean {
-  if (!stream || typeof stream.write !== 'function') {
-    if (callback) callback();
-    return true;
-  }
-  return stream.write('\x1b[0J', callback);
-}
-
-export function cursorTo(
-  stream: Writable,
-  x: number,
-  y?: number | (() => void),
-  callback?: () => void,
-): boolean {
-  if (!stream || typeof stream.write !== 'function') {
-    if (typeof y === 'function') y();
-    else if (callback) callback();
-    return true;
-  }
-  if (typeof y === 'function') { callback = y; y = undefined; }
-  const code = typeof y === 'number' ? `\x1b[${y + 1};${x + 1}H` : `\x1b[${x + 1}G`;
-  return stream.write(code, callback);
-}
-
-export function moveCursor(
-  stream: Writable,
-  dx: number,
-  dy: number,
-  callback?: () => void,
-): boolean {
-  if (!stream || typeof stream.write !== 'function') {
-    if (callback) callback();
-    return true;
-  }
-  let code = '';
-  if (dx > 0) code += `\x1b[${dx}C`;
-  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 (callback) callback();
-  return true;
-}
-
-// ── Keypress parser ───────────────────────────────────────────────────────────
-// Ported from refs/node/lib/internal/readline/utils.js (emitKeys generator)
-// Original: Node.js contributors, MIT.
-// Rewritten for TypeScript / GJS without Node.js primordials.
-
-export interface Key {
-  sequence: string;
-  name: string | undefined;
-  ctrl: boolean;
-  meta: boolean;
-  shift: boolean;
-  code?: string;
-}
-
-const ESCAPE_CODE_TIMEOUT = 500;
-
-function* emitKeys(stream: { emit(event: string, ...args: unknown[]): boolean }): Generator<void, void, string> {
-  while (true) {
-    let ch: string = yield;
-    let s = ch;
-    let escaped = false;
-    const key: Key = { sequence: '', name: undefined, 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: RegExpExecArray | null;
-        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 === '\t') {
-      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 <= '\x1a') {
-      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 ? undefined : 'escape'; key.meta = true;
-    }
-
-    key.sequence = s;
-    if (s.length !== 0 && (key.name !== undefined || escaped)) {
-      stream.emit('keypress', escaped ? undefined : s, key);
-    } else if (s.length === 1) {
-      stream.emit('keypress', s, key);
-    }
-  }
-}
-
-const _KEYPRESS_DECODER = Symbol('keypress-decoder');
-const _ESCAPE_DECODER   = Symbol('escape-decoder');
-
-// Idempotent — calling twice on the same stream is a no-op.
-// Ported from refs/node/lib/internal/readline/emitKeypressEvents.js.
-export function emitKeypressEvents(stream: Readable & Record<symbol, unknown>, iface: { escapeCodeTimeout?: number } = {}): void {
-  if ((stream as any)[_KEYPRESS_DECODER]) return;
-
-  (stream as any)[_KEYPRESS_DECODER] = new StringDecoder('utf8');
-  (stream as any)[_ESCAPE_DECODER] = emitKeys(stream as any);
-  (stream as any)[_ESCAPE_DECODER].next();
-
-  const escTimeout = iface.escapeCodeTimeout ?? ESCAPE_CODE_TIMEOUT;
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const triggerEscape = () => (stream as any)[_ESCAPE_DECODER].next('');
-
-  function onData(input: Buffer | string): void {
-    if ((stream as any).listenerCount('keypress') > 0) {
-      const str: string = (stream as any)[_KEYPRESS_DECODER].write(
-        typeof input === 'string' ? Buffer.from(input) : input,
-      );
-      if (str) {
-        clearTimeout(timeoutId);
-        for (const ch of str) {
-          try {
-            (stream as any)[_ESCAPE_DECODER].next(ch);
-            if (ch === '\x1b') timeoutId = setTimeout(triggerEscape, escTimeout);
-          } catch {
-            (stream as any)[_ESCAPE_DECODER] = emitKeys(stream as any);
-            (stream as any)[_ESCAPE_DECODER].next();
-          }
-        }
-      }
-    } else {
-      (stream as any).removeListener('data', onData);
-      delete (stream as any)[_KEYPRESS_DECODER];
-      delete (stream as any)[_ESCAPE_DECODER];
-    }
-  }
-
-  (stream as any).on('data', onData);
-}
-
-export default {
-  Interface,
-  createInterface,
-  clearLine,
-  clearScreenDown,
-  cursorTo,
-  moveCursor,
-  emitKeypressEvents,
-};

package/src/promises.spec.ts

@@ -1,122 +0,0 @@
-// Tests for readline/promises module
-// Reference: Node.js lib/readline/promises.js
-
-import { describe, it, expect } from '@gjsify/unit';
-import { createInterface, Interface } from 'node:readline/promises';
-import { Readable, Writable, PassThrough } from 'node:stream';
-
-export default async () => {
-  await describe('readline/promises', async () => {
-    await it('should export createInterface function', async () => {
-      expect(typeof createInterface).toBe('function');
-    });
-
-    await it('should export Interface class', async () => {
-      expect(Interface).toBeDefined();
-    });
-
-    await it('should create an interface with input stream', async () => {
-      const input = new PassThrough();
-      const rl = createInterface({ input });
-      expect(rl).toBeDefined();
-      expect(rl instanceof Interface).toBe(true);
-      rl.close();
-    });
-
-    await it('should create an interface with input and output', async () => {
-      const input = new PassThrough();
-      const output = new PassThrough();
-      const rl = createInterface({ input, output });
-      expect(rl).toBeDefined();
-      rl.close();
-    });
-
-    await it('should read lines via async iterator', async () => {
-      const input = new PassThrough();
-      const rl = createInterface({ input });
-
-      const lines: string[] = [];
-      const done = (async () => {
-        for await (const line of rl) {
-          lines.push(line);
-        }
-      })();
-
-      input.write('hello\n');
-      input.write('world\n');
-      input.end();
-
-      await done;
-      expect(lines.length).toBe(2);
-      expect(lines[0]).toBe('hello');
-      expect(lines[1]).toBe('world');
-    });
-
-    await it('question should return a promise', async () => {
-      const input = new PassThrough();
-      const output = new PassThrough();
-      const rl = createInterface({ input, output });
-
-      // Schedule the answer
-      setTimeout(() => {
-        input.write('my answer\n');
-      }, 10);
-
-      const answer = await rl.question('What? ');
-      expect(answer).toBe('my answer');
-      rl.close();
-    });
-
-    await it('should handle multiple questions sequentially', async () => {
-      const input = new PassThrough();
-      const output = new PassThrough();
-      const rl = createInterface({ input, output });
-
-      setTimeout(() => {
-        input.write('first\n');
-      }, 10);
-
-      const answer1 = await rl.question('Q1? ');
-      expect(answer1).toBe('first');
-
-      setTimeout(() => {
-        input.write('second\n');
-      }, 10);
-
-      const answer2 = await rl.question('Q2? ');
-      expect(answer2).toBe('second');
-
-      rl.close();
-    });
-
-    await it('should close properly', async () => {
-      const input = new PassThrough();
-      const rl = createInterface({ input });
-
-      let closed = false;
-      rl.on('close', () => { closed = true; });
-      rl.close();
-
-      // Give event loop a tick
-      await new Promise<void>((resolve) => setTimeout(resolve, 10));
-      expect(closed).toBe(true);
-    });
-
-    await it('should emit line events', async () => {
-      const input = new PassThrough();
-      const rl = createInterface({ input });
-
-      const lines: string[] = [];
-      rl.on('line', (line: string) => lines.push(line));
-
-      input.write('line1\nline2\n');
-      input.end();
-
-      // Wait for processing
-      await new Promise<void>((resolve) => rl.on('close', resolve));
-      expect(lines.length).toBe(2);
-      expect(lines[0]).toBe('line1');
-      expect(lines[1]).toBe('line2');
-    });
-  });
-};

package/src/promises.ts

@@ -1,35 +0,0 @@
-// readline/promises — Promise-based readline API
-// Reference: Node.js lib/readline/promises.js
-
-import { Interface as BaseInterface, createInterface as baseCreateInterface } from './index.js';
-import type { InterfaceOptions } from './index.js';
-import type { Readable, Writable } from 'node:stream';
-
-/**
- * Promise-based readline Interface.
- */
-export class Interface extends BaseInterface {
-  /** Ask a question and return the answer as a Promise. */
-  question(query: string, options?: any): Promise<string> {
-    return new Promise<string>((resolve) => {
-      super.question(query, resolve);
-    });
-  }
-}
-
-/**
- * Create a promise-based readline Interface.
- */
-export function createInterface(input?: Readable | InterfaceOptions, output?: Writable): Interface {
-  if (typeof input === 'object' && input !== null && !('read' in input && typeof (input as any).read === 'function')) {
-    const opts = input as InterfaceOptions;
-    const rl = new Interface(opts);
-    return rl;
-  }
-  return new Interface({ input: input as Readable, output });
-}
-
-export default {
-  Interface,
-  createInterface,
-};