@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/queue.mjs

@@ -0,0 +1,130 @@
+/*
+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 {
+  abortSignalAny,
+  abortSignalNever
+} from "@mnaoumov/typescript-lib/abort-controller";
+import {
+  addErrorHandler,
+  invokeAsyncSafely
+} from "@mnaoumov/typescript-lib/async";
+import { getStackTrace } from "@mnaoumov/typescript-lib/error";
+import {
+  noop,
+  noopAsync
+} from "@mnaoumov/typescript-lib/function";
+import { runWithTimeoutNotice } from "./async-with-notice.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { invokeAsyncAndLog } from "./logger.mjs";
+import { getObsidianDevUtilsState } from "./obsidian-dev-utils-state.mjs";
+function addToQueue(params) {
+  const stackTrace = params.stackTrace ?? getStackTrace(1);
+  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);
+}
+async function addToQueueAndWait(params) {
+  const abortSignal = params.abortSignal ?? abortSignalNever();
+  abortSignal.throwIfAborted();
+  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 6e4;
+  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;
+  const stackTrace = params.stackTrace ?? getStackTrace(1);
+  const operationName = params.operationName ?? "";
+  const queue = getQueue().value;
+  queue.items.push({
+    abortSignal,
+    operationFunction: params.operationFunction,
+    operationName,
+    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,
+    stackTrace,
+    timeoutInMilliseconds
+  });
+  queue.promise = queue.promise.then(() => processNextQueueItem());
+  await queue.promise;
+}
+async function flushQueue() {
+  await addToQueueAndWait({
+    operationFunction: noop,
+    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)
+  });
+}
+function getQueue() {
+  return getObsidianDevUtilsState("queue", { items: [], promise: noopAsync() });
+}
+async function processNextQueueItem() {
+  const queue = getQueue().value;
+  const item = queue.items[0];
+  if (!item) {
+    return;
+  }
+  await addErrorHandler(
+    () => runWithTimeoutNotice({
+      context: { queuedFunction: item.operationFunction },
+      async operationFunction(abortSignal) {
+        await invokeAsyncAndLog({
+          $function: item.operationFunction,
+          abortSignal: abortSignalAny(abortSignal, item.abortSignal),
+          stackTrace: item.stackTrace,
+          title: item.operationName || processNextQueueItem.name
+        });
+      },
+      operationName: item.operationName,
+      pluginNoticeComponent: null,
+      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,
+      stackTrace: item.stackTrace,
+      timeoutInMilliseconds: item.timeoutInMilliseconds
+    })
+  );
+  queue.items.shift();
+}
+export {
+  addToQueue,
+  addToQueueAndWait,
+  flushQueue
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/queue.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for enqueuing and processing functions in Obsidian.\n */\n\nimport type { ValueWrapper } from '@mnaoumov/typescript-lib/value-wrapper';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  abortSignalAny,\n  abortSignalNever\n} from '@mnaoumov/typescript-lib/abort-controller';\nimport {\n  addErrorHandler,\n  invokeAsyncSafely\n} from '@mnaoumov/typescript-lib/async';\nimport { getStackTrace } from '@mnaoumov/typescript-lib/error';\nimport {\n  noop,\n  noopAsync\n} from '@mnaoumov/typescript-lib/function';\n\nimport { runWithTimeoutNotice } from './async-with-notice.ts';\nimport { t } from './i18n/i18n.ts';\nimport { invokeAsyncAndLog } from './logger.ts';\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\n\n/**\n * Options for the {@link addToQueueAndWait} function.\n */\nexport interface AddToQueueAndWaitParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   *\n   * @default `60000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Options for the {@link addToQueue} function.\n */\nexport interface AddToQueueParams {\n  /**\n   * Optional abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The function to add.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * Optional name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * Whether to show a timeout notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n\n  /**\n   * Optional stack trace.\n   */\n  readonly stackTrace?: string;\n\n  /**\n   * The timeout in milliseconds.\n   *\n   * @default `60000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\ninterface Queue {\n  items: QueueItem[];\n  promise: Promise<void>;\n}\n\ninterface QueueItem {\n  abortSignal: AbortSignal;\n  operationFunction: (abortSignal: AbortSignal) => Promisable<void>;\n  operationName: string;\n  shouldShowTimeoutNotice: boolean;\n  stackTrace: string;\n  timeoutInMilliseconds: number;\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes.\n *\n * @param params - The parameters for the function.\n */\nexport function addToQueue(params: AddToQueueParams): void {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(() => addToQueueAndWait(params), stackTrace);\n}\n\n/**\n * Adds an asynchronous function to be executed after the previous function completes and returns a {@link Promise} that resolves when the function completes.\n *\n * @param params - The parameters for the function.\n */\nexport async function addToQueueAndWait(params: AddToQueueAndWaitParams): Promise<void> {\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const DEFAULT_TIMEOUT_IN_MILLISECONDS = 60_000;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const operationName = params.operationName ?? '';\n  const queue = getQueue().value;\n  queue.items.push({\n    abortSignal,\n    operationFunction: params.operationFunction,\n    operationName,\n    shouldShowTimeoutNotice: params.shouldShowTimeoutNotice ?? true,\n    stackTrace,\n    timeoutInMilliseconds\n  });\n  queue.promise = queue.promise.then(() => processNextQueueItem());\n  await queue.promise;\n}\n\n/**\n * Flushes the queue;\n */\nexport async function flushQueue(): Promise<void> {\n  await addToQueueAndWait({\n    operationFunction: noop,\n    operationName: t(($) => $.obsidianDevUtils.queue.flushQueue)\n  });\n}\n\nfunction getQueue(): ValueWrapper<Queue> {\n  return getObsidianDevUtilsState('queue', { items: [], promise: noopAsync() });\n}\n\nasync function processNextQueueItem(): Promise<void> {\n  const queue = getQueue().value;\n  const item = queue.items[0];\n  /* v8 ignore start -- Defensive check; processNextQueueItem is only called after an item is pushed. */\n  if (!item) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  await addErrorHandler(() =>\n    runWithTimeoutNotice({\n      context: { queuedFunction: item.operationFunction },\n      async operationFunction(abortSignal: AbortSignal): Promise<void> {\n        await invokeAsyncAndLog({\n          $function: item.operationFunction,\n          abortSignal: abortSignalAny(abortSignal, item.abortSignal),\n          stackTrace: item.stackTrace,\n          title: item.operationName || processNextQueueItem.name\n        });\n      },\n      operationName: item.operationName,\n      pluginNoticeComponent: null,\n      shouldShowTimeoutNotice: item.shouldShowTimeoutNotice,\n      stackTrace: item.stackTrace,\n      timeoutInMilliseconds: item.timeoutInMilliseconds\n    })\n  );\n  queue.items.shift();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,4BAA4B;AACrC,SAAS,SAAS;AAClB,SAAS,yBAAyB;AAClC,SAAS,gCAAgC;AAuGlC,SAAS,WAAW,QAAgC;AACzD,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,oBAAkB,MAAM,kBAAkB,MAAM,GAAG,UAAU;AAC/D;AAOA,eAAsB,kBAAkB,QAAgD;AACtF,QAAM,cAAc,OAAO,eAAe,iBAAiB;AAC3D,cAAY,eAAe;AAE3B,QAAM,kCAAkC;AACxC,QAAM,wBAAwB,OAAO,yBAAyB;AAC9D,QAAM,aAAa,OAAO,cAAc,cAAc,CAAC;AACvD,QAAM,gBAAgB,OAAO,iBAAiB;AAC9C,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,MAAM,KAAK;AAAA,IACf;AAAA,IACA,mBAAmB,OAAO;AAAA,IAC1B;AAAA,IACA,yBAAyB,OAAO,2BAA2B;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,KAAK,MAAM,qBAAqB,CAAC;AAC/D,QAAM,MAAM;AACd;AAKA,eAAsB,aAA4B;AAChD,QAAM,kBAAkB;AAAA,IACtB,mBAAmB;AAAA,IACnB,eAAe,EAAE,CAAC,MAAM,EAAE,iBAAiB,MAAM,UAAU;AAAA,EAC7D,CAAC;AACH;AAEA,SAAS,WAAgC;AACvC,SAAO,yBAAyB,SAAS,EAAE,OAAO,CAAC,GAAG,SAAS,UAAU,EAAE,CAAC;AAC9E;AAEA,eAAe,uBAAsC;AACnD,QAAM,QAAQ,SAAS,EAAE;AACzB,QAAM,OAAO,MAAM,MAAM,CAAC;AAE1B,MAAI,CAAC,MAAM;AACT;AAAA,EACF;AAGA,QAAM;AAAA,IAAgB,MACpB,qBAAqB;AAAA,MACnB,SAAS,EAAE,gBAAgB,KAAK,kBAAkB;AAAA,MAClD,MAAM,kBAAkB,aAAyC;AAC/D,cAAM,kBAAkB;AAAA,UACtB,WAAW,KAAK;AAAA,UAChB,aAAa,eAAe,aAAa,KAAK,WAAW;AAAA,UACzD,YAAY,KAAK;AAAA,UACjB,OAAO,KAAK,iBAAiB,qBAAqB;AAAA,QACpD,CAAC;AAAA,MACH;AAAA,MACA,eAAe,KAAK;AAAA,MACpB,uBAAuB;AAAA,MACvB,yBAAyB,KAAK;AAAA,MAC9B,YAAY,KAAK;AAAA,MACjB,uBAAuB,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AACA,QAAM,MAAM,MAAM;AACpB;",
  "names": []
}


package/dist/lib/esm/react/app-context.d.mts

@@ -0,0 +1,24 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Passes obsidian {@link App} instance to React components.
+ */
+import { App } from 'obsidian';
+/**
+ * A context for the app.
+ *
+ * Usage:
+ * ```tsx
+ * <AppContext.Provider value={app}>
+ *   <YourComponent />
+ * </AppContext.Provider>
+ * ```
+ */
+export declare const AppContext: import("react").Context<App | undefined>;
+/**
+ * A hook to use the app context.
+ *
+ * @returns The app instance.
+ */
+export declare function useApp(): App;

package/dist/lib/esm/react/app-context.mjs

@@ -0,0 +1,64 @@
+/*
+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 { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { App } from "obsidian";
+import {
+  createContext,
+  useContext
+} from "react";
+const AppContext = createContext(void 0);
+function useApp() {
+  return ensureNonNullable(useContext(AppContext), "AppContext not found");
+}
+export {
+  AppContext,
+  useApp
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3JlYWN0L2FwcC1jb250ZXh0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUGFzc2VzIG9ic2lkaWFuIHtAbGluayBBcHB9IGluc3RhbmNlIHRvIFJlYWN0IGNvbXBvbmVudHMuXG4gKi9cblxuaW1wb3J0IHsgZW5zdXJlTm9uTnVsbGFibGUgfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1saWIvdHlwZS1ndWFyZHMnO1xuaW1wb3J0IHsgQXBwIH0gZnJvbSAnb2JzaWRpYW4nO1xuaW1wb3J0IHtcbiAgY3JlYXRlQ29udGV4dCxcbiAgdXNlQ29udGV4dFxufSBmcm9tICdyZWFjdCc7XG5cbi8qKlxuICogQSBjb250ZXh0IGZvciB0aGUgYXBwLlxuICpcbiAqIFVzYWdlOlxuICogYGBgdHN4XG4gKiA8QXBwQ29udGV4dC5Qcm92aWRlciB2YWx1ZT17YXBwfT5cbiAqICAgPFlvdXJDb21wb25lbnQgLz5cbiAqIDwvQXBwQ29udGV4dC5Qcm92aWRlcj5cbiAqIGBgYFxuICovXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gUmVhY3QgY29udGV4dCByZXF1aXJlcyBSZWFjdCB0ZXN0aW5nIHNldHVwIHRoYXQgaXMgbm90IGF2YWlsYWJsZSBpbiB0aGlzIHByb2plY3QuICovXG5leHBvcnQgY29uc3QgQXBwQ29udGV4dCA9IGNyZWF0ZUNvbnRleHQ8QXBwIHwgdW5kZWZpbmVkPih1bmRlZmluZWQpO1xuXG4vKipcbiAqIEEgaG9vayB0byB1c2UgdGhlIGFwcCBjb250ZXh0LlxuICpcbiAqIEByZXR1cm5zIFRoZSBhcHAgaW5zdGFuY2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1c2VBcHAoKTogQXBwIHtcbiAgcmV0dXJuIGVuc3VyZU5vbk51bGxhYmxlKHVzZUNvbnRleHQoQXBwQ29udGV4dCksICdBcHBDb250ZXh0IG5vdCBmb3VuZCcpO1xufVxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFNQSxTQUFTLHlCQUF5QjtBQUNsQyxTQUFTLFdBQVc7QUFDcEI7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFhQSxNQUFNLGFBQWEsY0FBK0IsTUFBUztBQU8zRCxTQUFTLFNBQWM7QUFDNUIsU0FBTyxrQkFBa0IsV0FBVyxVQUFVLEdBQUcsc0JBQXNCO0FBQ3pFOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/react/index.d.mts

@@ -0,0 +1,2 @@
+/// <reference path="../library.d.mts" />
+export * as 'app-context' from './app-context.mjs';

package/dist/lib/esm/react/index.mjs

@@ -0,0 +1,54 @@
+/*
+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 * as app_context from "./app-context.mjs";
+export {
+  app_context as "app-context"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3JlYWN0L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2FwcC1jb250ZXh0JyBmcm9tICcuL2FwcC1jb250ZXh0LnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQSxZQUFZQSxpQkFBbUI7IiwKICAibmFtZXMiOiBbImFwcC1jb250ZXh0Il0KfQo=

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

@@ -0,0 +1,116 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for handling references in Obsidian.
+ */
+import type { FrontmatterLinkCache, Reference } from 'obsidian';
+import type { FileChange } from './file-change.mjs';
+/**
+ * A reference within a file node in a canvas.
+ */
+export interface CanvasFileNodeReference extends CanvasReference {
+    /**
+     * A type of reference.
+     */
+    type: 'file';
+}
+/**
+ * A reference within a canvas.
+ */
+export interface CanvasReference extends FrontmatterLinkCache {
+    /**
+     * Whether the reference is a canvas reference.
+     */
+    isCanvas: true;
+    /**
+     * An index of the node in the canvas.
+     */
+    nodeIndex: number;
+    /**
+     * A type of reference.
+     */
+    type: 'file' | 'text';
+}
+/**
+ * A reference within a text node in a canvas.
+ */
+export interface CanvasTextNodeReference extends CanvasReference {
+    /**
+     * An original reference.
+     */
+    originalReference: Reference;
+    /**
+     * A type of reference.
+     */
+    type: 'text';
+}
+/**
+ * A range within a file's content, expressed in character offsets.
+ *
+ * Both bounds are inclusive: a reference whose own offsets coincide exactly with
+ * {@link OffsetRange.startOffset} / {@link OffsetRange.endOffset} is inside the range.
+ */
+export interface OffsetRange {
+    /**
+     * An end offset of the range within the file's content.
+     */
+    readonly endOffset: number;
+    /**
+     * A start offset of the range within the file's content.
+     */
+    readonly startOffset: number;
+}
+/**
+ * Checks if a reference is a canvas file node reference.
+ *
+ * @param reference - The reference to check.
+ * @returns Whether the reference is a canvas file node reference.
+ */
+export declare function isCanvasFileNodeReference(reference: Reference): reference is CanvasFileNodeReference;
+/**
+ * Checks if a reference is a canvas reference.
+ *
+ * @param reference - The reference to check.
+ * @returns Whether the reference is a canvas reference.
+ */
+export declare function isCanvasReference(reference: Reference): reference is CanvasReference;
+/**
+ * Checks if a reference is a canvas text node reference.
+ *
+ * @param reference - The reference to check.
+ * @returns Whether the reference is a canvas text node reference.
+ */
+export declare function isCanvasTextNodeReference(reference: Reference): reference is CanvasTextNodeReference;
+/**
+ * Checks if a reference is fully contained within an offset range.
+ *
+ * Only a reference that carries a position within the file's content can be in a range. A
+ * {@link FrontmatterLinkCache} — a frontmatter link, a multi-link frontmatter value entry, or any canvas
+ * reference — carries no such position and is therefore never in range. Its `startOffset` / `endOffset`,
+ * where present, locate the link within its own property value rather than within the file, so they are
+ * deliberately not compared against the range.
+ *
+ * Containment is full and both bounds are inclusive: a reference that only partially overlaps the range is
+ * not in it, because rewriting part of a link corrupts it.
+ *
+ * @param reference - The reference to check.
+ * @param offsetRange - The offset range to check against.
+ * @returns Whether the reference is fully contained within the offset range.
+ */
+export declare function isReferenceInOffsetRange(reference: Reference, offsetRange: OffsetRange): boolean;
+/**
+ * Converts a reference to a file change.
+ *
+ * @param reference - The reference to convert.
+ * @param newContent - The new content for the reference.
+ * @returns The file change.
+ */
+export declare function referenceToFileChange(reference: Reference, newContent: string): FileChange;
+/**
+ * Sorts references by their type and position.
+ *
+ * @param references - The references to sort.
+ * @returns The sorted references.
+ */
+export declare function sortReferences(references: Reference[]): Reference[];

package/dist/lib/esm/reference.mjs

@@ -0,0 +1,95 @@
+/*
+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 {
+  isFrontmatterLinkCache,
+  isReferenceCache
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import { isFrontmatterLinkCacheWithOffsets } from "./frontmatter-link-cache-with-offsets.mjs";
+function isCanvasFileNodeReference(reference) {
+  return isCanvasReference(reference) && reference.type === "file";
+}
+function isCanvasReference(reference) {
+  return isFrontmatterLinkCache(reference) && !!reference.isCanvas;
+}
+function isCanvasTextNodeReference(reference) {
+  return isCanvasReference(reference) && reference.type === "text";
+}
+function isReferenceInOffsetRange(reference, offsetRange) {
+  return isReferenceCache(reference) && offsetRange.startOffset <= reference.position.start.offset && reference.position.end.offset <= offsetRange.endOffset;
+}
+function referenceToFileChange(reference, newContent) {
+  return {
+    newContent,
+    oldContent: isFrontmatterLinkCacheWithOffsets(reference) ? reference.original.slice(reference.startOffset, reference.endOffset) : reference.original,
+    reference
+  };
+}
+function sortReferences(references) {
+  return references.sort((a, b) => {
+    if (isFrontmatterLinkCache(a) && isFrontmatterLinkCache(b)) {
+      const aStartOffset = isFrontmatterLinkCacheWithOffsets(a) ? a.startOffset : 0;
+      const bStartOffset = isFrontmatterLinkCacheWithOffsets(b) ? b.startOffset : 0;
+      return a.key.localeCompare(b.key) || Number(isFrontmatterLinkCacheWithOffsets(b)) - Number(isFrontmatterLinkCacheWithOffsets(a)) || aStartOffset - bStartOffset;
+    }
+    if (isReferenceCache(a) && isReferenceCache(b)) {
+      return a.position.start.offset - b.position.start.offset;
+    }
+    return isFrontmatterLinkCache(a) ? 1 : -1;
+  });
+}
+export {
+  isCanvasFileNodeReference,
+  isCanvasReference,
+  isCanvasTextNodeReference,
+  isReferenceInOffsetRange,
+  referenceToFileChange,
+  sortReferences
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/reference.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for handling references in Obsidian.\n */\n\nimport type {\n  FrontmatterLinkCache,\n  Reference\n} from 'obsidian';\n\nimport {\n  isFrontmatterLinkCache,\n  isReferenceCache\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport type { FileChange } from './file-change.ts';\n\nimport { isFrontmatterLinkCacheWithOffsets } from './frontmatter-link-cache-with-offsets.ts';\n\n/**\n * A reference within a file node in a canvas.\n */\nexport interface CanvasFileNodeReference extends CanvasReference {\n  /**\n   * A type of reference.\n   */\n  type: 'file';\n}\n\n/**\n * A reference within a canvas.\n */\nexport interface CanvasReference extends FrontmatterLinkCache {\n  /**\n   * Whether the reference is a canvas reference.\n   */\n  isCanvas: true;\n\n  /**\n   * An index of the node in the canvas.\n   */\n  nodeIndex: number;\n\n  /**\n   * A type of reference.\n   */\n  type: 'file' | 'text';\n}\n\n/**\n * A reference within a text node in a canvas.\n */\nexport interface CanvasTextNodeReference extends CanvasReference {\n  /**\n   * An original reference.\n   */\n  originalReference: Reference;\n\n  /**\n   * A type of reference.\n   */\n  type: 'text';\n}\n\n/**\n * A range within a file's content, expressed in character offsets.\n *\n * Both bounds are inclusive: a reference whose own offsets coincide exactly with\n * {@link OffsetRange.startOffset} / {@link OffsetRange.endOffset} is inside the range.\n */\nexport interface OffsetRange {\n  /**\n   * An end offset of the range within the file's content.\n   */\n  readonly endOffset: number;\n\n  /**\n   * A start offset of the range within the file's content.\n   */\n  readonly startOffset: number;\n}\n\n/**\n * Checks if a reference is a canvas file node reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas file node reference.\n */\nexport function isCanvasFileNodeReference(reference: Reference): reference is CanvasFileNodeReference {\n  return isCanvasReference(reference) && reference.type === 'file';\n}\n\n/**\n * Checks if a reference is a canvas reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas reference.\n */\nexport function isCanvasReference(reference: Reference): reference is CanvasReference {\n  return isFrontmatterLinkCache(reference) && !!(reference as Partial<CanvasReference>).isCanvas;\n}\n\n/**\n * Checks if a reference is a canvas text node reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas text node reference.\n */\nexport function isCanvasTextNodeReference(reference: Reference): reference is CanvasTextNodeReference {\n  return isCanvasReference(reference) && reference.type === 'text';\n}\n\n/**\n * Checks if a reference is fully contained within an offset range.\n *\n * Only a reference that carries a position within the file's content can be in a range. A\n * {@link FrontmatterLinkCache} \u2014 a frontmatter link, a multi-link frontmatter value entry, or any canvas\n * reference \u2014 carries no such position and is therefore never in range. Its `startOffset` / `endOffset`,\n * where present, locate the link within its own property value rather than within the file, so they are\n * deliberately not compared against the range.\n *\n * Containment is full and both bounds are inclusive: a reference that only partially overlaps the range is\n * not in it, because rewriting part of a link corrupts it.\n *\n * @param reference - The reference to check.\n * @param offsetRange - The offset range to check against.\n * @returns Whether the reference is fully contained within the offset range.\n */\nexport function isReferenceInOffsetRange(reference: Reference, offsetRange: OffsetRange): boolean {\n  return isReferenceCache(reference) && offsetRange.startOffset <= reference.position.start.offset && reference.position.end.offset <= offsetRange.endOffset;\n}\n\n/**\n * Converts a reference to a file change.\n *\n * @param reference - The reference to convert.\n * @param newContent - The new content for the reference.\n * @returns The file change.\n */\nexport function referenceToFileChange(reference: Reference, newContent: string): FileChange {\n  return {\n    newContent,\n    oldContent: isFrontmatterLinkCacheWithOffsets(reference) ? reference.original.slice(reference.startOffset, reference.endOffset) : reference.original,\n    reference\n  };\n}\n\n/**\n * Sorts references by their type and position.\n *\n * @param references - The references to sort.\n * @returns The sorted references.\n */\nexport function sortReferences(references: Reference[]): Reference[] {\n  return references.sort((a, b) => {\n    if (isFrontmatterLinkCache(a) && isFrontmatterLinkCache(b)) {\n      const aStartOffset = isFrontmatterLinkCacheWithOffsets(a) ? a.startOffset : 0;\n      /* v8 ignore start -- v8 incorrectly reports this branch as uncovered, but it is covered by `should sort two frontmatter links without offsets` test. */\n      const bStartOffset = isFrontmatterLinkCacheWithOffsets(b) ? b.startOffset : 0;\n      /* v8 ignore stop */\n      return a.key.localeCompare(b.key) || Number(isFrontmatterLinkCacheWithOffsets(b)) - Number(isFrontmatterLinkCacheWithOffsets(a))\n        || aStartOffset - bStartOffset;\n    }\n\n    if (isReferenceCache(a) && isReferenceCache(b)) {\n      return a.position.start.offset - b.position.start.offset;\n    }\n\n    return isFrontmatterLinkCache(a) ? 1 : -1;\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAIP,SAAS,yCAAyC;AAuE3C,SAAS,0BAA0B,WAA4D;AACpG,SAAO,kBAAkB,SAAS,KAAK,UAAU,SAAS;AAC5D;AAQO,SAAS,kBAAkB,WAAoD;AACpF,SAAO,uBAAuB,SAAS,KAAK,CAAC,CAAE,UAAuC;AACxF;AAQO,SAAS,0BAA0B,WAA4D;AACpG,SAAO,kBAAkB,SAAS,KAAK,UAAU,SAAS;AAC5D;AAkBO,SAAS,yBAAyB,WAAsB,aAAmC;AAChG,SAAO,iBAAiB,SAAS,KAAK,YAAY,eAAe,UAAU,SAAS,MAAM,UAAU,UAAU,SAAS,IAAI,UAAU,YAAY;AACnJ;AASO,SAAS,sBAAsB,WAAsB,YAAgC;AAC1F,SAAO;AAAA,IACL;AAAA,IACA,YAAY,kCAAkC,SAAS,IAAI,UAAU,SAAS,MAAM,UAAU,aAAa,UAAU,SAAS,IAAI,UAAU;AAAA,IAC5I;AAAA,EACF;AACF;AAQO,SAAS,eAAe,YAAsC;AACnE,SAAO,WAAW,KAAK,CAAC,GAAG,MAAM;AAC/B,QAAI,uBAAuB,CAAC,KAAK,uBAAuB,CAAC,GAAG;AAC1D,YAAM,eAAe,kCAAkC,CAAC,IAAI,EAAE,cAAc;AAE5E,YAAM,eAAe,kCAAkC,CAAC,IAAI,EAAE,cAAc;AAE5E,aAAO,EAAE,IAAI,cAAc,EAAE,GAAG,KAAK,OAAO,kCAAkC,CAAC,CAAC,IAAI,OAAO,kCAAkC,CAAC,CAAC,KAC1H,eAAe;AAAA,IACtB;AAEA,QAAI,iBAAiB,CAAC,KAAK,iBAAiB,CAAC,GAAG;AAC9C,aAAO,EAAE,SAAS,MAAM,SAAS,EAAE,SAAS,MAAM;AAAA,IACpD;AAEA,WAAO,uBAAuB,CAAC,IAAI,IAAI;AAAA,EACzC,CAAC;AACH;",
  "names": []
}
