@gjsify/readline 0.1.0

package/README.md

@@ -0,0 +1,33 @@
+# @gjsify/readline
+
+GJS implementation of the Node.js `readline` module. Provides Interface, createInterface, question, prompt, and async iterator support.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/readline
+# or
+yarn add @gjsify/readline
+```
+
+## Usage
+
+```typescript
+import { createInterface } from '@gjsify/readline';
+
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+rl.question('What is your name? ', (answer) => {
+  console.log(`Hello, ${answer}!`);
+  rl.close();
+});
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,258 @@
+import { EventEmitter } from "node:events";
+class Interface extends EventEmitter {
+  terminal;
+  line = "";
+  cursor = 0;
+  _input;
+  _output;
+  _prompt;
+  _closed = false;
+  _paused = false;
+  history;
+  _historySize;
+  _crlfDelay;
+  _lineBuffer = "";
+  _questionCallback = null;
+  constructor(input, output) {
+    super();
+    let opts;
+    if (input && typeof input === "object" && !("read" in input && typeof input.read === "function")) {
+      opts = input;
+    } else {
+      opts = { input, 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) => this._onData(chunk));
+      this._input.on("end", () => this._onEnd());
+      this._input.on("error", (err) => this.emit("error", err));
+      if ("setEncoding" in this._input && typeof this._input.setEncoding === "function") {
+        this._input.setEncoding("utf8");
+      }
+    }
+  }
+  _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) {
+      const line = this._lineBuffer.substring(0, m.index);
+      this._lineBuffer = this._lineBuffer.substring(m.index + m[0].length);
+      this._onLine(line);
+    }
+  }
+  _onLine(line) {
+    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);
+  }
+  _onEnd() {
+    if (this._lineBuffer.length > 0) {
+      this._onLine(this._lineBuffer);
+      this._lineBuffer = "";
+    }
+    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);
+    }
+  }
+  question(query, optionsOrCallback, callback) {
+    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, key) {
+    if (this._closed) return;
+    if (data !== null && data !== void 0) {
+      if (this._output) {
+        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");
+    }
+    this.emit("close");
+  }
+  /** Pause the input stream. */
+  pause() {
+    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() {
+    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() {
+    return { rows: 0, cols: this.cursor };
+  }
+  [Symbol.asyncIterator]() {
+    const lines = [];
+    let resolve = null;
+    let done = false;
+    this.on("line", (line) => {
+      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: void 0, done: true });
+      }
+    });
+    return {
+      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() {
+        done = true;
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+}
+function createInterface(input, output, completer, terminal) {
+  if (typeof input === "object" && input !== null && !("read" in input && typeof input.read === "function")) {
+    return new Interface(input);
+  }
+  return new Interface({ input, output, completer, terminal });
+}
+function clearLine(stream, dir, callback) {
+  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);
+}
+function clearScreenDown(stream, callback) {
+  if (!stream || typeof stream.write !== "function") {
+    if (callback) callback();
+    return true;
+  }
+  return stream.write("\x1B[0J", callback);
+}
+function cursorTo(stream, x, y, callback) {
+  if (!stream || typeof stream.write !== "function") {
+    if (typeof y === "function") y();
+    else if (callback) callback();
+    return true;
+  }
+  if (typeof y === "function") {
+    callback = y;
+    y = void 0;
+  }
+  const code = typeof y === "number" ? `\x1B[${y + 1};${x + 1}H` : `\x1B[${x + 1}G`;
+  return stream.write(code, callback);
+}
+function moveCursor(stream, dx, dy, callback) {
+  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;
+}
+function emitKeypressEvents(_stream, _interface) {
+}
+var index_default = {
+  Interface,
+  createInterface,
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+  emitKeypressEvents
+};
+export {
+  Interface,
+  clearLine,
+  clearScreenDown,
+  createInterface,
+  cursorTo,
+  index_default as default,
+  emitKeypressEvents,
+  moveCursor
+};

package/lib/esm/promises.js

@@ -0,0 +1,26 @@
+import { Interface as BaseInterface } from "./index.js";
+class Interface extends BaseInterface {
+  /** Ask a question and return the answer as a Promise. */
+  question(query, options) {
+    return new Promise((resolve) => {
+      super.question(query, resolve);
+    });
+  }
+}
+function createInterface(input, output) {
+  if (typeof input === "object" && input !== null && !("read" in input && typeof input.read === "function")) {
+    const opts = input;
+    const rl = new Interface(opts);
+    return rl;
+  }
+  return new Interface({ input, output });
+}
+var promises_default = {
+  Interface,
+  createInterface
+};
+export {
+  Interface,
+  createInterface,
+  promises_default as default
+};

package/lib/types/index.d.ts

@@ -0,0 +1,102 @@
+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 declare class Interface extends EventEmitter {
+    terminal: boolean;
+    line: string;
+    cursor: number;
+    private _input;
+    private _output;
+    private _prompt;
+    private _closed;
+    private _paused;
+    history: string[];
+    private _historySize;
+    private _crlfDelay;
+    private _lineBuffer;
+    private _questionCallback;
+    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.
+     */
+    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. */
+    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;
+declare const _default: {
+    Interface: typeof Interface;
+    createInterface: typeof createInterface;
+    clearLine: typeof clearLine;
+    clearScreenDown: typeof clearScreenDown;
+    cursorTo: typeof cursorTo;
+    moveCursor: typeof moveCursor;
+    emitKeypressEvents: typeof emitKeypressEvents;
+};
+export default _default;

package/lib/types/promises.d.ts

@@ -0,0 +1,19 @@
+import { Interface as BaseInterface } from './index.js';
+import type { InterfaceOptions } from './index.js';
+import type { Readable, Writable } from 'node:stream';
+/**
+ * Promise-based readline Interface.
+ */
+export declare class Interface extends BaseInterface {
+    /** Ask a question and return the answer as a Promise. */
+    question(query: string, options?: any): Promise<string>;
+}
+/**
+ * Create a promise-based readline Interface.
+ */
+export declare function createInterface(input?: Readable | InterfaceOptions, output?: Writable): Interface;
+declare const _default: {
+    Interface: typeof Interface;
+    createInterface: typeof createInterface;
+};
+export default _default;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@gjsify/readline",
+  "version": "0.1.0",
+  "description": "Node.js readline module for Gjs",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    },
+    "./promises": {
+      "types": "./lib/types/promises.d.ts",
+      "default": "./lib/esm/promises.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "readline"
+  ],
+  "dependencies": {
+    "@gjsify/events": "^0.1.0"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  }
+}