@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/callout.mjs

@@ -0,0 +1,132 @@
+/*
+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 { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  assertNever,
+  ensureNonNullable
+} from "@mnaoumov/typescript-lib/type-guards";
+import { resolveValue } from "@mnaoumov/typescript-lib/value-provider";
+import { getRenderedContainer } from "./dataview.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { addToQueue } from "./queue.mjs";
+var CalloutMode = /* @__PURE__ */ ((CalloutMode2) => {
+  CalloutMode2[CalloutMode2["Default"] = 0] = "Default";
+  CalloutMode2[CalloutMode2["FoldableCollapsed"] = 1] = "FoldableCollapsed";
+  CalloutMode2[CalloutMode2["FoldableExpanded"] = 2] = "FoldableExpanded";
+  return CalloutMode2;
+})(CalloutMode || {});
+function renderCallout(params) {
+  const {
+    contentProvider = "",
+    dv,
+    header = "",
+    mode = 1 /* FoldableCollapsed */,
+    type = "NOTE"
+  } = params;
+  const modifier = getModifier(mode);
+  const callout = dv.paragraph(`> [!${type}]${modifier} ${header}
+>
+> <div class="content"></div>`);
+  const contentDiv = ensureNonNullable(callout.querySelector(".content"), "Content div not found");
+  dv.paragraph("Loading... \u23F3", { container: contentDiv });
+  const observer = new IntersectionObserver((entries) => {
+    for (const entry of entries) {
+      if (!entry.isIntersecting) {
+        continue;
+      }
+      observer.unobserve(entry.target);
+      addToQueue(normalizeOptionalProperties({
+        abortSignal: params.abortSignal,
+        operationFunction: loadContent,
+        operationName: t(($) => $.obsidianDevUtils.callout.loadContent)
+      }));
+    }
+  });
+  observer.observe(contentDiv);
+  async function loadContent(abortSignal) {
+    abortSignal.throwIfAborted();
+    let content;
+    const paragraph = await getRenderedContainer(dv, async () => {
+      content = await resolveValue(contentProvider, abortSignal);
+      abortSignal.throwIfAborted();
+    });
+    abortSignal.throwIfAborted();
+    content ??= paragraph;
+    contentDiv.empty();
+    dv.paragraph(content, { container: contentDiv });
+  }
+}
+function wrapForCallout(content) {
+  const lines = content.split("\n");
+  const prefixedLines = lines.map((line) => `> ${line}`);
+  return prefixedLines.join("\n");
+}
+function getModifier(mode) {
+  switch (mode) {
+    case 0 /* Default */: {
+      return "";
+    }
+    case 1 /* FoldableCollapsed */: {
+      return "-";
+    }
+    case 2 /* FoldableExpanded */: {
+      return "+";
+    }
+    default: {
+      assertNever(mode);
+    }
+  }
+}
+export {
+  CalloutMode,
+  renderCallout,
+  wrapForCallout
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/callout.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for rendering callouts in Dataview.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';\n\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  assertNever,\n  ensureNonNullable\n} from '@mnaoumov/typescript-lib/type-guards';\nimport { resolveValue } from '@mnaoumov/typescript-lib/value-provider';\n\nimport type { DataviewInlineApi } from './dataview.ts';\nimport type { AddToQueueParams } from './queue.ts';\n\nimport { getRenderedContainer } from './dataview.ts';\nimport { t } from './i18n/i18n.ts';\nimport { addToQueue } from './queue.ts';\n\n/**\n * Enum representing the mode of a callout.\n */\nexport enum CalloutMode {\n  /**\n  Default mode, with no special behavior.\n   */\n  Default,\n\n  /**\n  Foldable mode with the callout collapsed.\n   */\n  FoldableCollapsed,\n\n  /**\n  Foldable mode with the callout expanded.\n   */\n  FoldableExpanded\n}\n\n/**\n * Options for {@link renderCallout}.\n */\nexport interface RenderCalloutParams {\n  /**\n   * An abort signal.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * An optional provider for the content, which can be either a string or a Node.\n   *\n   * @default `''`\n   */\n  readonly contentProvider?: ValueProvider<MaybeReturn<Node | string>>;\n\n  /**\n   * A {@link DataviewInlineApi} instance.\n   */\n  readonly dv: DataviewInlineApi;\n\n  /**\n   * A header text of the callout, default is an empty string.\n   *\n   * @default `''`\n   */\n  readonly header?: string;\n\n  /**\n   * A callout mode, default is `CalloutMode.FoldableCollapsed`.\n   *\n   * @default {@link CalloutMode.FoldableCollapsed}\n   */\n  readonly mode?: CalloutMode;\n\n  /**\n   * A type of the callout, default is `\"NOTE\"`.\n   *\n   * @default `'NOTE'`\n   */\n  readonly type?: string;\n}\n\n/**\n * Renders a callout block in Dataview.\n *\n * @param params - The parameters for rendering the callout.\n */\nexport function renderCallout(params: RenderCalloutParams): void {\n  const {\n    contentProvider = '',\n    dv,\n    header = '',\n    mode = CalloutMode.FoldableCollapsed,\n    type = 'NOTE'\n  } = params;\n  const modifier = getModifier(mode);\n  const callout = dv.paragraph(`> [!${type}]${modifier} ${header}\\n>\\n> <div class=\"content\"></div>`);\n  const contentDiv = ensureNonNullable(callout.querySelector<HTMLDivElement>('.content'), 'Content div not found');\n  dv.paragraph('Loading... \u23F3', { container: contentDiv });\n\n  const observer = new IntersectionObserver((entries: IntersectionObserverEntry[]) => {\n    for (const entry of entries) {\n      if (!entry.isIntersecting) {\n        continue;\n      }\n\n      observer.unobserve(entry.target);\n      addToQueue(normalizeOptionalProperties<AddToQueueParams>({\n        abortSignal: params.abortSignal,\n        operationFunction: loadContent,\n        operationName: t(($) => $.obsidianDevUtils.callout.loadContent)\n      }));\n    }\n  });\n  observer.observe(contentDiv);\n\n  async function loadContent(abortSignal: AbortSignal): Promise<void> {\n    abortSignal.throwIfAborted();\n    let content: MaybeReturn<Node | string | undefined>;\n\n    const paragraph = await getRenderedContainer(dv, async () => {\n      content = await resolveValue(contentProvider, abortSignal);\n      abortSignal.throwIfAborted();\n    });\n    abortSignal.throwIfAborted();\n\n    content ??= paragraph;\n\n    contentDiv.empty();\n    dv.paragraph(content, { container: contentDiv });\n  }\n}\n\n/**\n * Wraps the provided content in blockquote syntax for a callout.\n *\n * @param content - The content to wrap.\n * @returns The content wrapped in blockquote syntax.\n */\nexport function wrapForCallout(content: string): string {\n  const lines = content.split('\\n');\n  const prefixedLines = lines.map((line) => `> ${line}`);\n  return prefixedLines.join('\\n');\n}\n\n/**\n * Returns the modifier string based on the callout mode.\n *\n * @param mode - The mode of the callout.\n * @returns The corresponding modifier string.\n */\nfunction getModifier(mode: CalloutMode): string {\n  switch (mode) {\n    case CalloutMode.Default: {\n      return '';\n    }\n    case CalloutMode.FoldableCollapsed: {\n      return '-';\n    }\n    case CalloutMode.FoldableExpanded: {\n      return '+';\n    }\n    default: {\n      assertNever(mode);\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,SAAS,mCAAmC;AAC5C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,oBAAoB;AAK7B,SAAS,4BAA4B;AACrC,SAAS,SAAS;AAClB,SAAS,kBAAkB;AAKpB,IAAK,cAAL,kBAAKA,iBAAL;AAIL,EAAAA,0BAAA;AAKA,EAAAA,0BAAA;AAKA,EAAAA,0BAAA;AAdU,SAAAA;AAAA,GAAA;AAiEL,SAAS,cAAc,QAAmC;AAC/D,QAAM;AAAA,IACJ,kBAAkB;AAAA,IAClB;AAAA,IACA,SAAS;AAAA,IACT,OAAO;AAAA,IACP,OAAO;AAAA,EACT,IAAI;AACJ,QAAM,WAAW,YAAY,IAAI;AACjC,QAAM,UAAU,GAAG,UAAU,OAAO,IAAI,IAAI,QAAQ,IAAI,MAAM;AAAA;AAAA,8BAAoC;AAClG,QAAM,aAAa,kBAAkB,QAAQ,cAA8B,UAAU,GAAG,uBAAuB;AAC/G,KAAG,UAAU,qBAAgB,EAAE,WAAW,WAAW,CAAC;AAEtD,QAAM,WAAW,IAAI,qBAAqB,CAAC,YAAyC;AAClF,eAAW,SAAS,SAAS;AAC3B,UAAI,CAAC,MAAM,gBAAgB;AACzB;AAAA,MACF;AAEA,eAAS,UAAU,MAAM,MAAM;AAC/B,iBAAW,4BAA8C;AAAA,QACvD,aAAa,OAAO;AAAA,QACpB,mBAAmB;AAAA,QACnB,eAAe,EAAE,CAAC,MAAM,EAAE,iBAAiB,QAAQ,WAAW;AAAA,MAChE,CAAC,CAAC;AAAA,IACJ;AAAA,EACF,CAAC;AACD,WAAS,QAAQ,UAAU;AAE3B,iBAAe,YAAY,aAAyC;AAClE,gBAAY,eAAe;AAC3B,QAAI;AAEJ,UAAM,YAAY,MAAM,qBAAqB,IAAI,YAAY;AAC3D,gBAAU,MAAM,aAAa,iBAAiB,WAAW;AACzD,kBAAY,eAAe;AAAA,IAC7B,CAAC;AACD,gBAAY,eAAe;AAE3B,gBAAY;AAEZ,eAAW,MAAM;AACjB,OAAG,UAAU,SAAS,EAAE,WAAW,WAAW,CAAC;AAAA,EACjD;AACF;AAQO,SAAS,eAAe,SAAyB;AACtD,QAAM,QAAQ,QAAQ,MAAM,IAAI;AAChC,QAAM,gBAAgB,MAAM,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE;AACrD,SAAO,cAAc,KAAK,IAAI;AAChC;AAQA,SAAS,YAAY,MAA2B;AAC9C,UAAQ,MAAM;AAAA,IACZ,KAAK,iBAAqB;AACxB,aAAO;AAAA,IACT;AAAA,IACA,KAAK,2BAA+B;AAClC,aAAO;AAAA,IACT;AAAA,IACA,KAAK,0BAA8B;AACjC,aAAO;AAAA,IACT;AAAA,IACA,SAAS;AACP,kBAAY,IAAI;AAAA,IAClB;AAAA,EACF;AACF;",
  "names": ["CalloutMode"]
}


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

