@gjsify/readline 0.1.0

package/src/index.ts

@@ -0,0 +1,360 @@
+// Node.js readline module for GJS
+// Reference: Node.js lib/readline.js
+
+import { EventEmitter } from 'node:events';
+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;
+}
+
+/**
+ * readline.Interface — reads lines from a Readable stream.
+ */
+export class Interface extends EventEmitter {
+  terminal: boolean;
+  line = '';
+  cursor = 0;
+
+  private _input: Readable | null;
+  private _output: Writable | null;
+  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;
+
+  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._input.on('data', (chunk: Buffer | string) => this._onData(chunk));
+      this._input.on('end', () => this._onEnd());
+      this._input.on('error', (err: Error) => this.emit('error', err));
+
+      if ('setEncoding' in this._input && typeof this._input.setEncoding === 'function') {
+        this._input.setEncoding('utf8');
+      }
+    }
+  }
+
+  private _onData(chunk: Buffer | string): void {
+    if (this._closed || this._paused) return;
+
+    const str = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    this._lineBuffer += str;
+
+    // Process lines separated by \n, \r\n, or standalone \r
+    const lineEnd = /\r\n|\r|\n/;
+    let m: RegExpExecArray | null;
+    while ((m = lineEnd.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 {
+    // Add to history
+    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 {
+    // Emit remaining buffer as last line
+    if (this._lineBuffer.length > 0) {
+      this._onLine(this._lineBuffer);
+      this._lineBuffer = '';
+    }
+    this.close();
+  }
+
+  /** Set the prompt string. */
+  setPrompt(prompt: string): void {
+    this._prompt = prompt;
+  }
+
+  /** Get the current prompt string. */
+  getPrompt(): string {
+    return this._prompt;
+  }
+
+  /** Write the prompt to the output stream. */
+  prompt(preserveCursor?: boolean): void {
+    if (this._closed) {
+      throw new Error('readline was closed');
+    }
+    if (this._output) {
+      this._output.write(this._prompt);
+    }
+  }
+
+  /**
+   * Display the query and wait for user input.
+   */
+  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;
+
+    if (this._output) {
+      this._output.write(query);
+    }
+  }
+
+  /** Write data to the output stream. */
+  write(data: string | Buffer | null, key?: { ctrl?: boolean; meta?: boolean; shift?: boolean; name?: string }): void {
+    if (this._closed) return;
+
+    if (data !== null && data !== undefined) {
+      if (this._output) {
+        this._output.write(data);
+      }
+    }
+  }
+
+  /** Close the interface. */
+  close(): void {
+    if (this._closed) return;
+    this._closed = true;
+
+    if (this._input) {
+      this._input.removeAllListeners('data');
+      this._input.removeAllListeners('end');
+    }
+
+    this.emit('close');
+  }
+
+  /** Pause the input stream. */
+  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 the input stream. */
+  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;
+  }
+
+  /** Get the current line content. */
+  getCursorPos(): { rows: number; cols: number } {
+    return { rows: 0, cols: this.cursor };
+  }
+
+  [Symbol.asyncIterator](): AsyncIterableIterator<string> {
+    const lines: string[] = [];
+    let resolve: ((value: IteratorResult<string>) => void) | null = null;
+    let done = false;
+
+    this.on('line', (line: string) => {
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: line, done: false });
+      } else {
+        lines.push(line);
+      }
+    });
+
+    this.on('close', () => {
+      done = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: undefined as unknown as string, done: true });
+      }
+    });
+
+    return {
+      next(): Promise<IteratorResult<string>> {
+        if (lines.length > 0) {
+          return Promise.resolve({ value: lines.shift()!, done: false });
+        }
+        if (done) {
+          return Promise.resolve({ value: undefined as unknown as string, done: true });
+        }
+        return new Promise<IteratorResult<string>>((r) => { resolve = r; });
+      },
+      return(): Promise<IteratorResult<string>> {
+        done = true;
+        return Promise.resolve({ value: undefined as unknown as string, done: true });
+      },
+      [Symbol.asyncIterator]() { return this; },
+    };
+  }
+}
+
+/**
+ * Create a readline Interface.
+ */
+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 });
+}
+
+// --- Terminal utility functions ---
+
+/**
+ * Clear the current line of a TTY stream.
+ * dir: -1 = to the left, 1 = to the right, 0 = entire line
+ */
+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);
+}
+
+/**
+ * Clear from cursor to end of screen.
+ */
+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);
+}
+
+/**
+ * Move cursor to the specified position.
+ */
+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);
+}
+
+/**
+ * Move cursor relative to its current position.
+ */
+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;
+}
+
+/**
+ * Enable keypress events on a stream (no-op in GJS — full implementation
+ * requires raw terminal mode which depends on the input stream type).
+ */
+export function emitKeypressEvents(_stream: Readable, _interface?: Interface): void {
+  // Keypress event emission requires raw terminal mode.
+  // This is a best-effort no-op; real keypress detection needs platform-specific code.
+}
+
+export default {
+  Interface,
+  createInterface,
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+  emitKeypressEvents,
+};

package/src/promises.spec.ts

@@ -0,0 +1,122 @@
+// 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

@@ -0,0 +1,35 @@
+// 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,
+};

package/src/test.mts

@@ -0,0 +1,4 @@
+import { run } from '@gjsify/unit';
+import testSuite from './index.spec.js';
+import promisesTestSuite from './promises.spec.js';
+run({ testSuite, promisesTestSuite });

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "target": "ESNext",
+    "moduleResolution": "bundler",
+    "types": [
+      "node"
+    ],
+    "experimentalDecorators": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "allowImportingTsExtensions": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "declarationDir": "lib/types",
+    "composite": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": false
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "src/test.ts",
+    "src/test.mts",
+    "src/**/*.spec.ts",
+    "src/**/*.spec.mts"
+  ]
+}