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

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

@@ -0,0 +1,245 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editor_lock_exports = {};
+__export(editor_lock_exports, {
+  isEditorLockedForPath: () => isEditorLockedForPath,
+  lockEditorForPath: () => lockEditorForPath,
+  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_disposable = require('../disposable.cjs');
+var import_function = require('../function.cjs');
+var import_obsidian_dev_utils_state = require('../obsidian-dev-utils-state.cjs');
+var import_editor = require('./editor.cjs');
+var import_file_system = require('./file-system.cjs');
+var import_i18n = require('./i18n/i18n.cjs');
+const EDITOR_LOCK_STATE_KEY = "editorLock";
+const LOCK_ICON_ID = "lock";
+class EditorPathLockManager {
+  eventRefs = [];
+  lockCountByPath = /* @__PURE__ */ new Map();
+  lockedIconElByView = /* @__PURE__ */ new Map();
+  isLocked(app, pathOrFile) {
+    return (this.lockCountByPath.get((0, import_file_system.getPath)(app, pathOrFile)) ?? 0) > 0;
+  }
+  lock(app, pathOrFile) {
+    const path = (0, import_file_system.getPath)(app, pathOrFile);
+    this.lockCountByPath.set(path, (this.lockCountByPath.get(path) ?? 0) + 1);
+    this.ensureEventsRegistered(app);
+    this.reconcile(app);
+    return new import_disposable.CallbackDisposable({
+      callback: () => {
+        this.unlockPath(app, path);
+      },
+      multipleDisposeBehavior: import_disposable.MultipleDisposeBehavior.Ignore
+    });
+  }
+  unlock(app, pathOrFile) {
+    this.unlockPath(app, (0, import_file_system.getPath)(app, pathOrFile));
+  }
+  ensureEventsRegistered(app) {
+    if (this.eventRefs.length > 0) {
+      return;
+    }
+    const reconcile = () => {
+      this.reconcile(app);
+    };
+    this.eventRefs.push(
+      app.workspace.on("active-leaf-change", reconcile),
+      app.workspace.on("layout-change", reconcile)
+    );
+  }
+  reconcile(app) {
+    const viewsToLock = /* @__PURE__ */ new Set();
+    for (const leaf of app.workspace.getLeavesOfType(import_implementations.ViewType.Markdown)) {
+      const view = leaf.view;
+      if (!(view instanceof import_obsidian.MarkdownView)) {
+        continue;
+      }
+      const path = view.file?.path;
+      if (path === void 0) {
+        continue;
+      }
+      if ((this.lockCountByPath.get(path) ?? 0) > 0) {
+        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);
+        }
+      }
+    }
+    for (const [view, iconEl] of this.lockedIconElByView) {
+      if (!viewsToLock.has(view)) {
+        (0, import_editor.unlockEditor)(view.editor);
+        iconEl.remove();
+        this.lockedIconElByView.delete(view);
+      }
+    }
+  }
+  unlockPath(app, path) {
+    const count = this.lockCountByPath.get(path) ?? 0;
+    if (count <= 0) {
+      return;
+    }
+    if (count === 1) {
+      this.lockCountByPath.delete(path);
+    } else {
+      this.lockCountByPath.set(path, count - 1);
+    }
+    this.reconcile(app);
+    if (this.lockCountByPath.size === 0) {
+      this.unregisterEvents(app);
+    }
+  }
+  unregisterEvents(app) {
+    for (const eventRef of this.eventRefs) {
+      app.workspace.offref(eventRef);
+    }
+    this.eventRefs = [];
+  }
+}
+function isEditorLockedForPath(app, pathOrFile) {
+  return getManager().isLocked(app, pathOrFile);
+}
+function lockEditorForPath(app, pathOrFile) {
+  return getManager().lock(app, pathOrFile);
+}
+function unlockEditorForPath(app, pathOrFile) {
+  getManager().unlock(app, pathOrFile);
+}
+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 = {
+  isEditorLockedForPath,
+  lockEditorForPath,
+  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": []
}


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

@@ -0,0 +1,57 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * 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
+ * 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.
+ *
+ * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration
+ * that releases automatically at scope exit (including on throw):
+ *
+ * ```ts
+ * using _lock = lockEditorForPath(app, path);
+ * // ... long-running work (process, processFrontMatter, merge/split) ...
+ * // auto-unlocked at scope exit
+ * ```
+ *
+ * The explicit {@link unlockEditorForPath} pair remains available for non-`using` call sites.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+/**
+ * Checks whether the note at the given path is currently locked.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to check.
+ * @returns `true` if the note has at least one active lock, `false` otherwise.
+ */
+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.
+ *
+ * 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).
+ *
+ * @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;
+/**
+ * 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.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to unlock.
+ */
+export declare function unlockEditorForPath(app: App, pathOrFile: PathOrFile): void;

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

@@ -131,6 +131,7 @@ __export(editor_exports, {
 module.exports = __toCommonJS(editor_exports);
 var import_state = require('@codemirror/state');
 var import_view = require('@codemirror/view');
+var import_disposable = require('../disposable.cjs');
 const editorCompartmentMap = /* @__PURE__ */ new WeakMap();
 function lockEditor(editor) {
   const compartment = ensureCompartment(editor);
@@ -140,6 +141,11 @@ function lockEditor(editor) {
       import_view.EditorView.editable.of(false)
     ])
   });
+  return new import_disposable.CallbackDisposable({
+    callback: () => {
+      unlockEditor(editor);
+    }
+  });
 }
 function unlockEditor(editor) {
   const compartment = ensureCompartment(editor);
@@ -163,4 +169,4 @@ function ensureCompartment(editor) {
   lockEditor,
   unlockEditor
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/editor.d.cts

@@ -4,13 +4,14 @@
  *
  * This module provides utility functions for working with markdown editors in Obsidian
  */
-import type { Editor } from 'obsidian';
+import type { Editor } from 'obsidian' with { 'resolution-mode': 'import' };
 /**
  * Locks the editor.
  *
  * @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): void;
+export declare function lockEditor(editor: Editor): Disposable;
 /**
  * Unlocks the editor.
  *