@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/cjs/components/worker-pool-component.cjs

@@ -0,0 +1,185 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var worker_pool_component_exports = {};
+__export(worker_pool_component_exports, {
+  MAX_DEFAULT_WORKER_POOL_SIZE: () => MAX_DEFAULT_WORKER_POOL_SIZE,
+  WorkerPoolComponent: () => WorkerPoolComponent,
+  getDefaultWorkerPoolSize: () => getDefaultWorkerPoolSize
+});
+module.exports = __toCommonJS(worker_pool_component_exports);
+var import_component_ex = require("./component-ex.cjs");
+var import_worker_component = require("./worker-component.cjs");
+const MAX_DEFAULT_WORKER_POOL_SIZE = 4;
+class WorkerPoolComponent extends import_component_ex.ComponentEx {
+  /**
+   * Creates the pool.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.params = params;
+    const size = params.size ?? getDefaultWorkerPoolSize();
+    if (!Number.isSafeInteger(size) || size < 1) {
+      throw new Error(`A worker pool needs a positive integer size, not ${String(size)}`);
+    }
+    for (let index = 0; index < size; index++) {
+      const workerParams = {
+        source: params.source,
+        ...params.fallbackHandlers !== void 0 && { fallbackHandlers: params.fallbackHandlers },
+        ...params.name !== void 0 && { name: `${params.name} ${String(index)}` }
+      };
+      this.workers.push(this.addChild(new import_worker_component.WorkerComponent(workerParams)));
+    }
+  }
+  params;
+  /**
+   * The number of workers.
+   *
+   * @returns The size.
+   */
+  get size() {
+    return this.workers.length;
+  }
+  workers = [];
+  /**
+   * 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.
+   */
+  async call(method, callArguments, options) {
+    let leastBusy = this.getWorker(0);
+    for (const worker of this.workers) {
+      if (worker.pendingCallCount < leastBusy.pendingCallCount) {
+        leastBusy = worker;
+      }
+    }
+    return await leastBusy.call(method, callArguments, options);
+  }
+  /**
+   * 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.
+   */
+  async callAll(method, callArguments, abortSignal) {
+    const options = abortSignal === void 0 ? {} : { abortSignal };
+    return await Promise.all(this.workers.map(async (worker) => await worker.call(method, callArguments, options)));
+  }
+  /**
+   * 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) {
+    const worker = this.workers[index];
+    if (!worker) {
+      throw new Error(`The worker pool has no worker at index ${String(index)}`);
+    }
+    return worker;
+  }
+}
+function getDefaultWorkerPoolSize(hardwareConcurrency) {
+  const processorCount = hardwareConcurrency ?? window.navigator.hardwareConcurrency;
+  return Math.max(1, Math.min(MAX_DEFAULT_WORKER_POOL_SIZE, processorCount - 1));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_DEFAULT_WORKER_POOL_SIZE,
+  WorkerPoolComponent,
+  getDefaultWorkerPoolSize
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/worker-pool-component.ts"],"sourcesContent":["/**\n * @file\n *\n * A component that owns several workers built from the same bundled source and spreads calls over them.\n */\n\nimport type {\n  WorkerApi,\n  WorkerApiHandlers\n} from '../worker-protocol.ts';\nimport type {\n  WorkerComponentCallOptions,\n  WorkerMethod,\n  WorkerMethodResult\n} from './worker-component.ts';\n\nimport { ComponentEx } from './component-ex.ts';\nimport { WorkerComponent } from './worker-component.ts';\n\n/**\n * The most workers {@link getDefaultWorkerPoolSize} suggests, so a pool on a many-core desktop does not starve\n * Obsidian's own renderer of memory.\n */\nexport const MAX_DEFAULT_WORKER_POOL_SIZE = 4;\n\n/**\n * Options of {@link WorkerPoolComponent.call}: the same as {@link WorkerComponent.call}'s.\n */\nexport type WorkerPoolComponentCallOptions = WorkerComponentCallOptions;\n\n/**\n * Parameters of {@link WorkerPoolComponent}.\n *\n * @typeParam TApi - The API every worker exposes.\n */\nexport interface WorkerPoolComponentConstructorParams<TApi extends WorkerApi<TApi>> {\n  /**\n   * The handlers to run on the main thread when no `Worker` can be created. See {@link WorkerComponent}.\n   */\n  readonly fallbackHandlers?: WorkerApiHandlers<TApi>;\n\n  /**\n   * The workers' name prefix, shown by the developer tools; each worker gets `<name> <index>`.\n   */\n  readonly name?: string;\n\n  /**\n   * The number of workers. Defaults to {@link getDefaultWorkerPoolSize}.\n   */\n  readonly size?: number;\n\n  /**\n   * The bundled worker source.\n   */\n  readonly source: string;\n}\n\n/**\n * Owns a fixed number of {@link WorkerComponent} children and sends each call to the one with the fewest pending calls.\n *\n * Use it for CPU-bound jobs that split into independent calls. A job that keeps state in a worker (a loaded corpus, an\n * instantiated module) addresses each worker by index through {@link WorkerPoolComponent.getWorker} instead.\n *\n * @typeParam TApi - The API every worker exposes.\n */\nexport class WorkerPoolComponent<TApi extends WorkerApi<TApi>> extends ComponentEx {\n  /**\n   * The number of workers.\n   *\n   * @returns The size.\n   */\n  public get size(): number {\n    return this.workers.length;\n  }\n\n  private readonly workers: WorkerComponent<TApi>[] = [];\n\n  /**\n   * Creates the pool.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(protected readonly params: WorkerPoolComponentConstructorParams<TApi>) {\n    super();\n    const size = params.size ?? getDefaultWorkerPoolSize();\n    if (!Number.isSafeInteger(size) || size < 1) {\n      throw new Error(`A worker pool needs a positive integer size, not ${String(size)}`);\n    }\n    for (let index = 0; index < size; index++) {\n      const workerParams = {\n        source: params.source,\n        ...(params.fallbackHandlers !== undefined && { fallbackHandlers: params.fallbackHandlers }),\n        ...(params.name !== undefined && { name: `${params.name} ${String(index)}` })\n      };\n      this.workers.push(this.addChild(new WorkerComponent<TApi>(workerParams)));\n    }\n  }\n\n  /**\n   * Calls a method on the least busy worker.\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.\n   */\n  public async call<TMethod extends WorkerMethod<TApi>>(\n    method: TMethod,\n    callArguments: Parameters<TApi[TMethod]>,\n    options?: WorkerPoolComponentCallOptions\n  ): Promise<WorkerMethodResult<TApi, TMethod>> {\n    let leastBusy = this.getWorker(0);\n    for (const worker of this.workers) {\n      if (worker.pendingCallCount < leastBusy.pendingCallCount) {\n        leastBusy = worker;\n      }\n    }\n    return await leastBusy.call(method, callArguments, options);\n  }\n\n  /**\n   * Calls a method on every worker with the same arguments, for instance to configure them all.\n   *\n   * @typeParam TMethod - The method.\n   * @param method - The method name.\n   * @param callArguments - The method's arguments, cloned for each worker; nothing can be transferred to all of them.\n   * @param abortSignal - Cancels every call.\n   * @returns The results, in worker order.\n   */\n  public async callAll<TMethod extends WorkerMethod<TApi>>(\n    method: TMethod,\n    callArguments: Parameters<TApi[TMethod]>,\n    abortSignal?: AbortSignal\n  ): Promise<WorkerMethodResult<TApi, TMethod>[]> {\n    const options: WorkerComponentCallOptions = abortSignal === undefined ? {} : { abortSignal };\n    return await Promise.all(this.workers.map(async (worker) => await worker.call(method, callArguments, options)));\n  }\n\n  /**\n   * Gets one worker, for jobs that keep state in a particular worker.\n   *\n   * @param index - The worker index, from `0` to {@link WorkerPoolComponent.size} minus one.\n   * @returns The worker.\n   */\n  public getWorker(index: number): WorkerComponent<TApi> {\n    const worker = this.workers[index];\n    if (!worker) {\n      throw new Error(`The worker pool has no worker at index ${String(index)}`);\n    }\n    return worker;\n  }\n}\n\n/**\n * Suggests a pool size: one fewer than the logical processors, so the main thread keeps one, between `1` and\n * {@link MAX_DEFAULT_WORKER_POOL_SIZE}.\n *\n * @param hardwareConcurrency - The number of logical processors. Defaults to `navigator.hardwareConcurrency`.\n * @returns The suggested size.\n */\nexport function getDefaultWorkerPoolSize(hardwareConcurrency?: number): number {\n  const processorCount = hardwareConcurrency ?? window.navigator.hardwareConcurrency;\n  return Math.max(1, Math.min(MAX_DEFAULT_WORKER_POOL_SIZE, processorCount - 1));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,0BAA4B;AAC5B,8BAAgC;AAMzB,MAAM,+BAA+B;AA0CrC,MAAM,4BAA0D,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiB1E,YAA+B,QAAoD;AACxF,UAAM;AAD8B;AAEpC,UAAM,OAAO,OAAO,QAAQ,yBAAyB;AACrD,QAAI,CAAC,OAAO,cAAc,IAAI,KAAK,OAAO,GAAG;AAC3C,YAAM,IAAI,MAAM,oDAAoD,OAAO,IAAI,CAAC,EAAE;AAAA,IACpF;AACA,aAAS,QAAQ,GAAG,QAAQ,MAAM,SAAS;AACzC,YAAM,eAAe;AAAA,QACnB,QAAQ,OAAO;AAAA,QACf,GAAI,OAAO,qBAAqB,UAAa,EAAE,kBAAkB,OAAO,iBAAiB;AAAA,QACzF,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,GAAG,OAAO,IAAI,IAAI,OAAO,KAAK,CAAC,GAAG;AAAA,MAC7E;AACA,WAAK,QAAQ,KAAK,KAAK,SAAS,IAAI,wCAAsB,YAAY,CAAC,CAAC;AAAA,IAC1E;AAAA,EACF;AAAA,EAdsC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAXtC,IAAW,OAAe;AACxB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEiB,UAAmC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgCrD,MAAa,KACX,QACA,eACA,SAC4C;AAC5C,QAAI,YAAY,KAAK,UAAU,CAAC;AAChC,eAAW,UAAU,KAAK,SAAS;AACjC,UAAI,OAAO,mBAAmB,UAAU,kBAAkB;AACxD,oBAAY;AAAA,MACd;AAAA,IACF;AACA,WAAO,MAAM,UAAU,KAAK,QAAQ,eAAe,OAAO;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAa,QACX,QACA,eACA,aAC8C;AAC9C,UAAM,UAAsC,gBAAgB,SAAY,CAAC,IAAI,EAAE,YAAY;AAC3F,WAAO,MAAM,QAAQ,IAAI,KAAK,QAAQ,IAAI,OAAO,WAAW,MAAM,OAAO,KAAK,QAAQ,eAAe,OAAO,CAAC,CAAC;AAAA,EAChH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,UAAU,OAAsC;AACrD,UAAM,SAAS,KAAK,QAAQ,KAAK;AACjC,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,MAAM,0CAA0C,OAAO,KAAK,CAAC,EAAE;AAAA,IAC3E;AACA,WAAO;AAAA,EACT;AACF;AASO,SAAS,yBAAyB,qBAAsC;AAC7E,QAAM,iBAAiB,uBAAuB,OAAO,UAAU;AAC/D,SAAO,KAAK,IAAI,GAAG,KAAK,IAAI,8BAA8B,iBAAiB,CAAC,CAAC;AAC/E;","names":[]}

package/dist/lib/cjs/components/worker-pool-component.d.cts

@@ -0,0 +1,102 @@
+/// <reference path="../library-references.d.cts" />
+/// <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.cjs';
+import type { WorkerComponentCallOptions, WorkerMethod, WorkerMethodResult } from './worker-component.cjs';
+import { ComponentEx } from './component-ex.cjs';
+import { WorkerComponent } from './worker-component.cjs';
+/**
+ * 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;