@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

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

@@ -0,0 +1,129 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * A pool that shares one loaded component per caller-defined key among several consumers, and unloads it when the
+ * last consumer releases it.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import { Component } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * One consumer's hold on a shared component.
+ *
+ * Releasing it is idempotent: the first call drops the hold, and every later call — including the one the consumer
+ * link makes when the consumer unloads — does nothing.
+ *
+ * @typeParam TComponent - The type of the shared component.
+ */
+export interface SharedComponentAcquisition<TComponent extends Component> extends DisposableEx {
+    /**
+     * The shared component, loaded. Every consumer of the same key receives the same instance.
+     */
+    readonly component: TComponent;
+    /**
+     * Whether this acquisition has been released.
+     */
+    readonly isReleased: boolean;
+    /**
+     * Releases this acquisition. The shared component is unloaded when its last acquisition is released.
+     */
+    readonly release: () => void;
+}
+/**
+ * Options of {@link SharedComponentPoolComponent.acquire}.
+ */
+export interface SharedComponentPoolComponentAcquireOptions {
+    /**
+     * Cancels the acquisition while the shared component is still loading. An abort after the acquisition resolved does
+     * nothing; release the acquisition instead.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * A component whose unload releases the acquisition automatically.
+     *
+     * The link is a child component added to the consumer, so it follows Obsidian's own rules: a consumer that is not
+     * loaded yet starts holding the link when it loads, and a {@link ComponentEx} consumer that is already unloaded
+     * refuses it with a {@link SilentError}. Releasing the acquisition by hand removes the link again, so a long-lived
+     * consumer that acquires and releases many times accumulates nothing.
+     */
+    readonly consumer?: Component;
+}
+/**
+ * Parameters of {@link SharedComponentPoolComponent}.
+ *
+ * @typeParam TKey - The type of the resource key.
+ * @typeParam TComponent - The type of the shared component.
+ */
+export interface SharedComponentPoolComponentConstructorParams<TKey, TComponent extends Component> {
+    /**
+     * Creates the component shared under a key. Called once per key each time the key goes from no consumer to one; the
+     * pool loads the component itself, so the factory must return it unloaded.
+     *
+     * @param key - The resource key.
+     * @returns The new, not yet loaded component.
+     */
+    readonly createComponent: (key: TKey) => TComponent;
+}
+/**
+ * Shares one loaded component per caller-defined key among several consumers.
+ *
+ * The first {@link acquire} of a key creates the component through the factory and loads it; every further acquire of
+ * the same key, concurrent or later, receives the same instance; the release of the last acquisition unloads it, and
+ * the next acquire creates a fresh one. A {@link ComponentEx} is loaded through {@link ComponentEx.loadWithPromises}, so
+ * an acquire resolves only once its `onloadAsync` and children have settled, and a failed load rejects every waiting
+ * acquire, unloads the component and leaves the key free for a fresh attempt.
+ *
+ * The pool is itself a component, and its parent is the owner of every shared instance: add it with `addChild` to the
+ * plugin (or any longer-lived component). Unloading the owner unloads every shared component still held, rejects
+ * every acquire still waiting with a {@link SilentError}, and refuses later acquires. Keys are compared the way a
+ * {@link Map} compares them, so two equal-looking object keys are two resources. The instances live on the pool
+ * object only, never in the shared-state bag, so two plugins — or two pools of one plugin — never share anything.
+ *
+ * Reach for it only when SEVERAL independent consumers want the same expensive component and none of them owns it.
+ * A component with a single owner is that owner's child: `addChild` is simpler and already unloads it with its owner.
+ *
+ * @typeParam TKey - The type of the resource key.
+ * @typeParam TComponent - The type of the shared component.
+ */
+export declare class SharedComponentPoolComponent<TKey, TComponent extends Component> extends ComponentEx {
+    /**
+     * Creates the component shared under a key; see {@link SharedComponentPoolComponentConstructorParams.createComponent}.
+     */
+    protected readonly createComponent: (key: TKey) => TComponent;
+    private readonly creatingKeys;
+    private readonly entries;
+    /**
+     * Creates a new pool.
+     *
+     * @param params - The pool parameters.
+     */
+    constructor(params: SharedComponentPoolComponentConstructorParams<TKey, TComponent>);
+    /**
+     * Acquires the component shared under a key, creating and loading it when the key has no consumer yet.
+     *
+     * @param key - The resource key.
+     * @param options - The acquisition options.
+     * @returns The acquisition, once the shared component has loaded.
+     * @throws An {@link Error} when the pool was never loaded, when the factory or the load fails, or when called for a
+     *   key from inside that key's own factory or synchronous load; a {@link SilentError} when the pool is unloaded, or
+     *   when the consumer unloads or the acquisition is released before the load completes; the abort reason when
+     *   `abortSignal` aborts first.
+     */
+    acquire(key: TKey, options?: SharedComponentPoolComponentAcquireOptions): Promise<SharedComponentAcquisition<TComponent>>;
+    /**
+     * Returns how many acquisitions currently hold the component shared under a key, pending ones included.
+     *
+     * @param key - The resource key.
+     * @returns The number of consumers, `0` when the key has no shared component.
+     */
+    getConsumerCount(key: TKey): number;
+    /**
+     * Registers the teardown that unloads every shared component when the pool unloads.
+     */
+    onload(): void;
+    private createEntry;
+    private releaseReference;
+    private unloadEntry;
+}

package/dist/lib/esm/components/shared-component-pool-component.mjs

@@ -0,0 +1,280 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { onAbort } from "@mnaoumov/typescript-lib/abort-controller";
+import { snapshot } from "@mnaoumov/typescript-lib/array";
+import { SilentError } from "@mnaoumov/typescript-lib/error";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { Component } from "obsidian";
+import { ComponentEx } from "./component-ex.mjs";
+class SharedComponentAcquisitionImpl {
+  constructor(component, onRelease) {
+    this.component = component;
+    this.onRelease = onRelease;
+  }
+  component;
+  onRelease;
+  get isReleased() {
+    return this._isReleased;
+  }
+  _isReleased = false;
+  unlinkConsumer = null;
+  dispose() {
+    this.release();
+  }
+  linkConsumer(consumer) {
+    const consumerLink = new Component();
+    consumerLink.register(() => {
+      this.unlinkConsumer = null;
+      this.release();
+    });
+    consumer.addChild(consumerLink);
+    this.unlinkConsumer = () => {
+      consumer.removeChild(consumerLink);
+    };
+  }
+  release() {
+    if (this._isReleased) {
+      return;
+    }
+    this._isReleased = true;
+    const unlinkConsumer = this.unlinkConsumer;
+    this.unlinkConsumer = null;
+    unlinkConsumer?.();
+    this.onRelease();
+  }
+  [Symbol.dispose]() {
+    this.release();
+  }
+}
+class SharedComponentPoolComponent extends ComponentEx {
+  /**
+   * Creates the component shared under a key; see {@link SharedComponentPoolComponentConstructorParams.createComponent}.
+   */
+  createComponent;
+  creatingKeys = /* @__PURE__ */ new Set();
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new pool.
+   *
+   * @param params - The pool parameters.
+   */
+  constructor(params) {
+    super();
+    this.createComponent = params.createComponent;
+  }
+  /**
+   * Acquires the component shared under a key, creating and loading it when the key has no consumer yet.
+   *
+   * @param key - The resource key.
+   * @param options - The acquisition options.
+   * @returns The acquisition, once the shared component has loaded.
+   * @throws An {@link Error} when the pool was never loaded, when the factory or the load fails, or when called for a
+   *   key from inside that key's own factory or synchronous load; a {@link SilentError} when the pool is unloaded, or
+   *   when the consumer unloads or the acquisition is released before the load completes; the abort reason when
+   *   `abortSignal` aborts first.
+   */
+  async acquire(key, options = {}) {
+    var _stack = [];
+    try {
+      this.ensureLoaded();
+      options.abortSignal?.throwIfAborted();
+      if (this.creatingKeys.has(key)) {
+        throw new Error("A shared component cannot be acquired from inside its own creation");
+      }
+      const entry = this.entries.get(key) ?? this.createEntry(key);
+      entry.consumerCount++;
+      const cancellation = createDeferred();
+      const acquisition = new SharedComponentAcquisitionImpl(entry.component, () => {
+        cancellation.reject(new SilentError("The shared component acquisition was released"));
+        this.releaseReference(entry);
+      });
+      const _abortListener = __using(_stack, options.abortSignal ? onAbort(options.abortSignal, (abortSignal) => {
+        cancellation.reject(abortSignal.reason);
+        acquisition.release();
+      }) : null);
+      try {
+        if (options.consumer) {
+          acquisition.linkConsumer(options.consumer);
+        }
+        await Promise.race([entry.ready.promise, cancellation.promise]);
+      } catch (error) {
+        acquisition.release();
+        throw error;
+      }
+      if (acquisition.isReleased) {
+        throw new SilentError("The shared component acquisition was released");
+      }
+      return acquisition;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /**
+   * Returns how many acquisitions currently hold the component shared under a key, pending ones included.
+   *
+   * @param key - The resource key.
+   * @returns The number of consumers, `0` when the key has no shared component.
+   */
+  getConsumerCount(key) {
+    return this.entries.get(key)?.consumerCount ?? 0;
+  }
+  /**
+   * Registers the teardown that unloads every shared component when the pool unloads.
+   */
+  onload() {
+    this.register(() => {
+      for (const entry of snapshot([...this.entries.values()])) {
+        this.unloadEntry(entry, new SilentError("The shared component pool is unloaded"));
+      }
+    });
+  }
+  createEntry(key) {
+    this.creatingKeys.add(key);
+    try {
+      const component = this.createComponent(key);
+      const entry = {
+        component,
+        consumerCount: 0,
+        isUnloaded: false,
+        key,
+        ready: createDeferred()
+      };
+      this.entries.set(key, entry);
+      let loadPromise = null;
+      try {
+        if (component instanceof ComponentEx) {
+          loadPromise = component.loadWithPromises();
+        } else {
+          component.load();
+        }
+      } catch (error) {
+        this.unloadEntry(entry, error);
+        throw error;
+      }
+      if (loadPromise) {
+        loadPromise.then(() => {
+          entry.ready.resolve();
+        }).catch((error) => {
+          this.unloadEntry(entry, error);
+        });
+      } else {
+        entry.ready.resolve();
+      }
+      return entry;
+    } finally {
+      this.creatingKeys.delete(key);
+    }
+  }
+  releaseReference(entry) {
+    entry.consumerCount--;
+    if (entry.consumerCount <= 0) {
+      this.unloadEntry(entry, new SilentError("The last consumer released the shared component before it loaded"));
+    }
+  }
+  unloadEntry(entry, reason) {
+    if (entry.isUnloaded) {
+      return;
+    }
+    entry.isUnloaded = true;
+    this.entries.delete(entry.key);
+    entry.ready.reject(reason);
+    entry.component.unload();
+  }
+}
+function createDeferred() {
+  let resolve = noop;
+  let reject = noop;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  promise.catch(noop);
+  return { promise, reject, resolve };
+}
+export {
+  SharedComponentPoolComponent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/shared-component-pool-component.ts"],"sourcesContent":["/**\n * @file\n *\n * A pool that shares one loaded component per caller-defined key among several consumers, and unloads it when the\n * last consumer releases it.\n */\n\nimport type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { SilentError } from '@mnaoumov/typescript-lib/error';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { Component } from 'obsidian';\n\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * One consumer's hold on a shared component.\n *\n * Releasing it is idempotent: the first call drops the hold, and every later call — including the one the consumer\n * link makes when the consumer unloads — does nothing.\n *\n * @typeParam TComponent - The type of the shared component.\n */\nexport interface SharedComponentAcquisition<TComponent extends Component> extends DisposableEx {\n  /**\n   * The shared component, loaded. Every consumer of the same key receives the same instance.\n   */\n  readonly component: TComponent;\n\n  /**\n   * Whether this acquisition has been released.\n   */\n  readonly isReleased: boolean;\n\n  /**\n   * Releases this acquisition. The shared component is unloaded when its last acquisition is released.\n   */\n  readonly release: () => void;\n}\n\n/**\n * Options of {@link SharedComponentPoolComponent.acquire}.\n */\nexport interface SharedComponentPoolComponentAcquireOptions {\n  /**\n   * Cancels the acquisition while the shared component is still loading. An abort after the acquisition resolved does\n   * nothing; release the acquisition instead.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * A component whose unload releases the acquisition automatically.\n   *\n   * The link is a child component added to the consumer, so it follows Obsidian's own rules: a consumer that is not\n   * loaded yet starts holding the link when it loads, and a {@link ComponentEx} consumer that is already unloaded\n   * refuses it with a {@link SilentError}. Releasing the acquisition by hand removes the link again, so a long-lived\n   * consumer that acquires and releases many times accumulates nothing.\n   */\n  readonly consumer?: Component;\n}\n\n/**\n * Parameters of {@link SharedComponentPoolComponent}.\n *\n * @typeParam TKey - The type of the resource key.\n * @typeParam TComponent - The type of the shared component.\n */\nexport interface SharedComponentPoolComponentConstructorParams<TKey, TComponent extends Component> {\n  /**\n   * Creates the component shared under a key. Called once per key each time the key goes from no consumer to one; the\n   * pool loads the component itself, so the factory must return it unloaded.\n   *\n   * @param key - The resource key.\n   * @returns The new, not yet loaded component.\n   */\n  readonly createComponent: (key: TKey) => TComponent;\n}\n\ninterface Deferred {\n  readonly promise: Promise<void>;\n  readonly reject: (reason: unknown) => void;\n  readonly resolve: () => void;\n}\n\ninterface PoolEntry<TKey, TComponent extends Component> {\n  readonly component: TComponent;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Mutable bookkeeping of the pool.\n  consumerCount: number;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Mutable bookkeeping of the pool.\n  isUnloaded: boolean;\n  readonly key: TKey;\n  readonly ready: Deferred;\n}\n\nclass SharedComponentAcquisitionImpl<TComponent extends Component> implements SharedComponentAcquisition<TComponent> {\n  public get isReleased(): boolean {\n    return this._isReleased;\n  }\n\n  private _isReleased = false;\n  private unlinkConsumer: (() => void) | null = null;\n\n  public constructor(public readonly component: TComponent, private readonly onRelease: () => void) {}\n\n  public dispose(): void {\n    this.release();\n  }\n\n  public linkConsumer(consumer: Component): void {\n    const consumerLink = new Component();\n    consumerLink.register(() => {\n      this.unlinkConsumer = null;\n      this.release();\n    });\n    consumer.addChild(consumerLink);\n    this.unlinkConsumer = (): void => {\n      consumer.removeChild(consumerLink);\n    };\n  }\n\n  public release(): void {\n    if (this._isReleased) {\n      return;\n    }\n\n    this._isReleased = true;\n    const unlinkConsumer = this.unlinkConsumer;\n    this.unlinkConsumer = null;\n    unlinkConsumer?.();\n    this.onRelease();\n  }\n\n  public [Symbol.dispose](): void {\n    this.release();\n  }\n}\n\n/**\n * Shares one loaded component per caller-defined key among several consumers.\n *\n * The first {@link acquire} of a key creates the component through the factory and loads it; every further acquire of\n * the same key, concurrent or later, receives the same instance; the release of the last acquisition unloads it, and\n * the next acquire creates a fresh one. A {@link ComponentEx} is loaded through {@link ComponentEx.loadWithPromises}, so\n * an acquire resolves only once its `onloadAsync` and children have settled, and a failed load rejects every waiting\n * acquire, unloads the component and leaves the key free for a fresh attempt.\n *\n * The pool is itself a component, and its parent is the owner of every shared instance: add it with `addChild` to the\n * plugin (or any longer-lived component). Unloading the owner unloads every shared component still held, rejects\n * every acquire still waiting with a {@link SilentError}, and refuses later acquires. Keys are compared the way a\n * {@link Map} compares them, so two equal-looking object keys are two resources. The instances live on the pool\n * object only, never in the shared-state bag, so two plugins — or two pools of one plugin — never share anything.\n *\n * Reach for it only when SEVERAL independent consumers want the same expensive component and none of them owns it.\n * A component with a single owner is that owner's child: `addChild` is simpler and already unloads it with its owner.\n *\n * @typeParam TKey - The type of the resource key.\n * @typeParam TComponent - The type of the shared component.\n */\nexport class SharedComponentPoolComponent<TKey, TComponent extends Component> extends ComponentEx {\n  /**\n   * Creates the component shared under a key; see {@link SharedComponentPoolComponentConstructorParams.createComponent}.\n   */\n  protected readonly createComponent: (key: TKey) => TComponent;\n\n  private readonly creatingKeys = new Set<TKey>();\n  private readonly entries = new Map<TKey, PoolEntry<TKey, TComponent>>();\n\n  /**\n   * Creates a new pool.\n   *\n   * @param params - The pool parameters.\n   */\n  public constructor(params: SharedComponentPoolComponentConstructorParams<TKey, TComponent>) {\n    super();\n    this.createComponent = params.createComponent;\n  }\n\n  /**\n   * Acquires the component shared under a key, creating and loading it when the key has no consumer yet.\n   *\n   * @param key - The resource key.\n   * @param options - The acquisition options.\n   * @returns The acquisition, once the shared component has loaded.\n   * @throws An {@link Error} when the pool was never loaded, when the factory or the load fails, or when called for a\n   *   key from inside that key's own factory or synchronous load; a {@link SilentError} when the pool is unloaded, or\n   *   when the consumer unloads or the acquisition is released before the load completes; the abort reason when\n   *   `abortSignal` aborts first.\n   */\n  public async acquire(key: TKey, options: SharedComponentPoolComponentAcquireOptions = {}): Promise<SharedComponentAcquisition<TComponent>> {\n    this.ensureLoaded();\n    options.abortSignal?.throwIfAborted();\n\n    if (this.creatingKeys.has(key)) {\n      throw new Error('A shared component cannot be acquired from inside its own creation');\n    }\n\n    const entry = this.entries.get(key) ?? this.createEntry(key);\n    entry.consumerCount++;\n\n    const cancellation = createDeferred();\n    const acquisition = new SharedComponentAcquisitionImpl(entry.component, () => {\n      cancellation.reject(new SilentError('The shared component acquisition was released'));\n      this.releaseReference(entry);\n    });\n\n    using _abortListener = options.abortSignal\n      ? onAbort(options.abortSignal, (abortSignal) => {\n        cancellation.reject(abortSignal.reason);\n        acquisition.release();\n      })\n      : null;\n\n    try {\n      if (options.consumer) {\n        acquisition.linkConsumer(options.consumer);\n      }\n      await Promise.race([entry.ready.promise, cancellation.promise]);\n    } catch (error) {\n      acquisition.release();\n      throw error;\n    }\n\n    if (acquisition.isReleased) {\n      throw new SilentError('The shared component acquisition was released');\n    }\n\n    return acquisition;\n  }\n\n  /**\n   * Returns how many acquisitions currently hold the component shared under a key, pending ones included.\n   *\n   * @param key - The resource key.\n   * @returns The number of consumers, `0` when the key has no shared component.\n   */\n  public getConsumerCount(key: TKey): number {\n    return this.entries.get(key)?.consumerCount ?? 0;\n  }\n\n  /**\n   * Registers the teardown that unloads every shared component when the pool unloads.\n   */\n  public override onload(): void {\n    this.register(() => {\n      for (const entry of snapshot([...this.entries.values()])) {\n        this.unloadEntry(entry, new SilentError('The shared component pool is unloaded'));\n      }\n    });\n  }\n\n  private createEntry(key: TKey): PoolEntry<TKey, TComponent> {\n    this.creatingKeys.add(key);\n    try {\n      const component = this.createComponent(key);\n      const entry: PoolEntry<TKey, TComponent> = {\n        component,\n        consumerCount: 0,\n        isUnloaded: false,\n        key,\n        ready: createDeferred()\n      };\n      this.entries.set(key, entry);\n\n      let loadPromise: null | Promise<void> = null;\n      try {\n        if (component instanceof ComponentEx) {\n          loadPromise = component.loadWithPromises();\n        } else {\n          component.load();\n        }\n      } catch (error) {\n        this.unloadEntry(entry, error);\n        throw error;\n      }\n\n      if (loadPromise) {\n        loadPromise.then(() => {\n          entry.ready.resolve();\n        }).catch((error: unknown) => {\n          this.unloadEntry(entry, error);\n        });\n      } else {\n        entry.ready.resolve();\n      }\n\n      return entry;\n    } finally {\n      this.creatingKeys.delete(key);\n    }\n  }\n\n  private releaseReference(entry: PoolEntry<TKey, TComponent>): void {\n    entry.consumerCount--;\n    if (entry.consumerCount <= 0) {\n      this.unloadEntry(entry, new SilentError('The last consumer released the shared component before it loaded'));\n    }\n  }\n\n  private unloadEntry(entry: PoolEntry<TKey, TComponent>, reason: unknown): void {\n    if (entry.isUnloaded) {\n      return;\n    }\n\n    entry.isUnloaded = true;\n    // An entry stays in the map until it is unloaded, and only once, so the key still maps to this entry.\n    this.entries.delete(entry.key);\n    entry.ready.reject(reason);\n    entry.component.unload();\n  }\n}\n\nfunction createDeferred(): Deferred {\n  let resolve: () => void = noop;\n  let reject: (reason: unknown) => void = noop;\n  const promise = new Promise<void>((resolvePromise, rejectPromise) => {\n    resolve = resolvePromise;\n    reject = rejectPromise;\n  });\n  // A deferred may be rejected while nobody awaits it; mark it handled so that is not an unhandled rejection.\n  promise.catch(noop);\n  return { promise, reject, resolve };\n}\n"],"mappings":"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","names":[]}

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;
+}