@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/editor.mjs

@@ -0,0 +1,115 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  Compartment,
+  EditorState,
+  Prec,
+  StateEffect
+} from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { castTo } from "@mnaoumov/typescript-lib/object-utils";
+import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
+import { MarkdownView } from "obsidian";
+import { getPath } from "./file-system.mjs";
+const compartmentByCodeMirror = /* @__PURE__ */ new WeakMap();
+const moduleState = {
+  isProcessingLockedEditorKeydown: false
+};
+function syncOpenEditorBuffersForPath(app, pathOrFile, content) {
+  const path = getPath(app, pathOrFile);
+  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+    const view = leaf.view;
+    if (!(view instanceof MarkdownView) || view.file?.path !== path) {
+      continue;
+    }
+    if (view.editor.getValue() !== content) {
+      view.editor.setValue(content);
+    }
+  }
+}
+function toggleEditorReadOnly(editor, isReadOnly) {
+  const compartment = ensureCompartment(editor);
+  editor.cm.dispatch({
+    effects: compartment.reconfigure(isReadOnly ? readOnlyExtension() : [])
+  });
+}
+function ensureCompartment(editor) {
+  const codeMirror = editor.cm;
+  const cachedCompartment = compartmentByCodeMirror.get(codeMirror);
+  if (cachedCompartment?.get(castTo(codeMirror.state)) !== void 0) {
+    return cachedCompartment;
+  }
+  const compartment = new Compartment();
+  compartmentByCodeMirror.set(codeMirror, compartment);
+  codeMirror.dispatch({
+    effects: StateEffect.appendConfig.of(compartment.of([]))
+  });
+  return compartment;
+}
+function readOnlyExtension() {
+  return [
+    EditorState.readOnly.of(true),
+    Prec.highest(EditorView.domEventHandlers({
+      keydown: () => {
+        moduleState.isProcessingLockedEditorKeydown = true;
+        queueMicrotask(() => {
+          moduleState.isProcessingLockedEditorKeydown = false;
+        });
+        return false;
+      }
+    })),
+    EditorState.changeFilter.of(() => !moduleState.isProcessingLockedEditorKeydown)
+  ];
+}
+export {
+  syncOpenEditorBuffersForPath,
+  toggleEditorReadOnly
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/editor.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for working with markdown editors in Obsidian\n */\n\nimport type { Extension } from '@codemirror/state';\nimport type {\n  App,\n  Editor\n} from 'obsidian';\n\nimport {\n  Compartment,\n  EditorState,\n  Prec,\n  StateEffect\n} from '@codemirror/state';\nimport { EditorView } from '@codemirror/view';\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { MarkdownView } from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { getPath } from './file-system.ts';\n\nconst compartmentByCodeMirror = new WeakMap<Editor['cm'], Compartment>();\n\n// Set true while a locked editor processes a `keydown` synchronously.\n// The read-only change filter reads it to block a keyboard-driven edit but pass a programmatic one.\n// It is reset in a microtask, after the key event's synchronous dispatch completes.\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\nconst moduleState = {\n  isProcessingLockedEditorKeydown: false\n};\n/**\n * Overwrites the buffer of every open {@link MarkdownView} currently showing the given path so that\n * it reflects `content`, in any window or popout.\n *\n * This is the fix for a subtle data-loss window: when a note is open in an editor with a **dirty\n * buffer** (a pending, not-yet-saved edit) and its file content is rewritten on disk out from under\n * the editor, the editor's next autosave re-writes its stale buffer and clobbers the on-disk content.\n * A caller that restores a file's content on disk (e.g. rolling back a transaction) must also reset\n * the open editor's buffer to the same content, so its next save is a no-op instead of a clobber.\n *\n * Only the view whose {@link MarkdownView.file} still matches `pathOrFile` is touched \u2014 if the editor\n * has since navigated to another note, it is left alone. The buffer is replaced only when it actually\n * differs from `content`, so a clean editor already in sync is not disturbed (no cursor reset).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file whose open editors should be synchronized.\n * @param content - The content to overwrite each matching editor's buffer with.\n */\nexport function syncOpenEditorBuffersForPath(app: App, pathOrFile: PathOrFile, content: string): void {\n  const path = getPath(app, pathOrFile);\n  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n    const view = leaf.view;\n    if (!(view instanceof MarkdownView) || (view.file?.path !== path)) {\n      continue;\n    }\n    if (view.editor.getValue() !== content) {\n      view.editor.setValue(content);\n    }\n  }\n}\n\n/**\n * Toggles the read-only state of a single CodeMirror instance \u2014 the low-level primitive behind\n * editor locking.\n *\n * When read-only, the editor stays focusable and interactive (selection, copy, and app hotkeys such\n * as the command palette keep working) \u2014 only document edits are prevented, via the CodeMirror\n * `readOnly` state plus a change filter that drops any user-originated change (see\n * {@link readOnlyExtension}).\n *\n * This toggles ONE CodeMirror instance, not \"a file\": an Obsidian {@link Editor} is reused as its\n * leaf navigates between notes, so this primitive does not follow a note around. To lock a note\n * across every editor that shows it (current and future, in any window), use `lockResourceForPath`\n * from `./resource-lock.ts`.\n *\n * @param editor - The editor whose CodeMirror instance to toggle.\n * @param isReadOnly - `true` to make the editor read-only, `false` to make it editable again.\n */\nexport function toggleEditorReadOnly(editor: Editor, isReadOnly: boolean): void {\n  const compartment = ensureCompartment(editor);\n  editor.cm.dispatch({\n    effects: compartment.reconfigure(isReadOnly ? readOnlyExtension() : [])\n  });\n}\n\nfunction ensureCompartment(editor: Editor): Compartment {\n  // Key the cache by the CodeMirror instance, not by the `Editor` wrapper.\n  // An `Editor` keeps its identity while its underlying CodeMirror view is swapped out.\n  const codeMirror = editor.cm;\n  const cachedCompartment = compartmentByCodeMirror.get(codeMirror);\n  // Reuse the cached compartment only while it is still part of the current configuration.\n  // A view can silently drop an appended compartment when it rebuilds its state.\n  // Opening a note into a freshly created leaf does this: it installs the compartment mid-open.\n  // The subsequent load then replaces the whole state, taking the compartment with it.\n  // Then `Compartment.get` returns `undefined`, since the compartment is no longer configured.\n  // Re-install it in that case, or every later `reconfigure` is silently ignored and nothing locks.\n  // The `castTo` bridges the dual CommonJS and ESM `EditorState` declarations of `@codemirror/state`.\n  // They are structurally identical, but TypeScript treats them as nominally incompatible.\n  if (cachedCompartment?.get(castTo<EditorState>(codeMirror.state)) !== undefined) {\n    return cachedCompartment;\n  }\n\n  const compartment = new Compartment();\n  compartmentByCodeMirror.set(codeMirror, compartment);\n  // A `Compartment` only takes effect once it is part of the editor's configuration.\n  // The compartment is created lazily here, so install it (initially empty) via `appendConfig`.\n  codeMirror.dispatch({\n    effects: StateEffect.appendConfig.of(compartment.of([]))\n  });\n  return compartment;\n}\n\n/**\n * The extension installed into the read-only compartment while a note is locked.\n *\n * `EditorState.readOnly` alone is not enough: it blocks CodeMirror's own editing commands and DOM\n * input, but Obsidian binds some keys (notably `Shift+Enter`) to handlers that dispatch a change\n * transaction directly, which slips past the `readOnly` facet and edits the \"locked\" note. Such a\n * transaction is indistinguishable from a programmatic one by its contents (no user-event\n * annotation), so it is told apart by origin instead: a highest-precedence `keydown` handler marks\n * the window during which the key is processed synchronously, and the added `changeFilter` drops the\n * changes of any transaction produced inside that window. Programmatic edits (e.g.\n * `syncOpenEditorBuffersForPath` restoring a buffer on rollback, or Obsidian reloading the buffer\n * from disk) happen outside a keydown, so they still go through.\n *\n * @returns The extension enforcing read-only for a locked editor.\n */\nfunction readOnlyExtension(): Extension {\n  return [\n    EditorState.readOnly.of(true),\n    Prec.highest(EditorView.domEventHandlers({\n      keydown: (): boolean => {\n        moduleState.isProcessingLockedEditorKeydown = true;\n        queueMicrotask(() => {\n          moduleState.isProcessingLockedEditorKeydown = false;\n        });\n        // Do not consume the event: let CodeMirror's keymap run so navigation/selection keys work.\n        return false;\n      }\n    })),\n    EditorState.changeFilter.of(() => !moduleState.isProcessingLockedEditorKeydown)\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAC3B,SAAS,cAAc;AACvB,SAAS,gBAAgB;AACzB,SAAS,oBAAoB;AAI7B,SAAS,eAAe;AAExB,MAAM,0BAA0B,oBAAI,QAAmC;AAQvE,MAAM,cAAc;AAAA,EAClB,iCAAiC;AACnC;AAmBO,SAAS,6BAA6B,KAAU,YAAwB,SAAuB;AACpG,QAAM,OAAO,QAAQ,KAAK,UAAU;AACpC,aAAW,QAAQ,IAAI,UAAU,gBAAgB,SAAS,QAAQ,GAAG;AACnE,UAAM,OAAO,KAAK;AAClB,QAAI,EAAE,gBAAgB,iBAAkB,KAAK,MAAM,SAAS,MAAO;AACjE;AAAA,IACF;AACA,QAAI,KAAK,OAAO,SAAS,MAAM,SAAS;AACtC,WAAK,OAAO,SAAS,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAmBO,SAAS,qBAAqB,QAAgB,YAA2B;AAC9E,QAAM,cAAc,kBAAkB,MAAM;AAC5C,SAAO,GAAG,SAAS;AAAA,IACjB,SAAS,YAAY,YAAY,aAAa,kBAAkB,IAAI,CAAC,CAAC;AAAA,EACxE,CAAC;AACH;AAEA,SAAS,kBAAkB,QAA6B;AAGtD,QAAM,aAAa,OAAO;AAC1B,QAAM,oBAAoB,wBAAwB,IAAI,UAAU;AAShE,MAAI,mBAAmB,IAAI,OAAoB,WAAW,KAAK,CAAC,MAAM,QAAW;AAC/E,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,IAAI,YAAY;AACpC,0BAAwB,IAAI,YAAY,WAAW;AAGnD,aAAW,SAAS;AAAA,IAClB,SAAS,YAAY,aAAa,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC;AAAA,EACzD,CAAC;AACD,SAAO;AACT;AAiBA,SAAS,oBAA+B;AACtC,SAAO;AAAA,IACL,YAAY,SAAS,GAAG,IAAI;AAAA,IAC5B,KAAK,QAAQ,WAAW,iBAAiB;AAAA,MACvC,SAAS,MAAe;AACtB,oBAAY,kCAAkC;AAC9C,uBAAe,MAAM;AACnB,sBAAY,kCAAkC;AAAA,QAChD,CAAC;AAED,eAAO;AAAA,MACT;AAAA,IACF,CAAC,CAAC;AAAA,IACF,YAAY,aAAa,GAAG,MAAM,CAAC,YAAY,+BAA+B;AAAA,EAChF;AACF;",
  "names": []
}


