import { resolve, toFileUrl } from "../path/mod.ts";import { notImplemented } from "./_utils.ts";import { EventEmitter } from "./events.ts";
const environmentData = new Map();let threads = 0;
export interface WorkerOptions { argv?: unknown[]; env?: Record<string, unknown>; execArgv?: string[]; stdin?: boolean; stdout?: boolean; stderr?: boolean; trackUnmanagedFds?: boolean; resourceLimits?: { maxYoungGenerationSizeMb?: number; maxOldGenerationSizeMb?: number; codeRangeSizeMb?: number; stackSizeMb?: number; };
eval?: boolean; transferList?: Transferable[]; workerData?: unknown;}
const kHandle = Symbol("kHandle");const PRIVATE_WORKER_THREAD_NAME = "$DENO_STD_NODE_WORKER_THREAD";class _Worker extends EventEmitter { readonly threadId: number; readonly resourceLimits: Required< NonNullable<WorkerOptions["resourceLimits"]> > = { maxYoungGenerationSizeMb: -1, maxOldGenerationSizeMb: -1, codeRangeSizeMb: -1, stackSizeMb: 4, }; private readonly [kHandle]: Worker;
postMessage: Worker["postMessage"];
constructor(specifier: URL | string, options?: WorkerOptions) { notImplemented("Worker"); super(); if (options?.eval === true) { specifier = `data:text/javascript,${specifier}`; } else if (typeof specifier === "string") { specifier = toFileUrl(resolve(specifier)); } const handle = this[kHandle] = new Worker( specifier, { name: PRIVATE_WORKER_THREAD_NAME, type: "module", } as globalThis.WorkerOptions, ); handle.addEventListener( "error", (event) => this.emit("error", event.error || event.message), ); handle.addEventListener( "messageerror", (event) => this.emit("messageerror", event.data), ); handle.addEventListener( "message", (event) => this.emit("message", event.data), ); handle.postMessage({ environmentData, threadId: (this.threadId = ++threads), workerData: options?.workerData, }, options?.transferList || []); this.postMessage = handle.postMessage.bind(handle); this.emit("online"); }
terminate() { this[kHandle].terminate(); this.emit("exit", 0); }
readonly getHeapSnapshot = () => notImplemented("Worker.prototype.getHeapSnapshot"); readonly performance = globalThis.performance;}
export const isMainThread = (globalThis as any).name !== PRIVATE_WORKER_THREAD_NAME;
export const resourceLimits = isMainThread ? {} : { maxYoungGenerationSizeMb: 48, maxOldGenerationSizeMb: 2048, codeRangeSizeMb: 0, stackSizeMb: 4,};
const threadId = 0;const workerData: unknown = null;
interface NodeEventTarget extends Pick< EventEmitter, "eventNames" | "listenerCount" | "emit" | "removeAllListeners" > { setMaxListeners(n: number): void; getMaxListeners(): number; off(eventName: string, listener: (...args: any[]) => void): NodeEventTarget; on(eventName: string, listener: (...args: any[]) => void): NodeEventTarget; once(eventName: string, listener: (...args: any[]) => void): NodeEventTarget; addListener: NodeEventTarget["on"]; removeListener: NodeEventTarget["off"];}
type ParentPort = typeof self & NodeEventTarget;
const parentPort: ParentPort = null as any;
export function getEnvironmentData(key: unknown) { notImplemented("getEnvironmentData"); return environmentData.get(key);}
export function setEnvironmentData(key: unknown, value?: unknown) { notImplemented("setEnvironmentData"); if (value === undefined) { environmentData.delete(key); } else { environmentData.set(key, value); }}
const _MessagePort: typeof MessagePort = (globalThis as any).MessagePort;const _MessageChannel: typeof MessageChannel = (globalThis as any).MessageChannel;export const BroadcastChannel = globalThis.BroadcastChannel;export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");export function markAsUntransferable() { notImplemented("markAsUntransferable");}export function moveMessagePortToContext() { notImplemented("moveMessagePortToContext");}export function receiveMessageOnPort() { notImplemented("receiveMessageOnPort");}export { _MessageChannel as MessageChannel, _MessagePort as MessagePort, _Worker as Worker, parentPort, threadId, workerData,};
export default { markAsUntransferable, moveMessagePortToContext, receiveMessageOnPort, MessagePort: _MessagePort, MessageChannel: _MessageChannel, BroadcastChannel, Worker: _Worker, getEnvironmentData, setEnvironmentData, SHARE_ENV, threadId, workerData, resourceLimits, parentPort, isMainThread,};