@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

package/dist/lib/esm/components/worker-component.d.mts

@@ -0,0 +1,156 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * A component that owns one browser `Worker` built from bundled source and calls it through a typed request/response
+ * channel.
+ */
+import type { SerializedWorkerError, WorkerApi, WorkerApiHandlers } from '../worker-protocol.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Options of {@link WorkerComponent.call}.
+ */
+export interface WorkerComponentCallOptions {
+    /**
+     * Cancels the call. The returned promise rejects with the signal's reason at once, and the worker's handler sees its
+     * own `this.abortSignal` aborted; whatever it answers afterwards is dropped.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * Objects inside the arguments to transfer rather than copy. They are unusable on the main thread afterwards.
+     */
+    readonly transfer?: readonly Transferable[];
+}
+/**
+ * Parameters of {@link WorkerComponent}.
+ *
+ * @typeParam TApi - The API the worker exposes.
+ */
+export interface WorkerComponentConstructorParams<TApi extends WorkerApi<TApi>> {
+    /**
+     * The same handlers the worker exposes, run on the main thread when no `Worker` can be created. Without them, a
+     * failure to create the worker fails the component's load.
+     */
+    readonly fallbackHandlers?: WorkerApiHandlers<TApi>;
+    /**
+     * The worker's name, shown by the developer tools.
+     */
+    readonly name?: string;
+    /**
+     * The bundled worker source: the string a `*.worker.ts?worker-source` import gives with
+     * `@mnaoumov/obsidian-dev-toolkit`'s `workers` feature.
+     */
+    readonly source: string;
+}
+/**
+ * The method names of a {@link WorkerApi}.
+ *
+ * @typeParam TApi - The API type.
+ */
+export type WorkerMethod<TApi> = Extract<keyof TApi, string>;
+/**
+ * The resolved result type of a worker method.
+ *
+ * @typeParam TApi - The API type.
+ * @typeParam TMethod - The method.
+ */
+export type WorkerMethodResult<TApi extends WorkerApi<TApi>, TMethod extends WorkerMethod<TApi>> = Awaited<ReturnType<TApi[TMethod]>>;
+/**
+ * The error a call rejects with when the worker's handler failed. It carries the worker-side name, message and stack,
+ * because an `Error` loses its class across the worker boundary.
+ */
+export declare class WorkerCallError extends Error {
+    /**
+     * The name of the error thrown in the worker.
+     */
+    readonly remoteName: string;
+    /**
+     * The stack of the error thrown in the worker, when there was one.
+     */
+    readonly remoteStack: string | undefined;
+    /**
+     * Creates the error.
+     *
+     * @param error - The serialized worker-side error.
+     */
+    constructor(error: SerializedWorkerError);
+}
+/**
+ * Owns one `Worker` for the component's lifetime.
+ *
+ * On load it turns the bundled source into a Blob URL and starts the worker; on unload it terminates the worker,
+ * revokes the URL and rejects every pending call. Add it as a child of the plugin (or of any component), so the worker
+ * never outlives what uses it.
+ *
+ * The worker entry point calls `exposeWorkerApi` from `@mnaoumov/obsidian-lib/worker-protocol`, and
+ * {@link WorkerComponent.call} reaches its handlers by name, typed by `TApi`.
+ *
+ * @typeParam TApi - The API the worker exposes.
+ */
+export declare class WorkerComponent<TApi extends WorkerApi<TApi>> extends ComponentEx {
+    /**
+     * Whether calls run on the main thread, because no `Worker` could be created and fallback handlers were given.
+     *
+     * @returns Whether the fallback is in use.
+     */
+    get isUsingFallback(): boolean;
+    /**
+     * The number of calls that have not settled yet.
+     *
+     * @returns The count.
+     */
+    get pendingCallCount(): number;
+    /**
+     * The handlers to run on the main thread when no `Worker` can be created, or `null`.
+     */
+    protected readonly fallbackHandlers: null | WorkerApiHandlers<TApi>;
+    /**
+     * The worker's name, or `null`.
+     */
+    protected readonly name: null | string;
+    /**
+     * The bundled worker source.
+     */
+    protected readonly source: string;
+    private _pendingCallCount;
+    private activeFallbackHandlers;
+    private lastCallId;
+    private readonly pendingCalls;
+    private worker;
+    private workerUrl;
+    /**
+     * Creates the component.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: WorkerComponentConstructorParams<TApi>);
+    /**
+     * Calls a worker method.
+     *
+     * @typeParam TMethod - The method.
+     * @param method - The method name.
+     * @param callArguments - The method's arguments.
+     * @param options - The call options.
+     * @returns The method's result. Rejects with a {@link WorkerCallError} when the handler failed, with the abort reason
+     *   when the call was cancelled, and with an `Error` when the worker failed or the component unloaded first.
+     */
+    call<TMethod extends WorkerMethod<TApi>>(method: TMethod, callArguments: Parameters<TApi[TMethod]>, options?: WorkerComponentCallOptions): Promise<WorkerMethodResult<TApi, TMethod>>;
+    /**
+     * Starts the worker.
+     */
+    onload(): void;
+    /**
+     * Terminates the worker and rejects the pending calls.
+     */
+    onunload(): void;
+    private callWorker;
+    private readonly handleError;
+    private readonly handleMessage;
+    private readonly handleMessageError;
+    private rejectAll;
+    private revokeWorkerUrl;
+    private startWorker;
+    private stopWorker;
+    private terminateWorker;
+}