@@ -0,0 +1,28 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains a utility function for extracting references from a canvas (`.canvas`) file.
+ */
+import type { App } from 'obsidian';
+import type { PathOrFile } from './file-system.mjs';
+import type { CanvasReference } from './reference.mjs';
+/**
+ * Extracts the outgoing references of a canvas (`.canvas`) file.
+ *
+ * Obsidian does not index canvas links into the per-file metadata cache, so a canvas file's
+ * {@link https://docs.obsidian.md/Reference/TypeScript+API/CachedMetadata | CachedMetadata} is empty and the
+ * usual cache-based readers return nothing for it. This helper reads the canvas JSON directly and returns
+ * both its file-node links and its text-node embeds as {@link CanvasReference}s.
+ *
+ * The returned references carry the `nodeIndex`/`type` (and, for text nodes, the `originalReference`) that
+ * the canvas-aware write path needs, so a consumer can move a canvas-referenced attachment and rewrite the
+ * canvas by composing `referenceToFileChange` (from `./reference.ts`) with `applyFileChanges` (from
+ * `./file-change.ts`).
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The canvas file (or its path) to extract references from.
+ * @returns A {@link Promise} that resolves to the canvas references, or an empty array when the file is
+ * missing or its content is not valid canvas JSON.
+ */
+export declare function getCanvasReferences(app: App, pathOrFile: PathOrFile): Promise<CanvasReference[]>;

