@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/file-change.mjs

@@ -0,0 +1,481 @@
+/*
+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 { printError } from "@mnaoumov/typescript-lib/error";
+import {
+  getNestedPropertyValue,
+  isDeepEqual,
+  normalizeOptionalProperties,
+  setNestedPropertyValue
+} from "@mnaoumov/typescript-lib/object-utils";
+import { resolveValue } from "@mnaoumov/typescript-lib/value-provider";
+import {
+  isFrontmatterLinkCache,
+  isReferenceCache
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import { getObsidianLibDebugger } from "./debug.mjs";
+import {
+  getPath,
+  isCanvasFile
+} from "./file-system.mjs";
+import {
+  isFrontmatterLinkCacheWithOffsets,
+  toFrontmatterLinkCacheWithOffsets
+} from "./frontmatter-link-cache-with-offsets.mjs";
+import {
+  parseFrontmatter,
+  setFrontmatter
+} from "./frontmatter.mjs";
+import {
+  isCanvasReference,
+  referenceToFileChange
+} from "./reference.mjs";
+import { process } from "./vault.mjs";
+const ESCAPED_WIKILINK_DIVIDER = String.raw`\|`;
+const OPTIONALLY_ESCAPED_WIKILINK_DIVIDER_REGEXP = /\\?\|/g;
+async function applyContentChanges(params) {
+  const {
+    abortSignal,
+    changesProvider,
+    content,
+    path,
+    shouldRetryOnInvalidChanges = true
+  } = params;
+  abortSignal.throwIfAborted();
+  let changes = await resolveValue(changesProvider, { abortSignal, content });
+  abortSignal.throwIfAborted();
+  if (changes === null) {
+    return null;
+  }
+  const { frontmatter, hasFrontmatterError } = parseFrontmatterSafely({ content, path });
+  if (!areChangesValid({ changes, content, frontmatter, path })) {
+    return shouldRetryOnInvalidChanges ? null : content;
+  }
+  changes = sortAndFilterChanges(changes);
+  const { frontmatterChanged, newContent } = applyContentChangesToText({ changes, content, hasFrontmatterError, path });
+  await applyFrontmatterChangesWithOffsets({
+    abortSignal,
+    frontmatter,
+    frontmatterChangesWithOffsetMap: frontmatterChanged,
+    path
+  });
+  abortSignal.throwIfAborted();
+  return buildFinalContent({ frontmatter, frontmatterChanged, newContent });
+}
+async function applyFileChanges(params) {
+  const {
+    app,
+    changesProvider,
+    pathOrFile,
+    shouldRetryOnInvalidChanges = true,
+    ...options
+  } = params;
+  await process(normalizeOptionalProperties({
+    app,
+    async newContentProvider({ abortSignal, content }) {
+      return isCanvasFile(pathOrFile) ? await applyCanvasChanges({
+        abortSignal,
+        changesProvider,
+        content,
+        path: getPath(app, pathOrFile),
+        shouldRetryOnInvalidChanges
+      }) : await applyContentChanges({
+        abortSignal,
+        changesProvider,
+        content,
+        path: getPath(app, pathOrFile),
+        shouldRetryOnInvalidChanges
+      });
+    },
+    pathOrFile,
+    ...options
+  }));
+}
+function isCanvasChange(change) {
+  return isCanvasReference(change.reference);
+}
+function isCanvasFileNodeChange(change) {
+  return isCanvasChange(change) && change.reference.type === "file";
+}
+function isCanvasTextNodeChange(change) {
+  return isCanvasChange(change) && change.reference.type === "text";
+}
+function isContentChange(fileChange) {
+  return isReferenceCache(fileChange.reference);
+}
+function isFrontmatterChange(fileChange) {
+  return isFrontmatterLinkCache(fileChange.reference);
+}
+function isFrontmatterChangeWithOffsets(fileChange) {
+  return isFrontmatterLinkCacheWithOffsets(fileChange.reference);
+}
+function toFrontmatterChangeWithOffsets(fileChange) {
+  return isFrontmatterChangeWithOffsets(fileChange) ? fileChange : {
+    ...fileChange,
+    reference: toFrontmatterLinkCacheWithOffsets(fileChange.reference)
+  };
+}
+async function applyCanvasChanges(params) {
+  const {
+    abortSignal,
+    changesProvider,
+    content,
+    path,
+    shouldRetryOnInvalidChanges = true
+  } = params;
+  const changes = await resolveValue(changesProvider, { abortSignal, content });
+  abortSignal.throwIfAborted();
+  if (changes === null) {
+    return null;
+  }
+  const canvasData = parseJsonSafe(content);
+  if (!Array.isArray(canvasData.nodes) || !Array.isArray(canvasData.edges)) {
+    getObsidianLibDebugger("FileChange:applyCanvasChanges")("Not a valid canvas; skipping rewrite", { path });
+    return content;
+  }
+  const canvasTextChanges = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (!isCanvasChange(change)) {
+      const message = "Only canvas changes are supported for canvas files";
+      console.error(message, {
+        change,
+        path
+      });
+      continue;
+    }
+    const node = canvasData.nodes[change.reference.nodeIndex];
+    if (!node) {
+      const message = "Node not found";
+      console.error(message, {
+        nodeIndex: change.reference.nodeIndex,
+        path
+      });
+      return content;
+    }
+    if (isCanvasFileNodeChange(change)) {
+      if (node.file !== change.oldContent) {
+        getObsidianLibDebugger("FileChange:applyCanvasChanges")("Content mismatch", {
+          actualContent: node.file,
+          expectedContent: change.oldContent,
+          nodeIndex: change.reference.nodeIndex,
+          path,
+          type: "file"
+        });
+        return content;
+      }
+      node.file = change.newContent;
+    } else if (isCanvasTextNodeChange(change)) {
+      let canvasTextChangesForNode = canvasTextChanges.get(change.reference.nodeIndex);
+      if (!canvasTextChangesForNode) {
+        canvasTextChangesForNode = [];
+        canvasTextChanges.set(change.reference.nodeIndex, canvasTextChangesForNode);
+      }
+      canvasTextChangesForNode.push(change);
+    }
+  }
+  for (const [nodeIndex, canvasTextChangesForNode] of canvasTextChanges) {
+    const node = canvasData.nodes[nodeIndex];
+    if (!node) {
+      const message = "Node not found";
+      console.error(message, {
+        nodeIndex,
+        path
+      });
+      return content;
+    }
+    if (typeof node.text !== "string") {
+      const message = "Node text is not a string";
+      console.error(message, {
+        nodeIndex,
+        path
+      });
+      return content;
+    }
+    const contentChanges = canvasTextChangesForNode.map((change) => {
+      const newContent = change.reference.originalReference.original.includes(ESCAPED_WIKILINK_DIVIDER) ? change.newContent.replaceAll(OPTIONALLY_ESCAPED_WIKILINK_DIVIDER_REGEXP, () => ESCAPED_WIKILINK_DIVIDER) : change.newContent;
+      return referenceToFileChange(change.reference.originalReference, newContent);
+    });
+    const newNodeText = await applyContentChanges({
+      abortSignal,
+      changesProvider: contentChanges,
+      content: node.text,
+      path: `${path}.node${String(nodeIndex)}.VIRTUAL_FILE.md`,
+      shouldRetryOnInvalidChanges
+    });
+    if (newNodeText === null) {
+      return content;
+    }
+    node.text = newNodeText;
+  }
+  return JSON.stringify(canvasData, null, "	");
+}
+function applyContentChangesToText(params) {
+  const {
+    changes,
+    content,
+    hasFrontmatterError,
+    path
+  } = params;
+  let newContent = "";
+  let lastIndex = 0;
+  let lastContentChange = {
+    newContent: "",
+    oldContent: "",
+    reference: {
+      link: "",
+      original: "",
+      position: {
+        end: { col: 0, line: 0, offset: 0 },
+        start: { col: 0, line: 0, offset: 0 }
+      }
+    }
+  };
+  const frontmatterChangesWithOffsetMap = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (isContentChange(change)) {
+      if (lastIndex <= change.reference.position.start.offset) {
+        newContent += content.slice(lastIndex, change.reference.position.start.offset);
+        newContent += change.newContent;
+        lastIndex = change.reference.position.end.offset;
+        lastContentChange = change;
+      } else {
+        const overlappingStartOffset = change.reference.position.start.offset - lastContentChange.reference.position.start.offset;
+        const overlappingEndOffset = change.reference.position.end.offset - lastContentChange.reference.position.start.offset;
+        const overlappingContent = lastContentChange.newContent.slice(overlappingStartOffset, overlappingEndOffset);
+        if (overlappingContent !== change.oldContent) {
+          const message = "Overlapping changes";
+          console.error(message, { change, lastContentChange });
+          throw new Error(message);
+        }
+        newContent = newContent.slice(0, newContent.length - lastContentChange.newContent.length) + lastContentChange.newContent.slice(0, overlappingStartOffset) + change.newContent + lastContentChange.newContent.slice(overlappingEndOffset);
+      }
+    } else if (isFrontmatterChange(change)) {
+      if (hasFrontmatterError) {
+        console.error(`Cannot apply frontmatter change in ${path}, because frontmatter parsing failed`, { change });
+      } else {
+        let frontmatterChangesWithOffsets = frontmatterChangesWithOffsetMap.get(change.reference.key);
+        if (!frontmatterChangesWithOffsets) {
+          frontmatterChangesWithOffsets = [];
+          frontmatterChangesWithOffsetMap.set(change.reference.key, frontmatterChangesWithOffsets);
+        }
+        frontmatterChangesWithOffsets.push(toFrontmatterChangeWithOffsets(change));
+      }
+    }
+  }
+  newContent += content.slice(lastIndex);
+  return { frontmatterChanged: frontmatterChangesWithOffsetMap, newContent };
+}
+async function applyFrontmatterChangesWithOffsets(params) {
+  const {
+    abortSignal,
+    frontmatter,
+    frontmatterChangesWithOffsetMap,
+    path
+  } = params;
+  for (const [key, frontmatterChangesWithOffsets] of frontmatterChangesWithOffsetMap) {
+    const propertyValue = getNestedPropertyValue(frontmatter, key);
+    if (typeof propertyValue !== "string") {
+      return;
+    }
+    const contentChanges = frontmatterChangesWithOffsets.map((change) => ({
+      newContent: change.newContent,
+      oldContent: change.oldContent,
+      reference: {
+        link: "",
+        original: "",
+        position: {
+          end: {
+            col: change.reference.endOffset,
+            line: 0,
+            offset: change.reference.endOffset
+          },
+          start: {
+            col: change.reference.startOffset,
+            line: 0,
+            offset: change.reference.startOffset
+          }
+        }
+      }
+    }));
+    const newPropertyValue = await applyContentChanges({
+      abortSignal,
+      changesProvider: contentChanges,
+      content: propertyValue,
+      path: `${path}.frontmatter.${key}.VIRTUAL_FILE.md`
+    });
+    if (newPropertyValue === null) {
+      return;
+    }
+    setNestedPropertyValue({
+      $object: frontmatter,
+      path: key,
+      value: newPropertyValue
+    });
+  }
+}
+function areChangesValid(params) {
+  const {
+    changes,
+    content,
+    frontmatter,
+    path
+  } = params;
+  const validateChangesDebugger = getObsidianLibDebugger("FileChange:validateChanges");
+  for (const change of changes) {
+    if (isContentChange(change)) {
+      const startOffset = change.reference.position.start.offset;
+      const endOffset = change.reference.position.end.offset;
+      const actualContent = content.slice(startOffset, endOffset);
+      if (actualContent !== change.oldContent) {
+        validateChangesDebugger("Content mismatch", {
+          actualContent,
+          endOffset,
+          expectedContent: change.oldContent,
+          path,
+          startOffset
+        });
+        return false;
+      }
+    } else if (isFrontmatterChangeWithOffsets(change)) {
+      const propertyValue = getNestedPropertyValue(frontmatter, change.reference.key);
+      if (typeof propertyValue !== "string") {
+        validateChangesDebugger("Property value is not a string", {
+          frontmatterKey: change.reference.key,
+          path,
+          propertyValue
+        });
+        return false;
+      }
+      const actualContent = propertyValue.slice(change.reference.startOffset, change.reference.endOffset);
+      if (actualContent !== change.oldContent) {
+        validateChangesDebugger("Content mismatch", {
+          actualContent,
+          expectedContent: change.oldContent,
+          frontmatterKey: change.reference.key,
+          path,
+          startOffset: change.reference.startOffset
+        });
+        return false;
+      }
+    } else if (isFrontmatterChange(change)) {
+      const actualContent = getNestedPropertyValue(frontmatter, change.reference.key);
+      if (actualContent !== change.oldContent) {
+        validateChangesDebugger("Content mismatch", {
+          actualContent,
+          expectedContent: change.oldContent,
+          frontmatterKey: change.reference.key,
+          path
+        });
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function buildFinalContent(params) {
+  const {
+    frontmatter,
+    frontmatterChanged,
+    newContent
+  } = params;
+  return frontmatterChanged.size > 0 ? setFrontmatter(newContent, frontmatter) : newContent;
+}
+function parseFrontmatterSafely(params) {
+  const { content, path } = params;
+  let frontmatter = {};
+  let hasFrontmatterError = false;
+  try {
+    frontmatter = parseFrontmatter(content);
+  } catch (error) {
+    printError(new Error(`Frontmatter parsing failed in ${path}`, { cause: error }));
+    hasFrontmatterError = true;
+  }
+  return { frontmatter, hasFrontmatterError };
+}
+function parseJsonSafe(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    parsed = null;
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    parsed = {};
+  }
+  return parsed;
+}
+function sortAndFilterChanges(changes) {
+  changes.sort((a, b) => {
+    if (isContentChange(a) && isContentChange(b)) {
+      return a.reference.position.start.offset - b.reference.position.start.offset;
+    }
+    if (isFrontmatterChangeWithOffsets(a) && isFrontmatterChangeWithOffsets(b)) {
+      return a.reference.key.localeCompare(b.reference.key) || a.reference.startOffset - b.reference.startOffset;
+    }
+    if (isFrontmatterChange(a) && isFrontmatterChange(b)) {
+      return a.reference.key.localeCompare(b.reference.key);
+    }
+    return isContentChange(a) ? -1 : 1;
+  });
+  return changes.filter((change, index) => {
+    return change.oldContent !== change.newContent && (index === 0 || !isDeepEqual(change, changes[index - 1]));
+  });
+}
+export {
+  applyContentChanges,
+  applyFileChanges,
+  isCanvasChange,
+  isCanvasFileNodeChange,
+  isCanvasTextNodeChange,
+  isContentChange,
+  isFrontmatterChange,
+  isFrontmatterChangeWithOffsets,
+  toFrontmatterChangeWithOffsets
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/file-change.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility types and functions for handling file changes in Obsidian.\n */\n\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';\nimport type {\n  App,\n  FrontmatterLinkCache,\n  Reference,\n  ReferenceCache\n} from 'obsidian';\nimport type { CanvasData } from 'obsidian/canvas.d.ts';\n\nimport { printError } from '@mnaoumov/typescript-lib/error';\nimport {\n  getNestedPropertyValue,\n  isDeepEqual,\n  normalizeOptionalProperties,\n  setNestedPropertyValue\n} from '@mnaoumov/typescript-lib/object-utils';\nimport { resolveValue } from '@mnaoumov/typescript-lib/value-provider';\nimport {\n  isFrontmatterLinkCache,\n  isReferenceCache\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport type { PathOrFile } from './file-system.ts';\nimport type { FrontmatterLinkCacheWithOffsets } from './frontmatter-link-cache-with-offsets.ts';\nimport type { CombinedFrontmatter } from './frontmatter.ts';\nimport type {\n  CanvasFileNodeReference,\n  CanvasReference,\n  CanvasTextNodeReference\n} from './reference.ts';\nimport type {\n  ContentArguments,\n  ProcessOptions,\n  ProcessParams\n} from './vault.ts';\n\nimport { getObsidianLibDebugger } from './debug.ts';\nimport {\n  getPath,\n  isCanvasFile\n} from './file-system.ts';\nimport {\n  isFrontmatterLinkCacheWithOffsets,\n  toFrontmatterLinkCacheWithOffsets\n} from './frontmatter-link-cache-with-offsets.ts';\nimport {\n  parseFrontmatter,\n  setFrontmatter\n} from './frontmatter.ts';\nimport {\n  isCanvasReference,\n  referenceToFileChange\n} from './reference.ts';\nimport { process } from './vault.ts';\n\nconst ESCAPED_WIKILINK_DIVIDER = String.raw`\\|`;\n/**\n * Matches a wikilink divider together with the backslash escaping it, if any. A lookbehind would say \"unescaped\"\n * directly, but it is a syntax error on iOS before 16.4, below the iOS 15 Obsidian mobile still supports.\n * Replacing every match with an escaped divider leaves an escaped one as it was and escapes a bare one.\n */\nconst OPTIONALLY_ESCAPED_WIKILINK_DIVIDER_REGEXP = /\\\\?\\|/g;\n\n/**\n * Parameters for {@link applyContentChanges}.\n */\nexport interface ApplyContentChangesParams {\n  /**\n   * The abort signal to control the execution of the function.\n   */\n  readonly abortSignal: AbortSignal;\n\n  /**\n   * A provider that returns an array of content changes to apply.\n   */\n  readonly changesProvider: ValueProvider<FileChange[] | null, ContentArguments>;\n\n  /**\n   * The content to which the changes should be applied.\n   */\n  readonly content: string;\n\n  /**\n   * The path to which the changes should be applied.\n   */\n  readonly path: string;\n\n  /**\n   * Whether to retry the operation if the changes are invalid.\n   *\n   * @default `true`\n   */\n  readonly shouldRetryOnInvalidChanges?: boolean;\n}\n/**\n * Options for {@link applyFileChanges}.\n */\nexport type ApplyFileChangesOptions = ProcessOptions;\n/**\n * Parameters for {@link applyFileChanges}.\n */\nexport interface ApplyFileChangesParams extends ApplyFileChangesOptions {\n  /**\n   * The application instance where the file changes will be applied.\n   */\n  readonly app: App;\n\n  /**\n   * A provider that returns an array of file changes to apply.\n   */\n  readonly changesProvider: ValueProvider<FileChange[] | null, ContentArguments>;\n\n  /**\n   * The path or file to which the changes should be applied.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * Whether to retry the operation if the changes are invalid.\n   *\n   * @default `true`\n   */\n  readonly shouldRetryOnInvalidChanges?: boolean;\n}\n/**\n * A file change in the vault.\n */\nexport interface FileChange {\n  /**\n   * A new content to replace the old content.\n   */\n  newContent: string;\n\n  /**\n   * An old content that will be replaced.\n   */\n  oldContent: string;\n\n  /**\n   * A reference that caused the change.\n   */\n  reference: Reference;\n}\ninterface ApplyCanvasChangesParams {\n  /**\n   * The abort signal to control the execution of the function.\n   */\n  readonly abortSignal: AbortSignal;\n\n  /**\n   * A provider that returns an array of file changes to apply.\n   */\n  readonly changesProvider: ValueProvider<FileChange[] | null, ContentArguments>;\n\n  /**\n   * The content to which the changes should be applied.\n   */\n  readonly content: string;\n\n  /**\n   * The path to which the changes should be applied.\n   */\n  readonly path: string;\n\n  /**\n   * Whether to retry the operation if the changes are invalid.\n   */\n  readonly shouldRetryOnInvalidChanges?: boolean;\n}\n\ninterface ApplyContentChangesToTextParams {\n  /**\n   * The content changes to apply.\n   */\n  readonly changes: FileChange[];\n\n  /**\n   * The content to which the changes should be applied.\n   */\n  readonly content: string;\n\n  /**\n   * Whether parsing the frontmatter failed.\n   */\n  readonly hasFrontmatterError: boolean;\n\n  /**\n   * The path to which the changes should be applied.\n   */\n  readonly path: string;\n}\n\ninterface ApplyContentChangesToTextResult {\n  readonly frontmatterChanged: Map<string, FrontmatterChangeWithOffsets[]>;\n  readonly newContent: string;\n}\n\ninterface ApplyFrontmatterChangesWithOffsetsParams {\n  /**\n   * The abort signal to control the execution of the function.\n   */\n  readonly abortSignal: AbortSignal;\n\n  /**\n   * The frontmatter to which the changes should be applied.\n   */\n  readonly frontmatter: CombinedFrontmatter<unknown>;\n\n  /**\n   * A map of frontmatter keys to the frontmatter changes with offsets to apply.\n   */\n  readonly frontmatterChangesWithOffsetMap: Map<string, FrontmatterChangeWithOffsets[]>;\n\n  /**\n   * The path to which the changes should be applied.\n   */\n  readonly path: string;\n}\n\ninterface BuildFinalContentParams {\n  /**\n   * The frontmatter to write into the final content.\n   */\n  readonly frontmatter: CombinedFrontmatter<unknown>;\n\n  /**\n   * A map of frontmatter keys to the frontmatter changes with offsets that were applied.\n   */\n  readonly frontmatterChanged: Map<string, FrontmatterChangeWithOffsets[]>;\n\n  /**\n   * The content to which the frontmatter should be applied.\n   */\n  readonly newContent: string;\n}\n\ntype CanvasChange = FileChange & WithReference<CanvasReference>;\ntype CanvasFileNodeChange = FileChange & WithReference<CanvasFileNodeReference>;\ntype CanvasTextNodeChange = FileChange & WithReference<CanvasTextNodeReference>;\ntype ContentChange = FileChange & WithReference<ReferenceCache>;\ntype FrontmatterChange = FileChange & WithReference<FrontmatterLinkCache>;\n\ntype FrontmatterChangeWithOffsets = FileChange & WithReference<FrontmatterLinkCacheWithOffsets>;\n\ninterface ParseFrontmatterSafelyParams {\n  /**\n   * The content to parse the frontmatter from.\n   */\n  readonly content: string;\n\n  /**\n   * The path the content belongs to.\n   */\n  readonly path: string;\n}\n\ninterface ParseFrontmatterSafelyResult {\n  readonly frontmatter: CombinedFrontmatter<unknown>;\n  readonly hasFrontmatterError: boolean;\n}\n\ninterface ValidateChangesParams {\n  /**\n   * The content changes to validate.\n   */\n  readonly changes: FileChange[];\n\n  /**\n   * The content the changes should be validated against.\n   */\n  readonly content: string;\n\n  /**\n   * The frontmatter the changes should be validated against.\n   */\n  readonly frontmatter: CombinedFrontmatter<unknown>;\n\n  /**\n   * The path the changes should be validated against.\n   */\n  readonly path: string;\n}\n\ninterface WithReference<R extends Reference> {\n  reference: R;\n}\n\n/**\n * Applies a series of content changes to the specified content.\n *\n * @param params - The parameters for applying the content changes.\n * @returns A {@link Promise} that resolves to the updated content or to `null` if update didn't succeed.\n */\nexport async function applyContentChanges(params: ApplyContentChangesParams): Promise<null | string> {\n  const {\n    abortSignal,\n    changesProvider,\n    content,\n    path,\n    shouldRetryOnInvalidChanges = true\n  } = params;\n  abortSignal.throwIfAborted();\n  let changes = await resolveValue(changesProvider, { abortSignal, content });\n  abortSignal.throwIfAborted();\n  if (changes === null) {\n    return null;\n  }\n\n  const { frontmatter, hasFrontmatterError } = parseFrontmatterSafely({ content, path });\n\n  if (!areChangesValid({ changes, content, frontmatter, path })) {\n    return shouldRetryOnInvalidChanges ? null : content;\n  }\n\n  changes = sortAndFilterChanges(changes);\n\n  const { frontmatterChanged, newContent } = applyContentChangesToText({ changes, content, hasFrontmatterError, path });\n\n  await applyFrontmatterChangesWithOffsets({\n    abortSignal,\n    frontmatter,\n    frontmatterChangesWithOffsetMap: frontmatterChanged,\n    path\n  });\n  abortSignal.throwIfAborted();\n\n  return buildFinalContent({ frontmatter, frontmatterChanged, newContent });\n}\n\n/**\n * Applies a series of file changes to the specified file or path within the application.\n *\n * @param params - The parameters for applying the file changes.\n * @returns A {@link Promise} that resolves when the file changes have been successfully applied.\n */\nexport async function applyFileChanges(params: ApplyFileChangesParams): Promise<void> {\n  const {\n    app,\n    changesProvider,\n    pathOrFile,\n    shouldRetryOnInvalidChanges = true,\n    ...options\n  } = params;\n  await process(normalizeOptionalProperties<ProcessParams>({\n    app,\n    async newContentProvider({ abortSignal, content }) {\n      return isCanvasFile(pathOrFile)\n        ? (await applyCanvasChanges({\n          abortSignal,\n          changesProvider,\n          content,\n          path: getPath(app, pathOrFile),\n          shouldRetryOnInvalidChanges\n        }))\n        : (await applyContentChanges({\n          abortSignal,\n          changesProvider,\n          content,\n          path: getPath(app, pathOrFile),\n          shouldRetryOnInvalidChanges\n        }));\n    },\n    pathOrFile,\n    ...options\n  }));\n}\n\n/**\n * Checks if a file change is a canvas change.\n *\n * @param change - The file change to check.\n * @returns Whether the file change is a canvas change.\n */\nexport function isCanvasChange(change: FileChange): change is CanvasChange {\n  return isCanvasReference(change.reference);\n}\n\n/**\n * Checks if a file change is a canvas file node change.\n *\n * @param change - The file change to check.\n * @returns Whether the file change is a canvas file node change.\n */\nexport function isCanvasFileNodeChange(change: FileChange): change is CanvasFileNodeChange {\n  return isCanvasChange(change) && change.reference.type === 'file';\n}\n\n/**\n * Checks if a file change is a canvas text node change.\n *\n * @param change - The file change to check.\n * @returns Whether the file change is a canvas text node change.\n */\nexport function isCanvasTextNodeChange(change: FileChange): change is CanvasTextNodeChange {\n  return isCanvasChange(change) && change.reference.type === 'text';\n}\n\n/**\n * Checks if a file change is a content change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a content change.\n */\nexport function isContentChange(fileChange: FileChange): fileChange is ContentChange {\n  return isReferenceCache(fileChange.reference);\n}\n\n/**\n * Checks if a file change is a frontmatter change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a frontmatter change.\n */\nexport function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange {\n  return isFrontmatterLinkCache(fileChange.reference);\n}\n\n/**\n * Checks if a file change is a frontmatter change with offsets.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a frontmatter change with offsets.\n */\nexport function isFrontmatterChangeWithOffsets(fileChange: FileChange): fileChange is FrontmatterChangeWithOffsets {\n  return isFrontmatterLinkCacheWithOffsets(fileChange.reference);\n}\n\n/**\n * Converts a frontmatter change to a frontmatter change with offsets.\n *\n * @param fileChange - The file change to convert.\n * @returns The converted file change.\n */\nexport function toFrontmatterChangeWithOffsets(fileChange: FrontmatterChange): FrontmatterChangeWithOffsets {\n  return isFrontmatterChangeWithOffsets(fileChange)\n    ? fileChange\n    : {\n      ...fileChange,\n      reference: toFrontmatterLinkCacheWithOffsets(fileChange.reference)\n    };\n}\n\nasync function applyCanvasChanges(params: ApplyCanvasChangesParams): Promise<null | string> {\n  const {\n    abortSignal,\n    changesProvider,\n    content,\n    path,\n    shouldRetryOnInvalidChanges = true\n  } = params;\n  const changes = await resolveValue(changesProvider, { abortSignal, content });\n  abortSignal.throwIfAborted();\n  if (changes === null) {\n    return null;\n  }\n\n  const canvasData = parseJsonSafe(content) as GenericObject<CanvasData>;\n\n  // The content is not a valid canvas (a transient `{}` or partial object).\n  // This happens when another plugin is still initializing the file.\n  // Skip the rewrite so no malformed object is written back and the renderer never crashes.\n  // Mirrors the `{ edges: [], nodes: [] }` fallback in `getCanvasReferences`.\n  // Returning the content unchanged rather than `null` completes the operation without a write: the\n  // refusal is permanent for this content, and `null` would ask `process()` to retry it forever.\n  if (!Array.isArray(canvasData.nodes) || !Array.isArray(canvasData.edges)) {\n    getObsidianLibDebugger('FileChange:applyCanvasChanges')('Not a valid canvas; skipping rewrite', { path });\n    return content;\n  }\n\n  const canvasTextChanges = new Map<number, CanvasTextNodeChange[]>();\n\n  for (const change of changes) {\n    if (!isCanvasChange(change)) {\n      const message = 'Only canvas changes are supported for canvas files';\n      console.error(message, {\n        change,\n        path\n      });\n      continue;\n    }\n\n    const node = canvasData.nodes[change.reference.nodeIndex];\n    if (!node) {\n      const message = 'Node not found';\n      console.error(message, {\n        nodeIndex: change.reference.nodeIndex,\n        path\n      });\n      return content;\n    }\n\n    if (isCanvasFileNodeChange(change)) {\n      if (node.file !== change.oldContent) {\n        getObsidianLibDebugger('FileChange:applyCanvasChanges')('Content mismatch', {\n          actualContent: node.file as string | undefined,\n          expectedContent: change.oldContent,\n          nodeIndex: change.reference.nodeIndex,\n          path,\n          type: 'file'\n        });\n\n        return content;\n      }\n      node.file = change.newContent;\n      /* v8 ignore start -- The false branch of the else-if is unreachable; only 'file' and 'text' canvas node types exist. */\n    } else if (isCanvasTextNodeChange(change)) {\n      /* v8 ignore stop */\n      let canvasTextChangesForNode = canvasTextChanges.get(change.reference.nodeIndex);\n      if (!canvasTextChangesForNode) {\n        canvasTextChangesForNode = [];\n        canvasTextChanges.set(change.reference.nodeIndex, canvasTextChangesForNode);\n      }\n\n      canvasTextChangesForNode.push(change);\n    }\n  }\n\n  for (const [nodeIndex, canvasTextChangesForNode] of canvasTextChanges) {\n    const node = canvasData.nodes[nodeIndex];\n    /* v8 ignore start -- Node existence is already verified in the first loop above. */\n    if (!node) {\n      const message = 'Node not found';\n      console.error(message, {\n        nodeIndex,\n        path\n      });\n\n      return content;\n    }\n    /* v8 ignore stop */\n\n    if (typeof node.text !== 'string') {\n      const message = 'Node text is not a string';\n      console.error(message, {\n        nodeIndex,\n        path\n      });\n\n      return content;\n    }\n\n    const contentChanges = canvasTextChangesForNode.map((change) => {\n      // A canvas text node can hold a markdown table, where a sized embed escapes the wikilink\n      // divider so the pipe does not terminate the table cell (`![[img.png\\|500]]`). The regenerated\n      // link uses an unescaped divider, so restore the escaping when the original reference had it,\n      // keeping both the table and the embed size intact across the rewrite.\n      const newContent = change.reference.originalReference.original.includes(ESCAPED_WIKILINK_DIVIDER)\n        ? change.newContent.replaceAll(OPTIONALLY_ESCAPED_WIKILINK_DIVIDER_REGEXP, () => ESCAPED_WIKILINK_DIVIDER)\n        : change.newContent;\n      return referenceToFileChange(change.reference.originalReference, newContent);\n    });\n    const newNodeText = await applyContentChanges({\n      abortSignal,\n      changesProvider: contentChanges,\n      content: node.text,\n      path: `${path}.node${String(nodeIndex)}.VIRTUAL_FILE.md`,\n      shouldRetryOnInvalidChanges\n    });\n\n    // `null` is `applyContentChanges`'s retry sentinel, not a value. Assigning it would serialize\n    // `\"text\": null` over the node and destroy its content. The mismatch is permanent for this content \u2014\n    // the same call the file-node mismatch above already makes \u2014 so return the content unchanged to\n    // complete the operation without a write, rather than `null`, which would retry forever.\n    if (newNodeText === null) {\n      return content;\n    }\n\n    node.text = newNodeText;\n  }\n\n  return JSON.stringify(canvasData, null, '\\t');\n}\n\nfunction applyContentChangesToText(params: ApplyContentChangesToTextParams): ApplyContentChangesToTextResult {\n  const {\n    changes,\n    content,\n    hasFrontmatterError,\n    path\n  } = params;\n  let newContent = '';\n  let lastIndex = 0;\n  let lastContentChange: ContentChange = {\n    newContent: '',\n    oldContent: '',\n    reference: {\n      link: '',\n      original: '',\n      position: {\n        end: { col: 0, line: 0, offset: 0 },\n        start: { col: 0, line: 0, offset: 0 }\n      }\n    }\n  };\n  const frontmatterChangesWithOffsetMap = new Map<string, FrontmatterChangeWithOffsets[]>();\n\n  for (const change of changes) {\n    /* v8 ignore start -- All change types are handled; the false branch leads to other else-if checks. */\n    if (isContentChange(change)) {\n      /* v8 ignore stop */\n      if (lastIndex <= change.reference.position.start.offset) {\n        newContent += content.slice(lastIndex, change.reference.position.start.offset);\n        newContent += change.newContent;\n        lastIndex = change.reference.position.end.offset;\n        lastContentChange = change;\n      } else {\n        const overlappingStartOffset = change.reference.position.start.offset - lastContentChange.reference.position.start.offset;\n        const overlappingEndOffset = change.reference.position.end.offset - lastContentChange.reference.position.start.offset;\n        const overlappingContent = lastContentChange.newContent.slice(overlappingStartOffset, overlappingEndOffset);\n        if (overlappingContent !== change.oldContent) {\n          const message = 'Overlapping changes';\n          console.error(message, { change, lastContentChange });\n          throw new Error(message);\n        }\n        newContent = newContent.slice(0, newContent.length - lastContentChange.newContent.length)\n          + lastContentChange.newContent.slice(0, overlappingStartOffset)\n          + change.newContent\n          + lastContentChange.newContent.slice(overlappingEndOffset);\n      }\n      /* v8 ignore start -- All change types are handled above; no unknown change types in practice. */\n    } else if (isFrontmatterChange(change)) {\n      /* v8 ignore stop */\n      /* v8 ignore start -- Validation rejects frontmatter changes when parsing fails, so this branch is unreachable. */\n      if (hasFrontmatterError) {\n        console.error(`Cannot apply frontmatter change in ${path}, because frontmatter parsing failed`, { change });\n      } else {\n        /* v8 ignore stop */\n        let frontmatterChangesWithOffsets = frontmatterChangesWithOffsetMap.get(change.reference.key);\n        if (!frontmatterChangesWithOffsets) {\n          frontmatterChangesWithOffsets = [];\n          frontmatterChangesWithOffsetMap.set(change.reference.key, frontmatterChangesWithOffsets);\n        }\n        frontmatterChangesWithOffsets.push(toFrontmatterChangeWithOffsets(change));\n      }\n    }\n  }\n\n  newContent += content.slice(lastIndex);\n\n  return { frontmatterChanged: frontmatterChangesWithOffsetMap, newContent };\n}\n\nasync function applyFrontmatterChangesWithOffsets(params: ApplyFrontmatterChangesWithOffsetsParams): Promise<void> {\n  const {\n    abortSignal,\n    frontmatter,\n    frontmatterChangesWithOffsetMap,\n    path\n  } = params;\n  for (const [key, frontmatterChangesWithOffsets] of frontmatterChangesWithOffsetMap) {\n    const propertyValue = getNestedPropertyValue(frontmatter, key);\n    /* v8 ignore start -- Validation ensures the property is a string before reaching this point. */\n    if (typeof propertyValue !== 'string') {\n      return;\n    }\n    /* v8 ignore stop */\n\n    const contentChanges: ContentChange[] = frontmatterChangesWithOffsets.map((change) => ({\n      newContent: change.newContent,\n      oldContent: change.oldContent,\n      reference: {\n        link: '',\n        original: '',\n        position: {\n          end: {\n            col: change.reference.endOffset,\n            line: 0,\n            offset: change.reference.endOffset\n          },\n          start: {\n            col: change.reference.startOffset,\n            line: 0,\n            offset: change.reference.startOffset\n          }\n        }\n      }\n    }));\n\n    const newPropertyValue = await applyContentChanges({\n      abortSignal,\n      changesProvider: contentChanges,\n      content: propertyValue,\n      path: `${path}.frontmatter.${key}.VIRTUAL_FILE.md`\n    });\n    /* v8 ignore start -- Inner applyContentChanges uses validated offsets, so null is not expected. */\n    if (newPropertyValue === null) {\n      return;\n    }\n    /* v8 ignore stop */\n\n    setNestedPropertyValue({\n      $object: frontmatter,\n      path: key,\n      value: newPropertyValue\n    });\n  }\n}\n\nfunction areChangesValid(params: ValidateChangesParams): boolean {\n  const {\n    changes,\n    content,\n    frontmatter,\n    path\n  } = params;\n  const validateChangesDebugger = getObsidianLibDebugger('FileChange:validateChanges');\n  for (const change of changes) {\n    /* v8 ignore start -- All change types are handled; the false branch leads to other else-if checks. */\n    if (isContentChange(change)) {\n      /* v8 ignore stop */\n      const startOffset = change.reference.position.start.offset;\n      const endOffset = change.reference.position.end.offset;\n      const actualContent = content.slice(startOffset, endOffset);\n      if (actualContent !== change.oldContent) {\n        validateChangesDebugger('Content mismatch', {\n          actualContent,\n          endOffset,\n          expectedContent: change.oldContent,\n          path,\n          startOffset\n        });\n\n        return false;\n      }\n      /* v8 ignore start -- All change types are handled; no unknown change types in practice. */\n    } else if (isFrontmatterChangeWithOffsets(change)) {\n      /* v8 ignore stop */\n      const propertyValue = getNestedPropertyValue(frontmatter, change.reference.key);\n      if (typeof propertyValue !== 'string') {\n        validateChangesDebugger('Property value is not a string', {\n          frontmatterKey: change.reference.key,\n          path,\n          propertyValue\n        });\n        return false;\n      }\n\n      const actualContent = propertyValue.slice(change.reference.startOffset, change.reference.endOffset);\n      if (actualContent !== change.oldContent) {\n        validateChangesDebugger('Content mismatch', {\n          actualContent,\n          expectedContent: change.oldContent,\n          frontmatterKey: change.reference.key,\n          path,\n          startOffset: change.reference.startOffset\n        });\n\n        return false;\n      }\n      /* v8 ignore start -- All change types are handled above; no unknown change types in practice. */\n    } else if (isFrontmatterChange(change)) {\n      /* v8 ignore stop */\n      const actualContent = getNestedPropertyValue(frontmatter, change.reference.key);\n      if (actualContent !== change.oldContent) {\n        validateChangesDebugger('Content mismatch', {\n          actualContent,\n          expectedContent: change.oldContent,\n          frontmatterKey: change.reference.key,\n          path\n        });\n\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\nfunction buildFinalContent(params: BuildFinalContentParams): string {\n  const {\n    frontmatter,\n    frontmatterChanged,\n    newContent\n  } = params;\n  return frontmatterChanged.size > 0 ? setFrontmatter(newContent, frontmatter) : newContent;\n}\n\nfunction parseFrontmatterSafely(params: ParseFrontmatterSafelyParams): ParseFrontmatterSafelyResult {\n  const { content, path } = params;\n  let frontmatter: CombinedFrontmatter<unknown> = {};\n  let hasFrontmatterError = false;\n\n  try {\n    frontmatter = parseFrontmatter(content);\n  } catch (error) {\n    printError(new Error(`Frontmatter parsing failed in ${path}`, { cause: error }));\n    hasFrontmatterError = true;\n  }\n\n  return { frontmatter, hasFrontmatterError };\n}\n\nfunction parseJsonSafe(content: string): GenericObject {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(content);\n  } catch {\n    parsed = null;\n  }\n\n  if (parsed === null || typeof parsed !== 'object') {\n    parsed = {};\n  }\n\n  return parsed as GenericObject;\n}\n\nfunction sortAndFilterChanges(changes: FileChange[]): FileChange[] {\n  // Sort changes by type and position\n  changes.sort((a, b) => {\n    if (isContentChange(a) && isContentChange(b)) {\n      return a.reference.position.start.offset - b.reference.position.start.offset;\n    }\n\n    if (isFrontmatterChangeWithOffsets(a) && isFrontmatterChangeWithOffsets(b)) {\n      return a.reference.key.localeCompare(b.reference.key) || a.reference.startOffset - b.reference.startOffset;\n    }\n\n    if (isFrontmatterChange(a) && isFrontmatterChange(b)) {\n      return a.reference.key.localeCompare(b.reference.key);\n    }\n\n    return isContentChange(a) ? -1 : 1;\n  });\n\n  // Filter out duplicate and no-op changes\n  return changes.filter((change, index) => {\n    return change.oldContent !== change.newContent && (index === 0 || !isDeepEqual(change, changes[index - 1]));\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -0,0 +1,34 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides utilities for working with Obsidian's core file explorer.
+ */
+import type { App, TAbstractFile } from 'obsidian';
+/**
+ * Parameters for {@link revealInFileExplorer}.
+ */
+export interface RevealInFileExplorerParams {
+    /**
+     * The file or folder to reveal.
+     */
+    readonly abstractFile: TAbstractFile;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+}
+/**
+ * Highlights a file or folder in the core file explorer, and resolves only once the explorer has
+ * finished taking the focus for it.
+ *
+ * The core plugin's `revealInFolder` is typed `void` but is asynchronous at runtime, and the explorer
+ * re-activates itself on a later frame. A caller that moves the focus somewhere else right after the
+ * reveal — back into an editor, say — loses that race unless it awaits this.
+ *
+ * A disabled file explorer reveals nothing, and the returned promise resolves at once.
+ *
+ * @param params - The parameters.
+ * @returns A {@link Promise} that resolves once the explorer has finished revealing.
+ */
+export declare function revealInFileExplorer(params: RevealInFileExplorerParams): Promise<void>;