@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

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

@@ -0,0 +1,495 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+(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 workspace_layout_state_component_exports = {};
+__export(workspace_layout_state_component_exports, {
+  WORKSPACE_LAYOUT_STATE_LAYOUT_KEY: () => WORKSPACE_LAYOUT_STATE_LAYOUT_KEY,
+  WorkspaceLayoutStateComponent: () => WorkspaceLayoutStateComponent,
+  parseWorkspaceLayoutStateRecord: () => parseWorkspaceLayoutStateRecord,
+  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');
+const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
+const SHARED_STATE_KEY = "workspaceLayoutStateV1";
+const KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;
+class WorkspaceLayoutStateKeyImpl {
+  key;
+  app;
+  defaultValue;
+  isValid;
+  pluginId;
+  subscribe;
+  constructor(params) {
+    this.app = params.app;
+    this.defaultValue = params.defaultValue;
+    this.isValid = params.isValid;
+    this.key = params.key;
+    this.pluginId = params.pluginId;
+    this.subscribe = params.subscribe;
+  }
+  get(leaf) {
+    return this.resolve(readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)));
+  }
+  has(leaf) {
+    return readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)) !== void 0;
+  }
+  onChange(callback) {
+    return this.subscribe((change) => {
+      if (change.key !== this.key) {
+        return;
+      }
+      callback({
+        leaf: change.leafId === null ? null : this.app.workspace.getLeafById(change.leafId),
+        leafId: change.leafId,
+        oldValue: this.resolve(change.oldValue),
+        value: this.resolve(change.newValue)
+      });
+    });
+  }
+  set(value, leaf) {
+    assertJsonValue(value);
+    this.write(cloneJson(value), getLeafId(leaf));
+  }
+  unset(leaf) {
+    this.write(void 0, getLeafId(leaf));
+  }
+  resolve(rawValue) {
+    return cloneJson(rawValue !== void 0 && this.isValid(rawValue) ? rawValue : this.defaultValue);
+  }
+  write(newValue, leafId) {
+    const state = getSharedState();
+    const oldValue = readRawValue(state, this.pluginId, this.key, leafId);
+    if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+      return;
+    }
+    if (newValue === void 0) {
+      delete ensureBucket(state, this.pluginId, leafId)[this.key];
+    } else {
+      ensureBucket(state, this.pluginId, leafId)[this.key] = newValue;
+    }
+    this.app.workspace.requestSaveLayout();
+    const change = { key: this.key, leafId, newValue, oldValue, pluginId: this.pluginId };
+    for (const subscription of (0, import_array.snapshot)(state.subscriptions)) {
+      subscription.onRecordChange(change);
+    }
+  }
+}
+class WorkspaceLayoutStateComponent extends import_component_ex.ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The id of the plugin the values belong to.
+   */
+  pluginId;
+  layoutLoadListeners = /* @__PURE__ */ new Set();
+  recordChangeListeners = /* @__PURE__ */ new Set();
+  /**
+   * Creates a new workspace layout state component.
+   *
+   * @param params - The parameters.
+   * @throws A `TypeError` if the plugin id is empty.
+   */
+  constructor(params) {
+    super();
+    if (!params.pluginId) {
+      throw new TypeError("The plugin id must not be empty");
+    }
+    this.app = params.app;
+    this.pluginId = params.pluginId;
+  }
+  /**
+   * Defines a typed key.
+   *
+   * @typeParam T - The value type.
+   * @param definition - The key definition.
+   * @returns The key handle.
+   * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.
+   */
+  defineKey(definition) {
+    if (!definition.key) {
+      throw new TypeError("The key must not be empty");
+    }
+    assertJsonValue(definition.defaultValue);
+    return new WorkspaceLayoutStateKeyImpl({
+      app: this.app,
+      defaultValue: cloneJson(definition.defaultValue),
+      isValid: definition.isValid ?? ((_value) => true),
+      key: definition.key,
+      pluginId: this.pluginId,
+      subscribe: (listener) => this.subscribeToRecordChanges(listener)
+    });
+  }
+  /**
+   * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when
+   * the component is first loaded after layout-ready. Every value may have changed.
+   *
+   * @param callback - Called after the layout is loaded, once its leaves exist.
+   * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+   */
+  onLayoutLoad(callback) {
+    this.layoutLoadListeners.add(callback);
+    return () => {
+      this.layoutLoadListeners.delete(callback);
+    };
+  }
+  /**
+   * Subscribes to the shared installation, installing it when nobody has yet.
+   */
+  onload() {
+    super.onload();
+    const state = getSharedState();
+    const subscription = {
+      install: () => installLayoutState(this.app, state),
+      onLayoutLoad: () => {
+        for (const listener of (0, import_array.snapshot)(this.layoutLoadListeners)) {
+          invokeListener(listener);
+        }
+      },
+      onRecordChange: (change) => {
+        if (change.pluginId !== this.pluginId) {
+          return;
+        }
+        for (const listener of (0, import_array.snapshot)(this.recordChangeListeners)) {
+          invokeListener(() => {
+            listener(change);
+          });
+        }
+      }
+    };
+    state.subscriptions.push(subscription);
+    state.installation ??= { owner: subscription, uninstall: subscription.install() };
+    this.register(() => {
+      this.layoutLoadListeners.clear();
+      this.recordChangeListeners.clear();
+      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);
+      if (state.installation?.owner !== subscription) {
+        return;
+      }
+      state.installation.uninstall();
+      const nextOwner = state.subscriptions[0];
+      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;
+    });
+  }
+  subscribeToRecordChanges(listener) {
+    this.recordChangeListeners.add(listener);
+    return () => {
+      this.recordChangeListeners.delete(listener);
+    };
+  }
+}
+function parseWorkspaceLayoutStateRecord(value) {
+  if (!isJsonObject(value)) {
+    return { plugins: {} };
+  }
+  const plugins = {};
+  const rawPlugins = value["plugins"];
+  if (isJsonObject(rawPlugins)) {
+    for (const [pluginId, rawPluginRecord] of Object.entries(rawPlugins)) {
+      const pluginRecord = parsePluginRecord(rawPluginRecord);
+      if (pluginRecord) {
+        plugins[pluginId] = pluginRecord;
+      }
+    }
+  }
+  return { ...cloneJson(value), plugins };
+}
+function serializeWorkspaceLayoutStateRecord(record, layout) {
+  const leafIds = collectLeafIds(layout);
+  const serialized = cloneJson(record);
+  const plugins = serialized.plugins;
+  for (const [pluginId, pluginRecord] of Object.entries(plugins)) {
+    for (const [leafId, bucket] of Object.entries(pluginRecord.leaves)) {
+      if (!leafIds.has(leafId) || Object.keys(bucket).length === 0) {
+        delete pluginRecord.leaves[leafId];
+      }
+    }
+    const isEmpty = Object.keys(pluginRecord.workspace).length === 0 && Object.keys(pluginRecord.leaves).length === 0 && Object.keys(pluginRecord).length === KNOWN_PLUGIN_RECORD_FIELD_COUNT;
+    if (isEmpty) {
+      delete plugins[pluginId];
+    }
+  }
+  return Object.keys(plugins).length === 0 && Object.keys(serialized).length === 1 ? null : serialized;
+}
+function assertJsonValue(value) {
+  if (!(0, import_data_store_replica.isDataStoreJsonValue)(value)) {
+    throw new TypeError("A workspace layout state value must be JSON-safe");
+  }
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function collectLeafIds(layout) {
+  const leafIds = /* @__PURE__ */ new Set();
+  function visit(item) {
+    if (!isPlainRecord(item)) {
+      return;
+    }
+    const id = item["id"];
+    if (item["type"] === "leaf" && typeof id === "string") {
+      leafIds.add(id);
+    }
+    const children = item["children"];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        visit(child);
+      }
+    }
+  }
+  if (isPlainRecord(layout)) {
+    for (const rootKey of ["main", "left", "right", "floating"]) {
+      visit(layout[rootKey]);
+    }
+  }
+  return leafIds;
+}
+function ensureBucket(state, pluginId, leafId) {
+  const pluginRecord = state.record.plugins[pluginId] ?? { leaves: {}, workspace: {} };
+  state.record.plugins[pluginId] = pluginRecord;
+  if (leafId === null) {
+    return pluginRecord.workspace;
+  }
+  const bucket = pluginRecord.leaves[leafId] ?? {};
+  pluginRecord.leaves[leafId] = bucket;
+  return bucket;
+}
+function getBucket(state, pluginId, leafId) {
+  const pluginRecord = state.record.plugins[pluginId];
+  if (!pluginRecord) {
+    return null;
+  }
+  return leafId === null ? pluginRecord.workspace : pluginRecord.leaves[leafId] ?? null;
+}
+function getLayoutRecordValue(layout) {
+  return isPlainRecord(layout) ? layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] : void 0;
+}
+function getLeafId(leaf) {
+  return leaf ? leaf.id : null;
+}
+function getSharedState() {
+  return (0, import_obsidian_lib_state.getObsidianLibState)(SHARED_STATE_KEY, {
+    installation: null,
+    isHydrated: false,
+    record: { plugins: {} },
+    subscriptions: []
+  }).value;
+}
+function installLayoutState(app, state) {
+  let isUninstalled = false;
+  const uninstallPatch = (0, import_monkey_around_component.around)(app.workspace, {
+    getLayout: (next) => function patchedGetLayout() {
+      const layout = next.call(this);
+      const record = serializeWorkspaceLayoutStateRecord(state.record, layout);
+      if (record) {
+        layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] = record;
+      }
+      return layout;
+    },
+    setLayout: (next) => async function patchedSetLayout(layout) {
+      state.record = parseWorkspaceLayoutStateRecord(getLayoutRecordValue(layout));
+      state.isHydrated = true;
+      try {
+        await next.call(this, layout);
+      } finally {
+        notifyLayoutLoad(state);
+      }
+    }
+  });
+  if (!state.isHydrated && app.workspace.layoutReady) {
+    (0, import_async.invokeAsyncSafely)(async () => {
+      const saved = await app.workspace.readWorkspaceFile();
+      if (isUninstalled || state.isHydrated) {
+        return;
+      }
+      mergeMissing(state.record, parseWorkspaceLayoutStateRecord(getLayoutRecordValue(saved)));
+      state.isHydrated = true;
+      notifyLayoutLoad(state);
+    });
+  }
+  return () => {
+    isUninstalled = true;
+    uninstallPatch();
+  };
+}
+function invokeListener(listener) {
+  try {
+    listener();
+  } catch (error) {
+    console.error("A workspace layout state listener failed", error);
+  }
+}
+function isJsonObject(value) {
+  return isPlainRecord(value) && (0, import_data_store_replica.isDataStoreJsonValue)(value);
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMissing(target, source) {
+  for (const [pluginId, sourcePlugin] of Object.entries(source.plugins)) {
+    const targetPlugin = target.plugins[pluginId];
+    if (!targetPlugin) {
+      target.plugins[pluginId] = sourcePlugin;
+      continue;
+    }
+    for (const [key, value] of Object.entries(sourcePlugin.workspace)) {
+      targetPlugin.workspace[key] ??= value;
+    }
+    for (const [leafId, bucket] of Object.entries(sourcePlugin.leaves)) {
+      targetPlugin.leaves[leafId] ??= bucket;
+    }
+  }
+}
+function notifyLayoutLoad(state) {
+  for (const subscription of (0, import_array.snapshot)(state.subscriptions)) {
+    subscription.onLayoutLoad();
+  }
+}
+function parsePluginRecord(value) {
+  if (!isJsonObject(value)) {
+    return null;
+  }
+  const leaves = {};
+  const rawLeaves = value["leaves"];
+  if (isJsonObject(rawLeaves)) {
+    for (const [leafId, bucket] of Object.entries(rawLeaves)) {
+      if (isJsonObject(bucket)) {
+        leaves[leafId] = cloneJson(bucket);
+      }
+    }
+  }
+  const rawWorkspace = value["workspace"];
+  return {
+    ...cloneJson(value),
+    leaves,
+    workspace: isJsonObject(rawWorkspace) ? cloneJson(rawWorkspace) : {}
+  };
+}
+function readRawValue(state, pluginId, key, leafId) {
+  return getBucket(state, pluginId, leafId)?.[key];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKSPACE_LAYOUT_STATE_LAYOUT_KEY,
+  WorkspaceLayoutStateComponent,
+  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":[]}