package/dist/lib/esm/canvas.mjs

@@ -0,0 +1,129 @@
+/*
+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 {
+  getLinks,
+  parseMetadata
+} from "./metadata-cache.mjs";
+import { readSafe } from "./vault.mjs";
+async function getCanvasReferences(app, pathOrFile) {
+  const content = await readSafe(app, pathOrFile);
+  if (content === null) {
+    return [];
+  }
+  let partialCanvasData;
+  try {
+    partialCanvasData = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  const canvasData = partialCanvasData?.nodes ? partialCanvasData : {
+    edges: [],
+    nodes: []
+  };
+  const references = [];
+  const hasFrontmatterMarkdownLinksPlugin = !!app.plugins.getPlugin("frontmatter-markdown-links");
+  for (const [nodeIndex, node] of canvasData.nodes.entries()) {
+    switch (node.type) {
+      case "file": {
+        const canvasFileNodeReference = {
+          isCanvas: true,
+          key: `nodes.${String(nodeIndex)}.file`,
+          link: node.file,
+          nodeIndex,
+          original: node.file,
+          type: "file"
+        };
+        references.push(canvasFileNodeReference);
+        break;
+      }
+      case "text": {
+        const metadata = await parseMetadata(app, node.text, { shouldParseMultiValueFrontmatterLinks: hasFrontmatterMarkdownLinksPlugin });
+        if (hasFrontmatterMarkdownLinksPlugin) {
+          contributeMultiValueFrontmatterLinks(metadata);
+        }
+        const links = getLinks({ cache: metadata });
+        for (const [linkIndex, link] of links.entries()) {
+          const canvasTextNodeReference = {
+            isCanvas: true,
+            key: `nodes.${String(nodeIndex)}.text.${String(linkIndex)}`,
+            link: link.link,
+            nodeIndex,
+            original: link.original,
+            originalReference: link,
+            type: "text"
+          };
+          references.push(canvasTextNodeReference);
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+  return references;
+}
+function contributeMultiValueFrontmatterLinks(metadata) {
+  const contributedLinks = ensureNonNullable(metadata.multiValueFrontmatterLinks);
+  if (contributedLinks.length === 0) {
+    return;
+  }
+  const contributedKeys = new Set(contributedLinks.map((link) => link.key));
+  const nativeLinks = metadata.frontmatterLinks ?? [];
+  metadata.frontmatterLinks = [
+    ...nativeLinks.filter((link) => !contributedKeys.has(link.key)),
+    ...contributedLinks
+  ];
+}
+export {
+  getCanvasReferences
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/canvas.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains a utility function for extracting references from a canvas (`.canvas`) file.\n */\n\nimport type { App } from 'obsidian';\nimport type { CanvasData } from 'obsidian/canvas.d.ts';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { PathOrFile } from './file-system.ts';\nimport type { CachedMetadataEx } from './metadata-cache.ts';\nimport type {\n  CanvasFileNodeReference,\n  CanvasReference,\n  CanvasTextNodeReference\n} from './reference.ts';\n\nimport {\n  getLinks,\n  parseMetadata\n} from './metadata-cache.ts';\nimport { readSafe } from './vault.ts';\n\n/**\n * Extracts the outgoing references of a canvas (`.canvas`) file.\n *\n * Obsidian does not index canvas links into the per-file metadata cache, so a canvas file's\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/CachedMetadata | CachedMetadata} is empty and the\n * usual cache-based readers return nothing for it. This helper reads the canvas JSON directly and returns\n * both its file-node links and its text-node embeds as {@link CanvasReference}s.\n *\n * The returned references carry the `nodeIndex`/`type` (and, for text nodes, the `originalReference`) that\n * the canvas-aware write path needs, so a consumer can move a canvas-referenced attachment and rewrite the\n * canvas by composing `referenceToFileChange` (from `./reference.ts`) with `applyFileChanges` (from\n * `./file-change.ts`).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The canvas file (or its path) to extract references from.\n * @returns A {@link Promise} that resolves to the canvas references, or an empty array when the file is\n * missing or its content is not valid canvas JSON.\n */\nexport async function getCanvasReferences(app: App, pathOrFile: PathOrFile): Promise<CanvasReference[]> {\n  const content = await readSafe(app, pathOrFile);\n  if (content === null) {\n    return [];\n  }\n\n  let partialCanvasData: null | Partial<CanvasData>;\n  try {\n    partialCanvasData = JSON.parse(content) as null | Partial<CanvasData>;\n  } catch {\n    return [];\n  }\n\n  const canvasData = partialCanvasData?.nodes\n    ? partialCanvasData as CanvasData\n    : {\n      edges: [],\n      nodes: []\n    };\n\n  const references: CanvasReference[] = [];\n  const hasFrontmatterMarkdownLinksPlugin = !!app.plugins.getPlugin('frontmatter-markdown-links');\n\n  for (const [nodeIndex, node] of canvasData.nodes.entries()) {\n    switch (node.type) {\n      case 'file': {\n        const canvasFileNodeReference: CanvasFileNodeReference = {\n          isCanvas: true,\n          key: `nodes.${String(nodeIndex)}.file`,\n          link: node.file,\n          nodeIndex,\n          original: node.file,\n          type: 'file'\n        };\n        references.push(canvasFileNodeReference);\n        break;\n      }\n      case 'text': {\n        const metadata = await parseMetadata(app, node.text, { shouldParseMultiValueFrontmatterLinks: hasFrontmatterMarkdownLinksPlugin });\n        if (hasFrontmatterMarkdownLinksPlugin) {\n          contributeMultiValueFrontmatterLinks(metadata);\n        }\n        const links = getLinks({ cache: metadata });\n        for (const [linkIndex, link] of links.entries()) {\n          const canvasTextNodeReference: CanvasTextNodeReference = {\n            isCanvas: true,\n            key: `nodes.${String(nodeIndex)}.text.${String(linkIndex)}`,\n            link: link.link,\n            nodeIndex,\n            original: link.original,\n            originalReference: link,\n            type: 'text'\n          };\n          references.push(canvasTextNodeReference);\n        }\n        break;\n      }\n      default: {\n        break;\n      }\n    }\n  }\n\n  return references;\n}\n\n/**\n * Makes the one change to a canvas text node's metadata that the Frontmatter Markdown Links plugin makes to a\n * note's cache, so a text node reads its links as a note with the same text would.\n *\n * Obsidian itself reads a property whose WHOLE value is one internal link, markdown links included, so the plugin\n * contributes only the links embedded in a multi-link value (`[A](a.md), [B](b.md)`) and replaces whatever Obsidian\n * recorded under the same key. A text node is parsed outside the metadata cache, where the plugin never sees it,\n * so the same step is repeated here.\n *\n * @param metadata - The text node's metadata, parsed with multi-value frontmatter links, so\n * `multiValueFrontmatterLinks` is always set.\n */\nfunction contributeMultiValueFrontmatterLinks(metadata: CachedMetadataEx): void {\n  const contributedLinks = ensureNonNullable(metadata.multiValueFrontmatterLinks);\n  if (contributedLinks.length === 0) {\n    return;\n  }\n\n  const contributedKeys = new Set(contributedLinks.map((link) => link.key));\n  // A contributed link means the note has a frontmatter record, and Obsidian assigns `frontmatterLinks` beside it.\n  /* v8 ignore next -- Never nullish when a link was contributed; the `?? []` is defensive. */\n  const nativeLinks = metadata.frontmatterLinks ?? [];\n  metadata.frontmatterLinks = [\n    ...nativeLinks.filter((link) => !contributedKeys.has(link.key)),\n    ...contributedLinks\n  ];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,SAAS,yBAAyB;AAUlC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;AAoBzB,eAAsB,oBAAoB,KAAU,YAAoD;AACtG,QAAM,UAAU,MAAM,SAAS,KAAK,UAAU;AAC9C,MAAI,YAAY,MAAM;AACpB,WAAO,CAAC;AAAA,EACV;AAEA,MAAI;AACJ,MAAI;AACF,wBAAoB,KAAK,MAAM,OAAO;AAAA,EACxC,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,aAAa,mBAAmB,QAClC,oBACA;AAAA,IACA,OAAO,CAAC;AAAA,IACR,OAAO,CAAC;AAAA,EACV;AAEF,QAAM,aAAgC,CAAC;AACvC,QAAM,oCAAoC,CAAC,CAAC,IAAI,QAAQ,UAAU,4BAA4B;AAE9F,aAAW,CAAC,WAAW,IAAI,KAAK,WAAW,MAAM,QAAQ,GAAG;AAC1D,YAAQ,KAAK,MAAM;AAAA,MACjB,KAAK,QAAQ;AACX,cAAM,0BAAmD;AAAA,UACvD,UAAU;AAAA,UACV,KAAK,SAAS,OAAO,SAAS,CAAC;AAAA,UAC/B,MAAM,KAAK;AAAA,UACX;AAAA,UACA,UAAU,KAAK;AAAA,UACf,MAAM;AAAA,QACR;AACA,mBAAW,KAAK,uBAAuB;AACvC;AAAA,MACF;AAAA,MACA,KAAK,QAAQ;AACX,cAAM,WAAW,MAAM,cAAc,KAAK,KAAK,MAAM,EAAE,uCAAuC,kCAAkC,CAAC;AACjI,YAAI,mCAAmC;AACrC,+CAAqC,QAAQ;AAAA,QAC/C;AACA,cAAM,QAAQ,SAAS,EAAE,OAAO,SAAS,CAAC;AAC1C,mBAAW,CAAC,WAAW,IAAI,KAAK,MAAM,QAAQ,GAAG;AAC/C,gBAAM,0BAAmD;AAAA,YACvD,UAAU;AAAA,YACV,KAAK,SAAS,OAAO,SAAS,CAAC,SAAS,OAAO,SAAS,CAAC;AAAA,YACzD,MAAM,KAAK;AAAA,YACX;AAAA,YACA,UAAU,KAAK;AAAA,YACf,mBAAmB;AAAA,YACnB,MAAM;AAAA,UACR;AACA,qBAAW,KAAK,uBAAuB;AAAA,QACzC;AACA;AAAA,MACF;AAAA,MACA,SAAS;AACP;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAcA,SAAS,qCAAqC,UAAkC;AAC9E,QAAM,mBAAmB,kBAAkB,SAAS,0BAA0B;AAC9E,MAAI,iBAAiB,WAAW,GAAG;AACjC;AAAA,EACF;AAEA,QAAM,kBAAkB,IAAI,IAAI,iBAAiB,IAAI,CAAC,SAAS,KAAK,GAAG,CAAC;AAGxE,QAAM,cAAc,SAAS,oBAAoB,CAAC;AAClD,WAAS,mBAAmB;AAAA,IAC1B,GAAG,YAAY,OAAO,CAAC,SAAS,CAAC,gBAAgB,IAAI,KAAK,GAAG,CAAC;AAAA,IAC9D,GAAG;AAAA,EACL;AACF;",
  "names": []
}


