@gjsify/worker_threads 0.1.0

package/README.md

@@ -0,0 +1,27 @@
+# @gjsify/worker_threads
+
+GJS stub implementation of the Node.js `worker_threads` module. Currently provides isMainThread only.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/worker_threads
+# or
+yarn add @gjsify/worker_threads
+```
+
+## Usage
+
+```typescript
+import { isMainThread } from '@gjsify/worker_threads';
+
+if (isMainThread) {
+  console.log('Running in the main thread');
+}
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,138 @@
+import { MessagePort } from "./message-port.js";
+import { Worker } from "./worker.js";
+import { MessagePort as MessagePort2 } from "./message-port.js";
+import { Worker as Worker2 } from "./worker.js";
+const _ctx = globalThis.__gjsify_worker_context;
+const isMainThread = !_ctx;
+const parentPort = _ctx?.parentPort ?? null;
+const workerData = _ctx?.workerData ?? null;
+const threadId = _ctx?.threadId ?? 0;
+const resourceLimits = {};
+const SHARE_ENV = /* @__PURE__ */ Symbol("worker_threads.SHARE_ENV");
+class MessageChannel {
+  port1;
+  port2;
+  constructor() {
+    this.port1 = new MessagePort2();
+    this.port2 = new MessagePort2();
+    this.port1._otherPort = this.port2;
+    this.port2._otherPort = this.port1;
+  }
+}
+const _broadcastRegistry = /* @__PURE__ */ new Map();
+class BroadcastChannel {
+  name;
+  _closed = false;
+  onmessage = null;
+  onmessageerror = null;
+  constructor(name) {
+    this.name = String(name);
+    if (!_broadcastRegistry.has(this.name)) {
+      _broadcastRegistry.set(this.name, /* @__PURE__ */ new Set());
+    }
+    _broadcastRegistry.get(this.name).add(this);
+  }
+  postMessage(message) {
+    if (this._closed) {
+      throw new Error("BroadcastChannel is closed");
+    }
+    const channels = _broadcastRegistry.get(this.name);
+    if (!channels) return;
+    for (const channel of channels) {
+      if (channel !== this && !channel._closed) {
+        const cloned = structuredClone(message);
+        Promise.resolve().then(() => {
+          if (!channel._closed && channel.onmessage) {
+            channel.onmessage({ data: cloned });
+          }
+        });
+      }
+    }
+  }
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    const channels = _broadcastRegistry.get(this.name);
+    if (channels) {
+      channels.delete(this);
+      if (channels.size === 0) {
+        _broadcastRegistry.delete(this.name);
+      }
+    }
+    this.onmessage = null;
+    this.onmessageerror = null;
+  }
+  addEventListener(type, listener) {
+    if (type === "message") {
+      this.onmessage = listener;
+    } else if (type === "messageerror") {
+      this.onmessageerror = listener;
+    }
+  }
+  removeEventListener(type, _listener) {
+    if (type === "message") this.onmessage = null;
+    else if (type === "messageerror") this.onmessageerror = null;
+  }
+  dispatchEvent(_event) {
+    return true;
+  }
+}
+const _environmentData = /* @__PURE__ */ new Map();
+function setEnvironmentData(key, value) {
+  if (value === void 0) {
+    _environmentData.delete(key);
+  } else {
+    _environmentData.set(key, value);
+  }
+}
+function getEnvironmentData(key) {
+  return _environmentData.get(key);
+}
+function receiveMessageOnPort(port) {
+  if (!port._hasQueuedMessages) return void 0;
+  return { message: port._dequeueMessage() };
+}
+function markAsUntransferable(_object) {
+}
+function markAsUncloneable(_object) {
+}
+function moveMessagePortToContext(port, _context) {
+  return port;
+}
+var index_default = {
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  resourceLimits,
+  SHARE_ENV,
+  Worker: Worker2,
+  MessageChannel,
+  MessagePort: MessagePort2,
+  BroadcastChannel,
+  setEnvironmentData,
+  getEnvironmentData,
+  receiveMessageOnPort,
+  markAsUntransferable,
+  markAsUncloneable,
+  moveMessagePortToContext
+};
+export {
+  BroadcastChannel,
+  MessageChannel,
+  MessagePort,
+  SHARE_ENV,
+  Worker,
+  index_default as default,
+  getEnvironmentData,
+  isMainThread,
+  markAsUncloneable,
+  markAsUntransferable,
+  moveMessagePortToContext,
+  parentPort,
+  receiveMessageOnPort,
+  resourceLimits,
+  setEnvironmentData,
+  threadId,
+  workerData
+};

