@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/resource-lock.d.cts

@@ -0,0 +1,318 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Path-scoped resource locking for vault files and folders, with three enforcement layers over one
+ * shared locked-path set:
+ *
+ * 1. **Editor read-only** — 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 indicator in its
+ *    tab header, its view action bar, and the status bar; a note inside a `subtree`-locked folder is
+ *    covered too. Locks are reference-counted per locking plugin (the indicators' tooltip lists which
+ *    plugins hold a lock), so nested/concurrent operations are safe — the path is unlocked only when
+ *    the last lock is released.
+ * 2. **Vault-mutation blocking** (opt-in via `shouldBlockMutations`) — any edit/delete/rename/move/
+ *    create of a locked path through the `Vault`/`FileManager` API throws {@link ResourceLockedError},
+ *    unless the owning operation has opened a {@link ResourceLockComponent.bypassBlockedMutations} scope
+ *    over that path.
+ * 3. **External-change detection** — a vault/metadata event on a locked path that no bypass scope
+ *    covers is treated as an intruder (Sync / raw filesystem / another plugin) and aborts the owning
+ *    operation's {@link AbortController}.
+ *
+ * A lock **follows its resource across a rename**: when a locked path (or an ancestor folder of it) is
+ * renamed, the lock registry and every active bypass scope are re-keyed onto the new path, so a
+ * multi-step operation that renames a folder it locked keeps its coverage for the rest of the
+ * transaction.
+ *
+ * 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 = lockResourceForPath({ app, pathOrFile: path, pluginId: this.manifest.id, operationName: 'Process note' });
+ * // ... long-running work (process, processFrontMatter, merge/split) ...
+ * // auto-unlocked at scope exit
+ * ```
+ *
+ * The explicit {@link unlockResourceForPath} pair remains available for non-`using` call sites.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+import { ComponentEx } from './components/component-ex.cjs';
+/**
+ * Parameters for {@link lockResourceForPath}.
+ */
+export interface LockResourceForPathParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * A human-readable name of the operation taking the lock (e.g. `'Move selection'`). Shown next to
+     * the plugin name in the unlock confirmation dialog.
+     */
+    readonly operationName: string;
+    /**
+     * The path or file of the note to lock.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * The id of the locking plugin (e.g. its `manifest.id`). The lock is attributed to it for
+     * reference-counting and the indicators' "locked by" tooltip.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Parameters for {@link ResourceLockComponent.lockForPath}.
+ */
+export interface ResourceLockComponentLockForPathParams {
+    /**
+     * An optional {@link AbortController} associated with the lock. When a lock indicator is clicked (with
+     * any mouse button) and the user confirms an unlock, the "Unlock active note" command runs, or
+     * {@link ResourceLockComponent.requestUnlockForPath} / {@link requestResourceUnlockForPath} is called
+     * for the path, this controller is aborted so the operation holding the lock can cancel itself. Unless
+     * {@link ResourceLockComponentLockForPathParams.shouldReleaseOnAbort} is set, the operation is
+     * expected to release the lock in its own cleanup. When omitted, an unlock still releases the lock but
+     * cannot cancel the operation that took it.
+     */
+    readonly abortController?: AbortController;
+    /**
+     * The lock scope. `'subtree'` also locks every descendant of a folder path; `'file'` locks only the
+     * exact path. A `subtree` lock must be released via the returned {@link Disposable} (not the
+     * explicit {@link ResourceLockComponent.unlockForPath}).
+     *
+     * @default `'file'`
+     */
+    readonly mode?: ResourceLockMode;
+    /**
+     * When provided, this callback is invoked when an unlock of the lock is requested — i.e. when the
+     * lock's {@link ResourceLockComponentLockForPathParams.abortController} is aborted (by the
+     * indicator's "Unlock" menu, the "Unlock active note" command, {@link ResourceLockComponent.requestUnlockForPath},
+     * or {@link handleExternalMutation}). Use it to clear consumer-side state that shadows the lock (e.g.
+     * a pending-operation buffer or a notice) without hand-wiring an `abort` listener. Fires at most once.
+     */
+    readonly onUnlockRequested?: () => void;
+    /**
+     * A human-readable name of the operation that took the lock (e.g. `'Move selection'`, `'Merge
+     * notes'`). It is shown — next to the locking plugin's name — in the unlock confirmation dialog, so
+     * the user sees exactly which operation an unlock would cancel.
+     */
+    readonly operationName: string;
+    /**
+     * The path or file of the note to lock.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * When `true`, the lock also **blocks vault mutations** of the covered path(s): any attempt to edit,
+     * delete, rename, move, or (re)create the resource through the `Vault`/`FileManager` API throws a
+     * {@link ResourceLockedError}. Installed lazily on the first such lock and removed when the last one
+     * is released. When `false` (the default) the lock only makes the editor read-only — legacy behavior,
+     * so existing consumers that write to a note they hold an editor lock on are unaffected.
+     *
+     * @default `false`
+     */
+    readonly shouldBlockMutations?: boolean;
+    /**
+     * When `true`, the lock releases itself the moment its
+     * {@link ResourceLockComponentLockForPathParams.abortController} is aborted, instead of relying on
+     * the owning operation to release it in its own cleanup. Use it for a lock held **indefinitely**
+     * outside a `using` scope (so there is no `finally` to release it) — e.g. a lock that stays until the
+     * user explicitly unlocks. Leave it `false` for a transactional operation that holds the lock through
+     * its own abort-driven rollback and releases it via `using` at scope exit. Has no effect without an
+     * {@link ResourceLockComponentLockForPathParams.abortController}.
+     *
+     * @default `false`
+     */
+    readonly shouldReleaseOnAbort?: boolean;
+}
+/**
+ * The scope of a lock.
+ *
+ * - `'file'` locks only the exact path.
+ * - `'subtree'` locks the path and every descendant under it (its whole folder subtree), so a file
+ *   inside a `subtree`-locked folder is treated as locked too.
+ */
+export type ResourceLockMode = 'file' | 'subtree';
+/**
+ * A per-plugin handle for path-scoped resource locking (editor read-only, optional vault-mutation
+ * blocking, and external-change detection — see the file overview). Add it as a child of your plugin
+ * (`this.addChild(new ResourceLockComponent(this.app))`) so that any locks it still holds are released
+ * automatically when the plugin unloads — a resource can never be left stuck locked 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 ResourceLockComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to it for
+     * reference-counting and the indicators' "locked by" tooltip.
+     */
+    protected readonly pluginId: string;
+    /**
+     * Creates an resource-lock handle owned by a plugin.
+     *
+     * @param app - The Obsidian app instance.
+     * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to
+     * it for reference-counting and the indicators' "locked by" tooltip.
+     */
+    constructor(app: App, pluginId: string);
+    /**
+     * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this
+     * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the
+     * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path
+     * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around
+     * the operation that legitimately mutates resources it has locked with
+     * {@link ResourceLockComponentLockForPathParams.shouldBlockMutations}:
+     *
+     * ```ts
+     * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);
+     * // ... the operation's own vault mutations of those paths are allowed ...
+     * // scope end: the paths are enforced again
+     * ```
+     *
+     * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.
+     * @returns A {@link Disposable} that ends the bypass scope when disposed.
+     */
+    bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): Disposable;
+    /**
+     * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.
+     *
+     * @param pathOrFile - The path or file to check.
+     * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.
+     */
+    isLockedByAncestorForPath(pathOrFile: PathOrFile): boolean;
+    /**
+     * 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;
+    /**
+     * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock
+     * on the path itself or on a `subtree`-locked ancestor folder.
+     *
+     * @param pathOrFile - The path or file to check.
+     * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a
+     * {@link ResourceLockedError}.
+     */
+    isMutationBlockedByAncestorForPath(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 params - Locking parameters. Its {@link ResourceLockComponentLockForPathParams.pathOrFile}
+     * and {@link ResourceLockComponentLockForPathParams.operationName} are required (the latter is shown
+     * in the unlock confirmation). Pass an {@link ResourceLockComponentLockForPathParams.abortController}
+     * to make the lock cancelable via a lock indicator's "unlock" menu, the "Unlock active note" command,
+     * or {@link requestResourceUnlockForPath}.
+     * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+     */
+    lockForPath(params: ResourceLockComponentLockForPathParams): 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;
+    /**
+     * Fully unlocks the note at the given path: resolves the lock covering it (the path itself when
+     * directly locked, otherwise a `subtree`-locked ancestor folder), cancels the operation(s) that took
+     * the lock by aborting their {@link AbortController}s, and releases the lock so the note becomes
+     * editable — regardless of which plugin holds the lock. Powers the "Unlock active note" command. A
+     * no-op when nothing covers the path.
+     *
+     * @param pathOrFile - The path or file of the note to unlock.
+     */
+    requestUnlockForPath(pathOrFile: PathOrFile): 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;
+}
+/**
+ * Thrown by the vault-mutation blocker when a plugin tries to edit, delete, rename, move, or create a
+ * resource whose path is covered by a lock taken with
+ * {@link ResourceLockComponentLockForPathParams.shouldBlockMutations}.
+ */
+export declare class ResourceLockedError extends Error {
+    /**
+     * The vault path whose mutation was blocked.
+     */
+    readonly path: string;
+    /**
+     * Creates a {@link ResourceLockedError}.
+     *
+     * @param path - The vault path whose mutation was blocked.
+     */
+    constructor(path: string);
+}
+/**
+ * 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 isResourceLockedForPath(app: App, pathOrFile: PathOrFile): boolean;
+/**
+ * Checks whether the note at the given path is currently locked directly OR is covered by a
+ * `subtree`-locked ancestor folder.
+ *
+ * Unlike {@link isResourceLockedForPath}, which only reports an exact-path lock, this also reports a
+ * path that lies under a folder locked in `subtree` mode. Use it to detect that a rename/move is
+ * happening inside a foreign plugin's in-flight locked transaction (which locks the affected folder
+ * subtree), so that a bystander (e.g. the rename/delete handler) can stay out of the way and let the
+ * transaction's owner keep its own links consistent.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file of the note to check.
+ * @returns `true` if the path is itself locked or lies under a `subtree`-locked ancestor folder.
+ */
+export declare function isResourceLockedForPathByAncestor(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, 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 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 unlockResourceForPath} call).
+ *
+ * @param params - The parameters for locking the note.
+ * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+ */
+export declare function lockResourceForPath(params: LockResourceForPathParams): 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 ResourceLockComponent.lockForPath}'s
+ * {@link ResourceLockComponentLockForPathParams.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 requestResourceUnlockForPath(app: App, pathOrFile: PathOrFile): void;
+/**
+ * Releases one lock previously acquired for the note at the given path via {@link lockResourceForPath}.
+ *
+ * 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.
+ * @param pluginId - The id of the plugin that holds the lock (e.g. its `manifest.id`); one of its
+ * locks on the note is released.
+ */
+export declare function unlockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): void;

