123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.// Copyright Joyent and Node contributors. All rights reserved. MIT license.
import { resolve, toFileUrl } from "../path/mod.ts";import { notImplemented } from "./_utils.ts";import { EventEmitter, once } from "./events.ts";
let environmentData = new Map();let threads = 0;
export interface WorkerOptions {  // only for typings  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");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) {    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,      {        ...(options || {}),        type: "module",        // unstable        deno: { namespace: true },      },    );    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;  // fake performance  readonly performance = globalThis.performance;}
export const isMainThread =  // deno-lint-ignore no-explicit-any  typeof (globalThis as any).DedicatedWorkerGlobalScope === "undefined" ||  // deno-lint-ignore no-explicit-any  self instanceof (globalThis as any).DedicatedWorkerGlobalScope === false;
// fake resourceLimitsexport const resourceLimits = isMainThread ? {} : {  maxYoungGenerationSizeMb: 48,  maxOldGenerationSizeMb: 2048,  codeRangeSizeMb: 0,  stackSizeMb: 4,};
let threadId = 0;let workerData: unknown = null;
// Like https://github.com/nodejs/node/blob/48655e17e1d84ba5021d7a94b4b88823f7c9c6cf/lib/internal/event_target.js#L611interface NodeEventTarget extends  Pick<    EventEmitter,    "eventNames" | "listenerCount" | "emit" | "removeAllListeners"  > {  setMaxListeners(n: number): void;  getMaxListeners(): number;  // deno-lint-ignore no-explicit-any  off(eventName: string, listener: (...args: any[]) => void): NodeEventTarget;  // deno-lint-ignore no-explicit-any  on(eventName: string, listener: (...args: any[]) => void): NodeEventTarget;  // deno-lint-ignore no-explicit-any  once(eventName: string, listener: (...args: any[]) => void): NodeEventTarget;  addListener: NodeEventTarget["on"];  removeListener: NodeEventTarget["off"];}
type ParentPort = typeof self & NodeEventTarget;
// deno-lint-ignore no-explicit-anylet parentPort: ParentPort = null as any;
if (!isMainThread) {  // deno-lint-ignore no-explicit-any  const listeners = new WeakMap<(...args: any[]) => void, (ev: any) => any>();
  parentPort = self as ParentPort;  parentPort.off = parentPort.removeListener = function (    this: ParentPort,    name,    listener,  ) {    this.removeEventListener(name, listeners.get(listener)!);    listeners.delete(listener);    return this;  };  parentPort.on = parentPort.addListener = function (    this: ParentPort,    name,    listener,  ) {    // deno-lint-ignore no-explicit-any    const _listener = (ev: any) => listener(ev.data);    listeners.set(listener, _listener);    this.addEventListener(name, _listener);    return this;  };  parentPort.once = function (this: ParentPort, name, listener) {    // deno-lint-ignore no-explicit-any    const _listener = (ev: any) => listener(ev.data);    listeners.set(listener, _listener);    this.addEventListener(name, _listener);    return this;  };
  // mocks  parentPort.setMaxListeners = () => {};  parentPort.getMaxListeners = () => Infinity;  parentPort.eventNames = () => [""];  parentPort.listenerCount = () => 0;
  parentPort.emit = () => notImplemented();  parentPort.removeAllListeners = () => notImplemented();
  // Receive startup message  [{ threadId, workerData, environmentData }] = await once(    parentPort,    "message",  );
  // alias  parentPort.addEventListener("offline", () => {    parentPort.emit("close");  });}
export function getEnvironmentData(key: unknown) {  return environmentData.get(key);}
export function setEnvironmentData(key: unknown, value?: unknown) {  if (value === undefined) {    environmentData.delete(key);  } else {    environmentData.set(key, value);  }}
// deno-lint-ignore no-explicit-anyconst _MessagePort: typeof MessagePort = (globalThis as any).MessagePort;const _MessageChannel: typeof MessageChannel =  // deno-lint-ignore no-explicit-any  (globalThis as any).MessageChannel;export const BroadcastChannel = globalThis.BroadcastChannel;export const SHARE_ENV = Symbol.for("nodejs.worker_threads.SHARE_ENV");export {  _MessageChannel as MessageChannel,  _MessagePort as MessagePort,  _Worker as Worker,  notImplemented as markAsUntransferable,  notImplemented as moveMessagePortToContext,  notImplemented as receiveMessageOnPort,  parentPort,  threadId,  workerData,};
export default {  markAsUntransferable: notImplemented,  moveMessagePortToContext: notImplemented,  receiveMessageOnPort: notImplemented,  MessagePort: _MessagePort,  MessageChannel: _MessageChannel,  BroadcastChannel,  Worker: _Worker,  getEnvironmentData,  setEnvironmentData,  SHARE_ENV,  threadId,  workerData,  resourceLimits,  parentPort,  isMainThread,};