@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/bug-report-diagnostics.mjs

@@ -0,0 +1,127 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+const REDACTED_VALUE = "[redacted]";
+const DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES = 200;
+const DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH = 2e3;
+const JSON_INDENT = 2;
+const MIN_FENCE_LENGTH = 3;
+const TRUNCATION_MARKER = " [truncated]";
+class BugReportLogBuffer {
+  entries = [];
+  maxEntries;
+  maxEntryLength;
+  now;
+  /**
+   * Constructs a new instance.
+   *
+   * @param options - Constructor options.
+   */
+  constructor(options = {}) {
+    this.maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES));
+    this.maxEntryLength = Math.max(1, Math.floor(options.maxEntryLength ?? DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH));
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  /**
+   * Adds an entry, stamped with the current time.
+   *
+   * @param message - The entry's text.
+   */
+  add(message) {
+    const text = message.length > this.maxEntryLength ? message.slice(0, this.maxEntryLength) + TRUNCATION_MARKER : message;
+    this.entries.push(`${this.now().toISOString()} ${text}`);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.splice(0, this.entries.length - this.maxEntries);
+    }
+  }
+  /**
+   * Removes every entry.
+   */
+  clear() {
+    this.entries.length = 0;
+  }
+  /**
+   * Gets the entries, oldest first.
+   *
+   * @returns The entries.
+   */
+  getEntries() {
+    return [...this.entries];
+  }
+  /**
+   * Builds a potentially private diagnostic section holding the entries.
+   *
+   * @param options - The options.
+   * @returns The section.
+   */
+  toSection(options = {}) {
+    return {
+      content: this.entries.length === 0 ? "(no log entries)" : this.entries.join("\n"),
+      id: options.id ?? "logs",
+      isPotentiallyPrivate: true,
+      title: options.title ?? "Logs"
+    };
+  }
+}
+function createSettingsDiagnosticSection(params) {
+  return {
+    content: JSON.stringify(redactSettings(params.settings, params.secretKeys ?? []), null, JSON_INDENT) ?? "undefined",
+    id: params.id ?? "settings",
+    isPotentiallyPrivate: true,
+    title: params.title ?? "Plugin settings"
+  };
+}
+function formatBugReportDiagnostics(sections) {
+  return sections.map((section) => {
+    const fence = getMarkdownFence(section.content);
+    return `### ${section.title}
+
+${fence}
+${section.content}
+${fence}`;
+  }).join("\n\n");
+}
+function getMarkdownFence(content) {
+  let longestRun = 0;
+  for (const match of content.matchAll(/`+/g)) {
+    longestRun = Math.max(longestRun, match[0].length);
+  }
+  return "`".repeat(Math.max(MIN_FENCE_LENGTH, longestRun + 1));
+}
+function redactSettings(settings, secretKeys) {
+  const lowerCaseSecretKeys = new Set(secretKeys.map((key) => key.toLowerCase()));
+  return redactValue(settings, lowerCaseSecretKeys, /* @__PURE__ */ new WeakSet());
+}
+function redactValue(value, lowerCaseSecretKeys, seen) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result2 = value.map((item) => redactValue(item, lowerCaseSecretKeys, seen));
+    seen.delete(value);
+    return result2;
+  }
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    result[key] = lowerCaseSecretKeys.has(key.toLowerCase()) ? REDACTED_VALUE : redactValue(child, lowerCaseSecretKeys, seen);
+  }
+  seen.delete(value);
+  return result;
+}
+export {
+  BugReportLogBuffer,
+  DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES,
+  DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH,
+  REDACTED_VALUE,
+  createSettingsDiagnosticSection,
+  formatBugReportDiagnostics,
+  getMarkdownFence,
+  redactSettings
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/bug-report-diagnostics.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Optional diagnostics a plugin can attach to a bug report: sections of text the user reviews before\n * anything leaves Obsidian, a bounded log buffer, and redaction of a plugin's own settings.\n *\n * Nothing here reads logs or settings by itself. A log buffer holds only what the plugin wrote to it since\n * the buffer was created, never the console's history, and a settings section holds only the object the\n * plugin hands over. Redaction replaces the values of caller-declared keys; it is not a promise to find\n * every secret, which is why every section is shown to the user, and a potentially private one is left\n * out unless the user includes it.\n */\n\n/**\n * A section of diagnostics for a bug report.\n */\nexport interface BugReportDiagnosticSection {\n  /**\n   * The section's text, shown to the user and sent as written.\n   */\n  readonly content: string;\n\n  /**\n   * A stable id, unique among the sections of one report.\n   */\n  readonly id: string;\n\n  /**\n   * Whether the section can hold private data, such as logs or settings. A potentially private section is\n   * left out of the report unless the user includes it.\n   *\n   * @default `false`\n   */\n  readonly isPotentiallyPrivate?: boolean;\n\n  /**\n   * The section's title.\n   */\n  readonly title: string;\n}\n\n/**\n * Constructor parameters for {@link BugReportLogBuffer}.\n */\nexport interface BugReportLogBufferConstructorOptions {\n  /**\n   * The most entries kept. Older entries are dropped first.\n   *\n   * @default {@link DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES}\n   */\n  readonly maxEntries?: number;\n\n  /**\n   * The most characters kept of one entry. A longer entry is cut, and says so.\n   *\n   * @default {@link DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH}\n   */\n  readonly maxEntryLength?: number;\n\n  /**\n   * Gets the current time. For tests.\n   *\n   * @default `() => new Date()`\n   */\n  readonly now?: () => Date;\n}\n\n/**\n * Parameters for {@link BugReportLogBuffer.toSection}.\n */\nexport interface BugReportLogBufferToSectionOptions {\n  /**\n   * The section's id.\n   *\n   * @default `'logs'`\n   */\n  readonly id?: string;\n\n  /**\n   * The section's title.\n   *\n   * @default `'Logs'`\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link createSettingsDiagnosticSection}.\n */\nexport interface CreateSettingsDiagnosticSectionParams {\n  /**\n   * The section's id.\n   *\n   * @default `'settings'`\n   */\n  readonly id?: string;\n\n  /**\n   * The keys whose values are replaced with {@link REDACTED_VALUE}, at any depth, compared without case.\n   */\n  readonly secretKeys?: readonly string[];\n\n  /**\n   * The reporting plugin's own settings, such as its `data.json`.\n   */\n  readonly settings: unknown;\n\n  /**\n   * The section's title.\n   *\n   * @default `'Plugin settings'`\n   */\n  readonly title?: string;\n}\n\n/**\n * The value that replaces a redacted setting.\n */\nexport const REDACTED_VALUE = '[redacted]';\n\n/**\n * The default number of entries a {@link BugReportLogBuffer} keeps.\n */\nexport const DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES = 200;\n\n/**\n * The default number of characters a {@link BugReportLogBuffer} keeps of one entry.\n */\nexport const DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH = 2000;\n\nconst JSON_INDENT = 2;\nconst MIN_FENCE_LENGTH = 3;\nconst TRUNCATION_MARKER = ' [truncated]';\n\n/**\n * A bounded buffer of log entries a plugin writes for its bug reports. It keeps only what the plugin adds\n * after creating it, at most {@link BugReportLogBufferConstructorOptions.maxEntries} entries, each cut to\n * {@link BugReportLogBufferConstructorOptions.maxEntryLength} characters.\n */\nexport class BugReportLogBuffer {\n  private readonly entries: string[] = [];\n  private readonly maxEntries: number;\n  private readonly maxEntryLength: number;\n  private readonly now: () => Date;\n\n  /**\n   * Constructs a new instance.\n   *\n   * @param options - Constructor options.\n   */\n  public constructor(options: BugReportLogBufferConstructorOptions = {}) {\n    this.maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_BUG_REPORT_LOG_MAX_ENTRIES));\n    this.maxEntryLength = Math.max(1, Math.floor(options.maxEntryLength ?? DEFAULT_BUG_REPORT_LOG_MAX_ENTRY_LENGTH));\n    this.now = options.now ?? ((): Date => new Date());\n  }\n\n  /**\n   * Adds an entry, stamped with the current time.\n   *\n   * @param message - The entry's text.\n   */\n  public add(message: string): void {\n    const text = message.length > this.maxEntryLength\n      ? message.slice(0, this.maxEntryLength) + TRUNCATION_MARKER\n      : message;\n    this.entries.push(`${this.now().toISOString()} ${text}`);\n    if (this.entries.length > this.maxEntries) {\n      this.entries.splice(0, this.entries.length - this.maxEntries);\n    }\n  }\n\n  /**\n   * Removes every entry.\n   */\n  public clear(): void {\n    this.entries.length = 0;\n  }\n\n  /**\n   * Gets the entries, oldest first.\n   *\n   * @returns The entries.\n   */\n  public getEntries(): readonly string[] {\n    return [...this.entries];\n  }\n\n  /**\n   * Builds a potentially private diagnostic section holding the entries.\n   *\n   * @param options - The options.\n   * @returns The section.\n   */\n  public toSection(options: BugReportLogBufferToSectionOptions = {}): BugReportDiagnosticSection {\n    return {\n      content: this.entries.length === 0 ? '(no log entries)' : this.entries.join('\\n'),\n      id: options.id ?? 'logs',\n      isPotentiallyPrivate: true,\n      title: options.title ?? 'Logs'\n    };\n  }\n}\n\n/**\n * Builds a potentially private diagnostic section holding the plugin's settings as JSON, with the values\n * of {@link CreateSettingsDiagnosticSectionParams.secretKeys} redacted.\n *\n * @param params - The parameters.\n * @returns The section.\n */\nexport function createSettingsDiagnosticSection(params: CreateSettingsDiagnosticSectionParams): BugReportDiagnosticSection {\n  return {\n    content: JSON.stringify(redactSettings(params.settings, params.secretKeys ?? []), null, JSON_INDENT) ?? 'undefined',\n    id: params.id ?? 'settings',\n    isPotentiallyPrivate: true,\n    title: params.title ?? 'Plugin settings'\n  };\n}\n\n/**\n * Renders diagnostic sections as Markdown: a level-3 heading and a fenced code block per section. The\n * fence is longer than any run of backticks in the content, so no content can close it.\n *\n * @param sections - The sections.\n * @returns The Markdown, or an empty string when there are no sections.\n */\nexport function formatBugReportDiagnostics(sections: readonly BugReportDiagnosticSection[]): string {\n  return sections.map((section) => {\n    const fence = getMarkdownFence(section.content);\n    return `### ${section.title}\\n\\n${fence}\\n${section.content}\\n${fence}`;\n  }).join('\\n\\n');\n}\n\n/**\n * Gets a Markdown code fence that the given content cannot close.\n *\n * @param content - The content to fence.\n * @returns A run of backticks longer than the longest run in the content, and at least three long.\n */\nexport function getMarkdownFence(content: string): string {\n  let longestRun = 0;\n  for (const match of content.matchAll(/`+/g)) {\n    longestRun = Math.max(longestRun, match[0].length);\n  }\n  return '`'.repeat(Math.max(MIN_FENCE_LENGTH, longestRun + 1));\n}\n\n/**\n * Copies settings, replacing the value of every key in `secretKeys`, at any depth and compared without\n * case, with {@link REDACTED_VALUE}. The original is not changed.\n *\n * @param settings - The settings.\n * @param secretKeys - The keys to redact.\n * @returns The redacted copy.\n */\nexport function redactSettings(settings: unknown, secretKeys: readonly string[]): unknown {\n  const lowerCaseSecretKeys = new Set(secretKeys.map((key) => key.toLowerCase()));\n  return redactValue(settings, lowerCaseSecretKeys, new WeakSet());\n}\n\nfunction redactValue(value: unknown, lowerCaseSecretKeys: ReadonlySet<string>, seen: WeakSet<object>): unknown {\n  if (typeof value !== 'object' || value === null) {\n    return value;\n  }\n\n  if (seen.has(value)) {\n    return '[circular]';\n  }\n  seen.add(value);\n\n  if (Array.isArray(value)) {\n    const result = value.map((item: unknown) => redactValue(item, lowerCaseSecretKeys, seen));\n    seen.delete(value);\n    return result;\n  }\n\n  const result: Record<string, unknown> = {};\n  for (const [key, child] of Object.entries(value)) {\n    result[key] = lowerCaseSecretKeys.has(key.toLowerCase()) ? REDACTED_VALUE : redactValue(child, lowerCaseSecretKeys, seen);\n  }\n  seen.delete(value);\n  return result;\n}\n"],
  "mappings": "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",
  "names": ["result"]
}


package/dist/lib/esm/bug-report.d.mts

@@ -13,6 +13,7 @@
  * structurally here, and reads as `unknown` if a later version drops it.
  */
 import type { App } from 'obsidian';
+import type { BugReportDiagnosticSection } from './bug-report-diagnostics.mjs';
 /**
  * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub
  * prefills a field from a query parameter named after the field's `id`, so a form must give its fields
@@ -40,6 +41,59 @@ export declare enum BugReportIssueFormFieldId {
  * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.
  */
 export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+/**
+ * The default budget, in characters of the encoded URL, of a prefilled bug-report link.
+ *
+ * Measured against `github.com` on 2026-11-07, signed out: an issue-form URL up to about 6,540 characters
+ * was answered with the usual redirect to the form, about 8,088 with a 502, and 8,288 and more with a 414.
+ * 6,000 leaves room for a longer repository name and for a signed-in session's own limits.
+ */
+export declare const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6000;
+/**
+ * A link to a bug-report issue form, as {@link buildBugReportIssueFormLink} builds it.
+ */
+export interface BugReportIssueFormLink {
+    /**
+     * The text the user must paste into the form's environment field, when the full report did not fit the
+     * URL budget; `null` when the URL carries the whole report.
+     */
+    readonly clipboardText: null | string;
+    /**
+     * The link.
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link buildBugReportIssueFormLink}.
+ */
+export interface BuildBugReportIssueFormLinkParams {
+    /**
+     * The diagnostics the user agreed to include, appended to the environment field.
+     */
+    readonly diagnostics?: readonly BugReportDiagnosticSection[];
+    /**
+     * The environment, from {@link getBugReportEnvironment}.
+     */
+    readonly environment: BugReportEnvironment;
+    /**
+     * The plugin's GitHub repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The most characters the encoded URL may have before the report moves to the clipboard.
+     *
+     * @default {@link DEFAULT_BUG_REPORT_MAX_URL_LENGTH}
+     */
+    readonly maxUrlLength?: number;
+    /**
+     * The issue's title. Leave it out to keep the form's own default title.
+     */
+    readonly title?: string;
+}
+/**
+ * The text the environment field holds when the report moved to the clipboard.
+ */
+export declare const BUG_REPORT_PASTE_INSTRUCTIONS = "The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.";
 /**
  * The environment a bug report needs.
  */
@@ -129,6 +183,17 @@ export interface GetGitHubIssueFormUrlParams {
      */
     readonly title?: string;
 }
+/**
+ * Builds a link to a plugin's bug-report issue form, prefilled with the environment and the given
+ * diagnostics. When the encoded link would be longer than
+ * {@link BuildBugReportIssueFormLinkParams.maxUrlLength}, the environment field gets
+ * {@link BUG_REPORT_PASTE_INSTRUCTIONS} instead, and the full text is returned as
+ * {@link BugReportIssueFormLink.clipboardText} for the caller to copy. Nothing is cut.
+ *
+ * @param params - The parameters.
+ * @returns The link, and the text to paste when it did not fit.
+ */
+export declare function buildBugReportIssueFormLink(params: BuildBugReportIssueFormLinkParams): BugReportIssueFormLink;
 /**
  * Renders a bug report's environment as a Markdown list.
  *

package/dist/lib/esm/bug-report.mjs

@@ -34,6 +34,7 @@ import {
   apiVersion,
   Platform
 } from "obsidian";
+import { formatBugReportDiagnostics } from "./bug-report-diagnostics.mjs";
 import { getMobileAppInfo } from "./mobile-app-info.mjs";
 var BugReportIssueFormFieldId = /* @__PURE__ */ ((BugReportIssueFormFieldId2) => {
   BugReportIssueFormFieldId2["Environment"] = "environment";
@@ -43,7 +44,31 @@ var BugReportIssueFormFieldId = /* @__PURE__ */ ((BugReportIssueFormFieldId2) =>
   return BugReportIssueFormFieldId2;
 })(BugReportIssueFormFieldId || {});
 const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6e3;
+const BUG_REPORT_PASTE_INSTRUCTIONS = "The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.";
 const UNKNOWN = "unknown";
+function buildBugReportIssueFormLink(params) {
+  const { environment } = params;
+  const diagnosticsMarkdown = formatBugReportDiagnostics(params.diagnostics ?? []);
+  const environmentText = diagnosticsMarkdown === "" ? formatBugReportEnvironment(environment) : `${formatBugReportEnvironment(environment)}
+
+${diagnosticsMarkdown}`;
+  function buildUrl(environmentFieldValue) {
+    return getGitHubIssueFormUrl({
+      fields: {
+        ["environment" /* Environment */]: environmentFieldValue,
+        ["obsidian-version" /* ObsidianVersion */]: environment.obsidianVersion,
+        ["operating-system" /* OperatingSystem */]: environment.operatingSystem,
+        ["plugin-version" /* PluginVersion */]: environment.plugin.version ?? UNKNOWN
+      },
+      gitHubRepo: params.gitHubRepo,
+      template: BUG_REPORT_ISSUE_FORM_TEMPLATE,
+      ...params.title !== void 0 && { title: params.title }
+    });
+  }
+  const fullUrl = buildUrl(environmentText);
+  return fullUrl.length <= (params.maxUrlLength ?? DEFAULT_BUG_REPORT_MAX_URL_LENGTH) ? { clipboardText: null, url: fullUrl } : { clipboardText: environmentText, url: buildUrl(BUG_REPORT_PASTE_INSTRUCTIONS) };
+}
 function formatBugReportEnvironment(environment) {
   const enabledPlugins = environment.enabledPlugins.length === 0 ? "none" : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(", ");
   return `- Plugin: ${formatPluginInfo(environment.plugin)}
@@ -68,17 +93,12 @@ async function getBugReportEnvironment(params) {
 }
 async function getBugReportIssueFormUrl(params) {
   const environment = await getBugReportEnvironment(params);
-  return getGitHubIssueFormUrl({
-    fields: {
-      ["environment" /* Environment */]: formatBugReportEnvironment(environment),
-      ["obsidian-version" /* ObsidianVersion */]: environment.obsidianVersion,
-      ["operating-system" /* OperatingSystem */]: environment.operatingSystem,
-      ["plugin-version" /* PluginVersion */]: environment.plugin.version ?? UNKNOWN
-    },
+  return buildBugReportIssueFormLink({
+    environment,
     gitHubRepo: params.gitHubRepo,
-    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,
+    maxUrlLength: Infinity,
     ...params.title !== void 0 && { title: params.title }
-  });
+  }).url;
 }
 function getGitHubIssueFormUrl(params) {
   const searchParams = new URLSearchParams({ template: params.template });
@@ -134,10 +154,13 @@ function getPluginInfo(app, pluginId) {
 }
 export {
   BUG_REPORT_ISSUE_FORM_TEMPLATE,
+  BUG_REPORT_PASTE_INSTRUCTIONS,
   BugReportIssueFormFieldId,
+  DEFAULT_BUG_REPORT_MAX_URL_LENGTH,
+  buildBugReportIssueFormLink,
   formatBugReportEnvironment,
   getBugReportEnvironment,
   getBugReportIssueFormUrl,
   getGitHubIssueFormUrl
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport type { BugReportDiagnosticSection } from './bug-report-diagnostics.ts';\n\nimport { formatBugReportDiagnostics } from './bug-report-diagnostics.ts';\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The default budget, in characters of the encoded URL, of a prefilled bug-report link.\n *\n * Measured against `github.com` on 2026-11-07, signed out: an issue-form URL up to about 6,540 characters\n * was answered with the usual redirect to the form, about 8,088 with a 502, and 8,288 and more with a 414.\n * 6,000 leaves room for a longer repository name and for a signed-in session's own limits.\n */\nexport const DEFAULT_BUG_REPORT_MAX_URL_LENGTH = 6000;\n\n/**\n * A link to a bug-report issue form, as {@link buildBugReportIssueFormLink} builds it.\n */\nexport interface BugReportIssueFormLink {\n  /**\n   * The text the user must paste into the form's environment field, when the full report did not fit the\n   * URL budget; `null` when the URL carries the whole report.\n   */\n  readonly clipboardText: null | string;\n\n  /**\n   * The link.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link buildBugReportIssueFormLink}.\n */\nexport interface BuildBugReportIssueFormLinkParams {\n  /**\n   * The diagnostics the user agreed to include, appended to the environment field.\n   */\n  readonly diagnostics?: readonly BugReportDiagnosticSection[];\n\n  /**\n   * The environment, from {@link getBugReportEnvironment}.\n   */\n  readonly environment: BugReportEnvironment;\n\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The most characters the encoded URL may have before the report moves to the clipboard.\n   *\n   * @default {@link DEFAULT_BUG_REPORT_MAX_URL_LENGTH}\n   */\n  readonly maxUrlLength?: number;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * The text the environment field holds when the report moved to the clipboard.\n */\nexport const BUG_REPORT_PASTE_INSTRUCTIONS = 'The full environment and diagnostics were copied to your clipboard because they are too long for a link. Replace this text by pasting them here.';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Builds a link to a plugin's bug-report issue form, prefilled with the environment and the given\n * diagnostics. When the encoded link would be longer than\n * {@link BuildBugReportIssueFormLinkParams.maxUrlLength}, the environment field gets\n * {@link BUG_REPORT_PASTE_INSTRUCTIONS} instead, and the full text is returned as\n * {@link BugReportIssueFormLink.clipboardText} for the caller to copy. Nothing is cut.\n *\n * @param params - The parameters.\n * @returns The link, and the text to paste when it did not fit.\n */\nexport function buildBugReportIssueFormLink(params: BuildBugReportIssueFormLinkParams): BugReportIssueFormLink {\n  const { environment } = params;\n  const diagnosticsMarkdown = formatBugReportDiagnostics(params.diagnostics ?? []);\n  const environmentText = diagnosticsMarkdown === ''\n    ? formatBugReportEnvironment(environment)\n    : `${formatBugReportEnvironment(environment)}\\n\\n${diagnosticsMarkdown}`;\n\n  function buildUrl(environmentFieldValue: string): string {\n    return getGitHubIssueFormUrl({\n      fields: {\n        [BugReportIssueFormFieldId.Environment]: environmentFieldValue,\n        [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n        [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n        [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n      },\n      gitHubRepo: params.gitHubRepo,\n      template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n      ...params.title !== undefined && { title: params.title }\n    });\n  }\n\n  const fullUrl = buildUrl(environmentText);\n  return fullUrl.length <= (params.maxUrlLength ?? DEFAULT_BUG_REPORT_MAX_URL_LENGTH) ? { clipboardText: null, url: fullUrl } : { clipboardText: environmentText, url: buildUrl(BUG_REPORT_PASTE_INSTRUCTIONS) };\n}\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return buildBugReportIssueFormLink({\n    environment,\n    gitHubRepo: params.gitHubRepo,\n    maxUrlLength: Infinity,\n    ...params.title !== undefined && { title: params.title }\n  }).url;\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}

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

@@ -26,3 +26,16 @@ import type { CanvasReference } from './reference.mjs';
  * missing or its content is not valid canvas JSON.
  */
 export declare function getCanvasReferences(app: App, pathOrFile: PathOrFile): Promise<CanvasReference[]>;
+/**
+ * Extracts the outgoing references of a canvas from its JSON content.
+ *
+ * This is {@link getCanvasReferences} without the read: use it when the content is already in hand, for example
+ * inside an `applyFileChanges` changes provider, so the references describe exactly the content the changes will be
+ * applied to.
+ *
+ * @param app - The Obsidian app instance.
+ * @param content - The canvas JSON content.
+ * @returns A {@link Promise} that resolves to the canvas references, or an empty array when the content is not valid
+ * canvas JSON.
+ */
+export declare function getCanvasReferencesFromContent(app: App, content: string): Promise<CanvasReference[]>;

package/dist/lib/esm/canvas.mjs

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

package/dist/lib/esm/command-handlers/abstract-file-command-handler.d.mts

@@ -136,39 +136,39 @@ export declare abstract class AbstractFileCommandHandler extends GlobalCommandHa
     /**
      * Gets the item name to use in the single-file menu.
      *
-     * @returns The item name, or `undefined` to use the command name.
+     * @returns The item name, or `null` to use the command name.
      */
-    protected get fileMenuItemName(): string | undefined;
+    protected get fileMenuItemName(): null | string;
     /**
      * Gets the section to use in the single-file menu.
      *
-     * @returns The section name, or `undefined` to use the plugin name.
+     * @returns The section name, or `null` to use the plugin name.
      */
-    protected get fileMenuSection(): string | undefined;
+    protected get fileMenuSection(): null | string;
     /**
      * Gets the icon to use in the single-file menu submenu.
      *
-     * @returns The icon, or `undefined` for no icon.
+     * @returns The icon, or `null` for no icon.
      */
-    protected get fileMenuSubmenuIcon(): IconName | undefined;
+    protected get fileMenuSubmenuIcon(): IconName | null;
     /**
      * Gets the item name to use in the multi-file menu.
      *
-     * @returns The item name, or `undefined` to fall back to single-file item name.
+     * @returns The item name, or `null` to fall back to single-file item name.
      */
-    protected get filesMenuItemName(): string | undefined;
+    protected get filesMenuItemName(): null | string;
     /**
      * Gets the section to use in the multi-file menu.
      *
-     * @returns The section name, or `undefined` to fall back to single-file section.
+     * @returns The section name, or `null` to fall back to single-file section.
      */
-    protected get filesMenuSection(): string | undefined;
+    protected get filesMenuSection(): null | string;
     /**
      * Gets the icon to use in the multi-file menu submenu.
      *
-     * @returns The icon, or `undefined` to fall back to single-file submenu icon.
+     * @returns The icon, or `null` to fall back to single-file submenu icon.
      */
-    protected get filesMenuSubmenuIcon(): IconName | undefined;
+    protected get filesMenuSubmenuIcon(): IconName | null;
     private _activeFileProvider?;
     private readonly _fileMenuItemName?;
     private readonly _fileMenuSection?;
@@ -247,7 +247,7 @@ export declare abstract class AbstractFileCommandHandler extends GlobalCommandHa
      *
      * @returns Whether to add to a submenu.
      */
-    protected shouldAddCommandToSubmenu(): boolean | undefined;
+    protected shouldAddCommandToSubmenu(): boolean;
     /**
      * Checks whether the command should appear in the single-file context menu.
      *