package/dist/lib/esm/events.d.mts

@@ -0,0 +1,98 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Typed helpers for subscribing to an Obsidian {@link Events} source. Both derive the valid event names and their
+ * callback argument types from the source's overloaded `on` method (via {@link ExtractEventMap}), so the event
+ * name and handler are fully autocompleted. {@link subscribeEvent} returns the raw {@link EventRef} (parity with
+ * {@link Events.on}); {@link subscribeDisposableEvent} returns a {@link DisposableEx} that unregisters it.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import type { ExtractEventMap } from '@mnaoumov/typescript-lib/type';
+import type { EventRef, Events } from 'obsidian';
+import { DisposableBase } from '@mnaoumov/typescript-lib/disposable';
+/**
+ * Parameters for {@link subscribeDisposableEvent}. Same shape as {@link SubscribeEventParams}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name, constrained to the source's known events.
+ */
+export type SubscribeDisposableEventParams<Source extends Events, EventName extends EventNameOf<Source>> = SubscribeEventParams<Source, EventName>;
+/**
+ * Parameters for {@link subscribeEvent}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name, constrained to the source's known events.
+ */
+export interface SubscribeEventParams<Source extends Events, EventName extends EventNameOf<Source>> {
+    /**
+     * The event callback. Its argument types are inferred from {@link SubscribeEventParams.name}.
+     */
+    readonly callback: EventCallbackOf<Source, EventName>;
+    /**
+     * The event source to subscribe on.
+     */
+    readonly events: Source;
+    /**
+     * The event name to subscribe to.
+     */
+    readonly name: EventName;
+    /**
+     * The context passed as `this` to the callback.
+     */
+    readonly thisArgument?: unknown;
+}
+/**
+ * The callback type for a given event on a {@link Events} source, with its argument tuple inferred from
+ * {@link ExtractEventMap}.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ */
+type EventCallbackOf<Source extends Events, EventName extends EventNameOf<Source>> = ExtractEventMap<Source>[EventName] extends infer Arguments extends unknown[] ? (...$arguments: Arguments) => unknown : never;
+/**
+ * The union of known event names for a {@link Events} source, derived from its `on` overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ */
+type EventNameOf<Source extends Events> = keyof ExtractEventMap<Source> & string;
+/**
+ * A {@link DisposableEx} that unregisters an Obsidian {@link EventRef} on dispose, via the event source exposed on
+ * the ref itself (`eventRef.e`).
+ */
+export declare class EventRefDisposable extends DisposableBase {
+    private readonly eventRef;
+    /**
+     * Creates a disposable wrapping an existing {@link EventRef}.
+     *
+     * @param eventRef - The event reference to unregister on dispose.
+     */
+    constructor(eventRef: EventRef);
+    /**
+     * Unregisters the event via the source stored on the ref (`eventRef.e.offref`).
+     */
+    protected performDispose(): void;
+}
+/**
+ * Subscribes to an event on an {@link Events} source and returns a {@link DisposableEx} that unregisters it on
+ * dispose. Typed wrapper over {@link Events.on}: the event name and callback arguments are autocompleted from the
+ * source's overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ * @param params - The subscription parameters.
+ * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+ */
+export declare function subscribeDisposableEvent<Source extends Events, EventName extends EventNameOf<Source>>(params: SubscribeDisposableEventParams<Source, EventName>): DisposableEx;
+/**
+ * Subscribes to an event on an {@link Events} source and returns the raw {@link EventRef} (parity with
+ * {@link Events.on}). Typed wrapper: the event name and callback arguments are autocompleted from the source's
+ * overloads.
+ *
+ * @typeParam Source - The {@link Events} source type.
+ * @typeParam EventName - The event name.
+ * @param params - The subscription parameters.
+ * @returns The {@link EventRef} for the registered handler.
+ */
+export declare function subscribeEvent<Source extends Events, EventName extends EventNameOf<Source>>(params: SubscribeEventParams<Source, EventName>): EventRef;
+export {};

