@scelar/nodepod 1.0.7 → 1.0.9

package/src/polyfills/worker_threads.ts

@@ -1,326 +1,326 @@
-// worker_threads polyfill using fork infrastructure for real Web Workers
-
-
-import { EventEmitter } from "./events";
-import { ref as eventLoopRef, unref as eventLoopUnref } from "../helpers/event-loop";
-
-// shared defaults for main thread; child workers get per-engine overrides via buildResolver
-export let isMainThread = true;
-export let parentPort: MessagePort | null = null;
-export let workerData: unknown = null;
-export let threadId = 0;
-
-// fork callback, set by process-worker-entry.ts
-
-export type WorkerThreadForkFn = (
-  modulePath: string,
-  opts: {
-    workerData: unknown;
-    threadId: number;
-    isEval?: boolean;
-    cwd: string;
-    env: Record<string, string>;
-    onMessage: (data: unknown) => void;
-    onError: (err: Error) => void;
-    onExit: (code: number) => void;
-    onStdout?: (data: string) => void;
-    onStderr?: (data: string) => void;
-  },
-) => {
-  postMessage: (data: unknown) => void;
-  terminate: () => void;
-  requestId: number;
-};
-
-let _workerThreadForkFn: WorkerThreadForkFn | null = null;
-
-export function setWorkerThreadForkCallback(fn: WorkerThreadForkFn): void {
-  _workerThreadForkFn = fn;
-}
-
-let _nextThreadId = 1;
-
-
-export interface MessagePort extends EventEmitter {
-  postMessage(_val: unknown, _transfer?: unknown[]): void;
-  start(): void;
-  close(): void;
-  ref(): void;
-  unref(): void;
-}
-
-interface MessagePortConstructor {
-  new (): MessagePort;
-  (this: any): void;
-  prototype: any;
-}
-
-export const MessagePort = function MessagePort(this: any) {
-  if (!this) return;
-  EventEmitter.call(this);
-} as unknown as MessagePortConstructor;
-
-Object.setPrototypeOf(MessagePort.prototype, EventEmitter.prototype);
-
-MessagePort.prototype.postMessage = function postMessage(_val: unknown, _transfer?: unknown[]): void {};
-MessagePort.prototype.start = function start(): void {};
-MessagePort.prototype.close = function close(): void {};
-MessagePort.prototype.ref = function ref(): void {};
-MessagePort.prototype.unref = function unref(): void {};
-
-
-export interface MessageChannel {
-  port1: MessagePort;
-  port2: MessagePort;
-}
-
-interface MessageChannelConstructor {
-  new (): MessageChannel;
-  (this: any): void;
-  prototype: any;
-}
-
-export const MessageChannel = function MessageChannel(this: any) {
-  if (!this) return;
-  this.port1 = new MessagePort();
-  this.port2 = new MessagePort();
-
-  // wire the two ports together
-  const p1 = this.port1;
-  const p2 = this.port2;
-  p1.postMessage = (val: unknown) => {
-    queueMicrotask(() => p2.emit("message", val));
-  };
-  p2.postMessage = (val: unknown) => {
-    queueMicrotask(() => p1.emit("message", val));
-  };
-} as unknown as MessageChannelConstructor;
-
-
-export interface Worker extends EventEmitter {
-  threadId: number;
-  resourceLimits: object;
-  _handle: ReturnType<WorkerThreadForkFn> | null;
-  _terminated: boolean;
-  _isReffed: boolean;
-  postMessage(value: unknown, _transferListOrOptions?: unknown): void;
-  terminate(): Promise<number>;
-  ref(): this;
-  unref(): this;
-  getHeapSnapshot(): Promise<unknown>;
-}
-
-interface WorkerConstructor {
-  new (
-    script: string | URL,
-    opts?: {
-      workerData?: unknown;
-      eval?: boolean;
-      env?: Record<string, string> | symbol;
-      argv?: string[];
-      execArgv?: string[];
-      resourceLimits?: Record<string, number>;
-      name?: string;
-      transferList?: unknown[];
-    },
-  ): Worker;
-  (this: any, script: string | URL, opts?: any): void;
-  prototype: any;
-}
-
-export const Worker = function Worker(
-  this: any,
-  script: string | URL,
-  opts?: {
-    workerData?: unknown;
-    eval?: boolean;
-    env?: Record<string, string> | symbol;
-    argv?: string[];
-    execArgv?: string[];
-    resourceLimits?: Record<string, number>;
-    name?: string;
-    transferList?: unknown[];
-  },
-) {
-  if (!this) return;
-  EventEmitter.call(this);
-
-  this.threadId = _nextThreadId++;
-  this.resourceLimits = {};
-  this._handle = null;
-  this._terminated = false;
-  this._isReffed = false;
-
-  const scriptStr = typeof script === "string" ? script : script.href;
-  const self = this;
-
-  if (!_workerThreadForkFn) {
-    // no fork callback wired
-    queueMicrotask(() => {
-      self.emit(
-        "error",
-        new Error(
-          "[Nodepod] worker_threads.Worker requires worker mode. " +
-            "Ensure the process is running in a worker context.",
-        ),
-      );
-    });
-    return;
-  }
-
-  const workerDataVal = opts?.workerData ?? null;
-  const isEval = !!opts?.eval;
-  const env =
-    opts?.env && typeof opts.env !== "symbol"
-      ? (opts.env as Record<string, string>)
-      : {};
-
-  const handle = _workerThreadForkFn(scriptStr, {
-    workerData: workerDataVal,
-    threadId: this.threadId,
-    isEval,
-    cwd: (globalThis as any).process?.cwd?.() ?? "/",
-    env,
-    onMessage: (data: unknown) => {
-      self.emit("message", data);
-    },
-    onError: (err: Error) => {
-      self.emit("error", err);
-    },
-    onExit: (code: number) => {
-      if (self._isReffed) {
-        self._isReffed = false;
-        eventLoopUnref();
-      }
-      self._terminated = true;
-      self.emit("exit", code);
-    },
-    onStdout: (data: string) => {
-        const sink = (globalThis as any).process?.stdout?.write;
-      if (typeof sink === "function") sink.call((globalThis as any).process.stdout, data);
-    },
-    onStderr: (data: string) => {
-      const sink = (globalThis as any).process?.stderr?.write;
-      if (typeof sink === "function") sink.call((globalThis as any).process.stderr, data);
-    },
-  });
-
-  this._handle = handle;
-
-  // keep parent alive while worker runs (Node.js default)
-  this._isReffed = true;
-  eventLoopRef();
-
-  queueMicrotask(() => {
-    if (!self._terminated) self.emit("online");
-  });
-} as unknown as WorkerConstructor;
-
-Object.setPrototypeOf(Worker.prototype, EventEmitter.prototype);
-
-Worker.prototype.postMessage = function postMessage(this: any, value: unknown, _transferListOrOptions?: unknown): void {
-  if (this._handle && !this._terminated) {
-    this._handle.postMessage(value);
-  }
-};
-
-Worker.prototype.terminate = function terminate(this: any): Promise<number> {
-  if (this._handle && !this._terminated) {
-    if (this._isReffed) {
-      this._isReffed = false;
-      eventLoopUnref();
-    }
-    this._terminated = true;
-    this._handle.terminate();
-  }
-  return Promise.resolve(0);
-};
-
-Worker.prototype.ref = function ref(this: any): any {
-  if (!this._isReffed && !this._terminated) {
-    this._isReffed = true;
-    eventLoopRef();
-  }
-  return this;
-};
-
-Worker.prototype.unref = function unref(this: any): any {
-  if (this._isReffed) {
-    this._isReffed = false;
-    eventLoopUnref();
-  }
-  return this;
-};
-
-Worker.prototype.getHeapSnapshot = function getHeapSnapshot(): Promise<unknown> {
-  return Promise.resolve({});
-};
-
-
-export interface BroadcastChannel extends EventEmitter {
-  name: string;
-  postMessage(_msg: unknown): void;
-  close(): void;
-  ref(): void;
-  unref(): void;
-}
-
-interface BroadcastChannelConstructor {
-  new (label: string): BroadcastChannel;
-  (this: any, label: string): void;
-  prototype: any;
-}
-
-export const BroadcastChannel = function BroadcastChannel(this: any, label: string) {
-  if (!this) return;
-  EventEmitter.call(this);
-  this.name = label;
-} as unknown as BroadcastChannelConstructor;
-
-Object.setPrototypeOf(BroadcastChannel.prototype, EventEmitter.prototype);
-
-BroadcastChannel.prototype.postMessage = function postMessage(_msg: unknown): void {};
-BroadcastChannel.prototype.close = function close(): void {};
-BroadcastChannel.prototype.ref = function ref(): void {};
-BroadcastChannel.prototype.unref = function unref(): void {};
-
-
-export function moveMessagePortToContext(
-  port: MessagePort,
-  _ctx: unknown,
-): MessagePort {
-  return port;
-}
-
-export function receiveMessageOnPort(
-  _port: MessagePort,
-): { message: unknown } | undefined {
-  return undefined;
-}
-
-export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");
-
-export function markAsUntransferable(_obj: unknown): void {}
-export function getEnvironmentData(_key: unknown): unknown {
-  return undefined;
-}
-export function setEnvironmentData(_key: unknown, _val: unknown): void {}
-
-
-export default {
-  isMainThread,
-  parentPort,
-  workerData,
-  threadId,
-  Worker,
-  MessageChannel,
-  MessagePort,
-  BroadcastChannel,
-  moveMessagePortToContext,
-  receiveMessageOnPort,
-  SHARE_ENV,
-  markAsUntransferable,
-  getEnvironmentData,
-  setEnvironmentData,
-  setWorkerThreadForkCallback,
-};
+// worker_threads polyfill using fork infrastructure for real Web Workers
+
+
+import { EventEmitter } from "./events";
+import { ref as eventLoopRef, unref as eventLoopUnref } from "../helpers/event-loop";
+
+// shared defaults for main thread; child workers get per-engine overrides via buildResolver
+export let isMainThread = true;
+export let parentPort: MessagePort | null = null;
+export let workerData: unknown = null;
+export let threadId = 0;
+
+// fork callback, set by process-worker-entry.ts
+
+export type WorkerThreadForkFn = (
+  modulePath: string,
+  opts: {
+    workerData: unknown;
+    threadId: number;
+    isEval?: boolean;
+    cwd: string;
+    env: Record<string, string>;
+    onMessage: (data: unknown) => void;
+    onError: (err: Error) => void;
+    onExit: (code: number) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+  },
+) => {
+  postMessage: (data: unknown) => void;
+  terminate: () => void;
+  requestId: number;
+};
+
+let _workerThreadForkFn: WorkerThreadForkFn | null = null;
+
+export function setWorkerThreadForkCallback(fn: WorkerThreadForkFn): void {
+  _workerThreadForkFn = fn;
+}
+
+let _nextThreadId = 1;
+
+
+export interface MessagePort extends EventEmitter {
+  postMessage(_val: unknown, _transfer?: unknown[]): void;
+  start(): void;
+  close(): void;
+  ref(): void;
+  unref(): void;
+}
+
+interface MessagePortConstructor {
+  new (): MessagePort;
+  (this: any): void;
+  prototype: any;
+}
+
+export const MessagePort = function MessagePort(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as MessagePortConstructor;
+
+Object.setPrototypeOf(MessagePort.prototype, EventEmitter.prototype);
+
+MessagePort.prototype.postMessage = function postMessage(_val: unknown, _transfer?: unknown[]): void {};
+MessagePort.prototype.start = function start(): void {};
+MessagePort.prototype.close = function close(): void {};
+MessagePort.prototype.ref = function ref(): void {};
+MessagePort.prototype.unref = function unref(): void {};
+
+
+export interface MessageChannel {
+  port1: MessagePort;
+  port2: MessagePort;
+}
+
+interface MessageChannelConstructor {
+  new (): MessageChannel;
+  (this: any): void;
+  prototype: any;
+}
+
+export const MessageChannel = function MessageChannel(this: any) {
+  if (!this) return;
+  this.port1 = new MessagePort();
+  this.port2 = new MessagePort();
+
+  // wire the two ports together
+  const p1 = this.port1;
+  const p2 = this.port2;
+  p1.postMessage = (val: unknown) => {
+    queueMicrotask(() => p2.emit("message", val));
+  };
+  p2.postMessage = (val: unknown) => {
+    queueMicrotask(() => p1.emit("message", val));
+  };
+} as unknown as MessageChannelConstructor;
+
+
+export interface Worker extends EventEmitter {
+  threadId: number;
+  resourceLimits: object;
+  _handle: ReturnType<WorkerThreadForkFn> | null;
+  _terminated: boolean;
+  _isReffed: boolean;
+  postMessage(value: unknown, _transferListOrOptions?: unknown): void;
+  terminate(): Promise<number>;
+  ref(): this;
+  unref(): this;
+  getHeapSnapshot(): Promise<unknown>;
+}
+
+interface WorkerConstructor {
+  new (
+    script: string | URL,
+    opts?: {
+      workerData?: unknown;
+      eval?: boolean;
+      env?: Record<string, string> | symbol;
+      argv?: string[];
+      execArgv?: string[];
+      resourceLimits?: Record<string, number>;
+      name?: string;
+      transferList?: unknown[];
+    },
+  ): Worker;
+  (this: any, script: string | URL, opts?: any): void;
+  prototype: any;
+}
+
+export const Worker = function Worker(
+  this: any,
+  script: string | URL,
+  opts?: {
+    workerData?: unknown;
+    eval?: boolean;
+    env?: Record<string, string> | symbol;
+    argv?: string[];
+    execArgv?: string[];
+    resourceLimits?: Record<string, number>;
+    name?: string;
+    transferList?: unknown[];
+  },
+) {
+  if (!this) return;
+  EventEmitter.call(this);
+
+  this.threadId = _nextThreadId++;
+  this.resourceLimits = {};
+  this._handle = null;
+  this._terminated = false;
+  this._isReffed = false;
+
+  const scriptStr = typeof script === "string" ? script : script.href;
+  const self = this;
+
+  if (!_workerThreadForkFn) {
+    // no fork callback wired
+    queueMicrotask(() => {
+      self.emit(
+        "error",
+        new Error(
+          "[Nodepod] worker_threads.Worker requires worker mode. " +
+            "Ensure the process is running in a worker context.",
+        ),
+      );
+    });
+    return;
+  }
+
+  const workerDataVal = opts?.workerData ?? null;
+  const isEval = !!opts?.eval;
+  const env =
+    opts?.env && typeof opts.env !== "symbol"
+      ? (opts.env as Record<string, string>)
+      : {};
+
+  const handle = _workerThreadForkFn(scriptStr, {
+    workerData: workerDataVal,
+    threadId: this.threadId,
+    isEval,
+    cwd: (globalThis as any).process?.cwd?.() ?? "/",
+    env,
+    onMessage: (data: unknown) => {
+      self.emit("message", data);
+    },
+    onError: (err: Error) => {
+      self.emit("error", err);
+    },
+    onExit: (code: number) => {
+      if (self._isReffed) {
+        self._isReffed = false;
+        eventLoopUnref();
+      }
+      self._terminated = true;
+      self.emit("exit", code);
+    },
+    onStdout: (data: string) => {
+        const sink = (globalThis as any).process?.stdout?.write;
+      if (typeof sink === "function") sink.call((globalThis as any).process.stdout, data);
+    },
+    onStderr: (data: string) => {
+      const sink = (globalThis as any).process?.stderr?.write;
+      if (typeof sink === "function") sink.call((globalThis as any).process.stderr, data);
+    },
+  });
+
+  this._handle = handle;
+
+  // keep parent alive while worker runs (Node.js default)
+  this._isReffed = true;
+  eventLoopRef();
+
+  queueMicrotask(() => {
+    if (!self._terminated) self.emit("online");
+  });
+} as unknown as WorkerConstructor;
+
+Object.setPrototypeOf(Worker.prototype, EventEmitter.prototype);
+
+Worker.prototype.postMessage = function postMessage(this: any, value: unknown, _transferListOrOptions?: unknown): void {
+  if (this._handle && !this._terminated) {
+    this._handle.postMessage(value);
+  }
+};
+
+Worker.prototype.terminate = function terminate(this: any): Promise<number> {
+  if (this._handle && !this._terminated) {
+    if (this._isReffed) {
+      this._isReffed = false;
+      eventLoopUnref();
+    }
+    this._terminated = true;
+    this._handle.terminate();
+  }
+  return Promise.resolve(0);
+};
+
+Worker.prototype.ref = function ref(this: any): any {
+  if (!this._isReffed && !this._terminated) {
+    this._isReffed = true;
+    eventLoopRef();
+  }
+  return this;
+};
+
+Worker.prototype.unref = function unref(this: any): any {
+  if (this._isReffed) {
+    this._isReffed = false;
+    eventLoopUnref();
+  }
+  return this;
+};
+
+Worker.prototype.getHeapSnapshot = function getHeapSnapshot(): Promise<unknown> {
+  return Promise.resolve({});
+};
+
+
+export interface BroadcastChannel extends EventEmitter {
+  name: string;
+  postMessage(_msg: unknown): void;
+  close(): void;
+  ref(): void;
+  unref(): void;
+}
+
+interface BroadcastChannelConstructor {
+  new (label: string): BroadcastChannel;
+  (this: any, label: string): void;
+  prototype: any;
+}
+
+export const BroadcastChannel = function BroadcastChannel(this: any, label: string) {
+  if (!this) return;
+  EventEmitter.call(this);
+  this.name = label;
+} as unknown as BroadcastChannelConstructor;
+
+Object.setPrototypeOf(BroadcastChannel.prototype, EventEmitter.prototype);
+
+BroadcastChannel.prototype.postMessage = function postMessage(_msg: unknown): void {};
+BroadcastChannel.prototype.close = function close(): void {};
+BroadcastChannel.prototype.ref = function ref(): void {};
+BroadcastChannel.prototype.unref = function unref(): void {};
+
+
+export function moveMessagePortToContext(
+  port: MessagePort,
+  _ctx: unknown,
+): MessagePort {
+  return port;
+}
+
+export function receiveMessageOnPort(
+  _port: MessagePort,
+): { message: unknown } | undefined {
+  return undefined;
+}
+
+export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");
+
+export function markAsUntransferable(_obj: unknown): void {}
+export function getEnvironmentData(_key: unknown): unknown {
+  return undefined;
+}
+export function setEnvironmentData(_key: unknown, _val: unknown): void {}
+
+
+export default {
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  Worker,
+  MessageChannel,
+  MessagePort,
+  BroadcastChannel,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  SHARE_ENV,
+  markAsUntransferable,
+  getEnvironmentData,
+  setEnvironmentData,
+  setWorkerThreadForkCallback,
+};