@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

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

@@ -0,0 +1,95 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { ComponentEx } from "./component-ex.mjs";
+import { WorkerComponent } from "./worker-component.mjs";
+const MAX_DEFAULT_WORKER_POOL_SIZE = 4;
+class WorkerPoolComponent extends 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 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));
+}
+export {
+  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": ";;;;;AAgBA,SAAS,mBAAmB;AAC5B,SAAS,uBAAuB;AAMzB,MAAM,+BAA+B;AA0CrC,MAAM,4BAA0D,YAAY;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,gBAAsB,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/esm/components/workspace-layout-state-component.mjs

@@ -401,4 +401,4 @@ export {
   parseWorkspaceLayoutStateRecord,
   serializeWorkspaceLayoutStateRecord
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/workspace-layout-state-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value\n * and switching workspaces restores it, instead of one global value in `data.json`.\n *\n * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,\n * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each\n * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through\n * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and\n * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry\n * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`\n * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the\n * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.\n *\n * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This\n * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not\n * own.\n *\n * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the\n * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while\n * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format\n * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of\n * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved\n * workspace.\n */\n\nimport type {\n  App,\n  Workspace,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type {\n  JsonObject,\n  JsonValue\n} from 'type-fest';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\n\nimport { isDataStoreJsonValue } from '../data-stores/data-store-replica.ts';\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { around } from './monkey-around-component.ts';\n\n/**\n * The top-level key of a serialized layout that holds the records.\n */\nexport const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = 'obsidianLibLayoutStateV1';\n\nconst SHARED_STATE_KEY = 'workspaceLayoutStateV1';\n\n/**\n * The fields of a plugin record this version knows: `leaves` and `workspace`.\n */\nconst KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;\n\n/**\n * A change of one key's value, in one scope.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateChange<T> {\n  /**\n   * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.\n   */\n  readonly leaf: null | WorkspaceLeaf;\n\n  /**\n   * The id of the leaf whose value changed, or `null` for the workspace scope.\n   */\n  readonly leafId: null | string;\n\n  /**\n   * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.\n   */\n  readonly oldValue: T;\n\n  /**\n   * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.\n   */\n  readonly value: T;\n}\n\n/**\n * Parameters for {@link WorkspaceLayoutStateComponent}.\n */\nexport interface WorkspaceLayoutStateComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to. Every value is namespaced by it.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * A typed handle to one layout-scoped key.\n *\n * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKey<T> {\n  /**\n   * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the\n   * key's guard.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns The value.\n   */\n  readonly get: (leaf?: WorkspaceLeaf) => T;\n\n  /**\n   * Checks whether a value is stored, valid or not.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns Whether a value is stored.\n   */\n  readonly has: (leaf?: WorkspaceLeaf) => boolean;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n\n  /**\n   * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A\n   * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.\n   *\n   * @param callback - Called after each change.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;\n\n  /**\n   * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.\n   *\n   * @param value - The value. It must be JSON-safe; `null` is stored as `null`.\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @throws A `TypeError` if the value is not JSON-safe.\n   */\n  readonly set: (value: T, leaf?: WorkspaceLeaf) => void;\n\n  /**\n   * Removes the stored value, so `get` reads the default again, and requests a layout save.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   */\n  readonly unset: (leaf?: WorkspaceLeaf) => void;\n}\n\n/**\n * Defines a layout-scoped key.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKeyDefinition<T> {\n  /**\n   * The value read when nothing valid is stored.\n   */\n  readonly defaultValue: T;\n\n  /**\n   * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.\n   *\n   * @default Accepts every JSON value.\n   */\n  readonly isValid?: (value: unknown) => value is T;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n}\n\n/**\n * One plugin's records. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStatePluginRecord {\n  /**\n   * The values by leaf id, then by key.\n   */\n  readonly leaves: Record<string, JsonRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n\n  /**\n   * The workspace-scope values by key.\n   */\n  readonly workspace: JsonRecord;\n}\n\n/**\n * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStateRecord {\n  /**\n   * The records by plugin id.\n   */\n  readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n}\n\ntype JsonRecord = Record<string, JsonValue>;\n\ninterface RecordChange {\n  readonly key: string;\n  readonly leafId: null | string;\n  readonly newValue: JsonValue | undefined;\n  readonly oldValue: JsonValue | undefined;\n  readonly pluginId: string;\n}\n\ninterface WorkspaceLayoutStateInstallation {\n  readonly owner: WorkspaceLayoutStateSubscription;\n  readonly uninstall: () => void;\n}\n\ninterface WorkspaceLayoutStateKeyImplParams<T> {\n  readonly app: App;\n  readonly defaultValue: T;\n  readonly isValid: (value: unknown) => value is T;\n  readonly key: string;\n  readonly pluginId: string;\n  readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n}\n\ninterface WorkspaceLayoutStateSharedState {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Subscriber changes replace or clear the shared installation.\n  installation: null | WorkspaceLayoutStateInstallation;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Set once a layout or the saved layout file has been read.\n  isHydrated: boolean;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- A layout load replaces the records.\n  record: WorkspaceLayoutStateRecord;\n  readonly subscriptions: WorkspaceLayoutStateSubscription[];\n}\n\n/**\n * A subscriber in the shared state. The shape is part of the wire format between copies: fields are only ever added.\n */\ninterface WorkspaceLayoutStateSubscription {\n  readonly install: () => () => void;\n  readonly onLayoutLoad: () => void;\n  readonly onRecordChange: (change: RecordChange) => void;\n}\n\nclass WorkspaceLayoutStateKeyImpl<T> implements WorkspaceLayoutStateKey<T> {\n  public readonly key: string;\n\n  private readonly app: App;\n  private readonly defaultValue: T;\n  private readonly isValid: (value: unknown) => value is T;\n  private readonly pluginId: string;\n  private readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n\n  public constructor(params: WorkspaceLayoutStateKeyImplParams<T>) {\n    this.app = params.app;\n    this.defaultValue = params.defaultValue;\n    this.isValid = params.isValid;\n    this.key = params.key;\n    this.pluginId = params.pluginId;\n    this.subscribe = params.subscribe;\n  }\n\n  public get(leaf?: WorkspaceLeaf): T {\n    return this.resolve(readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)));\n  }\n\n  public has(leaf?: WorkspaceLeaf): boolean {\n    return readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)) !== undefined;\n  }\n\n  public onChange(callback: (change: WorkspaceLayoutStateChange<T>) => void): () => void {\n    return this.subscribe((change) => {\n      if (change.key !== this.key) {\n        return;\n      }\n      callback({\n        leaf: change.leafId === null ? null : this.app.workspace.getLeafById(change.leafId),\n        leafId: change.leafId,\n        oldValue: this.resolve(change.oldValue),\n        value: this.resolve(change.newValue)\n      });\n    });\n  }\n\n  public set(value: T, leaf?: WorkspaceLeaf): void {\n    assertJsonValue(value);\n    this.write(cloneJson(value), getLeafId(leaf));\n  }\n\n  public unset(leaf?: WorkspaceLeaf): void {\n    this.write(undefined, getLeafId(leaf));\n  }\n\n  private resolve(rawValue: JsonValue | undefined): T {\n    return cloneJson(rawValue !== undefined && this.isValid(rawValue) ? rawValue : this.defaultValue);\n  }\n\n  private write(newValue: JsonValue | undefined, leafId: null | string): void {\n    const state = getSharedState();\n    const oldValue = readRawValue(state, this.pluginId, this.key, leafId);\n    if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {\n      return;\n    }\n\n    if (newValue === undefined) {\n      // A stored old value means the bucket exists, so this creates nothing.\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The bucket is a plain record keyed by user-chosen names.\n      delete ensureBucket(state, this.pluginId, leafId)[this.key];\n    } else {\n      ensureBucket(state, this.pluginId, leafId)[this.key] = newValue;\n    }\n\n    this.app.workspace.requestSaveLayout();\n    const change: RecordChange = { key: this.key, leafId, newValue, oldValue, pluginId: this.pluginId };\n    for (const subscription of snapshot(state.subscriptions)) {\n      subscription.onRecordChange(change);\n    }\n  }\n}\n\n/**\n * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.\n *\n * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a\n * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in\n * {@link onLayoutLoad}.\n */\nexport class WorkspaceLayoutStateComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to.\n   */\n  protected readonly pluginId: string;\n\n  private readonly layoutLoadListeners = new Set<() => void>();\n  private readonly recordChangeListeners = new Set<(change: RecordChange) => void>();\n\n  /**\n   * Creates a new workspace layout state component.\n   *\n   * @param params - The parameters.\n   * @throws A `TypeError` if the plugin id is empty.\n   */\n  public constructor(params: WorkspaceLayoutStateComponentConstructorParams) {\n    super();\n    if (!params.pluginId) {\n      throw new TypeError('The plugin id must not be empty');\n    }\n    this.app = params.app;\n    this.pluginId = params.pluginId;\n  }\n\n  /**\n   * Defines a typed key.\n   *\n   * @typeParam T - The value type.\n   * @param definition - The key definition.\n   * @returns The key handle.\n   * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.\n   */\n  public defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T> {\n    if (!definition.key) {\n      throw new TypeError('The key must not be empty');\n    }\n    assertJsonValue(definition.defaultValue);\n    return new WorkspaceLayoutStateKeyImpl<T>({\n      app: this.app,\n      defaultValue: cloneJson(definition.defaultValue),\n      isValid: definition.isValid ?? ((_value): _value is T => true),\n      key: definition.key,\n      pluginId: this.pluginId,\n      subscribe: (listener) => this.subscribeToRecordChanges(listener)\n    });\n  }\n\n  /**\n   * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when\n   * the component is first loaded after layout-ready. Every value may have changed.\n   *\n   * @param callback - Called after the layout is loaded, once its leaves exist.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  public onLayoutLoad(callback: () => void): () => void {\n    this.layoutLoadListeners.add(callback);\n    return () => {\n      this.layoutLoadListeners.delete(callback);\n    };\n  }\n\n  /**\n   * Subscribes to the shared installation, installing it when nobody has yet.\n   */\n  public override onload(): void {\n    super.onload();\n\n    const state = getSharedState();\n    const subscription: WorkspaceLayoutStateSubscription = {\n      install: () => installLayoutState(this.app, state),\n      onLayoutLoad: () => {\n        for (const listener of snapshot(this.layoutLoadListeners)) {\n          invokeListener(listener);\n        }\n      },\n      onRecordChange: (change) => {\n        if (change.pluginId !== this.pluginId) {\n          return;\n        }\n        for (const listener of snapshot(this.recordChangeListeners)) {\n          invokeListener(() => {\n            listener(change);\n          });\n        }\n      }\n    };\n    state.subscriptions.push(subscription);\n    state.installation ??= { owner: subscription, uninstall: subscription.install() };\n\n    this.register(() => {\n      this.layoutLoadListeners.clear();\n      this.recordChangeListeners.clear();\n      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);\n      if (state.installation?.owner !== subscription) {\n        return;\n      }\n\n      state.installation.uninstall();\n      const nextOwner = state.subscriptions[0];\n      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;\n    });\n  }\n\n  private subscribeToRecordChanges(listener: (change: RecordChange) => void): () => void {\n    this.recordChangeListeners.add(listener);\n    return () => {\n      this.recordChangeListeners.delete(listener);\n    };\n  }\n}\n\n/**\n * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as\n * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this\n * copy does not know are kept.\n *\n * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.\n * @returns The parsed record, sharing nothing with the input.\n */\nexport function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord {\n  if (!isJsonObject(value)) {\n    return { plugins: {} };\n  }\n\n  const plugins: Record<string, WorkspaceLayoutStatePluginRecord> = {};\n  const rawPlugins = value['plugins'];\n  if (isJsonObject(rawPlugins)) {\n    for (const [pluginId, rawPluginRecord] of Object.entries(rawPlugins)) {\n      const pluginRecord = parsePluginRecord(rawPluginRecord);\n      if (pluginRecord) {\n        plugins[pluginId] = pluginRecord;\n      }\n    }\n  }\n\n  return { ...cloneJson(value), plugins };\n}\n\n/**\n * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,\n * and so are plugins with nothing left.\n *\n * @param record - The current record.\n * @param layout - The serialized layout.\n * @returns The record to persist, or `null` when there is nothing to persist.\n */\nexport function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord {\n  const leafIds = collectLeafIds(layout);\n  const serialized = cloneJson(record);\n  const plugins = serialized.plugins;\n  for (const [pluginId, pluginRecord] of Object.entries(plugins)) {\n    for (const [leafId, bucket] of Object.entries(pluginRecord.leaves)) {\n      if (!leafIds.has(leafId) || Object.keys(bucket).length === 0) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Leaf ids are record keys.\n        delete pluginRecord.leaves[leafId];\n      }\n    }\n    const isEmpty = Object.keys(pluginRecord.workspace).length === 0 && Object.keys(pluginRecord.leaves).length === 0\n      && Object.keys(pluginRecord).length === KNOWN_PLUGIN_RECORD_FIELD_COUNT;\n    if (isEmpty) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Plugin ids are record keys.\n      delete plugins[pluginId];\n    }\n  }\n\n  return Object.keys(plugins).length === 0 && Object.keys(serialized).length === 1 ? null : serialized;\n}\n\nfunction assertJsonValue(value: unknown): asserts value is JsonValue {\n  if (!isDataStoreJsonValue(value)) {\n    throw new TypeError('A workspace layout state value must be JSON-safe');\n  }\n}\n\nfunction cloneJson<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value) as string) as T;\n}\n\nfunction collectLeafIds(layout: unknown): Set<string> {\n  const leafIds = new Set<string>();\n  function visit(item: unknown): void {\n    if (!isPlainRecord(item)) {\n      return;\n    }\n    const id = item['id'];\n    if (item['type'] === 'leaf' && typeof id === 'string') {\n      leafIds.add(id);\n    }\n    const children = item['children'];\n    if (Array.isArray(children)) {\n      for (const child of children) {\n        visit(child);\n      }\n    }\n  }\n\n  if (isPlainRecord(layout)) {\n    for (const rootKey of ['main', 'left', 'right', 'floating']) {\n      visit(layout[rootKey]);\n    }\n  }\n  return leafIds;\n}\n\nfunction ensureBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord {\n  const pluginRecord = state.record.plugins[pluginId] ?? { leaves: {}, workspace: {} };\n  state.record.plugins[pluginId] = pluginRecord;\n  if (leafId === null) {\n    return pluginRecord.workspace;\n  }\n\n  const bucket = pluginRecord.leaves[leafId] ?? {};\n  pluginRecord.leaves[leafId] = bucket;\n  return bucket;\n}\n\nfunction getBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord | null {\n  const pluginRecord = state.record.plugins[pluginId];\n  if (!pluginRecord) {\n    return null;\n  }\n  return leafId === null ? pluginRecord.workspace : pluginRecord.leaves[leafId] ?? null;\n}\n\nfunction getLayoutRecordValue(layout: unknown): unknown {\n  return isPlainRecord(layout) ? layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] : undefined;\n}\n\nfunction getLeafId(leaf: undefined | WorkspaceLeaf): null | string {\n  return leaf ? leaf.id : null;\n}\n\nfunction getSharedState(): WorkspaceLayoutStateSharedState {\n  return getObsidianLibState<WorkspaceLayoutStateSharedState>(SHARED_STATE_KEY, {\n    installation: null,\n    isHydrated: false,\n    record: { plugins: {} },\n    subscriptions: []\n  }).value;\n}\n\nfunction installLayoutState(app: App, state: WorkspaceLayoutStateSharedState): () => void {\n  let isUninstalled = false;\n  const uninstallPatch = around(app.workspace, {\n    getLayout: (next) =>\n      function patchedGetLayout(this: Workspace): Record<string, unknown> {\n        const layout = next.call(this);\n        const record = serializeWorkspaceLayoutStateRecord(state.record, layout);\n        if (record) {\n          layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] = record;\n        }\n        return layout;\n      },\n    setLayout: (next) =>\n      async function patchedSetLayout(this: Workspace, layout: Parameters<Workspace['setLayout']>[0]): Promise<void> {\n        state.record = parseWorkspaceLayoutStateRecord(getLayoutRecordValue(layout));\n        state.isHydrated = true;\n        try {\n          await next.call(this, layout);\n        } finally {\n          notifyLayoutLoad(state);\n        }\n      }\n  });\n\n  if (!state.isHydrated && app.workspace.layoutReady) {\n    // Loaded after the layout: read the layout the last installation saved, once, keeping what was set meanwhile.\n    invokeAsyncSafely(async () => {\n      const saved = await app.workspace.readWorkspaceFile();\n      if (isUninstalled || state.isHydrated) {\n        return;\n      }\n      mergeMissing(state.record, parseWorkspaceLayoutStateRecord(getLayoutRecordValue(saved)));\n      state.isHydrated = true;\n      notifyLayoutLoad(state);\n    });\n  }\n\n  return () => {\n    isUninstalled = true;\n    uninstallPatch();\n  };\n}\n\nfunction invokeListener(listener: () => void): void {\n  try {\n    listener();\n  } catch (error) {\n    console.error('A workspace layout state listener failed', error);\n  }\n}\n\nfunction isJsonObject(value: unknown): value is JsonObject {\n  return isPlainRecord(value) && isDataStoreJsonValue(value);\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction mergeMissing(target: WorkspaceLayoutStateRecord, source: WorkspaceLayoutStateRecord): void {\n  for (const [pluginId, sourcePlugin] of Object.entries(source.plugins)) {\n    const targetPlugin = target.plugins[pluginId];\n    if (!targetPlugin) {\n      target.plugins[pluginId] = sourcePlugin;\n      continue;\n    }\n    for (const [key, value] of Object.entries(sourcePlugin.workspace)) {\n      targetPlugin.workspace[key] ??= value;\n    }\n    for (const [leafId, bucket] of Object.entries(sourcePlugin.leaves)) {\n      targetPlugin.leaves[leafId] ??= bucket;\n    }\n  }\n}\n\nfunction notifyLayoutLoad(state: WorkspaceLayoutStateSharedState): void {\n  for (const subscription of snapshot(state.subscriptions)) {\n    subscription.onLayoutLoad();\n  }\n}\n\nfunction parsePluginRecord(value: unknown): null | WorkspaceLayoutStatePluginRecord {\n  if (!isJsonObject(value)) {\n    return null;\n  }\n\n  const leaves: Record<string, JsonRecord> = {};\n  const rawLeaves = value['leaves'];\n  if (isJsonObject(rawLeaves)) {\n    for (const [leafId, bucket] of Object.entries(rawLeaves)) {\n      if (isJsonObject(bucket)) {\n        leaves[leafId] = cloneJson<JsonRecord>(bucket);\n      }\n    }\n  }\n\n  const rawWorkspace = value['workspace'];\n  return {\n    ...cloneJson(value),\n    leaves,\n    workspace: isJsonObject(rawWorkspace) ? cloneJson<JsonRecord>(rawWorkspace) : {}\n  };\n}\n\nfunction readRawValue(state: WorkspaceLayoutStateSharedState, pluginId: string, key: string, leafId: null | string): JsonValue | undefined {\n  return getBucket(state, pluginId, leafId)?.[key];\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/workspace-layout-state-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value\n * and switching workspaces restores it, instead of one global value in `data.json`.\n *\n * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,\n * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each\n * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through\n * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and\n * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry\n * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`\n * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the\n * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.\n *\n * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This\n * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not\n * own.\n *\n * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the\n * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while\n * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format\n * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of\n * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved\n * workspace.\n */\n\nimport type {\n  App,\n  Workspace,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type {\n  JsonObject,\n  JsonValue\n} from 'type-fest';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\n\nimport { isDataStoreJsonValue } from '../data-stores/data-store-replica.ts';\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { around } from './monkey-around-component.ts';\n\n/**\n * The top-level key of a serialized layout that holds the records.\n */\nexport const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = 'obsidianLibLayoutStateV1';\n\nconst SHARED_STATE_KEY = 'workspaceLayoutStateV1';\n\n/**\n * The fields of a plugin record this version knows: `leaves` and `workspace`.\n */\nconst KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;\n\n/**\n * A change of one key's value, in one scope.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateChange<T> {\n  /**\n   * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.\n   */\n  readonly leaf: null | WorkspaceLeaf;\n\n  /**\n   * The id of the leaf whose value changed, or `null` for the workspace scope.\n   */\n  readonly leafId: null | string;\n\n  /**\n   * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.\n   */\n  readonly oldValue: T;\n\n  /**\n   * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.\n   */\n  readonly value: T;\n}\n\n/**\n * Parameters for {@link WorkspaceLayoutStateComponent}.\n */\nexport interface WorkspaceLayoutStateComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to. Every value is namespaced by it.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * A typed handle to one layout-scoped key.\n *\n * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKey<T> {\n  /**\n   * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the\n   * key's guard.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns The value.\n   */\n  readonly get: (leaf?: WorkspaceLeaf) => T;\n\n  /**\n   * Checks whether a value is stored, valid or not.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns Whether a value is stored.\n   */\n  readonly has: (leaf?: WorkspaceLeaf) => boolean;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n\n  /**\n   * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A\n   * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.\n   *\n   * @param callback - Called after each change.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;\n\n  /**\n   * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.\n   *\n   * @param value - The value. It must be JSON-safe; `null` is stored as `null`.\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @throws A `TypeError` if the value is not JSON-safe.\n   */\n  readonly set: (value: T, leaf?: WorkspaceLeaf) => void;\n\n  /**\n   * Removes the stored value, so `get` reads the default again, and requests a layout save.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   */\n  readonly unset: (leaf?: WorkspaceLeaf) => void;\n}\n\n/**\n * Defines a layout-scoped key.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKeyDefinition<T> {\n  /**\n   * The value read when nothing valid is stored.\n   */\n  readonly defaultValue: T;\n\n  /**\n   * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.\n   *\n   * @default Accepts every JSON value.\n   */\n  readonly isValid?: (value: unknown) => value is T;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n}\n\n/**\n * One plugin's records. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStatePluginRecord {\n  /**\n   * The values by leaf id, then by key.\n   */\n  readonly leaves: Record<string, JsonRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n\n  /**\n   * The workspace-scope values by key.\n   */\n  readonly workspace: JsonRecord;\n}\n\n/**\n * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStateRecord {\n  /**\n   * The records by plugin id.\n   */\n  readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n}\n\ntype JsonRecord = Record<string, JsonValue>;\n\ninterface RecordChange {\n  readonly key: string;\n  readonly leafId: null | string;\n  readonly newValue: JsonValue | undefined;\n  readonly oldValue: JsonValue | undefined;\n  readonly pluginId: string;\n}\n\ninterface WorkspaceLayoutStateInstallation {\n  readonly owner: WorkspaceLayoutStateSubscription;\n  readonly uninstall: () => void;\n}\n\ninterface WorkspaceLayoutStateKeyImplParams<T> {\n  readonly app: App;\n  readonly defaultValue: T;\n  readonly isValid: (value: unknown) => value is T;\n  readonly key: string;\n  readonly pluginId: string;\n  readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n}\n\ninterface WorkspaceLayoutStateSharedState {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Subscriber changes replace or clear the shared installation.\n  installation: null | WorkspaceLayoutStateInstallation;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Set once a layout or the saved layout file has been read.\n  isHydrated: boolean;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- A layout load replaces the records.\n  record: WorkspaceLayoutStateRecord;\n  readonly subscriptions: WorkspaceLayoutStateSubscription[];\n}\n\n/**\n * A subscriber in the shared state. The shape is part of the wire format between copies: fields are only ever added.\n */\ninterface WorkspaceLayoutStateSubscription {\n  readonly install: () => () => void;\n  readonly onLayoutLoad: () => void;\n  readonly onRecordChange: (change: RecordChange) => void;\n}\n\nclass WorkspaceLayoutStateKeyImpl<T> implements WorkspaceLayoutStateKey<T> {\n  public readonly key: string;\n\n  private readonly app: App;\n  private readonly defaultValue: T;\n  private readonly isValid: (value: unknown) => value is T;\n  private readonly pluginId: string;\n  private readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n\n  public constructor(params: WorkspaceLayoutStateKeyImplParams<T>) {\n    this.app = params.app;\n    this.defaultValue = params.defaultValue;\n    this.isValid = params.isValid;\n    this.key = params.key;\n    this.pluginId = params.pluginId;\n    this.subscribe = params.subscribe;\n  }\n\n  public get(leaf?: WorkspaceLeaf): T {\n    return this.resolve(readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)));\n  }\n\n  public has(leaf?: WorkspaceLeaf): boolean {\n    return readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)) !== undefined;\n  }\n\n  public onChange(callback: (change: WorkspaceLayoutStateChange<T>) => void): () => void {\n    return this.subscribe((change) => {\n      if (change.key !== this.key) {\n        return;\n      }\n      callback({\n        leaf: change.leafId === null ? null : this.app.workspace.getLeafById(change.leafId),\n        leafId: change.leafId,\n        oldValue: this.resolve(change.oldValue),\n        value: this.resolve(change.newValue)\n      });\n    });\n  }\n\n  public set(value: T, leaf?: WorkspaceLeaf): void {\n    assertJsonValue(value);\n    this.write(cloneJson(value), getLeafId(leaf));\n  }\n\n  public unset(leaf?: WorkspaceLeaf): void {\n    this.write(undefined, getLeafId(leaf));\n  }\n\n  private resolve(rawValue: JsonValue | undefined): T {\n    return cloneJson(rawValue !== undefined && this.isValid(rawValue) ? rawValue : this.defaultValue);\n  }\n\n  private write(newValue: JsonValue | undefined, leafId: null | string): void {\n    const state = getSharedState();\n    const oldValue = readRawValue(state, this.pluginId, this.key, leafId);\n    if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {\n      return;\n    }\n\n    if (newValue === undefined) {\n      // A stored old value means the bucket exists, so this creates nothing.\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The bucket is a plain record keyed by user-chosen names.\n      delete ensureBucket(state, this.pluginId, leafId)[this.key];\n    } else {\n      ensureBucket(state, this.pluginId, leafId)[this.key] = newValue;\n    }\n\n    this.app.workspace.requestSaveLayout();\n    const change: RecordChange = { key: this.key, leafId, newValue, oldValue, pluginId: this.pluginId };\n    for (const subscription of snapshot(state.subscriptions)) {\n      subscription.onRecordChange(change);\n    }\n  }\n}\n\n/**\n * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.\n *\n * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a\n * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in\n * {@link onLayoutLoad}.\n */\nexport class WorkspaceLayoutStateComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to.\n   */\n  protected readonly pluginId: string;\n\n  private readonly layoutLoadListeners = new Set<() => void>();\n  private readonly recordChangeListeners = new Set<(change: RecordChange) => void>();\n\n  /**\n   * Creates a new workspace layout state component.\n   *\n   * @param params - The parameters.\n   * @throws A `TypeError` if the plugin id is empty.\n   */\n  public constructor(params: WorkspaceLayoutStateComponentConstructorParams) {\n    super();\n    if (!params.pluginId) {\n      throw new TypeError('The plugin id must not be empty');\n    }\n    this.app = params.app;\n    this.pluginId = params.pluginId;\n  }\n\n  /**\n   * Defines a typed key.\n   *\n   * @typeParam T - The value type.\n   * @param definition - The key definition.\n   * @returns The key handle.\n   * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.\n   */\n  public defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T> {\n    if (!definition.key) {\n      throw new TypeError('The key must not be empty');\n    }\n    assertJsonValue(definition.defaultValue);\n    return new WorkspaceLayoutStateKeyImpl<T>({\n      app: this.app,\n      defaultValue: cloneJson(definition.defaultValue),\n      isValid: definition.isValid ?? ((_value): _value is T => true),\n      key: definition.key,\n      pluginId: this.pluginId,\n      subscribe: (listener) => this.subscribeToRecordChanges(listener)\n    });\n  }\n\n  /**\n   * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when\n   * the component is first loaded after layout-ready. Every value may have changed.\n   *\n   * @param callback - Called after the layout is loaded, once its leaves exist.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  public onLayoutLoad(callback: () => void): () => void {\n    this.layoutLoadListeners.add(callback);\n    return () => {\n      this.layoutLoadListeners.delete(callback);\n    };\n  }\n\n  /**\n   * Subscribes to the shared installation, installing it when nobody has yet.\n   */\n  public override onload(): void {\n    super.onload();\n\n    const state = getSharedState();\n    const subscription: WorkspaceLayoutStateSubscription = {\n      install: () => installLayoutState(this.app, state),\n      onLayoutLoad: () => {\n        for (const listener of snapshot(this.layoutLoadListeners)) {\n          invokeListener(listener);\n        }\n      },\n      onRecordChange: (change) => {\n        if (change.pluginId !== this.pluginId) {\n          return;\n        }\n        for (const listener of snapshot(this.recordChangeListeners)) {\n          invokeListener(() => {\n            listener(change);\n          });\n        }\n      }\n    };\n    state.subscriptions.push(subscription);\n    state.installation ??= { owner: subscription, uninstall: subscription.install() };\n\n    this.register(() => {\n      this.layoutLoadListeners.clear();\n      this.recordChangeListeners.clear();\n      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);\n      if (state.installation?.owner !== subscription) {\n        return;\n      }\n\n      state.installation.uninstall();\n      const nextOwner = state.subscriptions[0];\n      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;\n    });\n  }\n\n  private subscribeToRecordChanges(listener: (change: RecordChange) => void): () => void {\n    this.recordChangeListeners.add(listener);\n    return () => {\n      this.recordChangeListeners.delete(listener);\n    };\n  }\n}\n\n/**\n * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as\n * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this\n * copy does not know are kept.\n *\n * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.\n * @returns The parsed record, sharing nothing with the input.\n */\nexport function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord {\n  if (!isJsonObject(value)) {\n    return { plugins: {} };\n  }\n\n  const plugins: Record<string, WorkspaceLayoutStatePluginRecord> = {};\n  const rawPlugins = value['plugins'];\n  if (isJsonObject(rawPlugins)) {\n    for (const [pluginId, rawPluginRecord] of Object.entries(rawPlugins)) {\n      const pluginRecord = parsePluginRecord(rawPluginRecord);\n      if (pluginRecord) {\n        plugins[pluginId] = pluginRecord;\n      }\n    }\n  }\n\n  return { ...cloneJson(value), plugins };\n}\n\n/**\n * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,\n * and so are plugins with nothing left.\n *\n * @param record - The current record.\n * @param layout - The serialized layout.\n * @returns The record to persist, or `null` when there is nothing to persist.\n */\nexport function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord {\n  const leafIds = collectLeafIds(layout);\n  const serialized = cloneJson(record);\n  const plugins = serialized.plugins;\n  for (const [pluginId, pluginRecord] of Object.entries(plugins)) {\n    for (const [leafId, bucket] of Object.entries(pluginRecord.leaves)) {\n      if (!leafIds.has(leafId) || Object.keys(bucket).length === 0) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Leaf ids are record keys.\n        delete pluginRecord.leaves[leafId];\n      }\n    }\n    const isEmpty = Object.keys(pluginRecord.workspace).length === 0 && Object.keys(pluginRecord.leaves).length === 0\n      && Object.keys(pluginRecord).length === KNOWN_PLUGIN_RECORD_FIELD_COUNT;\n    if (isEmpty) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Plugin ids are record keys.\n      delete plugins[pluginId];\n    }\n  }\n\n  return Object.keys(plugins).length === 0 && Object.keys(serialized).length === 1 ? null : serialized;\n}\n\nfunction assertJsonValue(value: unknown): asserts value is JsonValue {\n  if (!isDataStoreJsonValue(value)) {\n    throw new TypeError('A workspace layout state value must be JSON-safe');\n  }\n}\n\nfunction cloneJson<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value) as string) as T;\n}\n\nfunction collectLeafIds(layout: unknown): Set<string> {\n  const leafIds = new Set<string>();\n  function visit(item: unknown): void {\n    if (!isPlainRecord(item)) {\n      return;\n    }\n    const id = item['id'];\n    if (item['type'] === 'leaf' && typeof id === 'string') {\n      leafIds.add(id);\n    }\n    const children = item['children'];\n    if (Array.isArray(children)) {\n      for (const child of children) {\n        visit(child);\n      }\n    }\n  }\n\n  if (isPlainRecord(layout)) {\n    for (const rootKey of ['main', 'left', 'right', 'floating']) {\n      visit(layout[rootKey]);\n    }\n  }\n  return leafIds;\n}\n\nfunction ensureBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord {\n  const pluginRecord = state.record.plugins[pluginId] ?? { leaves: {}, workspace: {} };\n  state.record.plugins[pluginId] = pluginRecord;\n  if (leafId === null) {\n    return pluginRecord.workspace;\n  }\n\n  const bucket = pluginRecord.leaves[leafId] ?? {};\n  pluginRecord.leaves[leafId] = bucket;\n  return bucket;\n}\n\nfunction getBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord | null {\n  const pluginRecord = state.record.plugins[pluginId];\n  if (!pluginRecord) {\n    return null;\n  }\n  return leafId === null ? pluginRecord.workspace : pluginRecord.leaves[leafId] ?? null;\n}\n\nfunction getLayoutRecordValue(layout: unknown): unknown {\n  return isPlainRecord(layout) ? layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] : undefined;\n}\n\nfunction getLeafId(leaf: undefined | WorkspaceLeaf): null | string {\n  return leaf ? leaf.id : null;\n}\n\nfunction getSharedState(): WorkspaceLayoutStateSharedState {\n  return getObsidianLibState<WorkspaceLayoutStateSharedState>(SHARED_STATE_KEY, {\n    installation: null,\n    isHydrated: false,\n    record: { plugins: {} },\n    subscriptions: []\n  }).value;\n}\n\nfunction installLayoutState(app: App, state: WorkspaceLayoutStateSharedState): () => void {\n  let isUninstalled = false;\n  const uninstallPatch = around(app.workspace, {\n    getLayout: (next) =>\n      function patchedGetLayout(this: Workspace): Record<string, unknown> {\n        const layout = next.call(this);\n        const record = serializeWorkspaceLayoutStateRecord(state.record, layout);\n        if (record) {\n          layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] = record;\n        }\n        return layout;\n      },\n    setLayout: (next) =>\n      async function patchedSetLayout(this: Workspace, layout: Parameters<Workspace['setLayout']>[0]): Promise<void> {\n        state.record = parseWorkspaceLayoutStateRecord(getLayoutRecordValue(layout));\n        state.isHydrated = true;\n        try {\n          await next.call(this, layout);\n        } finally {\n          notifyLayoutLoad(state);\n        }\n      }\n  });\n\n  if (!state.isHydrated && app.workspace.layoutReady) {\n    // Loaded after the layout: read the layout the last installation saved, once, keeping what was set meanwhile.\n    invokeAsyncSafely(async () => {\n      const saved = await app.workspace.readWorkspaceFile();\n      if (isUninstalled || state.isHydrated) {\n        return;\n      }\n      mergeMissing(state.record, parseWorkspaceLayoutStateRecord(getLayoutRecordValue(saved)));\n      state.isHydrated = true;\n      notifyLayoutLoad(state);\n    });\n  }\n\n  return () => {\n    isUninstalled = true;\n    uninstallPatch();\n  };\n}\n\nfunction invokeListener(listener: () => void): void {\n  try {\n    listener();\n  } catch (error) {\n    console.error('A workspace layout state listener failed', error);\n  }\n}\n\nfunction isJsonObject(value: unknown): value is JsonObject {\n  return isPlainRecord(value) && isDataStoreJsonValue(value);\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction mergeMissing(target: WorkspaceLayoutStateRecord, source: WorkspaceLayoutStateRecord): void {\n  for (const [pluginId, sourcePlugin] of Object.entries(source.plugins)) {\n    const targetPlugin = target.plugins[pluginId];\n    if (!targetPlugin) {\n      target.plugins[pluginId] = sourcePlugin;\n      continue;\n    }\n    for (const [key, value] of Object.entries(sourcePlugin.workspace)) {\n      targetPlugin.workspace[key] ??= value;\n    }\n    for (const [leafId, bucket] of Object.entries(sourcePlugin.leaves)) {\n      targetPlugin.leaves[leafId] ??= bucket;\n    }\n  }\n}\n\nfunction notifyLayoutLoad(state: WorkspaceLayoutStateSharedState): void {\n  for (const subscription of snapshot(state.subscriptions)) {\n    subscription.onLayoutLoad();\n  }\n}\n\nfunction parsePluginRecord(value: unknown): null | WorkspaceLayoutStatePluginRecord {\n  if (!isJsonObject(value)) {\n    return null;\n  }\n\n  const leaves: Record<string, JsonRecord> = {};\n  const rawLeaves = value['leaves'];\n  if (isJsonObject(rawLeaves)) {\n    for (const [leafId, bucket] of Object.entries(rawLeaves)) {\n      if (isJsonObject(bucket)) {\n        leaves[leafId] = cloneJson<JsonRecord>(bucket);\n      }\n    }\n  }\n\n  const rawWorkspace = value['workspace'];\n  return {\n    ...cloneJson(value),\n    leaves,\n    workspace: isJsonObject(rawWorkspace) ? cloneJson<JsonRecord>(rawWorkspace) : {}\n  };\n}\n\n// eslint-disable-next-line typescript-dev-toolkit/no-undefined-return-type -- A stored JSON `null` is a value, so a missing one must read differently.\nfunction readRawValue(state: WorkspaceLayoutStateSharedState, pluginId: string, key: string, leafId: null | string): JsonValue | undefined {\n  return getBucket(state, pluginId, leafId)?.[key];\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/data-handler.d.mts

@@ -11,8 +11,15 @@
  * `readJson` logs a parse failure and resolves `undefined`, and its `writeJson` catches every error. So the guard
  * has to decide BEFORE handing the call to Obsidian, which is the only point where refusing still changes the
  * outcome.
+ *
+ * The same `readJson` makes a `data.json` that EXISTS but does not parse indistinguishable from no file at all: both
+ * resolve `undefined`. A settings component reading that as "nothing stored" saves its defaults over the file, and
+ * the user's settings are gone. So when Obsidian answers `undefined` or `null`, {@link PluginDataHandler.loadData}
+ * reads the file raw and parses it itself; a file that does not parse is copied into the device-local
+ * {@link SettingsRecoveryStore} and reported as a {@link PluginDataParseError}, never as missing.
  */
 import type { Plugin } from 'obsidian';
+import type { SettingsRecoveryCopy, SettingsRecoveryStore } from './settings-recovery.mjs';
 /**
  * The default maximum size of a plugin's `data.json`, in bytes: 16 MiB.
  *
@@ -43,6 +50,12 @@ export interface DataHandler {
      * @returns The loaded data.
      */
     readonly loadData: () => Promise<unknown>;
+    /**
+     * Where a copy of the data file is kept before anything could lose what it held, or `null` (or absent) when the
+     * handler keeps none. A settings component keeps a copy here before a first save that would drop or change a
+     * stored value, and skips that save when the copy cannot be kept.
+     */
+    readonly recoveryStore?: null | SettingsRecoveryStore;
     /**
      * A function to save data to the plugin's data file.
      *
@@ -59,6 +72,38 @@ export interface PluginDataHandlerConstructorOptions {
      * {@link DEFAULT_PLUGIN_DATA_MAX_SIZE_IN_BYTES}. Pass `Infinity` to disable the guard.
      */
     readonly maxSizeInBytes?: number;
+    /**
+     * Where recovery copies of `data.json` are kept. Defaults to a device-local {@link LocalSettingsRecoveryStore}
+     * for the plugin. Pass `null` to keep none: an unparseable file is then still reported and never overwritten, so a
+     * settings component built on this handler fails its load rather than run on defaults, and a first save that drops
+     * or changes a stored value is written with no copy kept, as before recovery copies existed.
+     */
+    readonly recoveryStore?: null | SettingsRecoveryStore;
+}
+/**
+ * Parameters for {@link PluginDataParseError}.
+ */
+export interface PluginDataParseErrorConstructorParams {
+    /**
+     * The error `JSON.parse` threw.
+     */
+    readonly cause: unknown;
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The recovery copy kept of the file, or `null` when none could be kept.
+     */
+    readonly recoveryCopy: null | SettingsRecoveryCopy;
 }
 /**
  * Parameters for {@link PluginDataSizeLimitExceededError}.
@@ -94,6 +139,10 @@ export interface PluginDataSizeLimitExceededErrorConstructorParams {
  */
 export declare class PluginDataHandler implements DataHandler {
     protected readonly plugin: Plugin;
+    /**
+     * Where recovery copies of `data.json` are kept, or `null` when none are.
+     */
+    readonly recoveryStore: null | SettingsRecoveryStore;
     /**
      * The maximum size of `data.json`, in bytes.
      */
@@ -109,10 +158,13 @@ export declare class PluginDataHandler implements DataHandler {
      * Loads data from the plugin's data file.
      *
      * The file's size is read through the adapter BEFORE Obsidian reads and parses it, so an oversized file is never
-     * loaded into memory.
+     * loaded into memory. When Obsidian answers `undefined` or `null`, the file is read raw and parsed here, because
+     * Obsidian answers `undefined` for a file that exists but does not parse too.
      *
      * @returns The loaded data.
      * @throws {@link PluginDataSizeLimitExceededError} If the existing file is larger than the limit.
+     * @throws {@link PluginDataParseError} If the existing file is not valid JSON. The file is left untouched, and a
+     * recovery copy of it is kept first when the handler has a recovery store.
      */
     loadData(): Promise<unknown>;
     /**
@@ -132,8 +184,47 @@ export declare class PluginDataHandler implements DataHandler {
      * @returns The path, or `null` when the manifest has no folder.
      */
     protected getDataFilePath(): null | string;
+    /**
+     * Tells the user that `data.json` could not be parsed: a notice naming the plugin and the path, and the error in the
+     * console.
+     *
+     * @param error - The parse error.
+     */
+    protected reportParseError(error: PluginDataParseError): void;
     private createError;
     private getExistingFileSize;
+    private keepRecoveryCopy;
+    private readRawFile;
+}
+/**
+ * Thrown when a plugin's `data.json` exists but is not valid JSON.
+ *
+ * The file is never touched when this is thrown. When {@link recoveryCopy} is not `null`, a copy of the file's raw text
+ * was kept on this device first, so even a later save over the file loses nothing.
+ */
+export declare class PluginDataParseError extends Error {
+    /**
+     * The path of the plugin's `data.json`.
+     */
+    readonly path: string;
+    /**
+     * The `manifest.id` of the plugin.
+     */
+    readonly pluginId: string;
+    /**
+     * The `manifest.name` of the plugin.
+     */
+    readonly pluginName: string;
+    /**
+     * The recovery copy kept of the file, or `null` when none could be kept.
+     */
+    readonly recoveryCopy: null | SettingsRecoveryCopy;
+    /**
+     * Creates a {@link PluginDataParseError}.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: PluginDataParseErrorConstructorParams);
 }
 /**
  * Thrown when a plugin's `data.json` is, or would become, larger than the configured limit.