@mnaoumov/obsidian-lib 10.10.0 → 10.11.0

package/dist/lib/cjs/link.d.cts

@@ -7,7 +7,7 @@
  * functions to split paths, update links in files, and generate markdown links with various options.
  */
 import type { MaybeReturn } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
-import type { App, Reference, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { App, Reference, ReferenceLinkCache, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { PathOrFile } from './file-system.cjs';
 import type { LinkUpdateProgressReporter } from './link-update-progress.cjs';
@@ -392,6 +392,24 @@ export interface EditReferencesInContentParams {
      * The function that converts each reference.
      */
     readonly referenceConverter: (reference: Reference) => Promisable<MaybeReturn<string>>;
+    /**
+     * The function that returns the new destination of each reference-style link definition
+     * (`[id]: destination "title"`). Obsidian reports those in `CachedMetadata.referenceLinks`, not among the
+     * references {@link EditReferencesInContentParams.referenceConverter} receives, so without this function they
+     * are never edited.
+     *
+     * It returns the destination unescaped, in the form of `ReferenceLinkCache.link`, or `undefined` to leave the
+     * definition unchanged. Only the destination is rewritten: the id, the title, the angle brackets and every use
+     * of the definition (`[text][id]`, `[id]`) stay as written. A definition whose content no longer matches its
+     * metadata is left unchanged. See {@link referenceDefinitionToFileChange}.
+     *
+     * The offset range applies to the definition's whole position. The heading skip and
+     * {@link EditReferencesInContentParams.shouldSkipReference} do not apply, since a definition is never in a
+     * heading and is not a `Reference`.
+     *
+     * @default `undefined`, which leaves every definition unchanged
+     */
+    readonly referenceDefinitionConverter?: (definition: ReferenceLinkCache) => Promisable<MaybeReturn<string>>;
     /**
      * Whether to also edit external links parsed from the note body. When `true`, the converter also
      * receives references for external links.
@@ -476,6 +494,24 @@ export interface EditReferencesParams extends EditReferencesOptions {
      * The function that converts each reference.
      */
     readonly referenceConverter: (reference: Reference) => Promisable<MaybeReturn<string>>;
+    /**
+     * The function that returns the new destination of each reference-style link definition
+     * (`[id]: destination "title"`). Obsidian reports those in `CachedMetadata.referenceLinks`, not among the
+     * references {@link EditReferencesParams.referenceConverter} receives, so without this function they are never
+     * edited.
+     *
+     * It returns the destination unescaped, in the form of `ReferenceLinkCache.link`, or `undefined` to leave the
+     * definition unchanged. Only the destination is rewritten: the id, the title, the angle brackets and every use
+     * of the definition (`[text][id]`, `[id]`) stay as written. A definition whose content no longer matches its
+     * metadata is left unchanged. See {@link referenceDefinitionToFileChange}. A canvas file has no definitions.
+     *
+     * The offset range applies to the definition's whole position. The heading skip and
+     * {@link EditReferencesParams.shouldSkipReference} do not apply, since a definition is never in a heading and is
+     * not a `Reference`.
+     *
+     * @default `undefined`, which leaves every definition unchanged
+     */
+    readonly referenceDefinitionConverter?: (definition: ReferenceLinkCache) => Promisable<MaybeReturn<string>>;
     /**
      * Whether to also edit external links parsed from the note body. When `true`, the converter also
      * receives references for external links.

package/dist/lib/cjs/reference-definition.cjs

@@ -0,0 +1,234 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reference_definition_exports = {};
+__export(reference_definition_exports, {
+  referenceDefinitionToFileChange: () => referenceDefinitionToFileChange
+});
+module.exports = __toCommonJS(reference_definition_exports);
+var import_debug = require('./debug.cjs');
+const ASCII_PUNCTUATION_REG_EXP = /[!-/:-@[-`{-~]/;
+const BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP = /[\s\p{Cc}]/u;
+const DEFINITION_PREFIX_REG_EXP = /^[ \t]*\[(?:\\[\s\S]|[^\\\]])+\]:[ \t]*(?:\r?\n(?:[ \t]*>)*[ \t]*)?/;
+const LINE_BREAK_REG_EXP = /[\r\n]/;
+const WHITESPACE_REG_EXP = /\s/;
+function referenceDefinitionToFileChange(params) {
+  const { content, definition, newDestination } = params;
+  const referenceDefinitionDebugger = (0, import_debug.getObsidianLibDebugger)("ReferenceDefinition:referenceDefinitionToFileChange");
+  const token = findDestinationToken(content, definition);
+  if (!token) {
+    referenceDefinitionDebugger("Skipping a definition whose content does not match its metadata", { definition });
+    return null;
+  }
+  const newRaw = encodeDestination(newDestination, token.isAngle);
+  if (newRaw === null) {
+    referenceDefinitionDebugger("Skipping a destination that holds a line break", { definition, newDestination });
+    return null;
+  }
+  const reference = {
+    link: definition.link,
+    original: token.raw,
+    position: {
+      end: getLoc(content, definition, token.end),
+      start: getLoc(content, definition, token.start)
+    }
+  };
+  return {
+    newContent: newRaw,
+    oldContent: token.raw,
+    reference
+  };
+}
+function canBeBare(destination) {
+  if (destination === "" || destination.startsWith("<") || BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP.test(destination)) {
+    return false;
+  }
+  let depth = 0;
+  for (const character of destination) {
+    if (character === "(") {
+      depth++;
+    } else if (character === ")") {
+      depth--;
+      if (depth < 0) {
+        return false;
+      }
+    }
+  }
+  return depth === 0;
+}
+function encodeDestination(destination, isAngle) {
+  if (LINE_BREAK_REG_EXP.test(destination)) {
+    return null;
+  }
+  const shouldUseAngle = isAngle || !canBeBare(destination);
+  let encoded = "";
+  for (let index = 0; index < destination.length; index++) {
+    const character = destination.charAt(index);
+    const nextCharacter = destination.charAt(index + 1);
+    const isEscapeNeeded = shouldUseAngle ? character === "<" || character === ">" || character === "\\" && (nextCharacter === "" || ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) : character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter);
+    encoded += isEscapeNeeded ? `\\${character}` : character;
+  }
+  return shouldUseAngle ? `<${encoded}>` : encoded;
+}
+function findDestinationToken(content, definition) {
+  const definitionStart = definition.position.start.offset;
+  const definitionEnd = definition.position.end.offset;
+  if (definitionStart < 0 || definitionEnd > content.length || definitionEnd < definitionStart) {
+    return null;
+  }
+  const definitionText = content.slice(definitionStart, definitionEnd);
+  const prefix = DEFINITION_PREFIX_REG_EXP.exec(definitionText);
+  if (!prefix) {
+    return null;
+  }
+  const tokenStart = prefix[0].length;
+  const isAngle = definitionText.charAt(tokenStart) === "<";
+  let tokenEnd = isAngle ? tokenStart + 1 : tokenStart;
+  for (; tokenEnd < definitionText.length; tokenEnd++) {
+    const character = definitionText.charAt(tokenEnd);
+    if (isAngle ? character === ">" || LINE_BREAK_REG_EXP.test(character) : WHITESPACE_REG_EXP.test(character)) {
+      break;
+    }
+    if (character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(definitionText.charAt(tokenEnd + 1))) {
+      tokenEnd++;
+    }
+  }
+  if (isAngle) {
+    if (definitionText.charAt(tokenEnd) !== ">") {
+      return null;
+    }
+    tokenEnd++;
+  }
+  const boundary = definitionText.charAt(tokenEnd);
+  if (boundary !== "" && !WHITESPACE_REG_EXP.test(boundary)) {
+    return null;
+  }
+  const raw = definitionText.slice(tokenStart, tokenEnd);
+  const value = isAngle ? raw.slice(1, -1) : raw;
+  if (tokenEnd === tokenStart || unescapeDestination(value) !== definition.link) {
+    return null;
+  }
+  return {
+    end: definitionStart + tokenEnd,
+    isAngle,
+    raw,
+    start: definitionStart + tokenStart
+  };
+}
+function getLoc(content, definition, offset) {
+  const definitionStart = definition.position.start.offset;
+  let line = definition.position.start.line;
+  for (let index = definitionStart; index < offset; index++) {
+    if (content.charAt(index) === "\n") {
+      line++;
+    }
+  }
+  return {
+    col: offset - (content.lastIndexOf("\n", offset - 1) + 1),
+    line,
+    offset
+  };
+}
+function unescapeDestination(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index++) {
+    const character = value.charAt(index);
+    const nextCharacter = value.charAt(index + 1);
+    if (character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) {
+      result += nextCharacter;
+      index++;
+    } else {
+      result += character;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  referenceDefinitionToFileChange
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/reference-definition.ts"],"sourcesContent":["/**\n * @file\n *\n * Edits the destination of a reference-style link definition (`[id]: destination \"title\"`) that Obsidian reports\n * in `CachedMetadata.referenceLinks`.\n *\n * Read from Obsidian `1.15.1`: a definition's `position` spans the whole definition, its leading indentation\n * included and any blockquote or list marker excluded, and its `link` is the destination with the angle brackets\n * removed and every backslash escape resolved (`Target\\#Escaped.md` reports `Target#Escaped.md`). The uses of a\n * definition (`[text][id]`, `[id][]`, `[id]`) are not reported in `links` and name the definition by its id, so\n * rewriting only the destination keeps every one of them pointing at the new target.\n */\n\nimport type {\n  Loc,\n  ReferenceCache,\n  ReferenceLinkCache\n} from 'obsidian';\n\nimport type { FileChange } from './file-change.ts';\n\nimport { getObsidianLibDebugger } from './debug.ts';\n\n/**\n * Parameters for {@link referenceDefinitionToFileChange}.\n */\nexport interface ReferenceDefinitionToFileChangeParams {\n  /**\n   * The content the definition's position refers to.\n   */\n  readonly content: string;\n\n  /**\n   * The definition, as Obsidian reports it in `CachedMetadata.referenceLinks`.\n   */\n  readonly definition: ReferenceLinkCache;\n\n  /**\n   * The new destination, unescaped, in the same form as {@link ReferenceLinkCache.link}.\n   */\n  readonly newDestination: string;\n}\n\ninterface DestinationToken {\n  readonly end: number;\n  readonly isAngle: boolean;\n  readonly raw: string;\n  readonly start: number;\n}\n\nconst ASCII_PUNCTUATION_REG_EXP = /[!-/:-@[-`{-~]/;\nconst BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP = /[\\s\\p{Cc}]/u;\nconst DEFINITION_PREFIX_REG_EXP = /^[ \\t]*\\[(?:\\\\[\\s\\S]|[^\\\\\\]])+\\]:[ \\t]*(?:\\r?\\n(?:[ \\t]*>)*[ \\t]*)?/;\nconst LINE_BREAK_REG_EXP = /[\\r\\n]/;\nconst WHITESPACE_REG_EXP = /\\s/;\n\n/**\n * Builds the file change that replaces the destination of a reference-style link definition, leaving its id, its\n * title and the rest of the note unchanged.\n *\n * The destination keeps its form: one written in angle brackets stays in them, and a bare one stays bare unless\n * the new destination cannot be written bare (it is empty, holds whitespace or a control character, starts with\n * `<`, or has unbalanced parentheses), in which case it is written in angle brackets. Characters that would end\n * or change the destination are escaped with a backslash.\n *\n * @param params - The parameters for building the file change.\n * @returns The file change, or `null` when the content at the definition's position no longer holds a definition\n * whose destination reads as {@link ReferenceLinkCache.link}, or when the new destination holds a line break,\n * which no destination can.\n */\nexport function referenceDefinitionToFileChange(params: ReferenceDefinitionToFileChangeParams): FileChange | null {\n  const { content, definition, newDestination } = params;\n  const referenceDefinitionDebugger = getObsidianLibDebugger('ReferenceDefinition:referenceDefinitionToFileChange');\n\n  const token = findDestinationToken(content, definition);\n  if (!token) {\n    referenceDefinitionDebugger('Skipping a definition whose content does not match its metadata', { definition });\n    return null;\n  }\n\n  const newRaw = encodeDestination(newDestination, token.isAngle);\n  if (newRaw === null) {\n    referenceDefinitionDebugger('Skipping a destination that holds a line break', { definition, newDestination });\n    return null;\n  }\n\n  const reference: ReferenceCache = {\n    link: definition.link,\n    original: token.raw,\n    position: {\n      end: getLoc(content, definition, token.end),\n      start: getLoc(content, definition, token.start)\n    }\n  };\n\n  return {\n    newContent: newRaw,\n    oldContent: token.raw,\n    reference\n  };\n}\n\nfunction canBeBare(destination: string): boolean {\n  if (destination === '' || destination.startsWith('<') || BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP.test(destination)) {\n    return false;\n  }\n\n  let depth = 0;\n  for (const character of destination) {\n    if (character === '(') {\n      depth++;\n    } else if (character === ')') {\n      depth--;\n      if (depth < 0) {\n        return false;\n      }\n    }\n  }\n\n  return depth === 0;\n}\n\nfunction encodeDestination(destination: string, isAngle: boolean): null | string {\n  if (LINE_BREAK_REG_EXP.test(destination)) {\n    return null;\n  }\n\n  const shouldUseAngle = isAngle || !canBeBare(destination);\n  let encoded = '';\n  for (let index = 0; index < destination.length; index++) {\n    const character = destination.charAt(index);\n    const nextCharacter = destination.charAt(index + 1);\n    const isEscapeNeeded = shouldUseAngle\n      ? character === '<' || character === '>' || (character === '\\\\' && (nextCharacter === '' || ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)))\n      : character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter);\n    encoded += isEscapeNeeded ? `\\\\${character}` : character;\n  }\n\n  return shouldUseAngle ? `<${encoded}>` : encoded;\n}\n\nfunction findDestinationToken(content: string, definition: ReferenceLinkCache): DestinationToken | null {\n  const definitionStart = definition.position.start.offset;\n  const definitionEnd = definition.position.end.offset;\n  if (definitionStart < 0 || definitionEnd > content.length || definitionEnd < definitionStart) {\n    return null;\n  }\n\n  const definitionText = content.slice(definitionStart, definitionEnd);\n  const prefix = DEFINITION_PREFIX_REG_EXP.exec(definitionText);\n  if (!prefix) {\n    return null;\n  }\n\n  const tokenStart = prefix[0].length;\n  const isAngle = definitionText.charAt(tokenStart) === '<';\n  let tokenEnd = isAngle ? tokenStart + 1 : tokenStart;\n  for (; tokenEnd < definitionText.length; tokenEnd++) {\n    const character = definitionText.charAt(tokenEnd);\n    if (isAngle ? character === '>' || LINE_BREAK_REG_EXP.test(character) : WHITESPACE_REG_EXP.test(character)) {\n      break;\n    }\n    if (character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(definitionText.charAt(tokenEnd + 1))) {\n      tokenEnd++;\n    }\n  }\n\n  if (isAngle) {\n    if (definitionText.charAt(tokenEnd) !== '>') {\n      return null;\n    }\n    tokenEnd++;\n  }\n\n  const boundary = definitionText.charAt(tokenEnd);\n  if (boundary !== '' && !WHITESPACE_REG_EXP.test(boundary)) {\n    return null;\n  }\n\n  const raw = definitionText.slice(tokenStart, tokenEnd);\n  const value = isAngle ? raw.slice(1, -1) : raw;\n  if (tokenEnd === tokenStart || unescapeDestination(value) !== definition.link) {\n    return null;\n  }\n\n  return {\n    end: definitionStart + tokenEnd,\n    isAngle,\n    raw,\n    start: definitionStart + tokenStart\n  };\n}\n\nfunction getLoc(content: string, definition: ReferenceLinkCache, offset: number): Loc {\n  const definitionStart = definition.position.start.offset;\n  let line = definition.position.start.line;\n  for (let index = definitionStart; index < offset; index++) {\n    if (content.charAt(index) === '\\n') {\n      line++;\n    }\n  }\n\n  return {\n    col: offset - (content.lastIndexOf('\\n', offset - 1) + 1),\n    line,\n    offset\n  };\n}\n\nfunction unescapeDestination(value: string): string {\n  let result = '';\n  for (let index = 0; index < value.length; index++) {\n    const character = value.charAt(index);\n    const nextCharacter = value.charAt(index + 1);\n    if (character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) {\n      result += nextCharacter;\n      index++;\n    } else {\n      result += character;\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/reference-definition.d.cts

@@ -0,0 +1,47 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Edits the destination of a reference-style link definition (`[id]: destination "title"`) that Obsidian reports
+ * in `CachedMetadata.referenceLinks`.
+ *
+ * Read from Obsidian `1.15.1`: a definition's `position` spans the whole definition, its leading indentation
+ * included and any blockquote or list marker excluded, and its `link` is the destination with the angle brackets
+ * removed and every backslash escape resolved (`Target\#Escaped.md` reports `Target#Escaped.md`). The uses of a
+ * definition (`[text][id]`, `[id][]`, `[id]`) are not reported in `links` and name the definition by its id, so
+ * rewriting only the destination keeps every one of them pointing at the new target.
+ */
+import type { ReferenceLinkCache } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { FileChange } from './file-change.cjs';
+/**
+ * Parameters for {@link referenceDefinitionToFileChange}.
+ */
+export interface ReferenceDefinitionToFileChangeParams {
+    /**
+     * The content the definition's position refers to.
+     */
+    readonly content: string;
+    /**
+     * The definition, as Obsidian reports it in `CachedMetadata.referenceLinks`.
+     */
+    readonly definition: ReferenceLinkCache;
+    /**
+     * The new destination, unescaped, in the same form as {@link ReferenceLinkCache.link}.
+     */
+    readonly newDestination: string;
+}
+/**
+ * Builds the file change that replaces the destination of a reference-style link definition, leaving its id, its
+ * title and the rest of the note unchanged.
+ *
+ * The destination keeps its form: one written in angle brackets stays in them, and a bare one stays bare unless
+ * the new destination cannot be written bare (it is empty, holds whitespace or a control character, starts with
+ * `<`, or has unbalanced parentheses), in which case it is written in angle brackets. Characters that would end
+ * or change the destination are escaped with a backslash.
+ *
+ * @param params - The parameters for building the file change.
+ * @returns The file change, or `null` when the content at the definition's position no longer holds a definition
+ * whose destination reads as {@link ReferenceLinkCache.link}, or when the new destination holds a line break,
+ * which no destination can.
+ */
+export declare function referenceDefinitionToFileChange(params: ReferenceDefinitionToFileChangeParams): FileChange | null;