@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/cjs/misplaced-attachment.cjs

@@ -0,0 +1,297 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+(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 misplaced_attachment_exports = {};
+__export(misplaced_attachment_exports, {
+  ExternalAttachmentLinkMode: () => ExternalAttachmentLinkMode,
+  MisplacedAttachmentIndex: () => MisplacedAttachmentIndex,
+  getAttachmentPlacement: () => getAttachmentPlacement,
+  recordAttachmentPlacement: () => recordAttachmentPlacement
+});
+module.exports = __toCommonJS(misplaced_attachment_exports);
+var import_implementations = require("@obsidian-typings/obsidian-public-latest/implementations");
+var import_attachment_path = require("./attachment-path.cjs");
+var import_file_system = require("./file-system.cjs");
+var ExternalAttachmentLinkMode = /* @__PURE__ */ ((ExternalAttachmentLinkMode2) => {
+  ExternalAttachmentLinkMode2["Ignore"] = "Ignore";
+  ExternalAttachmentLinkMode2["Report"] = "Report";
+  ExternalAttachmentLinkMode2["ReportUnowned"] = "ReportUnowned";
+  return ExternalAttachmentLinkMode2;
+})(ExternalAttachmentLinkMode || {});
+class MisplacedAttachmentIndex extends Map {
+  /**
+   * Creates an empty index.
+   *
+   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.
+   */
+  constructor(mode = "Report" /* Report */) {
+    super();
+    this.mode = mode;
+  }
+  mode;
+  properNotePathsByAttachment = /* @__PURE__ */ new Map();
+  userNotePathsByAttachment = /* @__PURE__ */ new Map();
+  /**
+   * Records a reference to an attachment outside the referencing note's folder.
+   *
+   * @param notePath - The referencing note's vault-relative path.
+   * @param entry - The reference and the folder the note wants the attachment in.
+   */
+  add(notePath, entry) {
+    let entries = this.get(notePath);
+    if (!entries) {
+      entries = [];
+      this.set(notePath, entries);
+    }
+    entries.push(entry);
+    this.addUser(entry.attachmentPath, notePath);
+  }
+  /**
+   * Records that a note references an attachment, wherever the attachment sits.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note's vault-relative path.
+   */
+  addUser(attachmentPath, notePath) {
+    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);
+  }
+  /**
+   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note to leave out: the one whose reference is being reported.
+   * @returns The other notes' paths.
+   */
+  getOtherUserNotePaths(attachmentPath, notePath) {
+    const properNotePaths = this.getProperNotePaths(attachmentPath);
+    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];
+    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);
+  }
+  /**
+   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @returns The proper notes' paths, empty when the attachment has none.
+   */
+  getProperNotePaths(attachmentPath) {
+    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];
+  }
+  /**
+   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its
+   * entries survive.
+   *
+   * @returns The entries to report.
+   */
+  getReported() {
+    const reported = /* @__PURE__ */ new Map();
+    if (this.mode === "Ignore" /* Ignore */) {
+      return reported;
+    }
+    for (const [notePath, entries] of this) {
+      const surviving = this.mode === "ReportUnowned" /* ReportUnowned */ ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath)) : entries;
+      if (surviving.length > 0) {
+        reported.set(notePath, surviving);
+      }
+    }
+    return reported;
+  }
+  /**
+   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The note's vault-relative path.
+   * @returns `true` when the note's own attachment folder holds the attachment.
+   */
+  isProperNote(attachmentPath, notePath) {
+    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;
+  }
+  /**
+   * Records that an attachment sits in the folder configured for a note that references it, which makes that
+   * note its proper note.
+   *
+   * @param attachmentPath - The attachment's vault-relative path.
+   * @param notePath - The referencing note whose folder holds it.
+   */
+  markHomed(attachmentPath, notePath) {
+    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);
+    this.addUser(attachmentPath, notePath);
+  }
+}
+async function getAttachmentPlacement(params) {
+  const { app, attachmentFile, notePath } = params;
+  const properAttachmentFolderPath = await (0, import_attachment_path.getAttachmentFolderPathForAttachment)({
+    app,
+    attachmentPathOrFile: attachmentFile,
+    context: import_attachment_path.AttachmentPathContext.Unknown,
+    notePathOrFile: notePath
+  });
+  const isInsensitive = (0, import_implementations.getDataAdapterEx)(app).insensitive;
+  return {
+    isInProperFolder: fold((0, import_implementations.parentFolderPath)(attachmentFile.path)) === fold(properAttachmentFolderPath),
+    properAttachmentFolderPath
+  };
+  function fold(value) {
+    return isInsensitive ? value.toLowerCase() : value;
+  }
+}
+async function recordAttachmentPlacement(params) {
+  const {
+    app,
+    attachmentFile,
+    index,
+    isPathIgnored = isNone,
+    isSharedAttachmentPath = isNone,
+    isTreatedAsAttachment = isNone,
+    notePath,
+    reference
+  } = params;
+  if (index.mode === "Ignore" /* Ignore */) {
+    return;
+  }
+  if ((0, import_file_system.isNote)(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {
+    return;
+  }
+  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {
+    return;
+  }
+  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });
+  if (placement.isInProperFolder) {
+    index.markHomed(attachmentFile.path, notePath);
+    return;
+  }
+  index.add(notePath, {
+    attachmentPath: attachmentFile.path,
+    properAttachmentFolderPath: placement.properAttachmentFolderPath,
+    reference
+  });
+}
+function addToSetMap(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function isNone() {
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExternalAttachmentLinkMode,
+  MisplacedAttachmentIndex,
+  getAttachmentPlacement,
+  recordAttachmentPlacement
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/misplaced-attachment.ts"],"sourcesContent":["/**\n * @file\n *\n * Whether an attachment sits outside the attachment folder of the notes that use it, and which notes are its\n * proper home.\n *\n * Two things here are easy to get wrong:\n *\n * - **The judgement is about the FOLDER, not the path.** `getAttachmentFilePath` answers about the proper\n *   path, folder and templated base name both, so judging on it raw flags every attachment whose NAME does not\n *   match a rename template. That is a different defect. So the comparison is folder against folder, through\n *   `getAttachmentFolderPathForAttachment`, which also skips the name generation that dominates the cost of\n *   the question when `Custom Attachment Location` answers it.\n * - **The proper folder is asked for the REAL attachment, never a dummy.** A folder template may read the\n *   attachment's own name, extension or stats, so `getAttachmentFolderPath`'s dummy-file route can answer\n *   about a file that does not exist.\n *\n * A reference is judged from the note that makes it: `A.md` linking `B/image.png`, which sits in `B.md`'s folder,\n * is A linking an EXTERNAL attachment, even when B uses it too. Whether such a reference is worth reporting depends\n * on whether the attachment has a proper note anywhere, which is known only after every note has been judged, so\n * {@link MisplacedAttachmentIndex} collects the verdicts and {@link MisplacedAttachmentIndex.getReported} applies\n * the {@link ExternalAttachmentLinkMode} at the end.\n *\n * Rendering is the caller's: this module only judges and collects.\n */\n\nimport type {\n  App,\n  Reference,\n  TFile\n} from 'obsidian';\n\nimport {\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport {\n  AttachmentPathContext,\n  getAttachmentFolderPathForAttachment\n} from './attachment-path.ts';\nimport { isNote } from './file-system.ts';\n\n/**\n * Which references to an attachment outside the referencing note's attachment folder are reported.\n */\nexport enum ExternalAttachmentLinkMode {\n  /**\n   * Never report one: nothing is judged at all.\n   */\n  Ignore = 'Ignore',\n\n  /**\n   * Report every such reference, including one to an attachment filed in the folder of another note that\n   * references it too.\n   */\n  Report = 'Report',\n\n  /**\n   * Report such a reference only when no note that references the attachment has it in its own folder.\n   */\n  ReportUnowned = 'ReportUnowned'\n}\n\n/**\n * The folder an attachment sits in, judged against the folder one note's configuration puts its attachments in.\n */\nexport interface AttachmentPlacement {\n  /**\n   * Whether the attachment sits in {@link AttachmentPlacement.properAttachmentFolderPath}, compared the way the\n   * vault's adapter compares names (case-folded on a case-insensitive adapter).\n   */\n  readonly isInProperFolder: boolean;\n\n  /**\n   * The vault-relative folder the note's configuration puts this attachment in, `/` for the vault root.\n   */\n  readonly properAttachmentFolderPath: string;\n}\n\n/**\n * Parameters for {@link getAttachmentPlacement}.\n */\nexport interface GetAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The attachment to judge.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The vault-relative path of the note whose configuration the attachment is judged against.\n   */\n  readonly notePath: string;\n}\n\n/**\n * One reference to an attachment outside the attachment folder of the note that makes it.\n *\n * The same attachment referenced from two notes is two entries, because the two notes can configure different\n * attachment folders.\n */\nexport interface MisplacedAttachmentEntry {\n  /**\n   * The attachment's current vault-relative path.\n   */\n  readonly attachmentPath: string;\n\n  /**\n   * The vault-relative folder the referencing note's configuration puts the attachment in.\n   */\n  readonly properAttachmentFolderPath: string;\n\n  /**\n   * The reference that reaches the attachment.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * Parameters for {@link recordAttachmentPlacement}.\n */\nexport interface RecordAttachmentPlacementParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The file the reference resolved to. Pass only references that resolved: an unresolved one is a broken link,\n   * not a misplaced attachment.\n   */\n  readonly attachmentFile: TFile;\n\n  /**\n   * The index the verdict is recorded in.\n   */\n  readonly index: MisplacedAttachmentIndex;\n\n  /**\n   * Whether a path is never judged, for example because the user excluded it. Defaults to judging every path.\n   */\n  readonly isPathIgnored?: (path: string) => boolean;\n\n  /**\n   * Whether a path lies in a shared attachment location, which is anybody's folder, so no reference into it is\n   * external. Defaults to no shared location.\n   */\n  readonly isSharedAttachmentPath?: (path: string) => boolean;\n\n  /**\n   * Whether a note is treated as an attachment (an `.excalidraw.md` file, say), and so judged here. Defaults to\n   * no note being one.\n   */\n  readonly isTreatedAsAttachment?: (path: string) => boolean;\n\n  /**\n   * The vault-relative path of the note that makes the reference.\n   */\n  readonly notePath: string;\n\n  /**\n   * The reference, kept in the entry so a report can name its line or frontmatter key.\n   */\n  readonly reference: Reference;\n}\n\n/**\n * The verdicts of a walk over every reference to an attachment, grouped by the note that makes the reference.\n *\n * It keeps every external reference, every note that uses each attachment, and each attachment's proper notes:\n * the notes that reference it and whose own folder holds it. Which entries count as reported depends on the\n * {@link ExternalAttachmentLinkMode} and on the proper notes, which are known only once the whole vault has been\n * walked, so ask {@link MisplacedAttachmentIndex.getReported} after the walk.\n */\nexport class MisplacedAttachmentIndex extends Map<string, MisplacedAttachmentEntry[]> {\n  private readonly properNotePathsByAttachment = new Map<string, Set<string>>();\n  private readonly userNotePathsByAttachment = new Map<string, Set<string>>();\n\n  /**\n   * Creates an empty index.\n   *\n   * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.\n   */\n  public constructor(public readonly mode = ExternalAttachmentLinkMode.Report) {\n    super();\n  }\n\n  /**\n   * Records a reference to an attachment outside the referencing note's folder.\n   *\n   * @param notePath - The referencing note's vault-relative path.\n   * @param entry - The reference and the folder the note wants the attachment in.\n   */\n  public add(notePath: string, entry: MisplacedAttachmentEntry): void {\n    let entries = this.get(notePath);\n    if (!entries) {\n      entries = [];\n      this.set(notePath, entries);\n    }\n    entries.push(entry);\n    this.addUser(entry.attachmentPath, notePath);\n  }\n\n  /**\n   * Records that a note references an attachment, wherever the attachment sits.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note's vault-relative path.\n   */\n  public addUser(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.userNotePathsByAttachment, attachmentPath, notePath);\n  }\n\n  /**\n   * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note to leave out: the one whose reference is being reported.\n   * @returns The other notes' paths.\n   */\n  public getOtherUserNotePaths(attachmentPath: string, notePath: string): string[] {\n    const properNotePaths = this.getProperNotePaths(attachmentPath);\n    const userNotePaths = [...this.userNotePathsByAttachment.get(attachmentPath) ?? []];\n    return [...properNotePaths, ...userNotePaths.filter((path) => !properNotePaths.includes(path))].filter((path) => path !== notePath);\n  }\n\n  /**\n   * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @returns The proper notes' paths, empty when the attachment has none.\n   */\n  public getProperNotePaths(attachmentPath: string): string[] {\n    return [...this.properNotePathsByAttachment.get(attachmentPath) ?? []];\n  }\n\n  /**\n   * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its\n   * entries survive.\n   *\n   * @returns The entries to report.\n   */\n  public getReported(): Map<string, MisplacedAttachmentEntry[]> {\n    const reported = new Map<string, MisplacedAttachmentEntry[]>();\n    if (this.mode === ExternalAttachmentLinkMode.Ignore) {\n      return reported;\n    }\n\n    for (const [notePath, entries] of this) {\n      const surviving = this.mode === ExternalAttachmentLinkMode.ReportUnowned\n        ? entries.filter((entry) => !this.properNotePathsByAttachment.has(entry.attachmentPath))\n        : entries;\n      if (surviving.length > 0) {\n        reported.set(notePath, surviving);\n      }\n    }\n    return reported;\n  }\n\n  /**\n   * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The note's vault-relative path.\n   * @returns `true` when the note's own attachment folder holds the attachment.\n   */\n  public isProperNote(attachmentPath: string, notePath: string): boolean {\n    return this.properNotePathsByAttachment.get(attachmentPath)?.has(notePath) ?? false;\n  }\n\n  /**\n   * Records that an attachment sits in the folder configured for a note that references it, which makes that\n   * note its proper note.\n   *\n   * @param attachmentPath - The attachment's vault-relative path.\n   * @param notePath - The referencing note whose folder holds it.\n   */\n  public markHomed(attachmentPath: string, notePath: string): void {\n    addToSetMap(this.properNotePathsByAttachment, attachmentPath, notePath);\n    this.addUser(attachmentPath, notePath);\n  }\n}\n\n/**\n * Judges where an attachment sits against the attachment folder of one note.\n *\n * Asks the attachment-path seam once, folder-only, for the REAL attachment, so a `Custom Attachment Location`\n * folder template that reads the attachment's own name is honoured and no name is generated.\n *\n * @param params - The attachment and the note.\n * @returns The note's proper folder for the attachment, and whether the attachment is in it.\n */\nexport async function getAttachmentPlacement(params: GetAttachmentPlacementParams): Promise<AttachmentPlacement> {\n  const { app, attachmentFile, notePath } = params;\n  const properAttachmentFolderPath = await getAttachmentFolderPathForAttachment({\n    app,\n    attachmentPathOrFile: attachmentFile,\n    context: AttachmentPathContext.Unknown,\n    notePathOrFile: notePath\n  });\n\n  // Fold as `isAtProperAttachmentPath` does, so a case-insensitive adapter does not report a folder that differs\n  // only in case.\n  const isInsensitive = getDataAdapterEx(app).insensitive;\n  return {\n    isInProperFolder: fold(parentFolderPath(attachmentFile.path)) === fold(properAttachmentFolderPath),\n    properAttachmentFolderPath\n  };\n\n  function fold(value: string): string {\n    return isInsensitive ? value.toLowerCase() : value;\n  }\n}\n\n/**\n * Judges one resolved reference and records the verdict in the index.\n *\n * Records nothing under {@link ExternalAttachmentLinkMode.Ignore}, for a note that is not treated as an\n * attachment, and for an ignored or shared path. Otherwise the referencing note becomes a proper note of the\n * attachment when its folder holds it, and the reference becomes an entry when it does not.\n *\n * @param params - The reference, its note, its target and the index.\n * @returns A {@link Promise} that resolves once the verdict is recorded.\n */\nexport async function recordAttachmentPlacement(params: RecordAttachmentPlacementParams): Promise<void> {\n  const {\n    app,\n    attachmentFile,\n    index,\n    isPathIgnored = isNone,\n    isSharedAttachmentPath = isNone,\n    isTreatedAsAttachment = isNone,\n    notePath,\n    reference\n  } = params;\n\n  if (index.mode === ExternalAttachmentLinkMode.Ignore) {\n    return;\n  }\n\n  if (isNote(attachmentFile) && !isTreatedAsAttachment(attachmentFile.path)) {\n    return;\n  }\n\n  if (isPathIgnored(attachmentFile.path) || isSharedAttachmentPath(attachmentFile.path)) {\n    return;\n  }\n\n  const placement = await getAttachmentPlacement({ app, attachmentFile, notePath });\n\n  if (placement.isInProperFolder) {\n    index.markHomed(attachmentFile.path, notePath);\n    return;\n  }\n\n  index.add(notePath, {\n    attachmentPath: attachmentFile.path,\n    properAttachmentFolderPath: placement.properAttachmentFolderPath,\n    reference\n  });\n}\n\nfunction addToSetMap(map: Map<string, Set<string>>, key: string, value: string): void {\n  let set = map.get(key);\n  if (!set) {\n    set = new Set<string>();\n    map.set(key, set);\n  }\n  set.add(value);\n}\n\nfunction isNone(): boolean {\n  return false;\n}\n"],"mappings":"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","names":["ExternalAttachmentLinkMode"]}

package/dist/lib/cjs/misplaced-attachment.d.cts

@@ -0,0 +1,228 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Whether an attachment sits outside the attachment folder of the notes that use it, and which notes are its
+ * proper home.
+ *
+ * Two things here are easy to get wrong:
+ *
+ * - **The judgement is about the FOLDER, not the path.** `getAttachmentFilePath` answers about the proper
+ *   path, folder and templated base name both, so judging on it raw flags every attachment whose NAME does not
+ *   match a rename template. That is a different defect. So the comparison is folder against folder, through
+ *   `getAttachmentFolderPathForAttachment`, which also skips the name generation that dominates the cost of
+ *   the question when `Custom Attachment Location` answers it.
+ * - **The proper folder is asked for the REAL attachment, never a dummy.** A folder template may read the
+ *   attachment's own name, extension or stats, so `getAttachmentFolderPath`'s dummy-file route can answer
+ *   about a file that does not exist.
+ *
+ * A reference is judged from the note that makes it: `A.md` linking `B/image.png`, which sits in `B.md`'s folder,
+ * is A linking an EXTERNAL attachment, even when B uses it too. Whether such a reference is worth reporting depends
+ * on whether the attachment has a proper note anywhere, which is known only after every note has been judged, so
+ * {@link MisplacedAttachmentIndex} collects the verdicts and {@link MisplacedAttachmentIndex.getReported} applies
+ * the {@link ExternalAttachmentLinkMode} at the end.
+ *
+ * Rendering is the caller's: this module only judges and collects.
+ */
+import type { App, Reference, TFile } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Which references to an attachment outside the referencing note's attachment folder are reported.
+ */
+export declare enum ExternalAttachmentLinkMode {
+    /**
+     * Never report one: nothing is judged at all.
+     */
+    Ignore = "Ignore",
+    /**
+     * Report every such reference, including one to an attachment filed in the folder of another note that
+     * references it too.
+     */
+    Report = "Report",
+    /**
+     * Report such a reference only when no note that references the attachment has it in its own folder.
+     */
+    ReportUnowned = "ReportUnowned"
+}
+/**
+ * The folder an attachment sits in, judged against the folder one note's configuration puts its attachments in.
+ */
+export interface AttachmentPlacement {
+    /**
+     * Whether the attachment sits in {@link AttachmentPlacement.properAttachmentFolderPath}, compared the way the
+     * vault's adapter compares names (case-folded on a case-insensitive adapter).
+     */
+    readonly isInProperFolder: boolean;
+    /**
+     * The vault-relative folder the note's configuration puts this attachment in, `/` for the vault root.
+     */
+    readonly properAttachmentFolderPath: string;
+}
+/**
+ * Parameters for {@link getAttachmentPlacement}.
+ */
+export interface GetAttachmentPlacementParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The attachment to judge.
+     */
+    readonly attachmentFile: TFile;
+    /**
+     * The vault-relative path of the note whose configuration the attachment is judged against.
+     */
+    readonly notePath: string;
+}
+/**
+ * One reference to an attachment outside the attachment folder of the note that makes it.
+ *
+ * The same attachment referenced from two notes is two entries, because the two notes can configure different
+ * attachment folders.
+ */
+export interface MisplacedAttachmentEntry {
+    /**
+     * The attachment's current vault-relative path.
+     */
+    readonly attachmentPath: string;
+    /**
+     * The vault-relative folder the referencing note's configuration puts the attachment in.
+     */
+    readonly properAttachmentFolderPath: string;
+    /**
+     * The reference that reaches the attachment.
+     */
+    readonly reference: Reference;
+}
+/**
+ * Parameters for {@link recordAttachmentPlacement}.
+ */
+export interface RecordAttachmentPlacementParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The file the reference resolved to. Pass only references that resolved: an unresolved one is a broken link,
+     * not a misplaced attachment.
+     */
+    readonly attachmentFile: TFile;
+    /**
+     * The index the verdict is recorded in.
+     */
+    readonly index: MisplacedAttachmentIndex;
+    /**
+     * Whether a path is never judged, for example because the user excluded it. Defaults to judging every path.
+     */
+    readonly isPathIgnored?: (path: string) => boolean;
+    /**
+     * Whether a path lies in a shared attachment location, which is anybody's folder, so no reference into it is
+     * external. Defaults to no shared location.
+     */
+    readonly isSharedAttachmentPath?: (path: string) => boolean;
+    /**
+     * Whether a note is treated as an attachment (an `.excalidraw.md` file, say), and so judged here. Defaults to
+     * no note being one.
+     */
+    readonly isTreatedAsAttachment?: (path: string) => boolean;
+    /**
+     * The vault-relative path of the note that makes the reference.
+     */
+    readonly notePath: string;
+    /**
+     * The reference, kept in the entry so a report can name its line or frontmatter key.
+     */
+    readonly reference: Reference;
+}
+/**
+ * The verdicts of a walk over every reference to an attachment, grouped by the note that makes the reference.
+ *
+ * It keeps every external reference, every note that uses each attachment, and each attachment's proper notes:
+ * the notes that reference it and whose own folder holds it. Which entries count as reported depends on the
+ * {@link ExternalAttachmentLinkMode} and on the proper notes, which are known only once the whole vault has been
+ * walked, so ask {@link MisplacedAttachmentIndex.getReported} after the walk.
+ */
+export declare class MisplacedAttachmentIndex extends Map<string, MisplacedAttachmentEntry[]> {
+    readonly mode: ExternalAttachmentLinkMode;
+    private readonly properNotePathsByAttachment;
+    private readonly userNotePathsByAttachment;
+    /**
+     * Creates an empty index.
+     *
+     * @param mode - Which external references {@link MisplacedAttachmentIndex.getReported} returns.
+     */
+    constructor(mode?: ExternalAttachmentLinkMode);
+    /**
+     * Records a reference to an attachment outside the referencing note's folder.
+     *
+     * @param notePath - The referencing note's vault-relative path.
+     * @param entry - The reference and the folder the note wants the attachment in.
+     */
+    add(notePath: string, entry: MisplacedAttachmentEntry): void;
+    /**
+     * Records that a note references an attachment, wherever the attachment sits.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The referencing note's vault-relative path.
+     */
+    addUser(attachmentPath: string, notePath: string): void;
+    /**
+     * The notes that use an attachment besides the given one, its proper notes first, each group in walk order.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The note to leave out: the one whose reference is being reported.
+     * @returns The other notes' paths.
+     */
+    getOtherUserNotePaths(attachmentPath: string, notePath: string): string[];
+    /**
+     * The proper notes of an attachment: the notes that reference it and whose own folder holds it, in walk order.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @returns The proper notes' paths, empty when the attachment has none.
+     */
+    getProperNotePaths(attachmentPath: string): string[];
+    /**
+     * The entries to report, after the mode is applied, grouped by note, with a note left out once none of its
+     * entries survive.
+     *
+     * @returns The entries to report.
+     */
+    getReported(): Map<string, MisplacedAttachmentEntry[]>;
+    /**
+     * Whether a note is a proper note of an attachment: it references it, and its own folder holds it.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The note's vault-relative path.
+     * @returns `true` when the note's own attachment folder holds the attachment.
+     */
+    isProperNote(attachmentPath: string, notePath: string): boolean;
+    /**
+     * Records that an attachment sits in the folder configured for a note that references it, which makes that
+     * note its proper note.
+     *
+     * @param attachmentPath - The attachment's vault-relative path.
+     * @param notePath - The referencing note whose folder holds it.
+     */
+    markHomed(attachmentPath: string, notePath: string): void;
+}
+/**
+ * Judges where an attachment sits against the attachment folder of one note.
+ *
+ * Asks the attachment-path seam once, folder-only, for the REAL attachment, so a `Custom Attachment Location`
+ * folder template that reads the attachment's own name is honoured and no name is generated.
+ *
+ * @param params - The attachment and the note.
+ * @returns The note's proper folder for the attachment, and whether the attachment is in it.
+ */
+export declare function getAttachmentPlacement(params: GetAttachmentPlacementParams): Promise<AttachmentPlacement>;
+/**
+ * Judges one resolved reference and records the verdict in the index.
+ *
+ * Records nothing under {@link ExternalAttachmentLinkMode.Ignore}, for a note that is not treated as an
+ * attachment, and for an ignored or shared path. Otherwise the referencing note becomes a proper note of the
+ * attachment when its folder holds it, and the reference becomes an entry when it does not.
+ *
+ * @param params - The reference, its note, its target and the index.
+ * @returns A {@link Promise} that resolves once the verdict is recorded.
+ */
+export declare function recordAttachmentPlacement(params: RecordAttachmentPlacementParams): Promise<void>;

