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

package/dist/lib/cjs/obsidian/editor-lock.cjs

@@ -125,56 +125,154 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var editor_lock_exports = {};
 __export(editor_lock_exports, {
+  EditorLockComponent: () => EditorLockComponent,
   isEditorLockedForPath: () => isEditorLockedForPath,
   lockEditorForPath: () => lockEditorForPath,
+  requestEditorUnlockForPath: () => requestEditorUnlockForPath,
   unlockEditorForPath: () => unlockEditorForPath
 });
 module.exports = __toCommonJS(editor_lock_exports);
 var import_implementations = require('@obsidian-typings/obsidian-public-latest/implementations');
 var import_obsidian = require('obsidian');
+var import_async = require('../async.cjs');
 var import_disposable = require('../disposable.cjs');
 var import_function = require('../function.cjs');
 var import_obsidian_dev_utils_state = require('../obsidian-dev-utils-state.cjs');
+var import_type_guards = require('../type-guards.cjs');
+var import_component_ex = require('./components/component-ex.cjs');
 var import_editor = require('./editor.cjs');
 var import_file_system = require('./file-system.cjs');
 var import_i18n = require('./i18n/i18n.cjs');
+var import_confirm = require('./modals/confirm.cjs');
+var import_plugin_id = require('./plugin/plugin-id.cjs');
 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 import_component_ex.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((0, import_file_system.getPath)(app, pathOrFile)) ?? 0) > 0;
+    return this.isPathLocked((0, import_file_system.getPath)(app, pathOrFile));
   }