package/dist/lib/esm/events.mjs

@@ -0,0 +1,81 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { DisposableBase } from "@mnaoumov/typescript-lib/disposable";
+import { castTo } from "@mnaoumov/typescript-lib/object-utils";
+class EventRefDisposable extends DisposableBase {
+  /**
+   * Creates a disposable wrapping an existing {@link EventRef}.
+   *
+   * @param eventRef - The event reference to unregister on dispose.
+   */
+  constructor(eventRef) {
+    super();
+    this.eventRef = eventRef;
+  }
+  eventRef;
+  /**
+   * Unregisters the event via the source stored on the ref (`eventRef.e.offref`).
+   */
+  performDispose() {
+    this.eventRef.e.offref(this.eventRef);
+  }
+}
+function subscribeDisposableEvent(params) {
+  return new EventRefDisposable(subscribeEvent(params));
+}
+function subscribeEvent(params) {
+  return params.events.on(params.name, castTo(params.callback), params.thisArgument);
+}
+export {
+  EventRefDisposable,
+  subscribeDisposableEvent,
+  subscribeEvent
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/extensions-registrar.d.mts

@@ -0,0 +1,51 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Extensions registrars.
+ */
+import { Plugin } from 'obsidian';
+/**
+ * Extensions registrar.
+ */
+export interface ExtensionsRegistrar {
+    /**
+     * Registers extensions.
+     *
+     * @param params - The parameters for the extensions registration.
+     */
+    registerExtensions: (params: ExtensionsRegistrarRegisterExtensionsParams) => void;
+}
+/**
+ * Parameters for registering extensions.
+ */
+export interface ExtensionsRegistrarRegisterExtensionsParams {
+    /**
+     * The extensions to register.
+     */
+    readonly extensions: string[];
+    /**
+     * The view type to register the extensions for.
+     */
+    readonly viewType: string;
+}
+type PluginExtensionsRegistrarRegisterExtensionsParams = ExtensionsRegistrarRegisterExtensionsParams;
+/**
+ * Extensions registrar in an Obsidian plugin.
+ */
+export declare class PluginExtensionsRegistrar implements ExtensionsRegistrar {
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginExtensionsRegistrar} class.
+     *
+     * @param plugin - The Obsidian plugin instance.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers extensions.
+     *
+     * @param params - The parameters for the extensions registration.
+     */
+    registerExtensions(params: PluginExtensionsRegistrarRegisterExtensionsParams): void;
+}
+export {};