package/dist/lib/cjs/resource-url.cjs

@@ -0,0 +1,180 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // 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
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // 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.`);
+
+        return 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 resource_url_exports = {};
+__export(resource_url_exports, {
+  relativePathToResourceUrl: () => relativePathToResourceUrl
+});
+module.exports = __toCommonJS(resource_url_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_implementations = require('@obsidian-typings/obsidian-public-latest/implementations');
+var import_obsidian = require('obsidian');
+function relativePathToResourceUrl(params) {
+  const {
+    app,
+    notePath,
+    relativePath
+  } = params;
+  const noteFullPath = (0, import_path.toPosixPath)((0, import_implementations.getDataAdapterEx)(app).getFullRealPath(notePath));
+  const noteUrl = `${import_obsidian.Platform.resourcePathPrefix}${noteFullPath}`;
+  const relativeUrl = new URL(relativePath, noteUrl);
+  return relativeUrl.href;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  relativePathToResourceUrl
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/resource-url.d.cts

@@ -0,0 +1,31 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides utility functions for working with resource URLs in Obsidian.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link relativePathToResourceUrl}.
+ */
+export interface RelativePathToResourceUrlParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The path of the note.
+     */
+    readonly notePath: string;
+    /**
+     * The relative path to the resource.
+     */
+    readonly relativePath: string;
+}
+/**
+ * Converts a relative path to a resource URL.
+ *
+ * @param params - The parameters for the conversion.
+ * @returns The resource URL.
+ */
+export declare function relativePathToResourceUrl(params: RelativePathToResourceUrlParams): string;