@gjsify/console 0.0.4 → 0.1.1

package/README.md

@@ -1,6 +1,31 @@
 # @gjsify/console
 
-Node.js console module for Gjs
+GJS implementation of the Node.js `console` module with stream 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/console
+# or
+yarn add @gjsify/console
+```
+
+## Usage
+
+```typescript
+import { Console } from '@gjsify/console';
+
+const logger = new Console(process.stdout, process.stderr);
+logger.log('hello');
+logger.error('something went wrong');
+```
 
 ## Inspirations and credits
-- https://github.com/denoland/deno/tree/main/ext/console
+
+- https://github.com/denoland/deno/tree/main/ext/console
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,6 +1,246 @@
-export * from "@gjsify/deno_std/node/console";
-import console from "@gjsify/deno_std/node/console";
-var src_default = console;
+const _isGJS = typeof print === "function" && typeof printerr === "function";
+function _formatArgs(...args) {
+  const fmt = args[0];
+  const rest = args.slice(1);
+  if (typeof fmt !== "string" || !/%(s|d|i|f|o|O|c)/.test(fmt)) {
+    return args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+  }
+  let i = 0;
+  const result = fmt.replace(/%([sdifOoc])/g, (_match, spec) => {
+    if (i >= rest.length) return _match;
+    const val = rest[i++];
+    switch (spec) {
+      case "s":
+        return String(val);
+      case "d":
+      case "i":
+        return String(parseInt(String(val), 10));
+      case "f":
+        return String(parseFloat(String(val)));
+      case "o":
+      case "O":
+        return JSON.stringify(val);
+      case "c":
+        return "";
+      // CSS styles — ignore
+      default:
+        return _match;
+    }
+  });
+  const remaining = rest.slice(i);
+  if (remaining.length === 0) return result;
+  return result + " " + remaining.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+}
+class Console {
+  _stdout;
+  _stderr;
+  _groupDepth = 0;
+  _groupIndentation;
+  _timers = /* @__PURE__ */ new Map();
+  _counters = /* @__PURE__ */ new Map();
+  constructor(stdoutOrOptions, stderr) {
+    if (stdoutOrOptions && typeof stdoutOrOptions.write === "function") {
+      this._stdout = stdoutOrOptions;
+      this._stderr = stderr || this._stdout;
+    } else if (stdoutOrOptions && typeof stdoutOrOptions === "object") {
+      const opts = stdoutOrOptions;
+      this._stdout = opts.stdout;
+      this._stderr = opts.stderr || opts.stdout;
+    }
+    this._groupIndentation = 2;
+  }
+  _write(stream, ...args) {
+    const target = stream === "stderr" ? this._stderr || this._stdout : this._stdout;
+    if (target) {
+      const indent = " ".repeat(this._groupDepth * this._groupIndentation);
+      const message = _formatArgs(...args);
+      target.write(indent + message + "\n");
+    } else if (_isGJS) {
+      const indent = " ".repeat(this._groupDepth * this._groupIndentation);
+      const message = indent + _formatArgs(...args);
+      if (stream === "stderr") {
+        printerr(message);
+      } else {
+        print(message);
+      }
+    } else {
+      const gc = globalThis.console;
+      if (stream === "stderr") {
+        gc.error(...args);
+      } else {
+        gc.log(...args);
+      }
+    }
+  }
+  log(...args) {
+    this._write("stdout", ...args);
+  }
+  info(...args) {
+    this._write("stdout", ...args);
+  }
+  debug(...args) {
+    this._write("stdout", ...args);
+  }
+  warn(...args) {
+    this._write("stderr", ...args);
+  }
+  error(...args) {
+    this._write("stderr", ...args);
+  }
+  dir(obj, _options) {
+    this._write("stdout", obj);
+  }
+  dirxml(...args) {
+    this.log(...args);
+  }
+  assert(value, ...args) {
+    if (!value) {
+      this.error("Assertion failed:", ...args);
+    }
+  }
+  clear() {
+    if (this._stdout) {
+      this._stdout.write("\x1Bc");
+    } else if (_isGJS) {
+      print("\x1Bc");
+    } else {
+      globalThis.console.clear();
+    }
+  }
+  count(label = "default") {
+    const count2 = (this._counters.get(label) || 0) + 1;
+    this._counters.set(label, count2);
+    this.log(`${label}: ${count2}`);
+  }
+  countReset(label = "default") {
+    this._counters.delete(label);
+  }
+  group(...args) {
+    if (args.length > 0) this.log(...args);
+    this._groupDepth++;
+  }
+  groupCollapsed(...args) {
+    this.group(...args);
+  }
+  groupEnd() {
+    if (this._groupDepth > 0) this._groupDepth--;
+  }
+  table(tabularData, _properties) {
+    if (this._stdout) {
+      this._write("stdout", tabularData);
+    } else if (_isGJS) {
+      print(JSON.stringify(tabularData, null, 2));
+    } else {
+      globalThis.console.table(tabularData, _properties);
+    }
+  }
+  time(label = "default") {
+    this._timers.set(label, Date.now());
+  }
+  timeEnd(label = "default") {
+    const start = this._timers.get(label);
+    if (start !== void 0) {
+      this.log(`${label}: ${Date.now() - start}ms`);
+      this._timers.delete(label);
+    } else {
+      this.warn(`Warning: No such label '${label}' for console.timeEnd()`);
+    }
+  }
+  timeLog(label = "default", ...args) {
+    const start = this._timers.get(label);
+    if (start !== void 0) {
+      this.log(`${label}: ${Date.now() - start}ms`, ...args);
+    } else {
+      this.warn(`Warning: No such label '${label}' for console.timeLog()`);
+    }
+  }
+  trace(...args) {
+    const err = new Error();
+    const stack = err.stack?.split("\n").slice(1).join("\n") || "";
+    this._write("stderr", "Trace:", ...args, "\n" + stack);
+  }
+  profile(_label) {
+  }
+  profileEnd(_label) {
+  }
+  timeStamp(_label) {
+  }
+}
+const _default = new Console();
+const log = (...args) => _default.log(...args);
+const info = (...args) => _default.info(...args);
+const debug = (...args) => _default.debug(...args);
+const warn = (...args) => _default.warn(...args);
+const error = (...args) => _default.error(...args);
+const dir = (obj, options) => _default.dir(obj, options);
+const dirxml = (...args) => _default.dirxml(...args);
+const table = (data, properties) => _default.table(data, properties);
+const clear = () => _default.clear();
+const assert = (value, ...args) => _default.assert(value, ...args);
+const trace = (...args) => _default.trace(...args);
+const time = (label) => _default.time(label);
+const timeEnd = (label) => _default.timeEnd(label);
+const timeLog = (label, ...args) => _default.timeLog(label, ...args);
+const count = (label) => _default.count(label);
+const countReset = (label) => _default.countReset(label);
+const group = (...args) => _default.group(...args);
+const groupCollapsed = (...args) => _default.groupCollapsed(...args);
+const groupEnd = () => _default.groupEnd();
+const profile = (_label) => {
+};
+const profileEnd = (_label) => {
+};
+const timeStamp = (_label) => {
+};
+const consoleModule = {
+  Console,
+  log,
+  info,
+  debug,
+  warn,
+  error,
+  dir,
+  dirxml,
+  table,
+  time,
+  timeEnd,
+  timeLog,
+  trace,
+  assert,
+  clear,
+  count,
+  countReset,
+  group,
+  groupCollapsed,
+  groupEnd,
+  profile,
+  profileEnd,
+  timeStamp
+};
+var index_default = consoleModule;
 export {
-  src_default as default
+  Console,
+  assert,
+  clear,
+  count,
+  countReset,
+  debug,
+  index_default as default,
+  dir,
+  dirxml,
+  error,
+  group,
+  groupCollapsed,
+  groupEnd,
+  info,
+  log,
+  profile,
+  profileEnd,
+  table,
+  time,
+  timeEnd,
+  timeLog,
+  timeStamp,
+  trace,
+  warn
 };

package/lib/types/index.d.ts

@@ -0,0 +1,90 @@
+import type { ConsoleOptions } from 'node:console';
+/**
+ * The Console class can be used to create a simple logger with configurable output streams.
+ * This implementation delegates to the global console for the basic case,
+ * and writes to custom streams when provided.
+ */
+export declare class Console {
+    private _stdout;
+    private _stderr;
+    private _groupDepth;
+    private _groupIndentation;
+    private _timers;
+    private _counters;
+    constructor(stdoutOrOptions?: {
+        write: (data: string) => void;
+    } | ConsoleOptions, stderr?: {
+        write: (data: string) => void;
+    });
+    private _write;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    dir(obj: unknown, _options?: object): void;
+    dirxml(...args: unknown[]): void;
+    assert(value: unknown, ...args: unknown[]): void;
+    clear(): void;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    group(...args: unknown[]): void;
+    groupCollapsed(...args: unknown[]): void;
+    groupEnd(): void;
+    table(tabularData: unknown, _properties?: string[]): void;
+    time(label?: string): void;
+    timeEnd(label?: string): void;
+    timeLog(label?: string, ...args: unknown[]): void;
+    trace(...args: unknown[]): void;
+    profile(_label?: string): void;
+    profileEnd(_label?: string): void;
+    timeStamp(_label?: string): void;
+}
+export declare const log: (...args: unknown[]) => void;
+export declare const info: (...args: unknown[]) => void;
+export declare const debug: (...args: unknown[]) => void;
+export declare const warn: (...args: unknown[]) => void;
+export declare const error: (...args: unknown[]) => void;
+export declare const dir: (obj: unknown, options?: object) => void;
+export declare const dirxml: (...args: unknown[]) => void;
+export declare const table: (data: unknown, properties?: string[]) => void;
+export declare const clear: () => void;
+export declare const assert: (value: unknown, ...args: unknown[]) => void;
+export declare const trace: (...args: unknown[]) => void;
+export declare const time: (label?: string) => void;
+export declare const timeEnd: (label?: string) => void;
+export declare const timeLog: (label?: string, ...args: unknown[]) => void;
+export declare const count: (label?: string) => void;
+export declare const countReset: (label?: string) => void;
+export declare const group: (...args: unknown[]) => void;
+export declare const groupCollapsed: (...args: unknown[]) => void;
+export declare const groupEnd: () => void;
+export declare const profile: (_label?: string) => void;
+export declare const profileEnd: (_label?: string) => void;
+export declare const timeStamp: (_label?: string) => void;
+declare const consoleModule: {
+    Console: typeof Console;
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    dir: (obj: unknown, options?: object) => void;
+    dirxml: (...args: unknown[]) => void;
+    table: (data: unknown, properties?: string[]) => void;
+    time: (label?: string) => void;
+    timeEnd: (label?: string) => void;
+    timeLog: (label?: string, ...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+    assert: (value: unknown, ...args: unknown[]) => void;
+    clear: () => void;
+    count: (label?: string) => void;
+    countReset: (label?: string) => void;
+    group: (...args: unknown[]) => void;
+    groupCollapsed: (...args: unknown[]) => void;
+    groupEnd: () => void;
+    profile: (_label?: string) => void;
+    profileEnd: (_label?: string) => void;
+    timeStamp: (_label?: string) => void;
+};
+export default consoleModule;

package/package.json

@@ -1,32 +1,26 @@
 {
   "name": "@gjsify/console",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "Node.js console 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/console'",
-    "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 --project tsconfig.types.json || exit 0",
+    "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"
   },
@@ -36,12 +30,9 @@
     "console"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
-  },
-  "dependencies": {
-    "@gjsify/deno_std": "^0.0.4"
+    "@gjsify/cli": "^0.1.1",
+    "@gjsify/unit": "^0.1.1",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }