@mnaoumov/obsidian-lib 10.10.0 → 10.12.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/workspace-layout-state-component.d.mts

@@ -0,0 +1,239 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value
+ * and switching workspaces restores it, instead of one global value in `data.json`.
+ *
+ * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,
+ * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each
+ * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through
+ * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and
+ * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry
+ * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`
+ * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the
+ * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.
+ *
+ * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This
+ * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not
+ * own.
+ *
+ * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the
+ * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while
+ * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format
+ * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of
+ * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved
+ * workspace.
+ */
+import type { App, WorkspaceLeaf } from 'obsidian';
+import type { JsonValue } from 'type-fest';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The top-level key of a serialized layout that holds the records.
+ */
+export declare const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
+/**
+ * A change of one key's value, in one scope.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateChange<T> {
+    /**
+     * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.
+     */
+    readonly leaf: null | WorkspaceLeaf;
+    /**
+     * The id of the leaf whose value changed, or `null` for the workspace scope.
+     */
+    readonly leafId: null | string;
+    /**
+     * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.
+     */
+    readonly oldValue: T;
+    /**
+     * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.
+     */
+    readonly value: T;
+}
+/**
+ * Parameters for {@link WorkspaceLayoutStateComponent}.
+ */
+export interface WorkspaceLayoutStateComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The id of the plugin the values belong to. Every value is namespaced by it.
+     */
+    readonly pluginId: string;
+}
+/**
+ * A typed handle to one layout-scoped key.
+ *
+ * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKey<T> {
+    /**
+     * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the
+     * key's guard.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns The value.
+     */
+    readonly get: (leaf?: WorkspaceLeaf) => T;
+    /**
+     * Checks whether a value is stored, valid or not.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @returns Whether a value is stored.
+     */
+    readonly has: (leaf?: WorkspaceLeaf) => boolean;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+    /**
+     * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A
+     * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.
+     *
+     * @param callback - Called after each change.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;
+    /**
+     * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.
+     *
+     * @param value - The value. It must be JSON-safe; `null` is stored as `null`.
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     * @throws A `TypeError` if the value is not JSON-safe.
+     */
+    readonly set: (value: T, leaf?: WorkspaceLeaf) => void;
+    /**
+     * Removes the stored value, so `get` reads the default again, and requests a layout save.
+     *
+     * @param leaf - The leaf, or nothing for the workspace scope.
+     */
+    readonly unset: (leaf?: WorkspaceLeaf) => void;
+}
+/**
+ * Defines a layout-scoped key.
+ *
+ * @typeParam T - The value type.
+ */
+export interface WorkspaceLayoutStateKeyDefinition<T> {
+    /**
+     * The value read when nothing valid is stored.
+     */
+    readonly defaultValue: T;
+    /**
+     * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.
+     *
+     * @default Accepts every JSON value.
+     */
+    readonly isValid?: (value: unknown) => value is T;
+    /**
+     * The key name, unique within the plugin.
+     */
+    readonly key: string;
+}
+/**
+ * One plugin's records. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStatePluginRecord {
+    /**
+     * The values by leaf id, then by key.
+     */
+    readonly leaves: Record<string, JsonRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+    /**
+     * The workspace-scope values by key.
+     */
+    readonly workspace: JsonRecord;
+}
+/**
+ * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.
+ */
+export interface WorkspaceLayoutStateRecord {
+    /**
+     * The records by plugin id.
+     */
+    readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;
+    /**
+     * Fields a newer copy of the library added.
+     */
+    readonly [field: string]: unknown;
+}
+type JsonRecord = Record<string, JsonValue>;
+/**
+ * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.
+ *
+ * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a
+ * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in
+ * {@link onLayoutLoad}.
+ */
+export declare class WorkspaceLayoutStateComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The id of the plugin the values belong to.
+     */
+    protected readonly pluginId: string;
+    private readonly layoutLoadListeners;
+    private readonly recordChangeListeners;
+    /**
+     * Creates a new workspace layout state component.
+     *
+     * @param params - The parameters.
+     * @throws A `TypeError` if the plugin id is empty.
+     */
+    constructor(params: WorkspaceLayoutStateComponentConstructorParams);
+    /**
+     * Defines a typed key.
+     *
+     * @typeParam T - The value type.
+     * @param definition - The key definition.
+     * @returns The key handle.
+     * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.
+     */
+    defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T>;
+    /**
+     * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when
+     * the component is first loaded after layout-ready. Every value may have changed.
+     *
+     * @param callback - Called after the layout is loaded, once its leaves exist.
+     * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+     */
+    onLayoutLoad(callback: () => void): () => void;
+    /**
+     * Subscribes to the shared installation, installing it when nobody has yet.
+     */
+    onload(): void;
+    private subscribeToRecordChanges;
+}
+/**
+ * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as
+ * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this
+ * copy does not know are kept.
+ *
+ * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.
+ * @returns The parsed record, sharing nothing with the input.
+ */
+export declare function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord;
+/**
+ * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,
+ * and so are plugins with nothing left.
+ *
+ * @param record - The current record.
+ * @param layout - The serialized layout.
+ * @returns The record to persist, or `null` when there is nothing to persist.
+ */
+export declare function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord;
+export {};