obsidian-dev-utils 82.0.0-beta.0 → 82.0.0-beta.10

package/dist/lib/esm/obsidian/editor-lock.mjs

@@ -22,54 +22,154 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
-import { MarkdownView } from "obsidian";
+import {
+  MarkdownView,
+  Menu,
+  setIcon,
+  setTooltip
+} from "obsidian";
+import { convertAsyncToSync } from "../async.mjs";
 import {
   CallbackDisposable,
   MultipleDisposeBehavior
 } from "../disposable.mjs";
 import { noop } from "../function.mjs";
 import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
-import {
-  lockEditor,
-  unlockEditor
-} from "./editor.mjs";
+import { assertNonNullable } from "../type-guards.mjs";
+import { ComponentEx } from "./components/component-ex.mjs";
+import { toggleEditorReadOnly } from "./editor.mjs";
 import { getPath } from "./file-system.mjs";
 import { t } from "./i18n/i18n.mjs";
+import { confirm } from "./modals/confirm.mjs";
+import { getPluginId } from "./plugin/plugin-id.mjs";
 const EDITOR_LOCK_STATE_KEY = "editorLock";
 const LOCK_ICON_ID = "lock";
+const LOCK_INDICATOR_CSS_CLASS = "obsidian-dev-utils-lock-indicator";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+const STATUS_BAR_CSS_SELECTOR = ".status-bar";
+const UNLOCK_ICON_ID = "unlock";
+class EditorLockEventsComponent extends ComponentEx {
+  constructor(app, onChange) {
+    super();
+    this.app = app;
+    this.onChange = onChange;
+  }
+  app;
+  onChange;
+  onload() {
+    super.onload();
+    this.registerEvent(this.app.workspace.on("active-leaf-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("layout-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("file-open", this.onChange));
+  }
+}
 class EditorPathLockManager {
-  eventRefs = [];
-  lockCountByPath = /* @__PURE__ */ new Map();
-  lockedIconElByView = /* @__PURE__ */ new Map();
+  abortControllersByPath = /* @__PURE__ */ new Map();
+  eventsComponent;
+  indicatorsByView = /* @__PURE__ */ new Map();
+  lockCountByPluginIdByPath = /* @__PURE__ */ new Map();
+  statusBarItemEl = null;
   isLocked(app, pathOrFile) {
-    return (this.lockCountByPath.get(getPath(app, pathOrFile)) ?? 0) > 0;
+    return this.isPathLocked(getPath(app, pathOrFile));
   }
-  lock(app, pathOrFile) {
+  lock(app, pathOrFile, pluginId, abortController) {
     const path = getPath(app, pathOrFile);
-    this.lockCountByPath.set(path, (this.lockCountByPath.get(path) ?? 0) + 1);
-    this.ensureEventsRegistered(app);
+    let lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);
+    if (!lockCountByPluginId) {
+      lockCountByPluginId = /* @__PURE__ */ new Map();
+      this.lockCountByPluginIdByPath.set(path, lockCountByPluginId);
+    }
+    lockCountByPluginId.set(pluginId, (lockCountByPluginId.get(pluginId) ?? 0) + 1);
+    if (abortController) {
+      let abortControllers = this.abortControllersByPath.get(path);
+      if (!abortControllers) {
+        abortControllers = /* @__PURE__ */ new Set();
+        this.abortControllersByPath.set(path, abortControllers);
+      }
+      abortControllers.add(abortController);
+    }
+    this.ensureSubscribed(app);
     this.reconcile(app);
     return new CallbackDisposable({
       callback: () => {
-        this.unlockPath(app, path);
+        if (abortController) {
+          const abortControllers = this.abortControllersByPath.get(path);
+          assertNonNullable(abortControllers);
+          abortControllers.delete(abortController);
+          if (abortControllers.size === 0) {
+            this.abortControllersByPath.delete(path);
+          }
+        }
+        this.unlockPath(app, path, pluginId);
       },
       multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
     });
   }
-  unlock(app, pathOrFile) {
-    this.unlockPath(app, getPath(app, pathOrFile));
+  /**
+   * Aborts every {@link AbortController} currently registered for the note at the given path, which
+   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`
+   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller
+   * is registered for the path.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file of the note to request an unlock for.
+   */
+  requestUnlock(app, pathOrFile) {
+    const abortControllers = this.abortControllersByPath.get(getPath(app, pathOrFile));
+    if (!abortControllers) {
+      return;
+    }
+    for (const controller of abortControllers) {
+      controller.abort();
+    }
+  }
+  unlock(app, pathOrFile, pluginId) {
+    this.unlockPath(app, getPath(app, pathOrFile), pluginId);
+  }
+  unlockAllForPlugin(app, pluginId) {
+    for (const [path, lockCountByPluginId] of this.lockCountByPluginIdByPath) {
+      if (lockCountByPluginId.delete(pluginId) && lockCountByPluginId.size === 0) {
+        this.lockCountByPluginIdByPath.delete(path);
+      }
+    }
+    this.reconcileAndCleanup(app);
+  }
+  createIndicators(app, view, path, tooltip) {
+    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);
+    this.registerUnlockMenu(app, actionIconEl, () => path);
+    let tabIconEl = null;
+    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;
+    if (tabStatusContainerEl) {
+      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });
+      setIcon(tabIconEl, LOCK_ICON_ID);
+      setTooltip(tabIconEl, tooltip);
+      this.registerUnlockMenu(app, tabIconEl, () => path);
+    }
+    return {
+      actionIconEl,
+      tabIconEl
+    };
   }