package/lib/esm/message-port.js

@@ -0,0 +1,118 @@
+import { EventEmitter } from "node:events";
+class MessagePort extends EventEmitter {
+  _started = false;
+  _closed = false;
+  _messageQueue = [];
+  /** @internal Linked port for in-process communication */
+  _otherPort = null;
+  /** @internal Maps addEventListener listeners to their internal wrappers */
+  _aeWrappers = /* @__PURE__ */ new Map();
+  start() {
+    if (this._started || this._closed) return;
+    this._started = true;
+    this._drainQueue();
+  }
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    const other = this._otherPort;
+    this._otherPort = null;
+    if (other) other._otherPort = null;
+    this.emit("close");
+    this.removeAllListeners();
+  }
+  postMessage(value, _transferList) {
+    if (this._closed) return;
+    const target = this._otherPort;
+    if (!target) return;
+    let cloned;
+    try {
+      cloned = structuredClone(value);
+    } catch (err) {
+      this.emit("messageerror", err instanceof Error ? err : new Error("Could not clone message"));
+      return;
+    }
+    target._receiveMessage(cloned);
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  _receiveMessage(message) {
+    if (this._closed) return;
+    if (!this._started) {
+      this._messageQueue.push(message);
+      return;
+    }
+    this._dispatchMessage(message);
+  }
+  get _hasQueuedMessages() {
+    return this._messageQueue.length > 0;
+  }
+  _dequeueMessage() {
+    return this._messageQueue.shift();
+  }
+  _drainQueue() {
+    while (this._messageQueue.length > 0) {
+      this._dispatchMessage(this._messageQueue.shift());
+    }
+  }
+  _dispatchMessage(message) {
+    Promise.resolve().then(() => {
+      if (!this._closed) {
+        this.emit("message", message);
+      }
+    });
+  }
+  /**
+   * Web-compatible addEventListener. Wraps message data in a MessageEvent-like
+   * object `{ data, type }` before calling the listener.
+   * Requires explicit `port.start()` call (unlike `on('message')` which auto-starts).
+   */
+  addEventListener(type, listener) {
+    if (!listener) return;
+    if (type === "message") {
+      const wrapper = (data) => {
+        listener({ data, type: "message" });
+      };
+      this._aeWrappers.set(listener, wrapper);
+      super.on("message", wrapper);
+    } else {
+      super.on(type, listener);
+    }
+  }
+  removeEventListener(type, listener) {
+    if (!listener) return;
+    if (type === "message") {
+      const wrapper = this._aeWrappers.get(listener);
+      if (wrapper) {
+        super.off("message", wrapper);
+        this._aeWrappers.delete(listener);
+      }
+    } else {
+      super.off(type, listener);
+    }
+  }
+  on(event, listener) {
+    super.on(event, listener);
+    if (event === "message" && !this._started) {
+      this.start();
+    }
+    return this;
+  }
+  addListener(event, listener) {
+    return this.on(event, listener);
+  }
+  once(event, listener) {
+    super.once(event, listener);
+    if (event === "message" && !this._started) {
+      this.start();
+    }
+    return this;
+  }
+}
+export {
+  MessagePort
+};

package/lib/esm/worker.js

