@mnaoumov/obsidian-lib 10.6.0 → 10.8.0

package/dist/lib/cjs/components/index.cjs

@@ -130,6 +130,7 @@ __export(components_exports, {
   "rmdir-guard-component": () => rmdir_guard_component,
   "settings-facet-component": () => settings_facet_component,
   "settings-migration-component": () => settings_migration_component,
+  "style-sheet-component": () => style_sheet_component,
   "syntax-highlighting-component": () => syntax_highlighting_component,
   "templates-language-component": () => templates_language_component
 });
@@ -167,6 +168,7 @@ var rename_delete_handler_component = __toESM(((module) => module && module.__es
 var rmdir_guard_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./rmdir-guard-component.cjs')), 1);
 var settings_facet_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./settings-facet-component.cjs')), 1);
 var settings_migration_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./settings-migration-component.cjs')), 1);
+var style_sheet_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./style-sheet-component.cjs')), 1);
 var syntax_highlighting_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./syntax-highlighting-component.cjs')), 1);
 var templates_language_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./templates-language-component.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
@@ -204,7 +206,8 @@ var templates_language_component = __toESM(((module) => module && module.__esMod
   "rmdir-guard-component": null,
   "settings-facet-component": null,
   "settings-migration-component": null,
+  "style-sheet-component": null,
   "syntax-highlighting-component": null,
   "templates-language-component": null
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/index.d.cts

@@ -32,5 +32,6 @@ export * as 'rename-delete-handler-component' from './rename-delete-handler-comp
 export * as 'rmdir-guard-component' from './rmdir-guard-component.cjs';
 export * as 'settings-facet-component' from './settings-facet-component.cjs';
 export * as 'settings-migration-component' from './settings-migration-component.cjs';
+export * as 'style-sheet-component' from './style-sheet-component.cjs';
 export * as 'syntax-highlighting-component' from './syntax-highlighting-component.cjs';
 export * as 'templates-language-component' from './templates-language-component.cjs';

package/dist/lib/cjs/components/style-sheet-component.cjs

@@ -0,0 +1,198 @@
+/*
+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 style_sheet_component_exports = {};
+__export(style_sheet_component_exports, {
+  StyleSheetComponent: () => StyleSheetComponent,
+  registerStyle: () => registerStyle
+});
+module.exports = __toCommonJS(style_sheet_component_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_all_windows_event_component = require('./all-windows-event-component.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class StyleSheetComponent extends import_component_ex.ComponentEx {
+  /**
+   * The CSS currently attached.
+   *
+   * @returns The CSS.
+   */
+  get css() {
+    return this._css;
+  }
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  _css;
+  styleSheetsByWindow = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of the `StyleSheetComponent` class.
+   *
+   * @param params - The {@link StyleSheetComponentConstructorParams}.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this._css = params.css;
+  }
+  /**
+   * Attaches the stylesheet to every window, now and as popouts open.
+   */
+  onload() {
+    super.onload();
+    this.register(() => {
+      for (const [win, styleSheet] of this.styleSheetsByWindow) {
+        win.document.adoptedStyleSheets = win.document.adoptedStyleSheets.filter((sheet) => sheet !== styleSheet);
+      }
+      this.styleSheetsByWindow.clear();
+    });
+    this.registerEvent(this.app.workspace.on("window-close", (_workspaceWindow, win) => {
+      this.styleSheetsByWindow.delete(win);
+    }));
+    const allWindowsEventComponent = this.addChild(new import_all_windows_event_component.AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsHandler((win) => {
+      this.attach(win);
+    });
+  }
+  /**
+   * Replaces the attached CSS in every window.
+   *
+   * @param css - The new CSS.
+   */
+  setCss(css) {
+    this._css = css;
+    for (const styleSheet of this.styleSheetsByWindow.values()) {
+      styleSheet.replaceSync(css);
+    }
+  }
+  attach(win) {
+    if (this.styleSheetsByWindow.has(win)) {
+      return;
+    }
+    const styleSheet = new ((0, import_object_utils.castTo)(win)).CSSStyleSheet();
+    styleSheet.replaceSync(this._css);
+    win.document.adoptedStyleSheets = [...win.document.adoptedStyleSheets, styleSheet];
+    this.styleSheetsByWindow.set(win, styleSheet);
+  }
+}
+function registerStyle(params) {
+  const { app, component, css } = params;
+  return component.addChild(new StyleSheetComponent({ app, css }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StyleSheetComponent,
+  registerStyle
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/style-sheet-component.d.cts

@@ -0,0 +1,79 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Attaches a plugin stylesheet to the main window and every popout window, including popouts opened later, and
+ * removes it on unload.
+ *
+ * The stylesheet is a constructed `CSSStyleSheet` adopted through `document.adoptedStyleSheets`, so the plugin
+ * creates no `<style>` element (which the community review flags) and adds no CSS snippet to the user's list.
+ * A constructed sheet can be adopted only by a document of the realm that constructed it, so each window gets its
+ * own sheet, built with that window's `CSSStyleSheet` constructor. Constructable stylesheets need Electron 28 or
+ * iOS 16.4, both below the oldest runtime Obsidian supports.
+ */
+import type { App, Component } from 'obsidian' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * Parameters for {@link registerStyle}.
+ */
+export interface RegisterStyleParams extends StyleSheetComponentConstructorParams {
+    /**
+     * The component that owns the stylesheet: the stylesheet is removed when it unloads.
+     */
+    readonly component: Component;
+}
+/**
+ * Parameters for the {@link StyleSheetComponent} constructor.
+ */
+export interface StyleSheetComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The CSS to attach.
+     */
+    readonly css: string;
+}
+/**
+ * Attaches a stylesheet to the main window and every popout window while loaded.
+ */
+export declare class StyleSheetComponent extends ComponentEx {
+    /**
+     * The CSS currently attached.
+     *
+     * @returns The CSS.
+     */
+    get css(): string;
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    private _css;
+    private readonly styleSheetsByWindow;
+    /**
+     * Creates a new instance of the `StyleSheetComponent` class.
+     *
+     * @param params - The {@link StyleSheetComponentConstructorParams}.
+     */
+    constructor(params: StyleSheetComponentConstructorParams);
+    /**
+     * Attaches the stylesheet to every window, now and as popouts open.
+     */
+    onload(): void;
+    /**
+     * Replaces the attached CSS in every window.
+     *
+     * @param css - The new CSS.
+     */
+    setCss(css: string): void;
+    private attach;
+}
+/**
+ * Attaches a stylesheet to the main window and every popout window, including popouts opened later, until the
+ * owning component unloads.
+ *
+ * @param params - The {@link RegisterStyleParams}.
+ * @returns The {@link StyleSheetComponent}, whose {@link StyleSheetComponent.setCss} replaces the CSS.
+ */
+export declare function registerStyle(params: RegisterStyleParams): StyleSheetComponent;

package/dist/lib/cjs/data-stores/data-store-locations.cjs

@@ -0,0 +1,248 @@
+/*
+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 data_store_locations_exports = {};
+__export(data_store_locations_exports, {
+  DataStoreLocations: () => DataStoreLocations
+});
+module.exports = __toCommonJS(data_store_locations_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_data_store_transport = require('./data-store-transport.cjs');
+const MAX_LOCATIONS = 32;
+class DataStoreLocations {
+  /**
+   * Creates a coordinator without adapter calls.
+   *
+   * @param params - Permanent discovery anchor and store identity.
+   */
+  constructor(params) {
+    this.params = params;
+    this.anchor = new import_data_store_transport.DataStoreTransport(params);
+    this.initial = { folder: params.folder ?? "Plugin data", format: params.format ?? "markdown" };
+    this.locations = [this.initial];
+  }
+  params;
+  /**
+  All readers, oldest first; the last transport is the active writer.
+   *
+   * @returns All retained reader transports in transition order.
+   */
+  get transports() {
+    return this.locations.map((location) => this.createTransport(location));
+  }
+  anchor;
+  initial;
+  locations;
+  /**
+   * Discovers and finishes pending copies before allowing a writer to switch destinations.
+   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.
+   *
+   * @returns A promise that resolves after discovery and verification.
+   */
+  async refresh() {
+    const transitions = [];
+    for (const path of await this.anchor.list()) {
+      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith(".json")) {
+        continue;
+      }
+      const value = await this.anchor.read(path);
+      if (!isTransition(value)) {
+        throw new Error("Incomplete or invalid data-store transition");
+      }
+      this.validateLocation(value.from);
+      this.validateLocation(value.to);
+      transitions.push(value);
+    }
+    const locations = [this.initial];
+    let currentIdentity = identity(this.initial);
+    while (transitions.length > 0) {
+      const sourceIdentity = currentIdentity;
+      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);
+      const targets = new Set(next.map((transition) => identity(transition.to)));
+      if (targets.size !== 1) {
+        throw new Error("Conflicting or incomplete data-store relocation chain");
+      }
+      const target = (0, import_type_guards.ensureNonNullable)(next[0]);
+      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {
+        throw new Error("Data-store relocation loop or location limit");
+      }
+      locations.push(target.to);
+      currentIdentity = identity(target.to);
+      for (const transition of next) {
+        transitions.splice(transitions.indexOf(transition), 1);
+      }
+    }
+    for (const location of locations) {
+      this.validateLocation(location, locations);
+    }
+    for (const location of locations.slice(1)) {
+      const target = this.createTransport(location);
+      for (const source of locations.slice(0, locations.indexOf(location))) {
+        const transport = this.createTransport(source);
+        if (transport.root !== target.root) {
+          await transport.copyHistoryTo(target);
+        }
+      }
+    }
+    this.locations = locations;
+  }
+  /**
+   * Announces a transition durably at the anchor, then copies and verifies before activation.
+   * Retrying the same destination finishes an interrupted copy.
+   *
+   * @param location - Requested destination.
+   * @returns A promise that resolves when the new writer is ready.
+   */
+  async relocate(location) {
+    this.validateLocation(location);
+    await this.refresh();
+    this.validateLocation(location);
+    const from = (0, import_type_guards.ensureNonNullable)(this.locations.at(-1));
+    if (identity(from) === identity(location)) {
+      return;
+    }
+    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {
+      throw new Error("Data-store relocation loop or location limit");
+    }
+    const value = { format: 1, from, to: location };
+    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);
+    await this.refresh();
+  }
+  createTransport(location) {
+    return new import_data_store_transport.DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? "markdown" });
+  }
+  validateLocation(location, locations = this.locations) {
+    const transport = this.createTransport(location);
+    for (const previous of locations) {
+      const root = this.createTransport(previous).root;
+      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {
+        throw new Error("Overlapping data-store relocation roots");
+      }
+    }
+  }
+}
+function identity(location) {
+  return `${location.folder}:${location.format ?? "markdown"}`;
+}
+function isLocation(value) {
+  return typeof value === "object" && value !== null && "folder" in value && typeof value.folder === "string" && (!("format" in value) || value.format === "json" || value.format === "markdown");
+}
+function isTransition(value) {
+  return typeof value === "object" && value !== null && "format" in value && value.format === 1 && "from" in value && isLocation(value.from) && "to" in value && isLocation(value.to);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataStoreLocations
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-locations.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n * Append-only, anchored discovery of history-preserving transport transitions.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { DataStoreTransportConstructorParams } from './data-store-transport.ts';\n\nimport { DataStoreTransport } from './data-store-transport.ts';\n\nconst MAX_LOCATIONS = 32;\n\n/**\nA transport destination. Keep the original open parameters as the discovery anchor.\n */\nexport interface DataStoreLocation {\n  /**\n  Vault-relative parent of the plugin/store subtree.\n   */\n  readonly folder: string;\n  /**\n   * New document encoding.\n   *\n   * @default `'markdown'`\n   */\n  readonly format?: 'json' | 'markdown';\n}\n\ninterface Transition {\n  readonly format: 1;\n  readonly from: DataStoreLocation;\n  readonly to: DataStoreLocation;\n}\n\n/**\nAnchored relocation coordinator; source histories are never removed.\n */\nexport class DataStoreLocations {\n  /**\n  All readers, oldest first; the last transport is the active writer.\n   *\n   * @returns All retained reader transports in transition order.\n   */\n  public get transports(): DataStoreTransport[] {\n    return this.locations.map((location) => this.createTransport(location));\n  }\n\n  private readonly anchor: DataStoreTransport;\n  private readonly initial: DataStoreLocation;\n\n  private locations: DataStoreLocation[];\n\n  /**\n   * Creates a coordinator without adapter calls.\n   *\n   * @param params - Permanent discovery anchor and store identity.\n   */\n  public constructor(private readonly params: DataStoreTransportConstructorParams) {\n    this.anchor = new DataStoreTransport(params);\n    this.initial = { folder: params.folder ?? 'Plugin data', format: params.format ?? 'markdown' };\n    this.locations = [this.initial];\n  }\n\n  /**\n   * Discovers and finishes pending copies before allowing a writer to switch destinations.\n   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.\n   *\n   * @returns A promise that resolves after discovery and verification.\n   */\n  public async refresh(): Promise<void> {\n    const transitions: Transition[] = [];\n    for (const path of await this.anchor.list()) {\n      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith('.json')) {\n        continue;\n      }\n      const value = await this.anchor.read(path);\n      if (!isTransition(value)) {\n        throw new Error('Incomplete or invalid data-store transition');\n      }\n      this.validateLocation(value.from);\n      this.validateLocation(value.to);\n      transitions.push(value);\n    }\n    const locations = [this.initial];\n    let currentIdentity = identity(this.initial);\n    while (transitions.length > 0) {\n      const sourceIdentity = currentIdentity;\n      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);\n      const targets = new Set(next.map((transition) => identity(transition.to)));\n      if (targets.size !== 1) {\n        throw new Error('Conflicting or incomplete data-store relocation chain');\n      }\n      const target = ensureNonNullable(next[0]);\n      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {\n        throw new Error('Data-store relocation loop or location limit');\n      }\n      locations.push(target.to);\n      currentIdentity = identity(target.to);\n      for (const transition of next) {\n        transitions.splice(transitions.indexOf(transition), 1);\n      }\n    }\n    // Validate the entire chain before making any copies or activating a writer.\n    for (const location of locations) {\n      this.validateLocation(location, locations);\n    }\n    for (const location of locations.slice(1)) {\n      const target = this.createTransport(location);\n      for (const source of locations.slice(0, locations.indexOf(location))) {\n        const transport = this.createTransport(source);\n        if (transport.root !== target.root) {\n          await transport.copyHistoryTo(target);\n        }\n      }\n    }\n    this.locations = locations;\n  }\n\n  /**\n   * Announces a transition durably at the anchor, then copies and verifies before activation.\n   * Retrying the same destination finishes an interrupted copy.\n   *\n   * @param location - Requested destination.\n   * @returns A promise that resolves when the new writer is ready.\n   */\n  public async relocate(location: DataStoreLocation): Promise<void> {\n    this.validateLocation(location);\n    await this.refresh();\n    this.validateLocation(location);\n    const from = ensureNonNullable(this.locations.at(-1));\n    if (identity(from) === identity(location)) {\n      return;\n    }\n    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {\n      throw new Error('Data-store relocation loop or location limit');\n    }\n    const value: Transition = { format: 1, from, to: location };\n    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);\n    await this.refresh();\n  }\n\n  private createTransport(location: DataStoreLocation): DataStoreTransport {\n    return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? 'markdown' });\n  }\n\n  private validateLocation(location: DataStoreLocation, locations: readonly DataStoreLocation[] = this.locations): void {\n    const transport = this.createTransport(location);\n    for (const previous of locations) {\n      const root = this.createTransport(previous).root;\n      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {\n        throw new Error('Overlapping data-store relocation roots');\n      }\n    }\n  }\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n\nfunction identity(location: DataStoreLocation): string {\n  return `${location.folder}:${location.format ?? 'markdown'}`;\n}\n\nfunction isLocation(value: unknown): value is DataStoreLocation {\n  return typeof value === 'object' && value !== null && 'folder' in value && typeof value.folder === 'string'\n    && (!('format' in value) || value.format === 'json' || value.format === 'markdown');\n}\n\nfunction isTransition(value: unknown): value is Transition {\n  return typeof value === 'object' && value !== null && 'format' in value && value.format === 1\n    && 'from' in value && isLocation(value.from) && 'to' in value && isLocation(value.to);\n}\n"],"mappings":"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","names":[]}