-  ensureEventsRegistered(app) {
-    if (this.eventRefs.length > 0) {
+  ensureSubscribed(app) {
+    if (this.eventsComponent) {
       return;
     }
-    const reconcile = () => {
+    this.eventsComponent = new EditorLockEventsComponent(app, () => {
       this.reconcile(app);
-    };
-    this.eventRefs.push(
-      app.workspace.on("active-leaf-change", reconcile),
-      app.workspace.on("layout-change", reconcile)
-    );
+    });
+    this.eventsComponent.load();
+  }
+  isPathLocked(path) {
+    return (this.lockCountByPluginIdByPath.get(path)?.size ?? 0) > 0;
+  }
+  lockingPluginNames(app, path) {
+    const lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);
+    assertNonNullable(lockCountByPluginId);
+    return Array.from(lockCountByPluginId.keys()).map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);
+  }
+  lockTooltip(app, path) {
+    const header = t(($) => $.obsidianDevUtils.editorLock.lockedByTooltip);
+    return [header, ...this.lockingPluginNames(app, path)].join("\n");
   }
   reconcile(app) {
     const viewsToLock = /* @__PURE__ */ new Set();
@@ -82,60 +182,184 @@ class EditorPathLockManager {
       if (path === void 0) {
         continue;
       }
-      if ((this.lockCountByPath.get(path) ?? 0) > 0) {
+      if (this.isPathLocked(path)) {
         viewsToLock.add(view);
-        if (!this.lockedIconElByView.has(view)) {
-          lockEditor(view.editor);
-          const iconEl = view.addAction(LOCK_ICON_ID, t(($) => $.obsidianDevUtils.editorLock.lockedNoteTooltip), noop);
-          this.lockedIconElByView.set(view, iconEl);
+        const tooltip = this.lockTooltip(app, path);
+        toggleEditorReadOnly(view.editor, true);
+        const indicators = this.indicatorsByView.get(view);
+        if (indicators) {
+          this.updateIndicatorTooltips(indicators, tooltip);
+        } else {
+          this.indicatorsByView.set(view, this.createIndicators(app, view, path, tooltip));
         }
       }
     }
-    for (const [view, iconEl] of this.lockedIconElByView) {
+    for (const [view, indicators] of this.indicatorsByView) {
       if (!viewsToLock.has(view)) {
-        unlockEditor(view.editor);
-        iconEl.remove();
-        this.lockedIconElByView.delete(view);
+        toggleEditorReadOnly(view.editor, false);
+        indicators.actionIconEl.remove();
+        indicators.tabIconEl?.remove();
+        this.indicatorsByView.delete(view);
       }
     }
+    this.updateStatusBar(app);
   }
-  unlockPath(app, path) {
-    const count = this.lockCountByPath.get(path) ?? 0;
+  reconcileAndCleanup(app) {
+    this.reconcile(app);
+    if (this.lockCountByPluginIdByPath.size === 0) {
+      this.eventsComponent?.unload();
+      this.eventsComponent = void 0;
+    }
+  }
+  registerUnlockMenu(app, el, getContextPath) {
+    el.addEventListener("contextmenu", (evt) => {
+      evt.preventDefault();
+      const path = getContextPath();
+      if (path === void 0) {
+        return;
+      }
+      const menu = new Menu();
+      menu.addItem((item) => {
+        item.setTitle(t(($) => $.obsidianDevUtils.editorLock.unlockMenuItem)).setIcon(UNLOCK_ICON_ID).onClick(convertAsyncToSync(async () => {
+          const isConfirmed = await confirm({
+            app,
+            message: this.unlockConfirmMessage(app, path),
+            title: t(($) => $.obsidianDevUtils.editorLock.unlockConfirmTitle)
+          });
+          if (isConfirmed) {
+            this.requestUnlock(app, path);
+          }
+        }));
+      });
+      menu.showAtMouseEvent(evt);
+    });
+  }
+  unlockConfirmMessage(app, path) {
+    const header = t(($) => $.obsidianDevUtils.editorLock.unlockConfirmMessage);
+    return [header, ...this.lockingPluginNames(app, path)].join("\n");
+  }
+  unlockPath(app, path, pluginId) {
+    const lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);
+    if (!lockCountByPluginId) {
+      return;
+    }
+    const count = lockCountByPluginId.get(pluginId) ?? 0;
     if (count <= 0) {
       return;
     }
     if (count === 1) {
-      this.lockCountByPath.delete(path);
+      lockCountByPluginId.delete(pluginId);
     } else {
-      this.lockCountByPath.set(path, count - 1);
+      lockCountByPluginId.set(pluginId, count - 1);
     }
-    this.reconcile(app);
-    if (this.lockCountByPath.size === 0) {
-      this.unregisterEvents(app);
+    if (lockCountByPluginId.size === 0) {
+      this.lockCountByPluginIdByPath.delete(path);
     }
+    this.reconcileAndCleanup(app);
   }
-  unregisterEvents(app) {
-    for (const eventRef of this.eventRefs) {
-      app.workspace.offref(eventRef);
+  updateIndicatorTooltips(indicators, tooltip) {
+    setTooltip(indicators.actionIconEl, tooltip);
+    if (indicators.tabIconEl) {
+      setTooltip(indicators.tabIconEl, tooltip);
     }
-    this.eventRefs = [];
+  }
+  updateStatusBar(app) {
+    const activeView = app.workspace.getActiveViewOfType(MarkdownView);
+    const activePath = activeView?.file?.path;
+    const isActiveLocked = activePath !== void 0 && this.isPathLocked(activePath);
+    if (!isActiveLocked || !activeView) {
+      this.statusBarItemEl?.remove();
+      this.statusBarItemEl = null;
+      return;
+    }
+    if (!this.statusBarItemEl) {
+      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector(STATUS_BAR_CSS_SELECTOR);
+      if (!statusBarEl) {
+        return;
+      }
+      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });
+      setIcon(this.statusBarItemEl, LOCK_ICON_ID);
+      this.registerUnlockMenu(app, this.statusBarItemEl, () => app.workspace.getActiveViewOfType(MarkdownView)?.file?.path);
+    }
+    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activePath));
+  }
+}
+class EditorLockComponent extends ComponentEx {
+  app;
+  pluginId;
+  /**
+   * Creates an editor-lock handle owned by a plugin.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pluginId - The id of the owning plugin. Defaults to the current plugin context's id; pass
+   * it explicitly (e.g. from a plugin's `manifest.id`) when constructing before the plugin context is
+   * initialized, such as inside `PluginBase.onload`.
+   */
+  constructor(app, pluginId = getPluginId()) {
+    super();
+    this.app = app;
+    this.pluginId = pluginId;
+  }
+  /**
+   * Checks whether the note at the given path is currently locked by any plugin.
+   *
+   * @param pathOrFile - The path or file of the note to check.
+   * @returns `true` if the note has at least one active lock, `false` otherwise.
+   */
+  isLockedForPath(pathOrFile) {
+    return getManager().isLocked(this.app, pathOrFile);
+  }
+  /**
+   * Locks the note at the given path on behalf of this plugin, making it read-only in every current
+   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call
+   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.
+   *
+   * @param pathOrFile - The path or file of the note to lock.
+   * @param options - Optional locking options. Pass an
+   * {@link EditorLockComponentLockForPathOptions.abortController} to make the lock cancelable via the
+   * indicator's right-click "unlock" menu or {@link requestEditorUnlockForPath}.
+   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+   */
+  lockForPath(pathOrFile, options) {
+    return getManager().lock(this.app, pathOrFile, this.pluginId, options?.abortController);
+  }
+  /**
+   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,
+   * so no note is left stuck read-only by an operation that never completed.
+   */
+  onunload() {
+    getManager().unlockAllForPlugin(this.app, this.pluginId);
+    super.onunload();
+  }
+  /**
+   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.
+   *
+   * @param pathOrFile - The path or file of the note to unlock.
+   */
+  unlockForPath(pathOrFile) {
+    getManager().unlock(this.app, pathOrFile, this.pluginId);
   }
 }
 function isEditorLockedForPath(app, pathOrFile) {
   return getManager().isLocked(app, pathOrFile);
 }
 function lockEditorForPath(app, pathOrFile) {
-  return getManager().lock(app, pathOrFile);
+  return getManager().lock(app, pathOrFile, getPluginId());
+}
+function requestEditorUnlockForPath(app, pathOrFile) {
+  getManager().requestUnlock(app, pathOrFile);
 }
 function unlockEditorForPath(app, pathOrFile) {
-  getManager().unlock(app, pathOrFile);
+  getManager().unlock(app, pathOrFile, getPluginId());
 }
 function getManager() {
   return getObsidianDevUtilsState(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;
 }
 export {
+  EditorLockComponent,
   isEditorLockedForPath,
   lockEditorForPath,
+  requestEditorUnlockForPath,
   unlockEditorForPath
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/editor-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Note-scoped, reference-counted editor locking.\n *\n * Where {@link lockEditor} / {@link unlockEditor} from `./editor.ts` toggle the read-only state of a\n * single {@link Editor} instance, the helpers here lock a note by its **path**: while a path is\n * locked, every current and future {@link MarkdownView} of that note (in any window, including\n * popouts) is made read-only and shows a lock icon. Locks are reference-counted, so nested or\n * concurrent operations on the same note are safe \u2014 the note is unlocked only when the last lock is\n * released.\n *\n * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration\n * that releases automatically at scope exit (including on throw):\n *\n * ```ts\n * using _lock = lockEditorForPath(app, path);\n * // ... long-running work (process, processFrontMatter, merge/split) ...\n * // auto-unlocked at scope exit\n * ```\n *\n * The explicit {@link unlockEditorForPath} pair remains available for non-`using` call sites.\n */\n\nimport type {\n  App,\n  EventRef\n} from 'obsidian';\n\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { MarkdownView } from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '../disposable.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport {\n  lockEditor,\n  unlockEditor\n} from './editor.ts';\nimport { getPath } from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\n\nconst EDITOR_LOCK_STATE_KEY = 'editorLock';\nconst LOCK_ICON_ID = 'lock';\n\n/**\n * Tracks reference-counted, path-scoped editor locks and keeps every open {@link MarkdownView} in\n * sync with the locked-path set. A single instance lives on the shared `obsidian-dev-utils` state.\n */\nclass EditorPathLockManager {\n  private eventRefs: EventRef[] = [];\n  private readonly lockCountByPath = new Map<string, number>();\n  private readonly lockedIconElByView = new Map<MarkdownView, HTMLElement>();\n\n  public isLocked(app: App, pathOrFile: PathOrFile): boolean {\n    return (this.lockCountByPath.get(getPath(app, pathOrFile)) ?? 0) > 0;\n  }\n\n  public lock(app: App, pathOrFile: PathOrFile): Disposable {\n    const path = getPath(app, pathOrFile);\n    this.lockCountByPath.set(path, (this.lockCountByPath.get(path) ?? 0) + 1);\n    this.ensureEventsRegistered(app);\n    this.reconcile(app);\n\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.unlockPath(app, path);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  public unlock(app: App, pathOrFile: PathOrFile): void {\n    this.unlockPath(app, getPath(app, pathOrFile));\n  }\n\n  private ensureEventsRegistered(app: App): void {\n    if (this.eventRefs.length > 0) {\n      return;\n    }\n\n    const reconcile = (): void => {\n      this.reconcile(app);\n    };\n    this.eventRefs.push(\n      app.workspace.on('active-leaf-change', reconcile),\n      app.workspace.on('layout-change', reconcile)\n    );\n  }\n\n  private reconcile(app: App): void {\n    const viewsToLock = new Set<MarkdownView>();\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      const path = view.file?.path;\n      if (path === undefined) {\n        continue;\n      }\n\n      if ((this.lockCountByPath.get(path) ?? 0) > 0) {\n        viewsToLock.add(view);\n        if (!this.lockedIconElByView.has(view)) {\n          lockEditor(view.editor);\n          const iconEl = view.addAction(LOCK_ICON_ID, t(($) => $.obsidianDevUtils.editorLock.lockedNoteTooltip), noop);\n          this.lockedIconElByView.set(view, iconEl);\n        }\n      }\n    }\n\n    for (const [view, iconEl] of this.lockedIconElByView) {\n      if (!viewsToLock.has(view)) {\n        unlockEditor(view.editor);\n        iconEl.remove();\n        this.lockedIconElByView.delete(view);\n      }\n    }\n  }\n\n  private unlockPath(app: App, path: string): void {\n    const count = this.lockCountByPath.get(path) ?? 0;\n    if (count <= 0) {\n      return;\n    }\n\n    if (count === 1) {\n      this.lockCountByPath.delete(path);\n    } else {\n      this.lockCountByPath.set(path, count - 1);\n    }\n\n    this.reconcile(app);\n\n    if (this.lockCountByPath.size === 0) {\n      this.unregisterEvents(app);\n    }\n  }\n\n  private unregisterEvents(app: App): void {\n    for (const eventRef of this.eventRefs) {\n      app.workspace.offref(eventRef);\n    }\n    this.eventRefs = [];\n  }\n}\n\n/**\n * Checks whether the note at the given path is currently locked.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the note has at least one active lock, `false` otherwise.\n */\nexport function isEditorLockedForPath(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLocked(app, pathOrFile);\n}\n\n/**\n * Locks the note at the given path, making it read-only in every current and future\n * {@link MarkdownView} until the lock is released.\n *\n * The lock is reference-counted: each call must be balanced by exactly one release (either disposing\n * the returned {@link Disposable} \u2014 ideally via a `using` declaration \u2014 or a matching\n * {@link unlockEditorForPath} call).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to lock.\n * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n */\nexport function lockEditorForPath(app: App, pathOrFile: PathOrFile): Disposable {\n  return getManager().lock(app, pathOrFile);\n}\n\n/**\n * Releases one lock previously acquired for the note at the given path via {@link lockEditorForPath}.\n *\n * When the last lock is released the note becomes fully editable again and its lock icon is removed.\n * Calling this when the note is not locked is a no-op.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to unlock.\n */\nexport function unlockEditorForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().unlock(app, pathOrFile);\n}\n\nfunction getManager(): EditorPathLockManager {\n  return getObsidianDevUtilsState<EditorPathLockManager>(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/editor-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Note-scoped, reference-counted editor locking.\n *\n * Where {@link toggleEditorReadOnly} from `./editor.ts` toggles the read-only state of a single\n * {@link Editor} instance, the helpers here lock a note by its **path**: while a path is\n * locked, every current and future {@link MarkdownView} of that note (in any window, including\n * popouts) is made read-only and shows a lock indicator in its tab header, its view action bar, and\n * the status bar (while the note is active). Locks are reference-counted per locking plugin, so\n * nested or concurrent operations on the same note are safe \u2014 the note is unlocked only when the\n * last lock is released \u2014 and the indicators' tooltip lists which plugins currently hold a lock.\n *\n * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration\n * that releases automatically at scope exit (including on throw):\n *\n * ```ts\n * using _lock = lockEditorForPath(app, path);\n * // ... long-running work (process, processFrontMatter, merge/split) ...\n * // auto-unlocked at scope exit\n * ```\n *\n * The explicit {@link unlockEditorForPath} pair remains available for non-`using` call sites.\n */\n\nimport type { App } from 'obsidian';\n\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  MarkdownView,\n  Menu,\n  setIcon,\n  setTooltip\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { convertAsyncToSync } from '../async.ts';\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '../disposable.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport { ComponentEx } from './components/component-ex.ts';\nimport { toggleEditorReadOnly } from './editor.ts';\nimport { getPath } from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { getPluginId } from './plugin/plugin-id.ts';\n\nconst EDITOR_LOCK_STATE_KEY = 'editorLock';\nconst LOCK_ICON_ID = 'lock';\nconst LOCK_INDICATOR_CSS_CLASS = 'obsidian-dev-utils-lock-indicator';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\nconst STATUS_BAR_CSS_SELECTOR = '.status-bar';\nconst UNLOCK_ICON_ID = 'unlock';\n\n/**\n * Options for {@link EditorLockComponent.lockForPath}.\n */\nexport interface EditorLockComponentLockForPathOptions {\n  /**\n   * An optional {@link AbortController} associated with the lock. When the lock indicator is\n   * right-clicked and the user confirms an unlock (or {@link requestEditorUnlockForPath} is called for\n   * the path), this controller is aborted so the operation holding the lock can cancel itself and\n   * release the lock in its own cleanup.\n   */\n  readonly abortController?: AbortController;\n}\n\ninterface LockIndicators {\n  readonly actionIconEl: HTMLElement;\n  readonly tabIconEl: HTMLElement | null;\n}\n\n/**\n * Subscribes to the workspace events that should trigger a lock reconcile. Implemented as a\n * {@link ComponentEx} so the subscriptions are registered on `load()` and automatically removed on\n * `unload()`, instead of being tracked and torn down by hand.\n */\nclass EditorLockEventsComponent extends ComponentEx {\n  public constructor(private readonly app: App, private readonly onChange: () => void) {\n    super();\n  }\n\n  public override onload(): void {\n    super.onload();\n    this.registerEvent(this.app.workspace.on('active-leaf-change', this.onChange));\n    this.registerEvent(this.app.workspace.on('layout-change', this.onChange));\n    // Same-leaf navigation to another note fires no leaf/layout change; without this it stays read-only.\n    this.registerEvent(this.app.workspace.on('file-open', this.onChange));\n  }\n}\n\n/**\n * Tracks reference-counted, path-scoped editor locks and keeps every open {@link MarkdownView} in\n * sync with the locked-path set. A single instance lives on the shared `obsidian-dev-utils` state.\n * For each locked path the lock count is tracked per locking plugin, so the indicators can report\n * which plugins currently hold a lock.\n */\nclass EditorPathLockManager {\n  private readonly abortControllersByPath = new Map<string, Set<AbortController>>();\n  private eventsComponent: EditorLockEventsComponent | undefined;\n  private readonly indicatorsByView = new Map<MarkdownView, LockIndicators>();\n  private readonly lockCountByPluginIdByPath = new Map<string, Map<string, number>>();\n  private statusBarItemEl: HTMLElement | null = null;\n\n  public isLocked(app: App, pathOrFile: PathOrFile): boolean {\n    return this.isPathLocked(getPath(app, pathOrFile));\n  }\n\n  public lock(app: App, pathOrFile: PathOrFile, pluginId: string, abortController?: AbortController): Disposable {\n    const path = getPath(app, pathOrFile);\n    let lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);\n    if (!lockCountByPluginId) {\n      lockCountByPluginId = new Map<string, number>();\n      this.lockCountByPluginIdByPath.set(path, lockCountByPluginId);\n    }\n    lockCountByPluginId.set(pluginId, (lockCountByPluginId.get(pluginId) ?? 0) + 1);\n    if (abortController) {\n      let abortControllers = this.abortControllersByPath.get(path);\n      if (!abortControllers) {\n        abortControllers = new Set<AbortController>();\n        this.abortControllersByPath.set(path, abortControllers);\n      }\n      abortControllers.add(abortController);\n    }\n    this.ensureSubscribed(app);\n    this.reconcile(app);\n\n    return new CallbackDisposable({\n      callback: (): void => {\n        if (abortController) {\n          const abortControllers = this.abortControllersByPath.get(path);\n          // The set was created when this lock added its controller and is only removed here.\n          // It is therefore always present while this (single-run) disposable callback executes.\n          assertNonNullable(abortControllers);\n          abortControllers.delete(abortController);\n          if (abortControllers.size === 0) {\n            this.abortControllersByPath.delete(path);\n          }\n        }\n        this.unlockPath(app, path, pluginId);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  /**\n   * Aborts every {@link AbortController} currently registered for the note at the given path, which\n   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`\n   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller\n   * is registered for the path.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file of the note to request an unlock for.\n   */\n  public requestUnlock(app: App, pathOrFile: PathOrFile): void {\n    const abortControllers = this.abortControllersByPath.get(getPath(app, pathOrFile));\n    if (!abortControllers) {\n      return;\n    }\n    for (const controller of abortControllers) {\n      controller.abort();\n    }\n  }\n\n  public unlock(app: App, pathOrFile: PathOrFile, pluginId: string): void {\n    this.unlockPath(app, getPath(app, pathOrFile), pluginId);\n  }\n\n  public unlockAllForPlugin(app: App, pluginId: string): void {\n    for (const [path, lockCountByPluginId] of this.lockCountByPluginIdByPath) {\n      if (lockCountByPluginId.delete(pluginId) && lockCountByPluginId.size === 0) {\n        this.lockCountByPluginIdByPath.delete(path);\n      }\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  private createIndicators(app: App, view: MarkdownView, path: string, tooltip: string): LockIndicators {\n    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);\n    this.registerUnlockMenu(app, actionIconEl, () => path);\n\n    let tabIconEl: HTMLElement | null = null;\n    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;\n    if (tabStatusContainerEl) {\n      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });\n      setIcon(tabIconEl, LOCK_ICON_ID);\n      setTooltip(tabIconEl, tooltip);\n      this.registerUnlockMenu(app, tabIconEl, () => path);\n    }\n\n    return {\n      actionIconEl,\n      tabIconEl\n    };\n  }\n\n  private ensureSubscribed(app: App): void {\n    if (this.eventsComponent) {\n      return;\n    }\n    this.eventsComponent = new EditorLockEventsComponent(app, () => {\n      this.reconcile(app);\n    });\n    this.eventsComponent.load();\n  }\n\n  private isPathLocked(path: string): boolean {\n    return (this.lockCountByPluginIdByPath.get(path)?.size ?? 0) > 0;\n  }\n\n  private lockingPluginNames(app: App, path: string): string[] {\n    const lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);\n    // `lockingPluginNames` is only ever called for a locked path, so the per-plugin map is always present.\n    assertNonNullable(lockCountByPluginId);\n    return Array.from(lockCountByPluginId.keys()).map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);\n  }\n\n  private lockTooltip(app: App, path: string): string {\n    const header = t(($) => $.obsidianDevUtils.editorLock.lockedByTooltip);\n    // A runtime-length list of plugin names, one per line under the header.\n    return [header, ...this.lockingPluginNames(app, path)].join('\\n');\n  }\n\n  private reconcile(app: App): void {\n    const viewsToLock = new Set<MarkdownView>();\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      const path = view.file?.path;\n      if (path === undefined) {\n        continue;\n      }\n\n      if (this.isPathLocked(path)) {\n        viewsToLock.add(view);\n        const tooltip = this.lockTooltip(app, path);\n        // Re-apply the read-only toggle on every reconcile, not only the first time a view is tracked.\n        // The toggle is idempotent, so re-applying to an already-locked view is cheap.\n        // A view opened after the lock is reconciled synchronously, before its CodeMirror is ready.\n        // Its first toggle is therefore a no-op; re-applying makes the lock take hold once it settles.\n        toggleEditorReadOnly(view.editor, true);\n        const indicators = this.indicatorsByView.get(view);\n        if (indicators) {\n          this.updateIndicatorTooltips(indicators, tooltip);\n        } else {\n          this.indicatorsByView.set(view, this.createIndicators(app, view, path, tooltip));\n        }\n      }\n    }\n\n    for (const [view, indicators] of this.indicatorsByView) {\n      if (!viewsToLock.has(view)) {\n        toggleEditorReadOnly(view.editor, false);\n        indicators.actionIconEl.remove();\n        indicators.tabIconEl?.remove();\n        this.indicatorsByView.delete(view);\n      }\n    }\n\n    this.updateStatusBar(app);\n  }\n\n  private reconcileAndCleanup(app: App): void {\n    this.reconcile(app);\n    if (this.lockCountByPluginIdByPath.size === 0) {\n      this.eventsComponent?.unload();\n      this.eventsComponent = undefined;\n    }\n  }\n\n  private registerUnlockMenu(app: App, el: HTMLElement, getContextPath: () => string | undefined): void {\n    // A plain listener dies with the element when it is `.remove()`d on unlock, so it never leaks.\n    el.addEventListener('contextmenu', (evt) => {\n      evt.preventDefault();\n      const path = getContextPath();\n      if (path === undefined) {\n        return;\n      }\n      const menu = new Menu();\n      menu.addItem((item) => {\n        item\n          .setTitle(t(($) => $.obsidianDevUtils.editorLock.unlockMenuItem))\n          .setIcon(UNLOCK_ICON_ID)\n          .onClick(convertAsyncToSync(async () => {\n            const isConfirmed = await confirm({\n              app,\n              message: this.unlockConfirmMessage(app, path),\n              title: t(($) => $.obsidianDevUtils.editorLock.unlockConfirmTitle)\n            });\n            if (isConfirmed) {\n              this.requestUnlock(app, path);\n            }\n          }));\n      });\n      menu.showAtMouseEvent(evt);\n    });\n  }\n\n  private unlockConfirmMessage(app: App, path: string): string {\n    const header = t(($) => $.obsidianDevUtils.editorLock.unlockConfirmMessage);\n    // A runtime-length list of the plugins currently holding a lock, one per line under the header.\n    return [header, ...this.lockingPluginNames(app, path)].join('\\n');\n  }\n\n  private unlockPath(app: App, path: string, pluginId: string): void {\n    const lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);\n    if (!lockCountByPluginId) {\n      return;\n    }\n\n    const count = lockCountByPluginId.get(pluginId) ?? 0;\n    if (count <= 0) {\n      return;\n    }\n\n    if (count === 1) {\n      lockCountByPluginId.delete(pluginId);\n    } else {\n      lockCountByPluginId.set(pluginId, count - 1);\n    }\n\n    if (lockCountByPluginId.size === 0) {\n      this.lockCountByPluginIdByPath.delete(path);\n    }\n\n    this.reconcileAndCleanup(app);\n  }\n\n  private updateIndicatorTooltips(indicators: LockIndicators, tooltip: string): void {\n    setTooltip(indicators.actionIconEl, tooltip);\n    if (indicators.tabIconEl) {\n      setTooltip(indicators.tabIconEl, tooltip);\n    }\n  }\n\n  private updateStatusBar(app: App): void {\n    const activeView = app.workspace.getActiveViewOfType(MarkdownView);\n    const activePath = activeView?.file?.path;\n    const isActiveLocked = activePath !== undefined && this.isPathLocked(activePath);\n\n    if (!isActiveLocked || !activeView) {\n      this.statusBarItemEl?.remove();\n      this.statusBarItemEl = null;\n      return;\n    }\n\n    if (!this.statusBarItemEl) {\n      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector<HTMLElement>(STATUS_BAR_CSS_SELECTOR);\n      if (!statusBarEl) {\n        return;\n      }\n      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });\n      setIcon(this.statusBarItemEl, LOCK_ICON_ID);\n      // The single status-bar item is reused across active-note switches.\n      // It must resolve the currently active note's path at click time rather than capturing one path.\n      this.registerUnlockMenu(app, this.statusBarItemEl, () => app.workspace.getActiveViewOfType(MarkdownView)?.file?.path);\n    }\n\n    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activePath));\n  }\n}\n\n/**\n * A per-plugin handle for note-scoped editor locking. Add it as a child of your plugin\n * (`this.addChild(new EditorLockComponent(this.app))`) so that any locks it still holds are released\n * automatically when the plugin unloads \u2014 a note can never be left stuck read-only because the\n * plugin that locked it was disabled or reloaded mid-operation.\n *\n * Locks are reference-counted and attributed to this plugin, so the lock indicators' tooltip names\n * it among the plugins currently holding a lock.\n */\nexport class EditorLockComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly pluginId: string;\n\n  /**\n   * Creates an editor-lock handle owned by a plugin.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pluginId - The id of the owning plugin. Defaults to the current plugin context's id; pass\n   * it explicitly (e.g. from a plugin's `manifest.id`) when constructing before the plugin context is\n   * initialized, such as inside `PluginBase.onload`.\n   */\n  public constructor(app: App, pluginId: string = getPluginId()) {\n    super();\n    this.app = app;\n    this.pluginId = pluginId;\n  }\n\n  /**\n   * Checks whether the note at the given path is currently locked by any plugin.\n   *\n   * @param pathOrFile - The path or file of the note to check.\n   * @returns `true` if the note has at least one active lock, `false` otherwise.\n   */\n  public isLockedForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isLocked(this.app, pathOrFile);\n  }\n\n  /**\n   * Locks the note at the given path on behalf of this plugin, making it read-only in every current\n   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call\n   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.\n   *\n   * @param pathOrFile - The path or file of the note to lock.\n   * @param options - Optional locking options. Pass an\n   * {@link EditorLockComponentLockForPathOptions.abortController} to make the lock cancelable via the\n   * indicator's right-click \"unlock\" menu or {@link requestEditorUnlockForPath}.\n   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n   */\n  public lockForPath(pathOrFile: PathOrFile, options?: EditorLockComponentLockForPathOptions): Disposable {\n    return getManager().lock(this.app, pathOrFile, this.pluginId, options?.abortController);\n  }\n\n  /**\n   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,\n   * so no note is left stuck read-only by an operation that never completed.\n   */\n  public override onunload(): void {\n    getManager().unlockAllForPlugin(this.app, this.pluginId);\n    super.onunload();\n  }\n\n  /**\n   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.\n   *\n   * @param pathOrFile - The path or file of the note to unlock.\n   */\n  public unlockForPath(pathOrFile: PathOrFile): void {\n    getManager().unlock(this.app, pathOrFile, this.pluginId);\n  }\n}\n\n/**\n * Checks whether the note at the given path is currently locked.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the note has at least one active lock, `false` otherwise.\n */\nexport function isEditorLockedForPath(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLocked(app, pathOrFile);\n}\n\n/**\n * Locks the note at the given path, making it read-only in every current and future\n * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,\n * view action bar, and (while active) the status bar. The indicators' tooltip lists the plugins\n * that currently hold a lock on the note.\n *\n * The lock is reference-counted per calling plugin: each call must be balanced by exactly one\n * release (either disposing the returned {@link Disposable} \u2014 ideally via a `using` declaration \u2014 or\n * a matching {@link unlockEditorForPath} call).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to lock.\n * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n */\nexport function lockEditorForPath(app: App, pathOrFile: PathOrFile): Disposable {\n  return getManager().lock(app, pathOrFile, getPluginId());\n}\n\n/**\n * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was\n * associated with a lock on it (via {@link EditorLockComponent.lockForPath}'s\n * {@link EditorLockComponentLockForPathOptions.abortController}). The operations holding the lock\n * observe the abort and release their own locks. A no-op when no abortable lock is registered for the\n * path.\n *\n * This lets a consuming plugin wire its own \"unlock active note\" command without reaching into the\n * lock manager directly.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to request an unlock for.\n */\nexport function requestEditorUnlockForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().requestUnlock(app, pathOrFile);\n}\n\n/**\n * Releases one lock previously acquired for the note at the given path via {@link lockEditorForPath}.\n *\n * When the last lock is released the note becomes fully editable again and its lock indicators are\n * removed. Calling this when the note is not locked is a no-op.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to unlock.\n */\nexport function unlockEditorForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().unlock(app, pathOrFile, getPluginId());\n}\n\nfunction getManager(): EditorPathLockManager {\n  return getObsidianDevUtilsState<EditorPathLockManager>(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/editor.d.mts

@@ -6,15 +6,19 @@
  */
 import type { Editor } from 'obsidian';
 /**
- * Locks the editor.
+ * Toggles the read-only state of a single CodeMirror instance — the low-level primitive behind
+ * editor locking.
  *
- * @param editor - The editor to lock.
- * @returns A {@link Disposable} that unlocks the editor when disposed, for use with `using`.
- */
-export declare function lockEditor(editor: Editor): Disposable;
-/**
- * Unlocks the editor.
+ * When read-only, the editor stays focusable and interactive (selection, copy, and app hotkeys such
+ * as the command palette keep working) — only document edits are prevented, via the CodeMirror
+ * `readOnly` state.
+ *
+ * This toggles ONE CodeMirror instance, not "a file": an Obsidian {@link Editor} is reused as its
+ * leaf navigates between notes, so this primitive does not follow a note around. To lock a note
+ * across every editor that shows it (current and future, in any window), use `lockEditorForPath`
+ * from `./editor-lock.ts`.
  *
- * @param editor - The editor to unlock.
+ * @param editor - The editor whose CodeMirror instance to toggle.
+ * @param isReadOnly - `true` to make the editor read-only, `false` to make it editable again.
  */
-export declare function unlockEditor(editor: Editor): void;
+export declare function toggleEditorReadOnly(editor: Editor, isReadOnly: boolean): void;

package/dist/lib/esm/obsidian/editor.mjs

@@ -23,44 +23,31 @@ if you want to view the source, please visit the github repository of this plugi
 
 import {
   Compartment,
-  EditorState
+  EditorState,
+  StateEffect
 } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { CallbackDisposable } from "../disposable.mjs";
-const editorCompartmentMap = /* @__PURE__ */ new WeakMap();
-function lockEditor(editor) {
+import { castTo } from "../object-utils.mjs";
+const compartmentByCodeMirror = /* @__PURE__ */ new WeakMap();
+function toggleEditorReadOnly(editor, isReadOnly) {
   const compartment = ensureCompartment(editor);
   editor.cm.dispatch({
-    effects: compartment.reconfigure([
-      EditorState.readOnly.of(true),
-      EditorView.editable.of(false)
-    ])
-  });
-  return new CallbackDisposable({
-    callback: () => {
-      unlockEditor(editor);
-    }
-  });
-}
-function unlockEditor(editor) {
-  const compartment = ensureCompartment(editor);
-  editor.cm.dispatch({
-    effects: compartment.reconfigure([
-      EditorState.readOnly.of(false),
-      EditorView.editable.of(true)
-    ])
+    effects: compartment.reconfigure(isReadOnly ? EditorState.readOnly.of(true) : [])
   });
 }
 function ensureCompartment(editor) {
-  let compartment = editorCompartmentMap.get(editor);
-  if (!compartment) {
-    compartment = new Compartment();
-    editorCompartmentMap.set(editor, compartment);
+  const codeMirror = editor.cm;
+  const cachedCompartment = compartmentByCodeMirror.get(codeMirror);
+  if (cachedCompartment?.get(castTo(codeMirror.state)) !== void 0) {
+    return cachedCompartment;
   }
+  const compartment = new Compartment();
+  compartmentByCodeMirror.set(codeMirror, compartment);
+  codeMirror.dispatch({
+    effects: StateEffect.appendConfig.of(compartment.of([]))
+  });
   return compartment;
 }
 export {
-  lockEditor,
-  unlockEditor
+  toggleEditorReadOnly
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2VkaXRvci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIHV0aWxpdHkgZnVuY3Rpb25zIGZvciB3b3JraW5nIHdpdGggbWFya2Rvd24gZWRpdG9ycyBpbiBPYnNpZGlhblxuICovXG5cbmltcG9ydCB0eXBlIHsgRWRpdG9yIH0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQge1xuICBDb21wYXJ0bWVudCxcbiAgRWRpdG9yU3RhdGUsXG4gIFN0YXRlRWZmZWN0XG59IGZyb20gJ0Bjb2RlbWlycm9yL3N0YXRlJztcblxuaW1wb3J0IHsgY2FzdFRvIH0gZnJvbSAnLi4vb2JqZWN0LXV0aWxzLnRzJztcblxuY29uc3QgY29tcGFydG1lbnRCeUNvZGVNaXJyb3IgPSBuZXcgV2Vha01hcDxFZGl0b3JbJ2NtJ10sIENvbXBhcnRtZW50PigpO1xuXG4vKipcbiAqIFRvZ2dsZXMgdGhlIHJlYWQtb25seSBzdGF0ZSBvZiBhIHNpbmdsZSBDb2RlTWlycm9yIGluc3RhbmNlIFx1MjAxNCB0aGUgbG93LWxldmVsIHByaW1pdGl2ZSBiZWhpbmRcbiAqIGVkaXRvciBsb2NraW5nLlxuICpcbiAqIFdoZW4gcmVhZC1vbmx5LCB0aGUgZWRpdG9yIHN0YXlzIGZvY3VzYWJsZSBhbmQgaW50ZXJhY3RpdmUgKHNlbGVjdGlvbiwgY29weSwgYW5kIGFwcCBob3RrZXlzIHN1Y2hcbiAqIGFzIHRoZSBjb21tYW5kIHBhbGV0dGUga2VlcCB3b3JraW5nKSBcdTIwMTQgb25seSBkb2N1bWVudCBlZGl0cyBhcmUgcHJldmVudGVkLCB2aWEgdGhlIENvZGVNaXJyb3JcbiAqIGByZWFkT25seWAgc3RhdGUuXG4gKlxuICogVGhpcyB0b2dnbGVzIE9ORSBDb2RlTWlycm9yIGluc3RhbmNlLCBub3QgXCJhIGZpbGVcIjogYW4gT2JzaWRpYW4ge0BsaW5rIEVkaXRvcn0gaXMgcmV1c2VkIGFzIGl0c1xuICogbGVhZiBuYXZpZ2F0ZXMgYmV0d2VlbiBub3Rlcywgc28gdGhpcyBwcmltaXRpdmUgZG9lcyBub3QgZm9sbG93IGEgbm90ZSBhcm91bmQuIFRvIGxvY2sgYSBub3RlXG4gKiBhY3Jvc3MgZXZlcnkgZWRpdG9yIHRoYXQgc2hvd3MgaXQgKGN1cnJlbnQgYW5kIGZ1dHVyZSwgaW4gYW55IHdpbmRvdyksIHVzZSBgbG9ja0VkaXRvckZvclBhdGhgXG4gKiBmcm9tIGAuL2VkaXRvci1sb2NrLnRzYC5cbiAqXG4gKiBAcGFyYW0gZWRpdG9yIC0gVGhlIGVkaXRvciB3aG9zZSBDb2RlTWlycm9yIGluc3RhbmNlIHRvIHRvZ2dsZS5cbiAqIEBwYXJhbSBpc1JlYWRPbmx5IC0gYHRydWVgIHRvIG1ha2UgdGhlIGVkaXRvciByZWFkLW9ubHksIGBmYWxzZWAgdG8gbWFrZSBpdCBlZGl0YWJsZSBhZ2Fpbi5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRvZ2dsZUVkaXRvclJlYWRPbmx5KGVkaXRvcjogRWRpdG9yLCBpc1JlYWRPbmx5OiBib29sZWFuKTogdm9pZCB7XG4gIGNvbnN0IGNvbXBhcnRtZW50ID0gZW5zdXJlQ29tcGFydG1lbnQoZWRpdG9yKTtcbiAgZWRpdG9yLmNtLmRpc3BhdGNoKHtcbiAgICBlZmZlY3RzOiBjb21wYXJ0bWVudC5yZWNvbmZpZ3VyZShpc1JlYWRPbmx5ID8gRWRpdG9yU3RhdGUucmVhZE9ubHkub2YodHJ1ZSkgOiBbXSlcbiAgfSk7XG59XG5cbmZ1bmN0aW9uIGVuc3VyZUNvbXBhcnRtZW50KGVkaXRvcjogRWRpdG9yKTogQ29tcGFydG1lbnQge1xuICAvLyBLZXkgdGhlIGNhY2hlIGJ5IHRoZSBDb2RlTWlycm9yIGluc3RhbmNlLCBub3QgYnkgdGhlIGBFZGl0b3JgIHdyYXBwZXIuXG4gIC8vIEFuIGBFZGl0b3JgIGtlZXBzIGl0cyBpZGVudGl0eSB3aGlsZSBpdHMgdW5kZXJseWluZyBDb2RlTWlycm9yIHZpZXcgaXMgc3dhcHBlZCBvdXQuXG4gIGNvbnN0IGNvZGVNaXJyb3IgPSBlZGl0b3IuY207XG4gIGNvbnN0IGNhY2hlZENvbXBhcnRtZW50ID0gY29tcGFydG1lbnRCeUNvZGVNaXJyb3IuZ2V0KGNvZGVNaXJyb3IpO1xuICAvLyBSZXVzZSB0aGUgY2FjaGVkIGNvbXBhcnRtZW50IG9ubHkgd2hpbGUgaXQgaXMgc3RpbGwgcGFydCBvZiB0aGUgY3VycmVudCBjb25maWd1cmF0aW9uLlxuICAvLyBBIHZpZXcgY2FuIHNpbGVudGx5IGRyb3AgYW4gYXBwZW5kZWQgY29tcGFydG1lbnQgd2hlbiBpdCByZWJ1aWxkcyBpdHMgc3RhdGUuXG4gIC8vIE9wZW5pbmcgYSBub3RlIGludG8gYSBmcmVzaGx5IGNyZWF0ZWQgbGVhZiBkb2VzIHRoaXM6IGl0IGluc3RhbGxzIHRoZSBjb21wYXJ0bWVudCBtaWQtb3Blbi5cbiAgLy8gVGhlIHN1YnNlcXVlbnQgbG9hZCB0aGVuIHJlcGxhY2VzIHRoZSB3aG9sZSBzdGF0ZSwgdGFraW5nIHRoZSBjb21wYXJ0bWVudCB3aXRoIGl0LlxuICAvLyBUaGVuIGBDb21wYXJ0bWVudC5nZXRgIHJldHVybnMgYHVuZGVmaW5lZGAsIHNpbmNlIHRoZSBjb21wYXJ0bWVudCBpcyBubyBsb25nZXIgY29uZmlndXJlZC5cbiAgLy8gUmUtaW5zdGFsbCBpdCBpbiB0aGF0IGNhc2UsIG9yIGV2ZXJ5IGxhdGVyIGByZWNvbmZpZ3VyZWAgaXMgc2lsZW50bHkgaWdub3JlZCBhbmQgbm90aGluZyBsb2Nrcy5cbiAgLy8gVGhlIGBjYXN0VG9gIGJyaWRnZXMgdGhlIGR1YWwgQ29tbW9uSlMgYW5kIEVTTSBgRWRpdG9yU3RhdGVgIGRlY2xhcmF0aW9ucyBvZiBgQGNvZGVtaXJyb3Ivc3RhdGVgLlxuICAvLyBUaGV5IGFyZSBzdHJ1Y3R1cmFsbHkgaWRlbnRpY2FsLCBidXQgVHlwZVNjcmlwdCB0cmVhdHMgdGhlbSBhcyBub21pbmFsbHkgaW5jb21wYXRpYmxlLlxuICBpZiAoY2FjaGVkQ29tcGFydG1lbnQ/LmdldChjYXN0VG88RWRpdG9yU3RhdGU+KGNvZGVNaXJyb3Iuc3RhdGUpKSAhPT0gdW5kZWZpbmVkKSB7XG4gICAgcmV0dXJuIGNhY2hlZENvbXBhcnRtZW50O1xuICB9XG5cbiAgY29uc3QgY29tcGFydG1lbnQgPSBuZXcgQ29tcGFydG1lbnQoKTtcbiAgY29tcGFydG1lbnRCeUNvZGVNaXJyb3Iuc2V0KGNvZGVNaXJyb3IsIGNvbXBhcnRtZW50KTtcbiAgLy8gQSBgQ29tcGFydG1lbnRgIG9ubHkgdGFrZXMgZWZmZWN0IG9uY2UgaXQgaXMgcGFydCBvZiB0aGUgZWRpdG9yJ3MgY29uZmlndXJhdGlvbi5cbiAgLy8gVGhlIGNvbXBhcnRtZW50IGlzIGNyZWF0ZWQgbGF6aWx5IGhlcmUsIHNvIGluc3RhbGwgaXQgKGluaXRpYWxseSBlbXB0eSkgdmlhIGBhcHBlbmRDb25maWdgLlxuICBjb2RlTWlycm9yLmRpc3BhdGNoKHtcbiAgICBlZmZlY3RzOiBTdGF0ZUVmZmVjdC5hcHBlbmRDb25maWcub2YoY29tcGFydG1lbnQub2YoW10pKVxuICB9KTtcbiAgcmV0dXJuIGNvbXBhcnRtZW50O1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFRQTtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFFUCxTQUFTLGNBQWM7QUFFdkIsTUFBTSwwQkFBMEIsb0JBQUksUUFBbUM7QUFrQmhFLFNBQVMscUJBQXFCLFFBQWdCLFlBQTJCO0FBQzlFLFFBQU0sY0FBYyxrQkFBa0IsTUFBTTtBQUM1QyxTQUFPLEdBQUcsU0FBUztBQUFBLElBQ2pCLFNBQVMsWUFBWSxZQUFZLGFBQWEsWUFBWSxTQUFTLEdBQUcsSUFBSSxJQUFJLENBQUMsQ0FBQztBQUFBLEVBQ2xGLENBQUM7QUFDSDtBQUVBLFNBQVMsa0JBQWtCLFFBQTZCO0FBR3RELFFBQU0sYUFBYSxPQUFPO0FBQzFCLFFBQU0sb0JBQW9CLHdCQUF3QixJQUFJLFVBQVU7QUFTaEUsTUFBSSxtQkFBbUIsSUFBSSxPQUFvQixXQUFXLEtBQUssQ0FBQyxNQUFNLFFBQVc7QUFDL0UsV0FBTztBQUFBLEVBQ1Q7QUFFQSxRQUFNLGNBQWMsSUFBSSxZQUFZO0FBQ3BDLDBCQUF3QixJQUFJLFlBQVksV0FBVztBQUduRCxhQUFXLFNBQVM7QUFBQSxJQUNsQixTQUFTLFlBQVksYUFBYSxHQUFHLFlBQVksR0FBRyxDQUFDLENBQUMsQ0FBQztBQUFBLEVBQ3pELENBQUM7QUFDRCxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/obsidian/file-manager.d.mts

@@ -7,6 +7,7 @@
 import type { App } from 'obsidian';
 import type { Promisable } from 'type-fest';
 import type { MaybeReturn } from '../type.mjs';
+import type { EditorLockComponent } from './editor-lock.mjs';
 import type { PathOrFile } from './file-system.mjs';
 import type { CombinedFrontmatter } from './frontmatter.mjs';
 import type { ProcessOptions } from './vault.mjs';
@@ -22,6 +23,10 @@ export interface AddAliasParams {
      * The Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * The editor-lock component used to lock the note while it is being modified.
+     */
+    readonly editorLockComponent: EditorLockComponent | null;
     /**
      * The path or TFile object representing the note.
      */
@@ -39,6 +44,10 @@ export interface DeleteAliasParams {
      * The Obsidian app instance.
      */
     readonly app: App;
+    /**
+     * The editor-lock component used to lock the note while it is being modified.
+     */
+    readonly editorLockComponent: EditorLockComponent | null;
     /**
      * The path or TFile object representing the note.
      */