package/dist/lib/esm/components/worker-component.mjs

@@ -0,0 +1,279 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  invokeWorkerHandler,
+  isWorkerResponseMessage,
+  unwrapTransferredValue,
+  WORKER_PROTOCOL
+} from "../worker-protocol.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class WorkerCallError extends Error {
+  /**
+   * The name of the error thrown in the worker.
+   */
+  remoteName;
+  /**
+   * The stack of the error thrown in the worker, when there was one.
+   */
+  remoteStack;
+  /**
+   * Creates the error.
+   *
+   * @param error - The serialized worker-side error.
+   */
+  constructor(error) {
+    super(error.message);
+    this.name = "WorkerCallError";
+    this.remoteName = error.name;
+    this.remoteStack = error.stack;
+  }
+}
+class WorkerComponent extends ComponentEx {
+  /**
+   * Whether calls run on the main thread, because no `Worker` could be created and fallback handlers were given.
+   *
+   * @returns Whether the fallback is in use.
+   */
+  get isUsingFallback() {
+    return this.activeFallbackHandlers !== null;
+  }
+  /**
+   * The number of calls that have not settled yet.
+   *
+   * @returns The count.
+   */
+  get pendingCallCount() {
+    return this._pendingCallCount;
+  }
+  /**
+   * The handlers to run on the main thread when no `Worker` can be created, or `null`.
+   */
+  fallbackHandlers;
+  /**
+   * The worker's name, or `null`.
+   */
+  name;
+  /**
+   * The bundled worker source.
+   */
+  source;
+  _pendingCallCount = 0;
+  activeFallbackHandlers = null;
+  lastCallId = 0;
+  pendingCalls = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- The renderer's Web Worker, not Node's.
+  worker = null;
+  workerUrl = null;
+  /**
+   * Creates the component.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.fallbackHandlers = params.fallbackHandlers ?? null;
+    this.name = params.name ?? null;
+    this.source = params.source;
+  }
+  /**
+   * Calls a worker method.
+   *
+   * @typeParam TMethod - The method.
+   * @param method - The method name.
+   * @param callArguments - The method's arguments.
+   * @param options - The call options.
+   * @returns The method's result. Rejects with a {@link WorkerCallError} when the handler failed, with the abort reason
+   *   when the call was cancelled, and with an `Error` when the worker failed or the component unloaded first.
+   */
+  async call(method, callArguments, options = {}) {
+    if (!this._loaded) {
+      throw new Error("The worker component is not loaded");
+    }
+    const abortSignal = options.abortSignal ?? new AbortController().signal;
+    abortSignal.throwIfAborted();
+    this._pendingCallCount++;
+    try {
+      const result = this.activeFallbackHandlers === null ? await this.callWorker(method, callArguments, abortSignal, options.transfer ?? []) : await callFallback(this.activeFallbackHandlers, method, callArguments, abortSignal);
+      return result;
+    } finally {
+      this._pendingCallCount--;
+    }
+  }
+  /**
+   * Starts the worker.
+   */
+  onload() {
+    super.onload();
+    try {
+      this.startWorker();
+    } catch (error) {
+      this.stopWorker();
+      if (this.fallbackHandlers === null) {
+        throw error;
+      }
+      this.activeFallbackHandlers = this.fallbackHandlers;
+    }
+  }
+  /**
+   * Terminates the worker and rejects the pending calls.
+   */
+  onunload() {
+    super.onunload();
+    this.stopWorker();
+    this.rejectAll(new Error("The worker component was unloaded"));
+    this.activeFallbackHandlers = null;
+  }
+  async callWorker(method, callArguments, abortSignal, transfer) {
+    const worker = ensureNonNullable(this.worker);
+    this.lastCallId++;
+    const id = this.lastCallId;
+    let onAbort = noop;
+    try {
+      return await new Promise((resolve, reject) => {
+        onAbort = () => {
+          if (!this.pendingCalls.delete(id)) {
+            return;
+          }
+          const cancelMessage = { id, kind: "cancel", protocol: WORKER_PROTOCOL };
+          worker.postMessage(cancelMessage);
+          reject(getAbortReason(abortSignal));
+        };
+        this.pendingCalls.set(id, { reject, resolve });
+        const callMessage = { arguments: callArguments, id, kind: "call", method, protocol: WORKER_PROTOCOL };
+        try {
+          worker.postMessage(callMessage, [...transfer]);
+        } catch (error) {
+          this.pendingCalls.delete(id);
+          reject(toError(error));
+          return;
+        }
+        abortSignal.addEventListener("abort", onAbort, { once: true });
+      });
+    } finally {
+      abortSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- The renderer's Web ErrorEvent, not Node's.
+  handleError = ($event) => {
+    $event.preventDefault();
+    this.rejectAll(new Error(`The worker failed: ${$event.message || "unknown error"}`));
+  };
+  handleMessage = ($event) => {
+    const message = $event.data;
+    if (!isWorkerResponseMessage(message)) {
+      return;
+    }
+    const pendingCall = this.pendingCalls.get(message.id);
+    if (!pendingCall) {
+      return;
+    }
+    this.pendingCalls.delete(message.id);
+    if (message.kind === "result") {
+      pendingCall.resolve(message.value);
+    } else {
+      pendingCall.reject(new WorkerCallError(message.error));
+    }
+  };
+  handleMessageError = () => {
+    this.rejectAll(new Error("The worker sent a message that could not be deserialized"));
+  };
+  rejectAll(reason) {
+    const pendingCalls = [...this.pendingCalls.values()];
+    this.pendingCalls.clear();
+    for (const pendingCall of pendingCalls) {
+      pendingCall.reject(reason);
+    }
+  }
+  revokeWorkerUrl() {
+    if (this.workerUrl === null) {
+      return;
+    }
+    window.URL.revokeObjectURL(this.workerUrl);
+    this.workerUrl = null;
+  }
+  startWorker() {
+    this.workerUrl = window.URL.createObjectURL(new Blob([this.source], { type: "text/javascript" }));
+    const workerOptions = this.name === null ? {} : { name: this.name };
+    const worker = new window.Worker(this.workerUrl, workerOptions);
+    this.worker = worker;
+    worker.addEventListener("message", this.handleMessage);
+    worker.addEventListener("messageerror", this.handleMessageError);
+    worker.addEventListener("error", this.handleError);
+  }
+  stopWorker() {
+    this.terminateWorker();
+    this.revokeWorkerUrl();
+  }
+  terminateWorker() {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.removeEventListener("message", this.handleMessage);
+    this.worker.removeEventListener("messageerror", this.handleMessageError);
+    this.worker.removeEventListener("error", this.handleError);
+    this.worker.terminate();
+    this.worker = null;
+  }
+}
+async function callFallback(handlers, method, callArguments, callerSignal) {
+  const abortController = new AbortController();
+  function onAbort() {
+    abortController.abort(callerSignal.reason);
+  }
+  callerSignal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const handlerPromise = invokeWorkerHandler(handlers, method, callArguments, { abortSignal: abortController.signal });
+    handlerPromise.catch(noop);
+    const abortPromise = new Promise((_resolve, reject) => {
+      abortController.signal.addEventListener("abort", () => {
+        reject(getAbortReason(abortController.signal));
+      }, { once: true });
+    });
+    return unwrapTransferredValue(await Promise.race([handlerPromise, abortPromise])).value;
+  } finally {
+    callerSignal.removeEventListener("abort", onAbort);
+  }
+}
+function getAbortReason(abortSignal) {
+  return toError(abortSignal.reason);
+}
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+export {
+  WorkerCallError,
+  WorkerComponent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/worker-component.ts"],"sourcesContent":["/**\n * @file\n *\n * A component that owns one browser `Worker` built from bundled source and calls it through a typed request/response\n * channel.\n */\n\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type {\n  SerializedWorkerError,\n  WorkerApi,\n  WorkerApiHandlers,\n  WorkerCallMessage,\n  WorkerCancelMessage\n} from '../worker-protocol.ts';\n\nimport {\n  invokeWorkerHandler,\n  isWorkerResponseMessage,\n  unwrapTransferredValue,\n  WORKER_PROTOCOL\n} from '../worker-protocol.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Options of {@link WorkerComponent.call}.\n */\nexport interface WorkerComponentCallOptions {\n  /**\n   * Cancels the call. The returned promise rejects with the signal's reason at once, and the worker's handler sees its\n   * own `this.abortSignal` aborted; whatever it answers afterwards is dropped.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Objects inside the arguments to transfer rather than copy. They are unusable on the main thread afterwards.\n   */\n  readonly transfer?: readonly Transferable[];\n}\n\n/**\n * Parameters of {@link WorkerComponent}.\n *\n * @typeParam TApi - The API the worker exposes.\n */\nexport interface WorkerComponentConstructorParams<TApi extends WorkerApi<TApi>> {\n  /**\n   * The same handlers the worker exposes, run on the main thread when no `Worker` can be created. Without them, a\n   * failure to create the worker fails the component's load.\n   */\n  readonly fallbackHandlers?: WorkerApiHandlers<TApi>;\n\n  /**\n   * The worker's name, shown by the developer tools.\n   */\n  readonly name?: string;\n\n  /**\n   * The bundled worker source: the string a `*.worker.ts?worker-source` import gives with\n   * `@mnaoumov/obsidian-dev-toolkit`'s `workers` feature.\n   */\n  readonly source: string;\n}\n\n/**\n * The method names of a {@link WorkerApi}.\n *\n * @typeParam TApi - The API type.\n */\nexport type WorkerMethod<TApi> = Extract<keyof TApi, string>;\n\n/**\n * The resolved result type of a worker method.\n *\n * @typeParam TApi - The API type.\n * @typeParam TMethod - The method.\n */\nexport type WorkerMethodResult<TApi extends WorkerApi<TApi>, TMethod extends WorkerMethod<TApi>> = Awaited<ReturnType<TApi[TMethod]>>;\n\ninterface PendingCall {\n  readonly reject: (reason: Error) => void;\n  readonly resolve: (value: unknown) => void;\n}\n\n/**\n * The error a call rejects with when the worker's handler failed. It carries the worker-side name, message and stack,\n * because an `Error` loses its class across the worker boundary.\n */\nexport class WorkerCallError extends Error {\n  /**\n   * The name of the error thrown in the worker.\n   */\n  public readonly remoteName: string;\n\n  /**\n   * The stack of the error thrown in the worker, when there was one.\n   */\n  public readonly remoteStack: string | undefined;\n\n  /**\n   * Creates the error.\n   *\n   * @param error - The serialized worker-side error.\n   */\n  public constructor(error: SerializedWorkerError) {\n    super(error.message);\n    this.name = 'WorkerCallError';\n    this.remoteName = error.name;\n    this.remoteStack = error.stack;\n  }\n}\n\n/**\n * Owns one `Worker` for the component's lifetime.\n *\n * On load it turns the bundled source into a Blob URL and starts the worker; on unload it terminates the worker,\n * revokes the URL and rejects every pending call. Add it as a child of the plugin (or of any component), so the worker\n * never outlives what uses it.\n *\n * The worker entry point calls `exposeWorkerApi` from `@mnaoumov/obsidian-lib/worker-protocol`, and\n * {@link WorkerComponent.call} reaches its handlers by name, typed by `TApi`.\n *\n * @typeParam TApi - The API the worker exposes.\n */\nexport class WorkerComponent<TApi extends WorkerApi<TApi>> extends ComponentEx {\n  /**\n   * Whether calls run on the main thread, because no `Worker` could be created and fallback handlers were given.\n   *\n   * @returns Whether the fallback is in use.\n   */\n  public get isUsingFallback(): boolean {\n    return this.activeFallbackHandlers !== null;\n  }\n\n  /**\n   * The number of calls that have not settled yet.\n   *\n   * @returns The count.\n   */\n  public get pendingCallCount(): number {\n    return this._pendingCallCount;\n  }\n\n  /**\n   * The handlers to run on the main thread when no `Worker` can be created, or `null`.\n   */\n  protected readonly fallbackHandlers: null | WorkerApiHandlers<TApi>;\n\n  /**\n   * The worker's name, or `null`.\n   */\n  protected readonly name: null | string;\n\n  /**\n   * The bundled worker source.\n   */\n  protected readonly source: string;\n\n  private _pendingCallCount = 0;\n  private activeFallbackHandlers: null | WorkerApiHandlers<TApi> = null;\n  private lastCallId = 0;\n  private readonly pendingCalls = new Map<number, PendingCall>();\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- The renderer's Web Worker, not Node's.\n  private worker: null | Worker = null;\n  private workerUrl: null | string = null;\n\n  /**\n   * Creates the component.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: WorkerComponentConstructorParams<TApi>) {\n    super();\n    this.fallbackHandlers = params.fallbackHandlers ?? null;\n    this.name = params.name ?? null;\n    this.source = params.source;\n  }\n\n  /**\n   * Calls a worker method.\n   *\n   * @typeParam TMethod - The method.\n   * @param method - The method name.\n   * @param callArguments - The method's arguments.\n   * @param options - The call options.\n   * @returns The method's result. Rejects with a {@link WorkerCallError} when the handler failed, with the abort reason\n   *   when the call was cancelled, and with an `Error` when the worker failed or the component unloaded first.\n   */\n  public async call<TMethod extends WorkerMethod<TApi>>(\n    method: TMethod,\n    callArguments: Parameters<TApi[TMethod]>,\n    options: WorkerComponentCallOptions = {}\n  ): Promise<WorkerMethodResult<TApi, TMethod>> {\n    if (!this._loaded) {\n      throw new Error('The worker component is not loaded');\n    }\n    const abortSignal = options.abortSignal ?? new AbortController().signal;\n    abortSignal.throwIfAborted();\n\n    this._pendingCallCount++;\n    try {\n      const result = this.activeFallbackHandlers === null\n        ? await this.callWorker(method, callArguments, abortSignal, options.transfer ?? [])\n        : await callFallback(this.activeFallbackHandlers, method, callArguments, abortSignal);\n      return result as WorkerMethodResult<TApi, TMethod>;\n    } finally {\n      this._pendingCallCount--;\n    }\n  }\n\n  /**\n   * Starts the worker.\n   */\n  public override onload(): void {\n    super.onload();\n    try {\n      this.startWorker();\n    } catch (error) {\n      this.stopWorker();\n      if (this.fallbackHandlers === null) {\n        throw error;\n      }\n      this.activeFallbackHandlers = this.fallbackHandlers;\n    }\n  }\n\n  /**\n   * Terminates the worker and rejects the pending calls.\n   */\n  public override onunload(): void {\n    super.onunload();\n    this.stopWorker();\n    this.rejectAll(new Error('The worker component was unloaded'));\n    this.activeFallbackHandlers = null;\n  }\n\n  private async callWorker(\n    method: string,\n    callArguments: readonly unknown[],\n    abortSignal: AbortSignal,\n    transfer: readonly Transferable[]\n  ): Promise<unknown> {\n    // A loaded component without fallback handlers in use always holds its worker.\n    const worker = ensureNonNullable(this.worker);\n\n    this.lastCallId++;\n    const id = this.lastCallId;\n    let onAbort = noop;\n\n    try {\n      return await new Promise<unknown>((resolve, reject) => {\n        onAbort = (): void => {\n          if (!this.pendingCalls.delete(id)) {\n            return;\n          }\n          const cancelMessage: WorkerCancelMessage = { id, kind: 'cancel', protocol: WORKER_PROTOCOL };\n          worker.postMessage(cancelMessage);\n          reject(getAbortReason(abortSignal));\n        };\n        this.pendingCalls.set(id, { reject, resolve });\n        const callMessage: WorkerCallMessage = { arguments: callArguments, id, kind: 'call', method, protocol: WORKER_PROTOCOL };\n        try {\n          worker.postMessage(callMessage, [...transfer]);\n        } catch (error) {\n          this.pendingCalls.delete(id);\n          reject(toError(error));\n          return;\n        }\n        abortSignal.addEventListener('abort', onAbort, { once: true });\n      });\n    } finally {\n      abortSignal.removeEventListener('abort', onAbort);\n    }\n  }\n\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- The renderer's Web ErrorEvent, not Node's.\n  private readonly handleError = ($event: ErrorEvent): void => {\n    $event.preventDefault();\n    this.rejectAll(new Error(`The worker failed: ${$event.message || 'unknown error'}`));\n  };\n\n  private readonly handleMessage = ($event: MessageEvent<unknown>): void => {\n    const message = $event.data;\n    if (!isWorkerResponseMessage(message)) {\n      return;\n    }\n    const pendingCall = this.pendingCalls.get(message.id);\n    if (!pendingCall) {\n      return;\n    }\n    this.pendingCalls.delete(message.id);\n    if (message.kind === 'result') {\n      pendingCall.resolve(message.value);\n    } else {\n      pendingCall.reject(new WorkerCallError(message.error));\n    }\n  };\n\n  private readonly handleMessageError = (): void => {\n    this.rejectAll(new Error('The worker sent a message that could not be deserialized'));\n  };\n\n  private rejectAll(reason: Error): void {\n    const pendingCalls = [...this.pendingCalls.values()];\n    this.pendingCalls.clear();\n    for (const pendingCall of pendingCalls) {\n      pendingCall.reject(reason);\n    }\n  }\n\n  private revokeWorkerUrl(): void {\n    if (this.workerUrl === null) {\n      return;\n    }\n    window.URL.revokeObjectURL(this.workerUrl);\n    this.workerUrl = null;\n  }\n\n  private startWorker(): void {\n    this.workerUrl = window.URL.createObjectURL(new Blob([this.source], { type: 'text/javascript' }));\n    const workerOptions: WorkerOptions = this.name === null ? {} : { name: this.name };\n    const worker = new window.Worker(this.workerUrl, workerOptions);\n    this.worker = worker;\n    worker.addEventListener('message', this.handleMessage);\n    worker.addEventListener('messageerror', this.handleMessageError);\n    worker.addEventListener('error', this.handleError);\n  }\n\n  private stopWorker(): void {\n    this.terminateWorker();\n    this.revokeWorkerUrl();\n  }\n\n  private terminateWorker(): void {\n    if (!this.worker) {\n      return;\n    }\n    this.worker.removeEventListener('message', this.handleMessage);\n    this.worker.removeEventListener('messageerror', this.handleMessageError);\n    this.worker.removeEventListener('error', this.handleError);\n    this.worker.terminate();\n    this.worker = null;\n  }\n}\n\nasync function callFallback(\n  handlers: object,\n  method: string,\n  callArguments: readonly unknown[],\n  callerSignal: AbortSignal\n): Promise<unknown> {\n  const abortController = new AbortController();\n  function onAbort(): void {\n    abortController.abort(callerSignal.reason);\n  }\n  callerSignal.addEventListener('abort', onAbort, { once: true });\n  try {\n    const handlerPromise = invokeWorkerHandler(handlers, method, callArguments, { abortSignal: abortController.signal });\n    // The race below may settle on the abort first; the handler's own later rejection is then nobody's to report.\n    handlerPromise.catch(noop);\n    const abortPromise = new Promise<never>((_resolve, reject) => {\n      abortController.signal.addEventListener('abort', () => {\n        reject(getAbortReason(abortController.signal));\n      }, { once: true });\n    });\n    return unwrapTransferredValue(await Promise.race([handlerPromise, abortPromise])).value;\n  } finally {\n    callerSignal.removeEventListener('abort', onAbort);\n  }\n}\n\nfunction getAbortReason(abortSignal: AbortSignal): Error {\n  return toError(abortSignal.reason);\n}\n\nfunction toError(reason: unknown): Error {\n  return reason instanceof Error ? reason : new Error(String(reason));\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/components/worker-pool-component.d.mts

@@ -0,0 +1,102 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * A component that owns several workers built from the same bundled source and spreads calls over them.
+ */
+import type { WorkerApi, WorkerApiHandlers } from '../worker-protocol.mjs';
+import type { WorkerComponentCallOptions, WorkerMethod, WorkerMethodResult } from './worker-component.mjs';
+import { ComponentEx } from './component-ex.mjs';
+import { WorkerComponent } from './worker-component.mjs';
+/**
+ * The most workers {@link getDefaultWorkerPoolSize} suggests, so a pool on a many-core desktop does not starve
+ * Obsidian's own renderer of memory.
+ */
+export declare const MAX_DEFAULT_WORKER_POOL_SIZE = 4;
+/**
+ * Options of {@link WorkerPoolComponent.call}: the same as {@link WorkerComponent.call}'s.
+ */
+export type WorkerPoolComponentCallOptions = WorkerComponentCallOptions;
+/**
+ * Parameters of {@link WorkerPoolComponent}.
+ *
+ * @typeParam TApi - The API every worker exposes.
+ */
+export interface WorkerPoolComponentConstructorParams<TApi extends WorkerApi<TApi>> {
+    /**
+     * The handlers to run on the main thread when no `Worker` can be created. See {@link WorkerComponent}.
+     */
+    readonly fallbackHandlers?: WorkerApiHandlers<TApi>;
+    /**
+     * The workers' name prefix, shown by the developer tools; each worker gets `<name> <index>`.
+     */
+    readonly name?: string;
+    /**
+     * The number of workers. Defaults to {@link getDefaultWorkerPoolSize}.
+     */
+    readonly size?: number;
+    /**
+     * The bundled worker source.
+     */
+    readonly source: string;
+}
+/**
+ * Owns a fixed number of {@link WorkerComponent} children and sends each call to the one with the fewest pending calls.
+ *
+ * Use it for CPU-bound jobs that split into independent calls. A job that keeps state in a worker (a loaded corpus, an
+ * instantiated module) addresses each worker by index through {@link WorkerPoolComponent.getWorker} instead.
+ *
+ * @typeParam TApi - The API every worker exposes.
+ */
+export declare class WorkerPoolComponent<TApi extends WorkerApi<TApi>> extends ComponentEx {
+    protected readonly params: WorkerPoolComponentConstructorParams<TApi>;
+    /**
+     * The number of workers.
+     *
+     * @returns The size.
+     */
+    get size(): number;
+    private readonly workers;
+    /**
+     * Creates the pool.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: WorkerPoolComponentConstructorParams<TApi>);
+    /**
+     * Calls a method on the least busy worker.
+     *
+     * @typeParam TMethod - The method.
+     * @param method - The method name.
+     * @param callArguments - The method's arguments.
+     * @param options - The call options.
+     * @returns The method's result.
+     */
+    call<TMethod extends WorkerMethod<TApi>>(method: TMethod, callArguments: Parameters<TApi[TMethod]>, options?: WorkerPoolComponentCallOptions): Promise<WorkerMethodResult<TApi, TMethod>>;
+    /**
+     * Calls a method on every worker with the same arguments, for instance to configure them all.
+     *
+     * @typeParam TMethod - The method.
+     * @param method - The method name.
+     * @param callArguments - The method's arguments, cloned for each worker; nothing can be transferred to all of them.
+     * @param abortSignal - Cancels every call.
+     * @returns The results, in worker order.
+     */
+    callAll<TMethod extends WorkerMethod<TApi>>(method: TMethod, callArguments: Parameters<TApi[TMethod]>, abortSignal?: AbortSignal): Promise<WorkerMethodResult<TApi, TMethod>[]>;
+    /**
+     * Gets one worker, for jobs that keep state in a particular worker.
+     *
+     * @param index - The worker index, from `0` to {@link WorkerPoolComponent.size} minus one.
+     * @returns The worker.
+     */
+    getWorker(index: number): WorkerComponent<TApi>;
+}
+/**
+ * Suggests a pool size: one fewer than the logical processors, so the main thread keeps one, between `1` and
+ * {@link MAX_DEFAULT_WORKER_POOL_SIZE}.
+ *
+ * @param hardwareConcurrency - The number of logical processors. Defaults to `navigator.hardwareConcurrency`.
+ * @returns The suggested size.
+ */
+export declare function getDefaultWorkerPoolSize(hardwareConcurrency?: number): number;