@mnaoumov/obsidian-lib 10.12.0 → 11.0.0

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

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

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

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

package/dist/lib/cjs/components/workspace-layout-state-component.cjs

@@ -120,12 +120,12 @@ __export(workspace_layout_state_component_exports, {
   serializeWorkspaceLayoutStateRecord: () => serializeWorkspaceLayoutStateRecord
 });
 module.exports = __toCommonJS(workspace_layout_state_component_exports);
-var import_array = require('@mnaoumov/typescript-lib/array');
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_data_store_replica = require('../data-stores/data-store-replica.cjs');
-var import_obsidian_lib_state = require('../obsidian-lib-state.cjs');
-var import_component_ex = require('./component-ex.cjs');
-var import_monkey_around_component = require('./monkey-around-component.cjs');
+var import_array = require("@mnaoumov/typescript-lib/array");
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_data_store_replica = require("../data-stores/data-store-replica.cjs");
+var import_obsidian_lib_state = require("../obsidian-lib-state.cjs");
+var import_component_ex = require("./component-ex.cjs");
+var import_monkey_around_component = require("./monkey-around-component.cjs");
 const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
 const SHARED_STATE_KEY = "workspaceLayoutStateV1";
 const KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;
@@ -492,4 +492,4 @@ function readRawValue(state, pluginId, key, leafId) {
   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/cjs/constructors/get-dom-events-handlers-constructor.cjs

@@ -168,11 +168,11 @@ __export(get_dom_events_handlers_constructor_exports, {
   getDomEventsHandlersConstructor: () => getDomEventsHandlersConstructor
 });
 module.exports = __toCommonJS(get_dom_events_handlers_constructor_exports);
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
-var import_obsidian = require('obsidian');
-var import_monkey_around_component = require('../components/monkey-around-component.cjs');
-var import_vault = require('../vault.cjs');
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
+var import_obsidian = require("obsidian");
+var import_monkey_around_component = require("../components/monkey-around-component.cjs");
+var import_vault = require("../vault.cjs");
 class MarkdownPreviewRendererRegisterDomEventsPatchComponent extends import_monkey_around_component.MonkeyAroundComponent {
   domEventsHandlersConstructor = null;
   onload() {

package/dist/lib/cjs/constructors/index.cjs

@@ -100,7 +100,7 @@ __export(constructors_exports, {
   "get-dom-events-handlers-constructor": () => get_dom_events_handlers_constructor
 });
 module.exports = __toCommonJS(constructors_exports);
-var get_dom_events_handlers_constructor = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./get-dom-events-handlers-constructor.cjs')), 1);
+var get_dom_events_handlers_constructor = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require("./get-dom-events-handlers-constructor.cjs")), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "get-dom-events-handlers-constructor": null