package/dist/lib/cjs/mobile-app-info.cjs

@@ -117,7 +117,7 @@ __export(mobile_app_info_exports, {
   getMobileAppInfo: () => getMobileAppInfo
 });
 module.exports = __toCommonJS(mobile_app_info_exports);
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
 const isAppInfo = (0, import_type_guards.objectTypeGuard)({
   build: (0, import_type_guards.optionalTypeGuard)(import_type_guards.isString),
   version: import_type_guards.isString

package/dist/lib/cjs/modals/alert.cjs

@@ -117,10 +117,10 @@ __export(alert_exports, {
   alert: () => alert
 });
 module.exports = __toCommonJS(alert_exports);
-var import_i18next = require('i18next');
-var import_obsidian = require('obsidian');
-var import_css_class = require('../css-class.cjs');
-var import_modal = require('./modal.cjs');
+var import_i18next = require("i18next");
+var import_obsidian = require("obsidian");
+var import_css_class = require("../css-class.cjs");
+var import_modal = require("./modal.cjs");
 class AlertModal extends import_modal.ModalBase {
   message;
   okButtonText;

package/dist/lib/cjs/modals/code-block-builder.cjs

@@ -118,13 +118,13 @@ __export(code_block_builder_exports, {
   showCodeBlockBuilder: () => showCodeBlockBuilder
 });
 module.exports = __toCommonJS(code_block_builder_exports);
-var import_async = require('@mnaoumov/typescript-lib/async');
-var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
-var import_obsidian = require('obsidian');
-var import_css_class = require('../css-class.cjs');
-var import_i18n = require('../i18n/i18n.cjs');
-var import_multiple_dropdown_component = require('../setting-components/multiple-dropdown-component.cjs');
-var import_modal = require('./modal.cjs');
+var import_async = require("@mnaoumov/typescript-lib/async");
+var import_type_guards = require("@mnaoumov/typescript-lib/type-guards");
+var import_obsidian = require("obsidian");
+var import_css_class = require("../css-class.cjs");
+var import_i18n = require("../i18n/i18n.cjs");
+var import_multiple_dropdown_component = require("../setting-components/multiple-dropdown-component.cjs");
+var import_modal = require("./modal.cjs");
 const DEFAULT_SEPARATOR = ",";
 const MIN_FENCE_LENGTH = 3;
 const ROOT_FOLDER_PATH = "/";

package/dist/lib/cjs/modals/confirm.cjs

@@ -117,10 +117,10 @@ __export(confirm_exports, {
   confirm: () => confirm
 });
 module.exports = __toCommonJS(confirm_exports);
-var import_obsidian = require('obsidian');
-var import_css_class = require('../css-class.cjs');
-var import_i18n = require('../i18n/i18n.cjs');
-var import_modal = require('./modal.cjs');
+var import_obsidian = require("obsidian");
+var import_css_class = require("../css-class.cjs");
+var import_i18n = require("../i18n/i18n.cjs");
+var import_modal = require("./modal.cjs");
 class ConfirmModal extends import_modal.ModalBase {
   cancelButtonText;
   isConfirmed = false;