@gjsify/tty 0.0.4 → 0.1.1

package/README.md

@@ -1,8 +1,33 @@
 # @gjsify/tty
 
-## Inspirations
+GJS implementation of the Node.js `tty` module. Provides ReadStream, WriteStream, and ANSI escape 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/tty
+# or
+yarn add @gjsify/tty
+```
+
+## Usage
+
+```typescript
+import { isatty, ReadStream, WriteStream } from '@gjsify/tty';
+
+console.log(isatty(0)); // true if stdin is a TTY
+```
+
+## Inspirations and credits
+
 - https://github.com/geut/brode/blob/main/packages/browser-node-core/src/tty.js
 - https://github.com/browserify/tty-browserify
 - https://github.com/denoland/deno_std/blob/main/node/tty.ts
 - https://github.com/jvilk/bfs-process/blob/master/ts/tty.ts
-- https://nodejs.org/api/tty.html
+- https://nodejs.org/api/tty.html
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,66 +1,152 @@
-import { Writable, Readable } from "stream";
-import { warnNotImplemented } from "@gjsify/utils";
+import { Writable, Readable } from "node:stream";
+import GLib from "@girs/glib-2.0";
 class ReadStream extends Readable {
   isRaw = false;
+  fd;
+  constructor(fd = 0) {
+    super();
+    this.fd = fd;
+  }
   get isTTY() {
-    return true;
+    return isatty(this.fd);
   }
   setRawMode(mode) {
     if (this.isRaw !== mode) {
       this.isRaw = mode;
       this.emit("modeChange");
     }
+    return this;
   }
 }
 class WriteStream extends Writable {
   isRaw = false;
   columns = 80;
-  rows = 120;
-  // TODO stdout / stderr
+  rows = 24;
+  fd;
   _print = console.log;
-  // TODO fd
   constructor(fd) {
     super();
+    this.fd = fd;
+    this._detectSize();
   }
   get isTTY() {
-    return true;
+    return isatty(this.fd);
   }
+  /** Detect terminal size from environment or defaults. */
+  _detectSize() {
+    const cols = parseInt(
+      globalThis.process?.env?.COLUMNS || (typeof GLib !== "undefined" ? GLib.getenv("COLUMNS") : "") || "0",
+      10
+    );
+    const rows = parseInt(
+      globalThis.process?.env?.LINES || (typeof GLib !== "undefined" ? GLib.getenv("LINES") : "") || "0",
+      10
+    );
+    if (cols > 0) this.columns = cols;
+    if (rows > 0) this.rows = rows;
+  }
+  /**
+   * Clear the current line.
+   * dir: -1 = left of cursor, 0 = entire line, 1 = right of cursor
+   */
   clearLine(dir, callback) {
-    warnNotImplemented("WriteStream.clearLine");
-    if (callback)
-      callback();
-    return true;
+    let seq;
+    if (dir === -1) {
+      seq = "\x1B[1K";
+    } else if (dir === 1) {
+      seq = "\x1B[0K";
+    } else {
+      seq = "\x1B[2K";
+    }
+    return this.write(seq, callback);
   }
+  /** Clear the screen from the cursor down. */
   clearScreenDown(callback) {
-    warnNotImplemented("WriteStream.clearScreenDown");
-    if (callback)
-      callback();
-    return true;
+    return this.write("\x1B[0J", callback);
   }
+  /**
+   * Move cursor to absolute position (x, y).
+   * If y is omitted, only move horizontally.
+   */
   cursorTo(x, y, callback) {
-    warnNotImplemented("WriteStream.cursorTo");
-    if (callback)
-      callback();
-    return true;
+    if (typeof y === "function") {
+      callback = y;
+      y = void 0;
+    }
+    let seq;
+    if (y == null) {
+      seq = `\x1B[${x + 1}G`;
+    } else {
+      seq = `\x1B[${y + 1};${x + 1}H`;
+    }
+    return this.write(seq, callback);
+  }
+  /**
+   * Move cursor relative to its current position.
+   */
+  moveCursor(dx, dy, callback) {
+    let seq = "";
+    if (dx > 0) seq += `\x1B[${dx}C`;
+    else if (dx < 0) seq += `\x1B[${-dx}D`;
+    if (dy > 0) seq += `\x1B[${dy}B`;
+    else if (dy < 0) seq += `\x1B[${-dy}A`;
+    if (seq.length === 0) {
+      if (callback) callback();
+      return true;
+    }
+    return this.write(seq, callback);
   }
+  /**
+   * Get the color depth of the terminal.
+   * Returns 1 (no color), 4 (16 colors), 8 (256 colors), or 24 (true color).
+   */
   getColorDepth(env) {
-    warnNotImplemented("WriteStream.getColorDepth");
-    return 8;
+    const e = env || globalThis.process?.env || {};
+    if ("FORCE_COLOR" in e) {
+      const force = e.FORCE_COLOR;
+      if (force === "0" || force === "false") return 1;
+      if (force === "1") return 4;
+      if (force === "2") return 8;
+      if (force === "3") return 24;
+      return 4;
+    }
+    if ("NO_COLOR" in e) return 1;
+    const term = e.TERM || "";
+    const colorterm = e.COLORTERM || "";
+    if (colorterm === "truecolor" || colorterm === "24bit") return 24;
+    if (term === "xterm-256color" || term.endsWith("-256color")) return 8;
+    if (colorterm) return 4;
+    if (term === "dumb") return 1;
+    if (term.startsWith("xterm") || term.startsWith("screen") || term.startsWith("vt100") || term.startsWith("linux")) return 4;
+    return 1;
   }
+  /** Get the terminal window size as [columns, rows]. */
   getWindowSize() {
-    warnNotImplemented("WriteStream.getWindowSize");
     return [this.columns, this.rows];
   }
-  hasColors(count = 16, env) {
-    switch (this.getColorDepth(env)) {
+  /**
+   * Check if the terminal supports the given number of colors.
+   */
+  hasColors(count, env) {
+    let _count;
+    let _env;
+    if (typeof count === "object") {
+      _env = count;
+      _count = 16;
+    } else {
+      _count = count ?? 16;
+      _env = env;
+    }
+    const depth = this.getColorDepth(_env);
+    switch (depth) {
       case 1:
-        return count >= 2;
+        return _count >= 2;
       case 4:
-        return count >= 16;
+        return _count >= 16;
       case 8:
-        return count >= 256;
+        return _count >= 256;
       case 24:
-        return count >= 16777216;
+        return _count >= 16777216;
       default:
         return false;
     }
@@ -70,6 +156,7 @@ class WriteStream extends Writable {
       this.isRaw = mode;
       this.emit("modeChange");
     }
+    return this;
   }
   _write(chunk, enc, cb) {
     this._print(enc === "buffer" ? chunk.toString("utf-8") : chunk);
@@ -88,10 +175,16 @@ class WriteStream extends Writable {
     }
   }
 }
-const isatty = (fd) => {
-  return fd && (fd instanceof ReadStream || fd instanceof WriteStream);
-};
-var src_default = {
+function isatty(fd) {
+  if (fd instanceof ReadStream || fd instanceof WriteStream) {
+    return isatty(fd.fd);
+  }
+  if (typeof fd === "number") {
+    return GLib.log_writer_supports_color(fd);
+  }
+  return false;
+}
+var index_default = {
   isatty,
   WriteStream,
   ReadStream
@@ -99,6 +192,6 @@ var src_default = {
 export {
   ReadStream,
   WriteStream,
-  src_default as default,
+  index_default as default,
   isatty
 };

package/lib/types/index.d.ts

@@ -0,0 +1,62 @@
+import { Writable, Readable } from 'node:stream';
+export declare class ReadStream extends Readable {
+    isRaw: boolean;
+    readonly fd: number;
+    constructor(fd?: number);
+    get isTTY(): boolean;
+    setRawMode(mode: boolean): this;
+}
+export declare class WriteStream extends Writable {
+    isRaw: boolean;
+    columns: number;
+    rows: number;
+    readonly fd: number;
+    protected _print: (...data: any[]) => void;
+    constructor(fd: number);
+    get isTTY(): boolean;
+    /** Detect terminal size from environment or defaults. */
+    private _detectSize;
+    /**
+     * Clear the current line.
+     * dir: -1 = left of cursor, 0 = entire line, 1 = right of cursor
+     */
+    clearLine(dir: number, callback?: () => void): boolean;
+    /** Clear the screen from the cursor down. */
+    clearScreenDown(callback?: () => void): boolean;
+    /**
+     * Move cursor to absolute position (x, y).
+     * If y is omitted, only move horizontally.
+     */
+    cursorTo(x: number, y?: number | (() => void), callback?: () => void): boolean;
+    /**
+     * Move cursor relative to its current position.
+     */
+    moveCursor(dx: number, dy: number, callback?: () => void): boolean;
+    /**
+     * Get the color depth of the terminal.
+     * Returns 1 (no color), 4 (16 colors), 8 (256 colors), or 24 (true color).
+     */
+    getColorDepth(env?: Record<string, string>): number;
+    /** Get the terminal window size as [columns, rows]. */
+    getWindowSize(): [number, number];
+    /**
+     * Check if the terminal supports the given number of colors.
+     */
+    hasColors(count?: number | Record<string, string>, env?: Record<string, string>): boolean;
+    setRawMode(mode: boolean): this;
+    _write(chunk: any, enc: string, cb: Function): void;
+    _changeColumns(columns: number): void;
+    _changeRows(rows: number): void;
+}
+/**
+ * Check if a file descriptor refers to a TTY.
+ * Uses GLib.log_writer_supports_color() as a reliable TTY proxy: if a fd supports
+ * ANSI colors it is connected to an interactive terminal.
+ */
+export declare function isatty(fd: number | ReadStream | WriteStream): boolean;
+declare const _default: {
+    isatty: typeof isatty;
+    WriteStream: typeof WriteStream;
+    ReadStream: typeof ReadStream;
+};
+export default _default;

package/package.json

@@ -1,31 +1,26 @@
 {
   "name": "@gjsify/tty",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "Node.js tty module for Gjs",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/tty'",
-    "build": "yarn print:name && yarn build:gjsify",
+    "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 print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "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"
   },
@@ -35,10 +30,13 @@
     "tty"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@types/node": "^20.10.5"
+    "@gjsify/cli": "^0.1.1",
+    "@gjsify/unit": "^0.1.1",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gjsify/utils": "^0.0.4"
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.43",
+    "@gjsify/stream": "^0.1.1"
   }
 }

package/src/index.spec.ts

@@ -1,9 +1,296 @@
+// Ported from refs/node-test/parallel/test-tty-{isatty,get-color-depth,has-colors,window-size,wrap,stream-constructors}.js
+// Original: MIT license, Node.js contributors
+
 import { describe, it, expect } from '@gjsify/unit';
+import tty, { isatty, ReadStream, WriteStream } from 'node:tty';
+import process from 'node:process';
 
 export default async () => {
-	await describe('true', async () => {
-		await it('should be true', async () => {
-			expect(true).toBeTruthy();
-		});
-	});
-}
+  await describe('tty exports', async () => {
+    await it('should export isatty as a function', async () => {
+      expect(typeof isatty).toBe('function');
+    });
+
+    await it('should export ReadStream as a function', async () => {
+      expect(typeof ReadStream).toBe('function');
+    });
+
+    await it('should export WriteStream as a function', async () => {
+      expect(typeof WriteStream).toBe('function');
+    });
+
+    await it('should have all exports on default export', async () => {
+      expect(typeof tty.isatty).toBe('function');
+      expect(typeof tty.ReadStream).toBe('function');
+      expect(typeof tty.WriteStream).toBe('function');
+    });
+
+    await it('isatty should be same reference on default', async () => {
+      expect(tty.isatty).toBe(isatty);
+    });
+  });
+
+  await describe('tty.isatty', async () => {
+    await it('should return a boolean for fd 0 (stdin)', async () => {
+      expect(typeof isatty(0)).toBe('boolean');
+    });
+
+    await it('should return a boolean for fd 1 (stdout)', async () => {
+      expect(typeof isatty(1)).toBe('boolean');
+    });
+
+    await it('should return a boolean for fd 2 (stderr)', async () => {
+      expect(typeof isatty(2)).toBe('boolean');
+    });
+
+    await it('should return false for invalid fd -1', async () => {
+      expect(isatty(-1)).toBe(false);
+    });
+
+    await it('should return false for very large fd', async () => {
+      expect(isatty(999999)).toBe(false);
+    });
+
+    await it('should return false for fd 100', async () => {
+      expect(isatty(100)).toBe(false);
+    });
+
+    await it('should return false for fd 255', async () => {
+      expect(isatty(255)).toBe(false);
+    });
+
+    await it('should return false for fd 42', async () => {
+      expect(isatty(42)).toBe(false);
+    });
+  });
+
+  await describe('tty.ReadStream', async () => {
+    await it('should be a constructor', async () => {
+      expect(typeof ReadStream).toBe('function');
+    });
+
+    await it('should have setRawMode on prototype', async () => {
+      expect(typeof ReadStream.prototype.setRawMode).toBe('function');
+    });
+
+    await it('should have isTTY property', async () => {
+      const desc = Object.getOwnPropertyDescriptor(ReadStream.prototype, 'isTTY');
+      if (desc) {
+        expect(desc.get !== undefined || desc.value !== undefined).toBe(true);
+      } else {
+        expect('setRawMode' in ReadStream.prototype).toBe(true);
+      }
+    });
+  });
+
+  await describe('tty.WriteStream prototype', async () => {
+    await it('should be a constructor', async () => {
+      expect(typeof WriteStream).toBe('function');
+    });
+
+    await it('should have clearLine method', async () => {
+      expect(typeof WriteStream.prototype.clearLine).toBe('function');
+    });
+
+    await it('should have clearScreenDown method', async () => {
+      expect(typeof WriteStream.prototype.clearScreenDown).toBe('function');
+    });
+
+    await it('should have cursorTo method', async () => {
+      expect(typeof WriteStream.prototype.cursorTo).toBe('function');
+    });
+
+    await it('should have moveCursor method', async () => {
+      expect(typeof WriteStream.prototype.moveCursor).toBe('function');
+    });
+
+    await it('should have getColorDepth method', async () => {
+      expect(typeof WriteStream.prototype.getColorDepth).toBe('function');
+    });
+
+    await it('should have hasColors method', async () => {
+      expect(typeof WriteStream.prototype.hasColors).toBe('function');
+    });
+
+    await it('should have getWindowSize method', async () => {
+      expect(typeof WriteStream.prototype.getWindowSize).toBe('function');
+    });
+
+    await it('should have isTTY getter or property', async () => {
+      const desc = Object.getOwnPropertyDescriptor(WriteStream.prototype, 'isTTY');
+      if (desc) {
+        expect(desc.get !== undefined || desc.value !== undefined).toBe(true);
+      } else {
+        // Some implementations set isTTY as a direct property in constructor
+        expect(typeof WriteStream.prototype.getColorDepth).toBe('function');
+      }
+    });
+  });
+
+  await describe('WriteStream.getColorDepth (via process.stdout)', async () => {
+    // process.stdout may or may not be a tty.WriteStream
+    const ws = process.stdout as unknown as { getColorDepth?: (env?: Record<string, string>) => number };
+
+    if (typeof ws.getColorDepth === 'function') {
+      await it('should return a number', async () => {
+        expect(typeof ws.getColorDepth!()).toBe('number');
+      });
+
+      await it('should return 1, 4, 8, or 24', async () => {
+        expect([1, 4, 8, 24].includes(ws.getColorDepth!())).toBe(true);
+      });
+
+      await it('NO_COLOR should return 1', async () => {
+        expect(ws.getColorDepth!({ NO_COLOR: '1' })).toBe(1);
+      });
+
+      await it('COLORTERM=truecolor should return 24', async () => {
+        expect(ws.getColorDepth!({ COLORTERM: 'truecolor' })).toBe(24);
+      });
+
+      await it('COLORTERM=24bit should return 24', async () => {
+        expect(ws.getColorDepth!({ COLORTERM: '24bit' })).toBe(24);
+      });
+
+      await it('TERM=xterm-256color should return 8', async () => {
+        expect(ws.getColorDepth!({ TERM: 'xterm-256color' })).toBe(8);
+      });
+
+      await it('TERM=xterm should return 4', async () => {
+        expect(ws.getColorDepth!({ TERM: 'xterm' })).toBe(4);
+      });
+
+      await it('TERM=dumb should return 1', async () => {
+        expect(ws.getColorDepth!({ TERM: 'dumb' })).toBe(1);
+      });
+
+      await it('FORCE_COLOR=0 should return 1', async () => {
+        expect(ws.getColorDepth!({ FORCE_COLOR: '0' })).toBe(1);
+      });
+
+      await it('FORCE_COLOR=1 should return 4', async () => {
+        expect(ws.getColorDepth!({ FORCE_COLOR: '1' })).toBe(4);
+      });
+
+      await it('FORCE_COLOR=2 should return 8', async () => {
+        expect(ws.getColorDepth!({ FORCE_COLOR: '2' })).toBe(8);
+      });
+
+      await it('FORCE_COLOR=3 should return 24', async () => {
+        expect(ws.getColorDepth!({ FORCE_COLOR: '3' })).toBe(24);
+      });
+
+      await it('FORCE_COLOR overrides NO_COLOR', async () => {
+        expect(ws.getColorDepth!({ FORCE_COLOR: '1', NO_COLOR: '1' })).toBe(4);
+      });
+
+      await it('TERM=screen should return 4', async () => {
+        expect(ws.getColorDepth!({ TERM: 'screen' })).toBe(4);
+      });
+
+      await it('TERM=linux should return 4', async () => {
+        expect(ws.getColorDepth!({ TERM: 'linux' })).toBe(4);
+      });
+
+      await it('empty env should return 1', async () => {
+        expect(ws.getColorDepth!({})).toBe(1);
+      });
+    }
+  });
+
+  await describe('WriteStream.hasColors (via process.stdout)', async () => {
+    const ws = process.stdout as unknown as { hasColors?: (count?: number | Record<string, string>, env?: Record<string, string>) => boolean };
+
+    if (typeof ws.hasColors === 'function') {
+      await it('should return a boolean', async () => {
+        expect(typeof ws.hasColors!()).toBe('boolean');
+      });
+
+      await it('should accept count argument', async () => {
+        expect(typeof ws.hasColors!(256)).toBe('boolean');
+      });
+
+      await it('should accept env as first argument', async () => {
+        expect(typeof ws.hasColors!({ TERM: 'xterm-256color' })).toBe('boolean');
+      });
+
+      await it('truecolor env should support 256 colors', async () => {
+        expect(ws.hasColors!(256, { COLORTERM: 'truecolor' })).toBe(true);
+      });
+
+      await it('dumb terminal should not support 256 colors', async () => {
+        expect(ws.hasColors!(256, { TERM: 'dumb' })).toBe(false);
+      });
+
+      await it('xterm-256color should support 256 colors', async () => {
+        expect(ws.hasColors!(256, { TERM: 'xterm-256color' })).toBe(true);
+      });
+    }
+  });
+
+  await describe('WriteStream.getWindowSize (via process.stdout)', async () => {
+    const ws = process.stdout as unknown as { getWindowSize?: () => [number, number]; columns?: number; rows?: number };
+
+    if (typeof ws.getWindowSize === 'function') {
+      await it('should return array of two numbers', async () => {
+        const size = ws.getWindowSize!();
+        expect(Array.isArray(size)).toBe(true);
+        expect(size.length).toBe(2);
+        expect(typeof size[0]).toBe('number');
+        expect(typeof size[1]).toBe('number');
+      });
+
+      await it('columns should be positive', async () => {
+        expect(ws.getWindowSize!()[0]).toBeGreaterThan(0);
+      });
+
+      await it('rows should be positive', async () => {
+        expect(ws.getWindowSize!()[1]).toBeGreaterThan(0);
+      });
+    }
+
+    if (typeof ws.columns === 'number') {
+      await it('columns property should be positive', async () => {
+        expect(ws.columns!).toBeGreaterThan(0);
+      });
+
+      await it('rows property should be positive', async () => {
+        expect(ws.rows!).toBeGreaterThan(0);
+      });
+
+      await it('columns should match getWindowSize()[0]', async () => {
+        if (typeof ws.getWindowSize === 'function') {
+          expect(ws.columns).toBe(ws.getWindowSize!()[0]);
+        }
+      });
+    }
+  });
+
+  await describe('process.stdout/stderr', async () => {
+    await it('process.stdout should have write method', async () => {
+      expect(typeof process.stdout.write).toBe('function');
+    });
+
+    await it('process.stderr should have write method', async () => {
+      expect(typeof process.stderr.write).toBe('function');
+    });
+
+    await it('process.stdout.isTTY should be boolean if defined', async () => {
+      if (process.stdout.isTTY !== undefined) {
+        expect(typeof process.stdout.isTTY).toBe('boolean');
+      }
+    });
+
+    await it('process.stderr.isTTY should be boolean if defined', async () => {
+      if (process.stderr.isTTY !== undefined) {
+        expect(typeof process.stderr.isTTY).toBe('boolean');
+      }
+    });
+
+    await it('process.stdin should have isTTY property if available', async () => {
+      if ((process.stdin as any).isTTY !== undefined) {
+        expect(typeof (process.stdin as any).isTTY).toBe('boolean');
+      }
+    });
+  });
+};