package/dist/lib/esm/case-insensitive-file-index.d.mts

@@ -0,0 +1,92 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.
+ *
+ * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves
+ * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an
+ * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension
+ * checks and cache lookups are performed on already-removed paths. This module backs the
+ * case-insensitive lookup with a `lowercase-path → TAbstractFile` index so misses are O(1) too.
+ *
+ * The index is explicitly opt-in: a consumer installs it by loading a
+ * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in
+ * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,
+ * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.
+ */
+import type { App, TAbstractFile } from 'obsidian';
+/**
+ * An O(1) case-insensitive index of the loaded files and folders of a single vault.
+ *
+ * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept
+ * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.
+ */
+export declare class CaseInsensitiveFileIndex {
+    protected readonly app: App;
+    private readonly map;
+    /**
+     * Creates a new case-insensitive file index.
+     *
+     * @param app - The Obsidian application instance whose vault this index mirrors.
+     */
+    constructor(app: App);
+    /**
+     * Adds an abstract file to the index.
+     *
+     * @param abstractFile - The abstract file to add.
+     */
+    add(abstractFile: TAbstractFile): void;
+    /**
+     * Removes the abstract file at the given path from the index, along with all of its descendants
+     * (for folder deletions, where Obsidian removes the whole subtree).
+     *
+     * @param path - The path of the abstract file to remove.
+     */
+    delete(path: string): void;
+    /**
+     * Resolves an abstract file by its path, case-insensitively, in O(1).
+     *
+     * @param path - The path to resolve.
+     * @returns The abstract file if found, otherwise `null`.
+     */
+    get(path: string): null | TAbstractFile;
+    /**
+     * Checks whether this index mirrors the given application's vault.
+     *
+     * @param app - The application instance to check against.
+     * @returns `true` if this index belongs to the given application, `false` otherwise.
+     */
+    ownsApp(app: App): boolean;
+    /**
+     * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.
+     *
+     * Obsidian fires a single `rename` event for the renamed abstract file and updates its
+     * descendants' paths in place without firing per-descendant events, so descendant keys are
+     * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the
+     * old and new keys coincide).
+     *
+     * @param oldPath - The path the abstract file had before the rename.
+     * @param newAbstractFile - The abstract file with its updated (post-rename) path.
+     */
+    rename(oldPath: string, newAbstractFile: TAbstractFile): void;
+}
+/**
+ * Retrieves the installed case-insensitive file index for the given application, if any.
+ *
+ * @param app - The application instance whose index to retrieve.
+ * @returns The index if one is installed for this application, otherwise `null`.
+ */
+export declare function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null;
+/**
+ * Installs a case-insensitive file index as the active resolver.
+ *
+ * @param index - The index to install.
+ */
+export declare function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void;
+/**
+ * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.
+ *
+ * @param index - The index to uninstall.
+ */
+export declare function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void;