@@ -0,0 +1,315 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { EventEmitter } from "node:events";
+let _nextThreadId = 1;
+const _encoder = new TextEncoder();
+const BOOTSTRAP_CODE = `import GLib from 'gi://GLib';
+import Gio from 'gi://Gio';
+
+const loop = new GLib.MainLoop(null, false);
+const stdinStream = Gio.UnixInputStream.new(0, false);
+const dataIn = Gio.DataInputStream.new(stdinStream);
+const stdoutStream = Gio.UnixOutputStream.new(1, false);
+
+function send(obj) {
+  const line = JSON.stringify(obj) + '\\n';
+  stdoutStream.write_all(_encoder.encode(line), null);
+}
+
+// Read init data (first line, blocking)
+const [initLine] = dataIn.read_line_utf8(null);
+const init = JSON.parse(initLine);
+
+// Simplified EventEmitter for parentPort
+const _listeners = new Map();
+const parentPort = {
+  on(ev, fn) {
+    if (!_listeners.has(ev)) _listeners.set(ev, []);
+    _listeners.get(ev).push(fn);
+    return this;
+  },
+  once(ev, fn) {
+    const w = (...a) => { parentPort.off(ev, w); fn(...a); };
+    return parentPort.on(ev, w);
+  },
+  off(ev, fn) {
+    const a = _listeners.get(ev);
+    if (a) _listeners.set(ev, a.filter(f => f !== fn));
+    return this;
+  },
+  emit(ev, ...a) { (_listeners.get(ev) || []).forEach(fn => fn(...a)); },
+  postMessage(data) { send({ type: 'message', data }); },
+  close() { send({ type: 'exit', code: 0 }); loop.quit(); },
+  removeAllListeners(ev) {
+    if (ev) _listeners.delete(ev); else _listeners.clear();
+    return this;
+  },
+};
+
+// Set worker context globals (read by @gjsify/worker_threads when imported by user script)
+globalThis.__gjsify_worker_context = {
+  isMainThread: false,
+  parentPort,
+  workerData: init.workerData ?? null,
+  threadId: init.threadId ?? 0,
+};
+
+send({ type: 'online' });
+
+// Async stdin reader for messages from parent
+function readNext() {
+  dataIn.read_line_async(GLib.PRIORITY_DEFAULT, null, (source, result) => {
+    try {
+      const [line] = source.read_line_finish_utf8(result);
+      if (line === null) { loop.quit(); return; }
+      const msg = JSON.parse(line);
+      if (msg.type === 'message') parentPort.emit('message', msg.data);
+      else if (msg.type === 'terminate') { send({ type: 'exit', code: 1 }); loop.quit(); return; }
+      readNext();
+    } catch { loop.quit(); }
+  });
+}
+readNext();
+
+// Execute worker code
+try {
+  if (init.eval) {
+    const AsyncFn = Object.getPrototypeOf(async function(){}).constructor;
+    await new AsyncFn('parentPort', 'workerData', 'threadId', init.code)(
+      parentPort, init.workerData, init.threadId
+    );
+  } else {
+    await import(init.filename);
+  }
+} catch (error) {
+  send({ type: 'error', message: error.message, stack: error.stack || '' });
+}
+
+loop.run();
+`;
+const BOOTSTRAP_BYTES = _encoder.encode(BOOTSTRAP_CODE);
+class Worker extends EventEmitter {
+  threadId;
+  resourceLimits;
+  _subprocess = null;
+  _stdinPipe = null;
+  _exited = false;
+  _bootstrapFile = null;
+  constructor(filename, options) {
+    super();
+    this.threadId = _nextThreadId++;
+    this.resourceLimits = options?.resourceLimits || {};
+    const isEval = options?.eval === true;
+    const resolvedFilename = Worker._resolveFilename(filename, isEval);
+    const tmpDir = GLib.get_tmp_dir();
+    const bootstrapPath = `${tmpDir}/gjsify-worker-${this.threadId}-${Date.now()}.mjs`;
+    this._bootstrapFile = Gio.File.new_for_path(bootstrapPath);
+    try {
+      this._bootstrapFile.replace_contents(
+        BOOTSTRAP_BYTES,
+        null,
+        false,
+        Gio.FileCreateFlags.REPLACE_DESTINATION,
+        null
+      );
+    } catch (err) {
+      throw new Error(`Failed to create worker bootstrap: ${err instanceof Error ? err.message : err}`);
+    }
+    const launcher = new Gio.SubprocessLauncher({
+      flags: Gio.SubprocessFlags.STDIN_PIPE | Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE
+    });
+    if (options?.env && typeof options.env === "object") {
+      for (const [key, value] of Object.entries(options.env)) {
+        launcher.setenv(key, String(value), true);
+      }
+    }
+    try {
+      this._subprocess = launcher.spawnv(["gjs", "-m", bootstrapPath]);
+    } catch (err) {
+      this._cleanup();
+      throw new Error(`Failed to spawn worker: ${err instanceof Error ? err.message : err}`);
+    }
+    this._stdinPipe = this._subprocess.get_stdin_pipe();
+    const stdoutPipe = this._subprocess.get_stdout_pipe();
+    if (!isEval) {
+      const filePath = resolvedFilename.startsWith("file://") ? resolvedFilename.slice(7) : resolvedFilename;
+      const file = Gio.File.new_for_path(filePath);
+      if (!file.query_exists(null)) {
+        this._cleanup();
+        const err = new Error(`Cannot find module '${filePath}'`);
+        err.code = "ERR_MODULE_NOT_FOUND";
+        Promise.resolve().then(() => {
+          this.emit("error", err);
+          this._exited = true;
+          this.emit("exit", 1);
+        });
+        return;
+      }
+    }
+    const initData = JSON.stringify({
+      threadId: this.threadId,
+      workerData: options?.workerData ?? null,
+      eval: isEval,
+      filename: isEval ? void 0 : resolvedFilename,
+      code: isEval ? resolvedFilename : void 0
+    }) + "\n";
+    try {
+      this._stdinPipe.write_all(_encoder.encode(initData), null);
+    } catch (err) {
+      this._cleanup();
+      throw new Error(`Failed to send init data: ${err instanceof Error ? err.message : err}`);
+    }
+    if (stdoutPipe) {
+      const dataStream = Gio.DataInputStream.new(stdoutPipe);
+      this._readMessages(dataStream);
+    }
+    const stderrPipe = this._subprocess.get_stderr_pipe();
+    if (stderrPipe) {
+      this._readStderr(Gio.DataInputStream.new(stderrPipe));
+    }
+    this._subprocess.wait_async(null, () => {
+      this._onExit();
+    });
+  }
+  postMessage(value, _transferList) {
+    if (this._exited || !this._stdinPipe) return;
+    try {
+      const line = JSON.stringify({ type: "message", data: value }) + "\n";
+      this._stdinPipe.write_all(_encoder.encode(line), null);
+    } catch {
+    }
+  }
+  terminate() {
+    if (this._exited) return Promise.resolve(0);
+    const exitPromise = new Promise((resolve) => {
+      this.once("exit", (code) => resolve(code));
+    });
+    try {
+      if (this._stdinPipe) {
+        const msg = JSON.stringify({ type: "terminate" }) + "\n";
+        this._stdinPipe.write_all(_encoder.encode(msg), null);
+      }
+    } catch {
+    }
+    setTimeout(() => {
+      if (!this._exited && this._subprocess) {
+        this._subprocess.force_exit();
+      }
+    }, 500);
+    return exitPromise;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  /**
+   * Resolve a worker filename to an absolute path or file:// URL.
+   *
+   * - URL instances → href string
+   * - file:// URLs → kept as-is
+   * - Absolute paths → converted to file:// URL
+   * - Relative paths (./foo, ../bar) → resolved relative to cwd, converted to file:// URL
+   * - eval mode → returned as-is (it's code, not a path)
+   */
+  static _resolveFilename(filename, isEval) {
+    if (isEval) return String(filename);
+    if (filename instanceof URL) return filename.href;
+    const str = String(filename);
+    if (str.startsWith("file://") || str.startsWith("http://") || str.startsWith("https://")) {
+      return str;
+    }
+    if (str.startsWith("/")) {
+      return "file://" + str;
+    }
+    if (str.startsWith("./") || str.startsWith("../") || !str.includes("/")) {
+      const cwd = GLib.get_current_dir();
+      const resolved = GLib.build_filenamev([cwd, str]);
+      const file = Gio.File.new_for_path(resolved);
+      const canonical = file.get_path();
+      return "file://" + (canonical || resolved);
+    }
+    return "file://" + str;
+  }
+  _readMessages(dataStream) {
+    dataStream.read_line_async(
+      GLib.PRIORITY_DEFAULT,
+      null,
+      (_source, result) => {
+        try {
+          const [line] = dataStream.read_line_finish_utf8(result);
+          if (line === null) return;
+          const msg = JSON.parse(line);
+          switch (msg.type) {
+            case "online":
+              this.emit("online");
+              break;
+            case "message":
+              this.emit("message", msg.data);
+              break;
+            case "error": {
+              const err = new Error(msg.message);
+              if (msg.stack) err.stack = msg.stack;
+              this.emit("error", err);
+              break;
+            }
+          }
+          this._readMessages(dataStream);
+        } catch {
+        }
+      }
+    );
+  }
+  _stderrChunks = [];
+  _readStderr(dataStream) {
+    dataStream.read_line_async(
+      GLib.PRIORITY_DEFAULT,
+      null,
+      (_source, result) => {
+        try {
+          const [line] = dataStream.read_line_finish_utf8(result);
+          if (line === null) {
+            if (this._stderrChunks.length > 0) {
+              const stderrText = this._stderrChunks.join("\n");
+              if (this.listenerCount("error") === 0) {
+                this.emit("error", new Error(stderrText));
+              }
+            }
+            return;
+          }
+          this._stderrChunks.push(line);
+          this._readStderr(dataStream);
+        } catch {
+        }
+      }
+    );
+  }
+  _onExit() {
+    if (this._exited) return;
+    this._exited = true;
+    const exitCode = this._subprocess?.get_if_exited() ? this._subprocess.get_exit_status() : 1;
+    this._cleanup();
+    this.emit("exit", exitCode);
+  }
+  _cleanup() {
+    if (this._bootstrapFile) {
+      try {
+        this._bootstrapFile.delete(null);
+      } catch {
+      }
+      this._bootstrapFile = null;
+    }
+    if (this._stdinPipe) {
+      try {
+        this._stdinPipe.close(null);
+      } catch {
+      }
+      this._stdinPipe = null;
+    }
+    this._subprocess = null;
+  }
+}
+export {
+  Worker
+};

package/lib/types/index.d.ts

@@ -0,0 +1,59 @@
+export { MessagePort } from './message-port.ts';
+export { Worker } from './worker.ts';
+export type { WorkerOptions } from './worker.ts';
+import { MessagePort } from './message-port.ts';
+import { Worker } from './worker.ts';
+export declare const isMainThread: boolean;
+export declare const parentPort: MessagePort | null;
+export declare const workerData: unknown;
+export declare const threadId: number;
+export declare const resourceLimits: Record<string, unknown>;
+export declare const SHARE_ENV: unique symbol;
+export declare class MessageChannel {
+    readonly port1: MessagePort;
+    readonly port2: MessagePort;
+    constructor();
+}
+export declare class BroadcastChannel {
+    readonly name: string;
+    private _closed;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onmessageerror: ((event: {
+        data: unknown;
+    }) => void) | null;
+    constructor(name: string);
+    postMessage(message: unknown): void;
+    close(): void;
+    addEventListener(type: string, listener: ((event: unknown) => void) | null): void;
+    removeEventListener(type: string, _listener: ((event: unknown) => void) | null): void;
+    dispatchEvent(_event: Event): boolean;
+}
+export declare function setEnvironmentData(key: string, value: unknown): void;
+export declare function getEnvironmentData(key: string): unknown;
+export declare function receiveMessageOnPort(port: MessagePort): {
+    message: unknown;
+} | undefined;
+export declare function markAsUntransferable(_object: unknown): void;
+export declare function markAsUncloneable(_object: unknown): void;
+export declare function moveMessagePortToContext(port: MessagePort, _context: unknown): MessagePort;
+declare const _default: {
+    isMainThread: boolean;
+    parentPort: MessagePort;
+    workerData: unknown;
+    threadId: number;
+    resourceLimits: Record<string, unknown>;
+    SHARE_ENV: symbol;
+    Worker: typeof Worker;
+    MessageChannel: typeof MessageChannel;
+    MessagePort: typeof MessagePort;
+    BroadcastChannel: typeof BroadcastChannel;
+    setEnvironmentData: typeof setEnvironmentData;
+    getEnvironmentData: typeof getEnvironmentData;
+    receiveMessageOnPort: typeof receiveMessageOnPort;
+    markAsUntransferable: typeof markAsUntransferable;
+    markAsUncloneable: typeof markAsUncloneable;
+    moveMessagePortToContext: typeof moveMessagePortToContext;
+};
+export default _default;

package/lib/types/message-port.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from 'node:events';
+export declare class MessagePort extends EventEmitter {
+    private _started;
+    private _closed;
+    private _messageQueue;
+    /** @internal Linked port for in-process communication */
+    _otherPort: MessagePort | null;
+    /** @internal Maps addEventListener listeners to their internal wrappers */
+    private _aeWrappers;
+    start(): void;
+    close(): void;
+    postMessage(value: unknown, _transferList?: unknown[]): void;
+    ref(): this;
+    unref(): this;
+    _receiveMessage(message: unknown): void;
+    get _hasQueuedMessages(): boolean;
+    _dequeueMessage(): unknown | undefined;
+    private _drainQueue;
+    private _dispatchMessage;
+    /**
+     * Web-compatible addEventListener. Wraps message data in a MessageEvent-like
+     * object `{ data, type }` before calling the listener.
+     * Requires explicit `port.start()` call (unlike `on('message')` which auto-starts).
+     */
+    addEventListener(type: string, listener: ((event: unknown) => void) | null): void;
+    removeEventListener(type: string, listener: ((event: unknown) => void) | null): void;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}