package/dist/lib/esm/extensions-registrar.mjs

@@ -0,0 +1,73 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { Plugin } from "obsidian";
+class PluginExtensionsRegistrar {
+  /**
+   * Creates a new instance of the {@link PluginExtensionsRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers extensions.
+   *
+   * @param params - The parameters for the extensions registration.
+   */
+  registerExtensions(params) {
+    this.plugin.registerExtensions(params.extensions, params.viewType);
+  }
+}
+export {
+  PluginExtensionsRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/file-change.d.mts

@@ -0,0 +1,156 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility types and functions for handling file changes in Obsidian.
+ */
+import type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';
+import type { App, FrontmatterLinkCache, Reference, ReferenceCache } from 'obsidian';
+import type { PathOrFile } from './file-system.mjs';
+import type { FrontmatterLinkCacheWithOffsets } from './frontmatter-link-cache-with-offsets.mjs';
+import type { CanvasFileNodeReference, CanvasReference, CanvasTextNodeReference } from './reference.mjs';
+import type { ContentArguments, ProcessOptions } from './vault.mjs';
+/**
+ * Parameters for {@link applyContentChanges}.
+ */
+export interface ApplyContentChangesParams {
+    /**
+     * The abort signal to control the execution of the function.
+     */
+    readonly abortSignal: AbortSignal;
+    /**
+     * A provider that returns an array of content changes to apply.
+     */
+    readonly changesProvider: ValueProvider<FileChange[] | null, ContentArguments>;
+    /**
+     * The content to which the changes should be applied.
+     */
+    readonly content: string;
+    /**
+     * The path to which the changes should be applied.
+     */
+    readonly path: string;
+    /**
+     * Whether to retry the operation if the changes are invalid.
+     *
+     * @default `true`
+     */
+    readonly shouldRetryOnInvalidChanges?: boolean;
+}
+/**
+ * Options for {@link applyFileChanges}.
+ */
+export type ApplyFileChangesOptions = ProcessOptions;
+/**
+ * Parameters for {@link applyFileChanges}.
+ */
+export interface ApplyFileChangesParams extends ApplyFileChangesOptions {
+    /**
+     * The application instance where the file changes will be applied.
+     */
+    readonly app: App;
+    /**
+     * A provider that returns an array of file changes to apply.
+     */
+    readonly changesProvider: ValueProvider<FileChange[] | null, ContentArguments>;
+    /**
+     * The path or file to which the changes should be applied.
+     */
+    readonly pathOrFile: PathOrFile;
+    /**
+     * Whether to retry the operation if the changes are invalid.
+     *
+     * @default `true`
+     */
+    readonly shouldRetryOnInvalidChanges?: boolean;
+}
+/**
+ * A file change in the vault.
+ */
+export interface FileChange {
+    /**
+     * A new content to replace the old content.
+     */
+    newContent: string;
+    /**
+     * An old content that will be replaced.
+     */
+    oldContent: string;
+    /**
+     * A reference that caused the change.
+     */
+    reference: Reference;
+}
+type CanvasChange = FileChange & WithReference<CanvasReference>;
+type CanvasFileNodeChange = FileChange & WithReference<CanvasFileNodeReference>;
+type CanvasTextNodeChange = FileChange & WithReference<CanvasTextNodeReference>;
+type ContentChange = FileChange & WithReference<ReferenceCache>;
+type FrontmatterChange = FileChange & WithReference<FrontmatterLinkCache>;
+type FrontmatterChangeWithOffsets = FileChange & WithReference<FrontmatterLinkCacheWithOffsets>;
+interface WithReference<R extends Reference> {
+    reference: R;
+}
+/**
+ * Applies a series of content changes to the specified content.
+ *
+ * @param params - The parameters for applying the content changes.
+ * @returns A {@link Promise} that resolves to the updated content or to `null` if update didn't succeed.
+ */
+export declare function applyContentChanges(params: ApplyContentChangesParams): Promise<null | string>;
+/**
+ * Applies a series of file changes to the specified file or path within the application.
+ *
+ * @param params - The parameters for applying the file changes.
+ * @returns A {@link Promise} that resolves when the file changes have been successfully applied.
+ */
+export declare function applyFileChanges(params: ApplyFileChangesParams): Promise<void>;
+/**
+ * Checks if a file change is a canvas change.
+ *
+ * @param change - The file change to check.
+ * @returns Whether the file change is a canvas change.
+ */
+export declare function isCanvasChange(change: FileChange): change is CanvasChange;
+/**
+ * Checks if a file change is a canvas file node change.
+ *
+ * @param change - The file change to check.
+ * @returns Whether the file change is a canvas file node change.
+ */
+export declare function isCanvasFileNodeChange(change: FileChange): change is CanvasFileNodeChange;
+/**
+ * Checks if a file change is a canvas text node change.
+ *
+ * @param change - The file change to check.
+ * @returns Whether the file change is a canvas text node change.
+ */
+export declare function isCanvasTextNodeChange(change: FileChange): change is CanvasTextNodeChange;
+/**
+ * Checks if a file change is a content change.
+ *
+ * @param fileChange - The file change to check.
+ * @returns A boolean indicating whether the file change is a content change.
+ */
+export declare function isContentChange(fileChange: FileChange): fileChange is ContentChange;
+/**
+ * Checks if a file change is a frontmatter change.
+ *
+ * @param fileChange - The file change to check.
+ * @returns A boolean indicating whether the file change is a frontmatter change.
+ */
+export declare function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange;
+/**
+ * Checks if a file change is a frontmatter change with offsets.
+ *
+ * @param fileChange - The file change to check.
+ * @returns A boolean indicating whether the file change is a frontmatter change with offsets.
+ */
+export declare function isFrontmatterChangeWithOffsets(fileChange: FileChange): fileChange is FrontmatterChangeWithOffsets;
+/**
+ * Converts a frontmatter change to a frontmatter change with offsets.
+ *
+ * @param fileChange - The file change to convert.
+ * @returns The converted file change.
+ */
+export declare function toFrontmatterChangeWithOffsets(fileChange: FrontmatterChange): FrontmatterChangeWithOffsets;
+export {};