package/dist/lib/esm/case-insensitive-file-index.mjs

@@ -0,0 +1,152 @@
+/*
+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 { snapshot } from "@mnaoumov/typescript-lib/array";
+import { getObsidianDevUtilsState } from "./obsidian-dev-utils-state.mjs";
+const STATE_KEY = "caseInsensitiveFileIndex";
+class CaseInsensitiveFileIndex {
+  /**
+   * Creates a new case-insensitive file index.
+   *
+   * @param app - The Obsidian application instance whose vault this index mirrors.
+   */
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  map = /* @__PURE__ */ new Map();
+  /**
+   * Adds an abstract file to the index.
+   *
+   * @param abstractFile - The abstract file to add.
+   */
+  add(abstractFile) {
+    this.map.set(abstractFile.path.toLowerCase(), abstractFile);
+  }
+  /**
+   * Removes the abstract file at the given path from the index, along with all of its descendants
+   * (for folder deletions, where Obsidian removes the whole subtree).
+   *
+   * @param path - The path of the abstract file to remove.
+   */
+  delete(path) {
+    const key = path.toLowerCase();
+    this.map.delete(key);
+    const descendantPrefix = `${key}/`;
+    for (const existingKey of snapshot(this.map.keys())) {
+      if (existingKey.startsWith(descendantPrefix)) {
+        this.map.delete(existingKey);
+      }
+    }
+  }
+  /**
+   * Resolves an abstract file by its path, case-insensitively, in O(1).
+   *
+   * @param path - The path to resolve.
+   * @returns The abstract file if found, otherwise `null`.
+   */
+  get(path) {
+    return this.map.get(path.toLowerCase()) ?? null;
+  }
+  /**
+   * Checks whether this index mirrors the given application's vault.
+   *
+   * @param app - The application instance to check against.
+   * @returns `true` if this index belongs to the given application, `false` otherwise.
+   */
+  ownsApp(app) {
+    return this.app === app;
+  }
+  /**
+   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.
+   *
+   * Obsidian fires a single `rename` event for the renamed abstract file and updates its
+   * descendants' paths in place without firing per-descendant events, so descendant keys are
+   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the
+   * old and new keys coincide).
+   *
+   * @param oldPath - The path the abstract file had before the rename.
+   * @param newAbstractFile - The abstract file with its updated (post-rename) path.
+   */
+  rename(oldPath, newAbstractFile) {
+    const oldKey = oldPath.toLowerCase();
+    const newKey = newAbstractFile.path.toLowerCase();
+    this.map.delete(oldKey);
+    this.map.set(newKey, newAbstractFile);
+    const oldDescendantPrefix = `${oldKey}/`;
+    const newDescendantPrefix = `${newKey}/`;
+    for (const [existingKey, existingValue] of snapshot(this.map)) {
+      if (!existingKey.startsWith(oldDescendantPrefix)) {
+        continue;
+      }
+      this.map.delete(existingKey);
+      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);
+    }
+  }
+}
+function getCaseInsensitiveFileIndex(app) {
+  const index = getObsidianDevUtilsState(STATE_KEY, null).value;
+  return index?.ownsApp(app) ? index : null;
+}
+function setCaseInsensitiveFileIndex(index) {
+  getObsidianDevUtilsState(STATE_KEY, null).value = index;
+}
+function unsetCaseInsensitiveFileIndex(index) {
+  const wrapper = getObsidianDevUtilsState(STATE_KEY, null);
+  if (wrapper.value === index) {
+    wrapper.value = null;
+  }
+}
+export {
+  CaseInsensitiveFileIndex,
+  getCaseInsensitiveFileIndex,
+  setCaseInsensitiveFileIndex,
+  unsetCaseInsensitiveFileIndex
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/case-insensitive-file-index.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.\n *\n * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves\n * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an\n * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension\n * checks and cache lookups are performed on already-removed paths. This module backs the\n * case-insensitive lookup with a `lowercase-path \u2192 TAbstractFile` index so misses are O(1) too.\n *\n * The index is explicitly opt-in: a consumer installs it by loading a\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in\n * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,\n * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\n\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\n\nconst STATE_KEY = 'caseInsensitiveFileIndex';\n\n/**\n * An O(1) case-insensitive index of the loaded files and folders of a single vault.\n *\n * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept\n * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.\n */\nexport class CaseInsensitiveFileIndex {\n  private readonly map = new Map<string, TAbstractFile>();\n\n  /**\n   * Creates a new case-insensitive file index.\n   *\n   * @param app - The Obsidian application instance whose vault this index mirrors.\n   */\n  public constructor(protected readonly app: App) {}\n\n  /**\n   * Adds an abstract file to the index.\n   *\n   * @param abstractFile - The abstract file to add.\n   */\n  public add(abstractFile: TAbstractFile): void {\n    this.map.set(abstractFile.path.toLowerCase(), abstractFile);\n  }\n\n  /**\n   * Removes the abstract file at the given path from the index, along with all of its descendants\n   * (for folder deletions, where Obsidian removes the whole subtree).\n   *\n   * @param path - The path of the abstract file to remove.\n   */\n  public delete(path: string): void {\n    const key = path.toLowerCase();\n    this.map.delete(key);\n    const descendantPrefix = `${key}/`;\n    for (const existingKey of snapshot(this.map.keys())) {\n      if (existingKey.startsWith(descendantPrefix)) {\n        this.map.delete(existingKey);\n      }\n    }\n  }\n\n  /**\n   * Resolves an abstract file by its path, case-insensitively, in O(1).\n   *\n   * @param path - The path to resolve.\n   * @returns The abstract file if found, otherwise `null`.\n   */\n  public get(path: string): null | TAbstractFile {\n    return this.map.get(path.toLowerCase()) ?? null;\n  }\n\n  /**\n   * Checks whether this index mirrors the given application's vault.\n   *\n   * @param app - The application instance to check against.\n   * @returns `true` if this index belongs to the given application, `false` otherwise.\n   */\n  public ownsApp(app: App): boolean {\n    return this.app === app;\n  }\n\n  /**\n   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.\n   *\n   * Obsidian fires a single `rename` event for the renamed abstract file and updates its\n   * descendants' paths in place without firing per-descendant events, so descendant keys are\n   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the\n   * old and new keys coincide).\n   *\n   * @param oldPath - The path the abstract file had before the rename.\n   * @param newAbstractFile - The abstract file with its updated (post-rename) path.\n   */\n  public rename(oldPath: string, newAbstractFile: TAbstractFile): void {\n    const oldKey = oldPath.toLowerCase();\n    const newKey = newAbstractFile.path.toLowerCase();\n    this.map.delete(oldKey);\n    this.map.set(newKey, newAbstractFile);\n\n    const oldDescendantPrefix = `${oldKey}/`;\n    const newDescendantPrefix = `${newKey}/`;\n    for (const [existingKey, existingValue] of snapshot(this.map)) {\n      if (!existingKey.startsWith(oldDescendantPrefix)) {\n        continue;\n      }\n\n      this.map.delete(existingKey);\n      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);\n    }\n  }\n}\n\n/**\n * Retrieves the installed case-insensitive file index for the given application, if any.\n *\n * @param app - The application instance whose index to retrieve.\n * @returns The index if one is installed for this application, otherwise `null`.\n */\nexport function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null {\n  const index = getObsidianDevUtilsState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value;\n  return index?.ownsApp(app) ? index : null;\n}\n\n/**\n * Installs a case-insensitive file index as the active resolver.\n *\n * @param index - The index to install.\n */\nexport function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  getObsidianDevUtilsState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value = index;\n}\n\n/**\n * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.\n *\n * @param index - The index to uninstall.\n */\nexport function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  const wrapper = getObsidianDevUtilsState<CaseInsensitiveFileIndex | null>(STATE_KEY, null);\n  if (wrapper.value === index) {\n    wrapper.value = null;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,gBAAgB;AAEzB,SAAS,gCAAgC;AAEzC,MAAM,YAAY;AAQX,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7B,YAA+B,KAAU;AAAV;AAAA,EAAW;AAAA,EAAX;AAAA,EAPrB,MAAM,oBAAI,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc/C,IAAI,cAAmC;AAC5C,SAAK,IAAI,IAAI,aAAa,KAAK,YAAY,GAAG,YAAY;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,MAAoB;AAChC,UAAM,MAAM,KAAK,YAAY;AAC7B,SAAK,IAAI,OAAO,GAAG;AACnB,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,eAAe,SAAS,KAAK,IAAI,KAAK,CAAC,GAAG;AACnD,UAAI,YAAY,WAAW,gBAAgB,GAAG;AAC5C,aAAK,IAAI,OAAO,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,MAAoC;AAC7C,WAAO,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,KAAmB;AAChC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,OAAO,SAAiB,iBAAsC;AACnE,UAAM,SAAS,QAAQ,YAAY;AACnC,UAAM,SAAS,gBAAgB,KAAK,YAAY;AAChD,SAAK,IAAI,OAAO,MAAM;AACtB,SAAK,IAAI,IAAI,QAAQ,eAAe;AAEpC,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,KAAK,SAAS,KAAK,GAAG,GAAG;AAC7D,UAAI,CAAC,YAAY,WAAW,mBAAmB,GAAG;AAChD;AAAA,MACF;AAEA,WAAK,IAAI,OAAO,WAAW;AAC3B,WAAK,IAAI,IAAI,sBAAsB,YAAY,MAAM,oBAAoB,MAAM,GAAG,aAAa;AAAA,IACjG;AAAA,EACF;AACF;AAQO,SAAS,4BAA4B,KAA2C;AACrF,QAAM,QAAQ,yBAA0D,WAAW,IAAI,EAAE;AACzF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,2BAA0D,WAAW,IAAI,EAAE,QAAQ;AACrF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,UAAU,yBAA0D,WAAW,IAAI;AACzF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;",
  "names": []
}


package/dist/lib/esm/code-block-markdown-information.d.mts

@@ -0,0 +1,48 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides a helper type for the information about a code block in a markdown file.
+ */
+import type { MarkdownSectionInformation, Pos } from 'obsidian';
+/**
+ * Information about a code block in a markdown file.
+ */
+export interface CodeBlockMarkdownInformation {
+    /**
+     * Arguments of the code block.
+     */
+    $arguments: string[];
+    /**
+     * An end delimiter of the code block.
+     */
+    endDelimiter: string;
+    /**
+     * A language of the code block.
+     */
+    language: string;
+    /**
+     * A line prefix of each line of the code block.
+     */
+    linePrefix: string;
+    /**
+     * A content of the note.
+     */
+    noteContent: string;
+    /**
+     * A position of the code block in the note.
+     */
+    positionInNote: Pos;
+    /**
+     * Raw arguments string of the code block.
+     */
+    rawArgumentsString: string;
+    /**
+     * A section information of the code block.
+     */
+    sectionInfo: MarkdownSectionInformation;
+    /**
+     * A start delimiter of the code block.
+     */
+    startDelimiter: string;
+}