-  lock(app, pathOrFile) {
+  lock(app, pathOrFile, pluginId, abortController) {
     const path = (0, import_file_system.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 import_disposable.CallbackDisposable({
       callback: () => {
-        this.unlockPath(app, path);
+        if (abortController) {
+          const abortControllers = this.abortControllersByPath.get(path);
+          (0, import_type_guards.assertNonNullable)(abortControllers);
+          abortControllers.delete(abortController);
+          if (abortControllers.size === 0) {
+            this.abortControllersByPath.delete(path);
+          }
+        }
+        this.unlockPath(app, path, pluginId);
       },
       multipleDisposeBehavior: import_disposable.MultipleDisposeBehavior.Ignore
     });
   }
-  unlock(app, pathOrFile) {
-    this.unlockPath(app, (0, import_file_system.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((0, import_file_system.getPath)(app, pathOrFile));
+    if (!abortControllers) {
+      return;
+    }
+    for (const controller of abortControllers) {
+      controller.abort();
+    }
+  }
+  unlock(app, pathOrFile, pluginId) {
+    this.unlockPath(app, (0, import_file_system.getPath)(app, pathOrFile), pluginId);
   }
-  ensureEventsRegistered(app) {
-    if (this.eventRefs.length > 0) {
+  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, import_function.noop);
+    this.registerUnlockMenu(app, actionIconEl, () => path);
+    let tabIconEl = null;
+    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;
+    if (tabStatusContainerEl) {
+      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });
+      (0, import_obsidian.setIcon)(tabIconEl, LOCK_ICON_ID);
+      (0, import_obsidian.setTooltip)(tabIconEl, tooltip);
+      this.registerUnlockMenu(app, tabIconEl, () => path);
+    }
+    return {
+      actionIconEl,
+      tabIconEl
+    };
+  }
+  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),
-      // Same-leaf navigation to another note fires no leaf/layout change; without this it stays read-only.
-      app.workspace.on("file-open", reconcile)
-    );
+    });
+    this.eventsComponent.load();
+  }
+  isPathLocked(path) {
+    return (this.lockCountByPluginIdByPath.get(path)?.size ?? 0) > 0;
+  }
+  lockingPluginNames(app, path) {
+    const lockCountByPluginId = this.lockCountByPluginIdByPath.get(path);
+    (0, import_type_guards.assertNonNullable)(lockCountByPluginId);
+    return Array.from(lockCountByPluginId.keys()).map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);
+  }
+  lockTooltip(app, path) {
+    const header = (0, import_i18n.t)(($) => $.obsidianDevUtils.editorLock.lockedByTooltip);
+    return [header, ...this.lockingPluginNames(app, path)].join("\n");
   }
   reconcile(app) {
     const viewsToLock = /* @__PURE__ */ new Set();
@@ -187,61 +285,185 @@ 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)) {
-          (0, import_editor.lockEditor)(view.editor);
-          const iconEl = view.addAction(LOCK_ICON_ID, (0, import_i18n.t)(($) => $.obsidianDevUtils.editorLock.lockedNoteTooltip), import_function.noop);
-          this.lockedIconElByView.set(view, iconEl);
+        const tooltip = this.lockTooltip(app, path);
+        (0, import_editor.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)) {
-        (0, import_editor.unlockEditor)(view.editor);
-        iconEl.remove();
-        this.lockedIconElByView.delete(view);
+        (0, import_editor.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 import_obsidian.Menu();
+      menu.addItem((item) => {
+        item.setTitle((0, import_i18n.t)(($) => $.obsidianDevUtils.editorLock.unlockMenuItem)).setIcon(UNLOCK_ICON_ID).onClick((0, import_async.convertAsyncToSync)(async () => {
+          const isConfirmed = await (0, import_confirm.confirm)({
+            app,
+            message: this.unlockConfirmMessage(app, path),
+            title: (0, import_i18n.t)(($) => $.obsidianDevUtils.editorLock.unlockConfirmTitle)
+          });
+          if (isConfirmed) {
+            this.requestUnlock(app, path);
+          }
+        }));
+      });
+      menu.showAtMouseEvent(evt);
+    });
+  }
+  unlockConfirmMessage(app, path) {
+    const header = (0, import_i18n.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) {
+    (0, import_obsidian.setTooltip)(indicators.actionIconEl, tooltip);
+    if (indicators.tabIconEl) {
+      (0, import_obsidian.setTooltip)(indicators.tabIconEl, tooltip);
     }
-    this.eventRefs = [];
+  }
+  updateStatusBar(app) {
+    const activeView = app.workspace.getActiveViewOfType(import_obsidian.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] });
+      (0, import_obsidian.setIcon)(this.statusBarItemEl, LOCK_ICON_ID);
+      this.registerUnlockMenu(app, this.statusBarItemEl, () => app.workspace.getActiveViewOfType(import_obsidian.MarkdownView)?.file?.path);
+    }
+    (0, import_obsidian.setTooltip)(this.statusBarItemEl, this.lockTooltip(app, activePath));
+  }
+}
+class EditorLockComponent extends import_component_ex.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 = (0, import_plugin_id.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, (0, import_plugin_id.getPluginId)());
+}
+function requestEditorUnlockForPath(app, pathOrFile) {
+  getManager().requestUnlock(app, pathOrFile);
 }
 function unlockEditorForPath(app, pathOrFile) {
-  getManager().unlock(app, pathOrFile);
+  getManager().unlock(app, pathOrFile, (0, import_plugin_id.getPluginId)());
 }
 function getManager() {
   return (0, import_obsidian_dev_utils_state.getObsidianDevUtilsState)(EDITOR_LOCK_STATE_KEY, new EditorPathLockManager()).value;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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      // Same-leaf navigation to another note fires no leaf/layout change; without this it stays read-only.\n      app.workspace.on('file-open', 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/cjs/obsidian/editor-lock.d.cts

@@ -4,12 +4,13 @@
  *
  * Note-scoped, reference-counted editor locking.
  *
- * Where {@link lockEditor} / {@link unlockEditor} from `./editor.ts` toggle the read-only state of a
- * single {@link Editor} instance, the helpers here lock a note by its **path**: while a path is
+ * Where {@link toggleEditorReadOnly} from `./editor.ts` toggles the read-only state of a single
+ * {@link Editor} instance, the helpers here lock a note by its **path**: while a path is
  * locked, every current and future {@link MarkdownView} of that note (in any window, including
- * popouts) is made read-only and shows a lock icon. Locks are reference-counted, so nested or
- * concurrent operations on the same note are safe — the note is unlocked only when the last lock is
- * released.
+ * popouts) is made read-only and shows a lock indicator in its tab header, its view action bar, and
+ * the status bar (while the note is active). Locks are reference-counted per locking plugin, so
+ * nested or concurrent operations on the same note are safe — the note is unlocked only when the
+ * last lock is released — and the indicators' tooltip lists which plugins currently hold a lock.
  *
  * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration
  * that releases automatically at scope exit (including on throw):
@@ -24,6 +25,71 @@
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 import type { PathOrFile } from './file-system.cjs';
+import { ComponentEx } from './components/component-ex.cjs';
+/**
+ * Options for {@link EditorLockComponent.lockForPath}.
+ */
+export interface EditorLockComponentLockForPathOptions {
+    /**
+     * An optional {@link AbortController} associated with the lock. When the lock indicator is
+     * right-clicked and the user confirms an unlock (or {@link requestEditorUnlockForPath} is called for
+     * the path), this controller is aborted so the operation holding the lock can cancel itself and
+     * release the lock in its own cleanup.
+     */
+    readonly abortController?: AbortController;
+}
+/**
+ * A per-plugin handle for note-scoped editor locking. Add it as a child of your plugin
+ * (`this.addChild(new EditorLockComponent(this.app))`) so that any locks it still holds are released
+ * automatically when the plugin unloads — a note can never be left stuck read-only because the
+ * plugin that locked it was disabled or reloaded mid-operation.
+ *
+ * Locks are reference-counted and attributed to this plugin, so the lock indicators' tooltip names
+ * it among the plugins currently holding a lock.
+ */
+export declare class EditorLockComponent extends ComponentEx {
+    private readonly app;
+    private readonly 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: App, pluginId?: string);
+    /**
+     * 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: PathOrFile): boolean;
+    /**
+     * 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: PathOrFile, options?: EditorLockComponentLockForPathOptions): Disposable;
+    /**
+     * 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(): void;
+    /**
+     * 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: PathOrFile): void;
+}
 /**
  * Checks whether the note at the given path is currently locked.
  *
@@ -34,22 +100,38 @@ import type { PathOrFile } from './file-system.cjs';
 export declare function isEditorLockedForPath(app: App, pathOrFile: PathOrFile): boolean;
 /**
  * Locks the note at the given path, making it read-only in every current and future
- * {@link MarkdownView} until the lock is released.
+ * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,
+ * view action bar, and (while active) the status bar. The indicators' tooltip lists the plugins
+ * that currently hold a lock on the note.
  *
- * The lock is reference-counted: each call must be balanced by exactly one release (either disposing
- * the returned {@link Disposable} — ideally via a `using` declaration — or a matching
- * {@link unlockEditorForPath} call).
+ * The lock is reference-counted per calling plugin: each call must be balanced by exactly one
+ * release (either disposing the returned {@link Disposable} — ideally via a `using` declaration — or
+ * a matching {@link unlockEditorForPath} call).
  *
  * @param app - The Obsidian app instance.
  * @param pathOrFile - The path or file of the note to lock.
  * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
  */
 export declare function lockEditorForPath(app: App, pathOrFile: PathOrFile): Disposable;
+/**
+ * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was
+ * associated with a lock on it (via {@link EditorLockComponent.lockForPath}'s
+ * {@link EditorLockComponentLockForPathOptions.abortController}). The operations holding the lock
+ * observe the abort and release their own locks. A no-op when no abortable lock is registered for the
+ * path.
+ *
+ * This lets a consuming plugin wire its own "unlock active note" command without reaching into the
+ * lock manager directly.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to request an unlock for.
+ */
+export declare function requestEditorUnlockForPath(app: App, pathOrFile: PathOrFile): void;
 /**
  * Releases one lock previously acquired for the note at the given path via {@link lockEditorForPath}.
  *
- * When the last lock is released the note becomes fully editable again and its lock icon is removed.
- * Calling this when the note is not locked is a no-op.
+ * When the last lock is released the note becomes fully editable again and its lock indicators are
+ * removed. Calling this when the note is not locked is a no-op.
  *
  * @param app - The Obsidian app instance.
  * @param pathOrFile - The path or file of the note to unlock.