obsidian-dev-utils 101.8.0 → 102.1.0

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

@@ -65,6 +65,111 @@ export declare enum LinkStyle {
      */
     Wikilink = "Wikilink"
 }
+/**
+ * Params passed to the link converter of {@link editBacklinksSnapshot}.
+ *
+ * @typeParam TPayload - The payload recorded for each link when the snapshot was built.
+ */
+export interface BacklinkConversionParams<TPayload> {
+    /**
+     * The link being converted.
+     */
+    readonly link: Reference;
+    /**
+     * The payload captured for the link when the snapshot was built.
+     *
+     * `undefined` when the link is not in the snapshot, which can only happen if
+     * {@link EditBacklinksSnapshotParams.shouldVisitUnmatchedLinks} is `true`.
+     */
+    readonly payload: TPayload | undefined;
+    /**
+     * The path of the note holding the link.
+     */
+    readonly sourcePath: string;
+}
+/**
+ * The minimal shape {@link buildBacklinksSnapshot} reads a set of backlinks from.
+ *
+ * Both a `CustomArrayDict<Reference>` — what
+ * {@link ../obsidian/metadata-cache!getBacklinksForFileSafe | getBacklinksForFileSafe} returns — and a plain
+ * `Map<string, Reference[]>` satisfy it, so a caller can pass either without converting first.
+ */
+export interface BacklinksLike {
+    /**
+     * Returns the links the note at `key` holds, or a nullish value when it holds none.
+     *
+     * @param key - The path of the backlink-holding note.
+     * @returns The links, or a nullish value.
+     */
+    get(key: string): null | readonly Reference[] | undefined;
+    /**
+     * Returns the paths of the backlink-holding notes.
+     *
+     * @returns The paths.
+     */
+    keys(): Iterable<string>;
+}
+/**
+ * A captured snapshot of a set of backlinks: the path of each backlink-holding note, mapped to the identity
+ * keys of that note's own links to the target(s), each mapped to the payload recorded for it.
+ *
+ * The snapshot exists so that the fetch and the rewrite can happen at different moments. A rename invalidates
+ * the metadata cache for the old path, so a caller that rewrites links **after** renaming has to capture the
+ * backlinks **before** — which is why {@link editBacklinksSnapshot} takes a snapshot rather than a path.
+ *
+ * The payload is whatever the caller needs to remember per link. It is `undefined` for a single-target
+ * rewrite (the target is implied), and the old target's path for a multi-target one, where one note's links
+ * may point at several files that all moved and each link has to be resolved to its own new path.
+ *
+ * @typeParam TPayload - The payload recorded for each link.
+ */
+export type BacklinksSnapshot<TPayload> = ReadonlyMap<string, ReadonlyMap<string, TPayload>>;
+/**
+ * Params for {@link buildBacklinksSnapshot}.
+ *
+ * @typeParam TPayload - The payload recorded for each link.
+ */
+export interface BuildBacklinksSnapshotParams<TPayload> {
+    /**
+     * The backlinks to record.
+     */
+    readonly backlinks: BacklinksLike;
+    /**
+     * Computes the identity key of a link.
+     *
+     * Must be the same function passed to {@link editBacklinksSnapshot}, or no link will ever match.
+     *
+     * @default `JSON.stringify`
+     */
+    linkIdentityKeyProvider?(this: void, link: Reference): string;
+    /**
+     * Rewrites the path of a backlink-holding note as it will be **after** the operation.
+     *
+     * A note that holds a backlink can itself be renamed or moved by the same operation — including the
+     * renamed note's own self-links. Remapping here keys the snapshot by the path the rewrite will actually
+     * open.
+     *
+     * @default the identity function
+     */
+    pathRemapper?(this: void, backlinkPath: string): string;
+    /**
+     * Produces the payload to record for a link. See {@link BacklinksSnapshot} for what a payload is for.
+     *
+     * @param link - The link being recorded.
+     * @returns The payload.
+     */
+    payloadProvider(this: void, link: Reference): TPayload;
+    /**
+     * An existing snapshot to merge into, so several sets of backlinks can be accumulated into one.
+     *
+     * Merging is what makes a single rewrite pass per note possible when a note links to several moved
+     * targets: without it, calling the rewrite once per target would open — and write — the same note
+     * repeatedly.
+     *
+     * When omitted, a new snapshot is created.
+     */
+    readonly target?: MutableBacklinksSnapshot<TPayload>;
+}
 /**
  * Params for {@link convertLink}.
  */
@@ -198,6 +303,54 @@ export interface EditBacklinksParams extends EditBacklinksOptions {
      */
     readonly pathOrFile: PathOrFile;
 }
+/**
+ * Options for {@link editBacklinksSnapshot}.
+ */
+export type EditBacklinksSnapshotOptions = ProcessOptions;
+/**
+ * Parameters for {@link editBacklinksSnapshot}.
+ *
+ * @typeParam TPayload - The payload recorded for each link when the snapshot was built.
+ */
+export interface EditBacklinksSnapshotParams<TPayload> extends EditBacklinksSnapshotOptions {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The function that converts each link.
+     */
+    linkConverter(this: void, params: BacklinkConversionParams<TPayload>): Promisable<MaybeReturn<string>>;
+    /**
+     * Computes the identity key of a link.
+     *
+     * Must be the same function passed to {@link buildBacklinksSnapshot}, or no link will ever match.
+     *
+     * @default `JSON.stringify`
+     */
+    linkIdentityKeyProvider?(this: void, link: Reference): string;
+    /**
+     * An optional reporter invoked once per backlink file after its links are updated, with the running
+     * count of processed files and the total. When omitted, no progress is reported.
+     */
+    readonly linkUpdateProgressReporter?: LinkUpdateProgressReporter;
+    /**
+     * Whether the converter is also shown links that are **not** in the snapshot, with an `undefined`
+     * {@link BacklinkConversionParams.payload}.
+     *
+     * The default filters them out, which is what a plain rename wants: a link absent from the snapshot was
+     * either never the caller's to rewrite, or has already been rewritten by someone else. Set this to `true`
+     * only when the caller has its own reason to look at them — a widened match of its own, or logging a skip
+     * that would otherwise be silent.
+     *
+     * @default `false`
+     */
+    readonly shouldVisitUnmatchedLinks?: boolean;
+    /**
+     * The captured backlinks to edit.
+     */
+    readonly snapshot: BacklinksSnapshot<TPayload>;
+}
 /**
  * Parameters for {@link editLinksInContent}.
  */
@@ -537,6 +690,12 @@ export interface GenerateRawMarkdownLinkParams {
      */
     readonly url: string;
 }
+/**
+ * A {@link BacklinksSnapshot} while it is still being accumulated by {@link buildBacklinksSnapshot}.
+ *
+ * @typeParam TPayload - The payload recorded for each link.
+ */
+export type MutableBacklinksSnapshot<TPayload> = Map<string, Map<string, TPayload>>;
 /**
  * Params for {@link shouldResetAlias}.
  */
@@ -958,6 +1117,17 @@ interface UpdateLinksInContentParams {
      */
     readonly shouldUseLeadingSlashForAbsolutePaths?: boolean;
 }
+/**
+ * Records a set of backlinks into a snapshot that {@link editBacklinksSnapshot} can rewrite later.
+ *
+ * Call it once per target and pass {@link BuildBacklinksSnapshotParams.target} to accumulate several targets
+ * into one snapshot, so that a note linking to several of them is still rewritten exactly once.
+ *
+ * @typeParam TPayload - The payload recorded for each link.
+ * @param params - The parameters for building the snapshot.
+ * @returns The snapshot — {@link BuildBacklinksSnapshotParams.target} itself when one was passed.
+ */
+export declare function buildBacklinksSnapshot<TPayload>(params: BuildBacklinksSnapshotParams<TPayload>): MutableBacklinksSnapshot<TPayload>;
 /**
  * Converts a link to a new path.
  *
@@ -972,6 +1142,18 @@ export declare function convertLink(params: ConvertLinkParams): string;
  * @returns A {@link Promise} that resolves when the backlinks have been edited.
  */
 export declare function editBacklinks(params: EditBacklinksParams): Promise<void>;
+/**
+ * Edits a captured snapshot of backlinks, rewriting each backlink-holding note exactly once.
+ *
+ * The counterpart of {@link editBacklinks} for callers that cannot fetch the backlinks at rewrite time —
+ * because the rename that invalidated them has already happened — or that rewrite links to several targets
+ * at once. See {@link BacklinksSnapshot} for both cases.
+ *
+ * @typeParam TPayload - The payload recorded for each link when the snapshot was built.
+ * @param params - The parameters for editing the backlinks.
+ * @returns A {@link Promise} that resolves when the backlinks have been edited.
+ */
+export declare function editBacklinksSnapshot<TPayload>(params: EditBacklinksSnapshotParams<TPayload>): Promise<void>;
 /**
  * Edits the links for a file or path.
  *

package/dist/lib/cjs/script-utils/demo-vault-app-json.cjs

@@ -182,4 +182,4 @@ function parseDemoVaultAppJson(params) {
   findOwnedDemoVaultAppJsonSettings,
   parseDemoVaultAppJson
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/script-utils/demo-vault-app-json.d.cts

@@ -21,7 +21,7 @@
  * All four are written explicitly, never left to an Obsidian default: a vault leaning on a default changes
  * behavior when that default does.
  *
- * Kept free of both `vitest` and `adm-zip` on purpose — the coverage suite pulls in the former and the
+ * Kept free of both `vitest` and `fflate` on purpose — the coverage suite pulls in the former and the
  * archiver the latter, and neither may reach the other's environment.
  */
 /**

package/dist/lib/cjs/script-utils/demo-vault.cjs

@@ -123,11 +123,9 @@ function keepName($unknown) {
 })();
 
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -141,27 +139,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var demo_vault_exports = {};
 __export(demo_vault_exports, {
   archivePluginDemoVault: () => archivePluginDemoVault
 });
 module.exports = __toCommonJS(demo_vault_exports);
-var import_adm_zip = __toESM(__extractDefault(require('adm-zip')), 1);
+var import_fflate = require('fflate');
 var import_node_fs = require('node:fs');
 var import_promises = require('node:fs/promises');
 var import_demo_vault_naming = require('../obsidian/demo-vault-naming.cjs');
 var import_obsidian_plugin_repo_paths = require('../obsidian/plugin/obsidian-plugin-repo-paths.cjs');
 var import_path = require('../path.cjs');
 var import_demo_vault_app_json = require('./demo-vault-app-json.cjs');
+var import_fs = require('./fs.cjs');
 var import_obsidian_dev_utils_repo_paths = require('./obsidian-dev-utils-repo-paths.cjs');
 var import_root = require('./root.cjs');
 var __import_meta_url = globalThis["import.meta.url"] ?? (() => {
@@ -208,22 +199,31 @@ async function archivePluginDemoVault() {
     pluginId: manifest.id,
     version: manifest.version
   });
-  const zip = new import_adm_zip.default();
-  zip.addLocalFolder(demoVaultPath, rootFolderName);
-  injectAppJson(zip, await readCommittedAppJson(), rootFolderName);
-  injectReadmeVersion(zip, rootFolderName, manifest.version);
-  await zip.writeZipPromise(zipPath);
+  const entries = await readDemoVaultEntries({
+    demoVaultPath,
+    rootFolderName
+  });
+  injectAppJson({
+    appJson: await readCommittedAppJson(),
+    entries,
+    rootFolderName
+  });
+  injectReadmeVersion({
+    entries,
+    rootFolderName,
+    version: manifest.version
+  });
+  await (0, import_promises.writeFile)(zipPath, (0, import_fflate.zipSync)(Object.fromEntries(entries)));
   return zipPath;
 }
-function injectAppJson(zip, appJson, rootFolderName) {
+function injectAppJson(params) {
+  const {
+    appJson,
+    entries,
+    rootFolderName
+  } = params;
   const entryName = (0, import_path.join)(rootFolderName, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DotObsidian, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.AppJson);
-  const content = Buffer.from((0, import_demo_vault_app_json.buildArchivedDemoVaultAppJsonContent)({ appJson }), "utf-8");
-  const entry = zip.getEntry(entryName);
-  if (entry) {
-    zip.updateFile(entry, content);
-    return;
-  }
-  zip.addFile(entryName, content);
+  entries.set(entryName, Buffer.from((0, import_demo_vault_app_json.buildArchivedDemoVaultAppJsonContent)({ appJson }), "utf-8"));
 }
 async function injectDemoVaultHelper(demoedPluginId) {
   const packageFolder = (0, import_root.getRootFolder)((0, import_path.getFolderName)(__import_meta_url));
@@ -245,17 +245,23 @@ async function injectDemoVaultHelper(demoedPluginId) {
   await (0, import_promises.writeFile)((0, import_path.join)(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}
 `, "utf-8");
 }
-function injectReadmeVersion(zip, rootFolderName, version) {
-  const entry = zip.getEntry((0, import_path.join)(rootFolderName, README_FILE_NAME));
+function injectReadmeVersion(params) {
+  const {
+    entries,
+    rootFolderName,
+    version
+  } = params;
+  const entryName = (0, import_path.join)(rootFolderName, README_FILE_NAME);
+  const entry = entries.get(entryName);
   if (!entry) {
     return;
   }
-  const content = entry.getData().toString("utf-8");
+  const content = entry.toString("utf-8");
   const versionedContent = content.replace(OPENING_HEADING_REG_EXP, (heading) => `${heading} v${version}`);
   if (versionedContent === content) {
     return;
   }
-  zip.updateFile(entry, Buffer.from(versionedContent, "utf-8"));
+  entries.set(entryName, Buffer.from(versionedContent, "utf-8"));
 }
 async function readCommittedAppJson() {
   const appJsonPath = (0, import_root.resolvePathFromRootSafe)({
@@ -271,8 +277,23 @@ async function readCommittedAppJson() {
   }
   return appJson;
 }
+async function readDemoVaultEntries(params) {
+  const {
+    demoVaultPath,
+    rootFolderName
+  } = params;
+  const entries = /* @__PURE__ */ new Map();
+  for (const dirent of await (0, import_fs.readdirPosix)(demoVaultPath, { recursive: true, withFileTypes: true })) {
+    if (!dirent.isFile()) {
+      continue;
+    }
+    const path = (0, import_path.join)(dirent.parentPath, dirent.name);
+    entries.set((0, import_path.join)(rootFolderName, (0, import_path.relative)(demoVaultPath, path)), await (0, import_promises.readFile)(path));
+  }
+  return entries;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   archivePluginDemoVault
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (() => {\n      if (typeof __filename === 'string') {\n        const localRequire = require;\n        const url = localRequire('node:url');\n        if (typeof url.pathToFileURL === 'function') {\n          return url.pathToFileURL(__filename).href;\n        }\n      }\n\n      if (typeof window !== 'undefined') {\n        return activeWindow.location.href;\n      }\n\n      // Fallback to an empty string if the environment is unknown\n      return '';\n    })();\n/**\n * @file\n *\n * Archives a plugin's demo vault as a release artifact.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this\n * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and\n * zips the whole vault into `dist/build/<plugin-id>-demo-vault.zip`, so the existing GitHub-release\n * step (which uploads every file in `dist/build/`) attaches it automatically.\n *\n * The version is deliberately absent from that name and lives INSIDE the archive instead \u2014 see\n * `obsidian/demo-vault-naming.ts` for why \u2014 in the two places a person actually meets it: the vault\n * sits under a single `<plugin-id>-demo-vault-<version>/` folder, so unzipping several releases by hand\n * into one folder neither collides nor produces anonymous directories, and the vault's `README.md`\n * heading gains the version it demonstrates.\n *\n * The archived copy also carries the `.obsidian/app.json` settings this package owns (see\n * `demo-vault-app-json.ts`). Those settings and the README heading are written into the ZIP ENTRY and\n * never into the repo folder: both files are tracked, and `updateVersion` archives after it has already\n * pushed, so an in-place write would leave an uncommitted change behind a published release.\n */\n\nimport AdmZip from 'adm-zip';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type { DemoVaultHelperSettings } from '../obsidian/demo-vault-helper-settings.ts';\nimport type { DemoVaultAppJson } from './demo-vault-app-json.ts';\n\nimport {\n  getDemoVaultArchiveFileName,\n  getDemoVaultFolderName\n} from '../obsidian/demo-vault-naming.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join\n} from '../path.ts';\nimport {\n  buildArchivedDemoVaultAppJsonContent,\n  findOwnedDemoVaultAppJsonSettings,\n  parseDemoVaultAppJson\n} from './demo-vault-app-json.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport {\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\nconst DATA_JSON_FILE_NAME = 'data.json';\nconst DATA_JSON_INDENT = 2;\nconst README_FILE_NAME = 'README.md';\n\n// The README's opening `# H1`, and only that one: without the `m` flag the match is anchored to the start\n// Of the file, and `.` stops at the newline that ends the line.\nconst OPENING_HEADING_REG_EXP = /^# .*/;\n\n/**\n * The minimal shape of a plugin `manifest.json` read by {@link archivePluginDemoVault}.\n */\ninterface PluginManifest {\n  /**\n   * The plugin id, used as the folder name under `demo-vault/.obsidian/plugins/`.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin version, embedded in the archive's top-level folder name and its README heading.\n   */\n  readonly version: string;\n}\n\n/**\n * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.\n *\n * Installs the freshly built plugin from `dist/build/` into the vault's\n * `.obsidian/plugins/<id>/` folder, then zips the whole vault to\n * `dist/build/<plugin-id>-demo-vault.zip`, under a single `<plugin-id>-demo-vault-<version>/` folder.\n *\n * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or\n * `null` if the repo has no `demo-vault/` folder.\n */\nexport async function archivePluginDemoVault(): Promise<null | string> {\n  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });\n  if (!existsSync(demoVaultPath)) {\n    return null;\n  }\n\n  const manifestPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson });\n  const manifest = JSON.parse(await readFile(manifestPath, 'utf-8')) as PluginManifest;\n\n  const pluginFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      manifest.id\n    )\n  });\n  await mkdir(pluginFolder, { recursive: true });\n\n  const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });\n  await cp(distBuildPath, pluginFolder, { recursive: true });\n\n  await injectDemoVaultHelper(manifest.id);\n\n  const zipPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DistBuild, getDemoVaultArchiveFileName(manifest.id))\n  });\n  const rootFolderName = getDemoVaultFolderName({\n    pluginId: manifest.id,\n    version: manifest.version\n  });\n  const zip = new AdmZip();\n  zip.addLocalFolder(demoVaultPath, rootFolderName);\n  injectAppJson(zip, await readCommittedAppJson(), rootFolderName);\n  injectReadmeVersion(zip, rootFolderName, manifest.version);\n  await zip.writeZipPromise(zipPath);\n  return zipPath;\n}\n\n// Stores the archived vault's `.obsidian/app.json` \u2014 the committed settings with the owned ones merged\n// Over them. The entry is replaced rather than the file, so the repo folder is left exactly as it was.\nfunction injectAppJson(zip: AdmZip, appJson: DemoVaultAppJson, rootFolderName: string): void {\n  const entryName = join(rootFolderName, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);\n  const content = Buffer.from(buildArchivedDemoVaultAppJsonContent({ appJson }), 'utf-8');\n  const entry = zip.getEntry(entryName);\n  if (entry) {\n    zip.updateFile(entry, content);\n    return;\n  }\n\n  // A vault with nothing else to configure commits no `app.json` at all, which is the expected state.\n  zip.addFile(entryName, content);\n}\n\n// Injects the built, `obsidian-dev-utils`-owned `demo-vault-helper` bootstrap plugin (shipped in this package) into the demo vault, so no per-vault copy is committed and an `obsidian-dev-utils` bump propagates fixes.\n//\n// Alongside the binaries it writes the helper's own `data.json` naming the demonstrated plugin. That is\n// The one moment the id is known for certain \u2014 it comes from the plugin's own manifest \u2014 whereas the\n// Opened vault only offers plugin folders to count, which the bootstrap itself adds to (see\n// `DemoVaultHelperSettings`).\nasync function injectDemoVaultHelper(demoedPluginId: string): Promise<void> {\n  const packageFolder = getRootFolder(getFolderName(import.meta.url));\n  if (!packageFolder) {\n    throw new Error('Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.');\n  }\n\n  const helperSourcePath = join(packageFolder, ObsidianDevUtilsRepoPaths.DistDemoVaultHelper);\n  const helperFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      DEMO_VAULT_HELPER_PLUGIN_ID\n    )\n  });\n  await mkdir(helperFolder, { recursive: true });\n  await cp(helperSourcePath, helperFolder, { recursive: true });\n\n  const settings: DemoVaultHelperSettings = { demoedPluginId };\n  await writeFile(join(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}\\n`, 'utf-8');\n}\n\n// Names the version on the archived `README.md`'s heading, so the vault says which release it demonstrates\n// However far it travels from the release page it was downloaded from.\n//\n// Entry-only, for the same reason `injectAppJson` is: the committed README is a tracked, hand-authored\n// File and `updateVersion` archives after it has already pushed.\n//\n// A vault that ships no README, or one opening on something other than an `# H1`, is left alone rather\n// Than corrected. The demo-vault coverage suite exempts `README.md` from its H1 check, so neither shape\n// Is a defect \u2014 and a release is the wrong moment to start failing on one.\nfunction injectReadmeVersion(zip: AdmZip, rootFolderName: string, version: string): void {\n  const entry = zip.getEntry(join(rootFolderName, README_FILE_NAME));\n  if (!entry) {\n    return;\n  }\n\n  const content = entry.getData().toString('utf-8');\n  const versionedContent = content.replace(OPENING_HEADING_REG_EXP, (heading) => `${heading} v${version}`);\n  if (versionedContent === content) {\n    return;\n  }\n\n  zip.updateFile(entry, Buffer.from(versionedContent, 'utf-8'));\n}\n\n// Reads the demo vault's committed `.obsidian/app.json`, refusing the settings this package owns.\n//\n// Those settings are injected into the archive, so a committed one is a second source of truth that\n// Nothing keeps in step. The demo-vault coverage suite already fails on it, which means reaching here\n// Means that gate was skipped \u2014 so this refuses rather than overwriting a value somebody chose on purpose.\nasync function readCommittedAppJson(): Promise<DemoVaultAppJson> {\n  const appJsonPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DemoVault, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson)\n  });\n  const content = existsSync(appJsonPath) ? await readFile(appJsonPath, 'utf-8') : null;\n  const appJson = parseDemoVaultAppJson({ content, path: appJsonPath });\n\n  const ownedSettings = findOwnedDemoVaultAppJsonSettings({ appJson });\n  if (ownedSettings.length > 0) {\n    throw new Error(\n      `${appJsonPath} sets ${ownedSettings.join(', ')}, which obsidian-dev-utils owns and writes into the archived demo vault. Settings it owns must not be committed.`\n    );\n  }\n\n  return appJson;\n}\n"],
  "mappings": "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",
  "names": ["AdmZip"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault.ts"],
  "sourcesContent": ["var __import_meta_url = globalThis['import.meta.url'] ?? (() => {\n      if (typeof __filename === 'string') {\n        const localRequire = require;\n        const url = localRequire('node:url');\n        if (typeof url.pathToFileURL === 'function') {\n          return url.pathToFileURL(__filename).href;\n        }\n      }\n\n      if (typeof window !== 'undefined') {\n        return activeWindow.location.href;\n      }\n\n      // Fallback to an empty string if the environment is unknown\n      return '';\n    })();\n/**\n * @file\n *\n * Archives a plugin's demo vault as a release artifact.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this\n * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and\n * zips the whole vault into `dist/build/<plugin-id>-demo-vault.zip`, so the existing GitHub-release\n * step (which uploads every file in `dist/build/`) attaches it automatically.\n *\n * The version is deliberately absent from that name and lives INSIDE the archive instead \u2014 see\n * `obsidian/demo-vault-naming.ts` for why \u2014 in the two places a person actually meets it: the vault\n * sits under a single `<plugin-id>-demo-vault-<version>/` folder, so unzipping several releases by hand\n * into one folder neither collides nor produces anonymous directories, and the vault's `README.md`\n * heading gains the version it demonstrates.\n *\n * The archived copy also carries the `.obsidian/app.json` settings this package owns (see\n * `demo-vault-app-json.ts`). Those settings and the README heading are written into the ZIP ENTRY and\n * never into the repo folder: both files are tracked, and `updateVersion` archives after it has already\n * pushed, so an in-place write would leave an uncommitted change behind a published release.\n */\n\nimport { zipSync } from 'fflate';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  writeFile\n} from 'node:fs/promises';\n\nimport type { DemoVaultHelperSettings } from '../obsidian/demo-vault-helper-settings.ts';\nimport type { DemoVaultAppJson } from './demo-vault-app-json.ts';\n\nimport {\n  getDemoVaultArchiveFileName,\n  getDemoVaultFolderName\n} from '../obsidian/demo-vault-naming.ts';\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join,\n  relative\n} from '../path.ts';\nimport {\n  buildArchivedDemoVaultAppJsonContent,\n  findOwnedDemoVaultAppJsonSettings,\n  parseDemoVaultAppJson\n} from './demo-vault-app-json.ts';\nimport { readdirPosix } from './fs.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport {\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\nconst DATA_JSON_FILE_NAME = 'data.json';\nconst DATA_JSON_INDENT = 2;\nconst README_FILE_NAME = 'README.md';\n\n// The README's opening `# H1`, and only that one: without the `m` flag the match is anchored to the start\n// Of the file, and `.` stops at the newline that ends the line.\nconst OPENING_HEADING_REG_EXP = /^# .*/;\n\n/**\n * The archive's entries, keyed by the name each one takes inside the ZIP.\n *\n * The whole archive is assembled as this map and serialized once, so injecting an entry is an ordinary\n * `set` rather than a mutation of a half-built archive object.\n */\ntype DemoVaultZipEntries = Map<string, Buffer>;\n\n/**\n * Parameters for {@link injectAppJson}.\n */\ninterface InjectAppJsonParams {\n  /**\n   * The committed settings the owned ones are merged over.\n   */\n  readonly appJson: DemoVaultAppJson;\n\n  /**\n   * The archive's entries, edited in place.\n   */\n  readonly entries: DemoVaultZipEntries;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n}\n\n/**\n * Parameters for {@link injectReadmeVersion}.\n */\ninterface InjectReadmeVersionParams {\n  /**\n   * The archive's entries, edited in place.\n   */\n  readonly entries: DemoVaultZipEntries;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n\n  /**\n   * The plugin version the vault demonstrates.\n   */\n  readonly version: string;\n}\n\n/**\n * The minimal shape of a plugin `manifest.json` read by {@link archivePluginDemoVault}.\n */\ninterface PluginManifest {\n  /**\n   * The plugin id, used as the folder name under `demo-vault/.obsidian/plugins/`.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin version, embedded in the archive's top-level folder name and its README heading.\n   */\n  readonly version: string;\n}\n\n/**\n * Parameters for {@link readDemoVaultEntries}.\n */\ninterface ReadDemoVaultEntriesParams {\n  /**\n   * The vault folder to read, as an absolute path.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * The archive's single top-level folder, which every entry name is relative to.\n   */\n  readonly rootFolderName: string;\n}\n\n/**\n * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.\n *\n * Installs the freshly built plugin from `dist/build/` into the vault's\n * `.obsidian/plugins/<id>/` folder, then zips the whole vault to\n * `dist/build/<plugin-id>-demo-vault.zip`, under a single `<plugin-id>-demo-vault-<version>/` folder.\n *\n * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or\n * `null` if the repo has no `demo-vault/` folder.\n */\nexport async function archivePluginDemoVault(): Promise<null | string> {\n  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });\n  if (!existsSync(demoVaultPath)) {\n    return null;\n  }\n\n  const manifestPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.ManifestJson });\n  const manifest = JSON.parse(await readFile(manifestPath, 'utf-8')) as PluginManifest;\n\n  const pluginFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      manifest.id\n    )\n  });\n  await mkdir(pluginFolder, { recursive: true });\n\n  const distBuildPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DistBuild });\n  await cp(distBuildPath, pluginFolder, { recursive: true });\n\n  await injectDemoVaultHelper(manifest.id);\n\n  const zipPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DistBuild, getDemoVaultArchiveFileName(manifest.id))\n  });\n  const rootFolderName = getDemoVaultFolderName({\n    pluginId: manifest.id,\n    version: manifest.version\n  });\n  const entries = await readDemoVaultEntries({\n    demoVaultPath,\n    rootFolderName\n  });\n  injectAppJson({\n    appJson: await readCommittedAppJson(),\n    entries,\n    rootFolderName\n  });\n  injectReadmeVersion({\n    entries,\n    rootFolderName,\n    version: manifest.version\n  });\n  // Every entry is stamped with the moment the archive is built rather than the file's own mtime, which is\n  // What the previous archiver wrote. A demo vault's committed timestamps are checkout artifacts of whoever\n  // Ran the release, so they carry nothing a reader could use; the build time at least describes the\n  // Archive.\n  await writeFile(zipPath, zipSync(Object.fromEntries(entries)));\n  return zipPath;\n}\n\n// Stores the archived vault's `.obsidian/app.json` \u2014 the committed settings with the owned ones merged\n// Over them. The ENTRY is written rather than the file, so the repo folder is left exactly as it was, and\n// A vault with nothing else to configure \u2014 which commits no `app.json` at all \u2014 gets one here regardless.\nfunction injectAppJson(params: InjectAppJsonParams): void {\n  const {\n    appJson,\n    entries,\n    rootFolderName\n  } = params;\n\n  const entryName = join(rootFolderName, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);\n  entries.set(entryName, Buffer.from(buildArchivedDemoVaultAppJsonContent({ appJson }), 'utf-8'));\n}\n\n// Injects the built, `obsidian-dev-utils`-owned `demo-vault-helper` bootstrap plugin (shipped in this package) into the demo vault, so no per-vault copy is committed and an `obsidian-dev-utils` bump propagates fixes.\n//\n// Alongside the binaries it writes the helper's own `data.json` naming the demonstrated plugin. That is\n// The one moment the id is known for certain \u2014 it comes from the plugin's own manifest \u2014 whereas the\n// Opened vault only offers plugin folders to count, which the bootstrap itself adds to (see\n// `DemoVaultHelperSettings`).\nasync function injectDemoVaultHelper(demoedPluginId: string): Promise<void> {\n  const packageFolder = getRootFolder(getFolderName(import.meta.url));\n  if (!packageFolder) {\n    throw new Error('Could not resolve the obsidian-dev-utils package folder to inject the demo-vault-helper plugin.');\n  }\n\n  const helperSourcePath = join(packageFolder, ObsidianDevUtilsRepoPaths.DistDemoVaultHelper);\n  const helperFolder = resolvePathFromRootSafe({\n    path: join(\n      ObsidianPluginRepoPaths.DemoVault,\n      ObsidianPluginRepoPaths.DotObsidian,\n      ObsidianPluginRepoPaths.Plugins,\n      DEMO_VAULT_HELPER_PLUGIN_ID\n    )\n  });\n  await mkdir(helperFolder, { recursive: true });\n  await cp(helperSourcePath, helperFolder, { recursive: true });\n\n  const settings: DemoVaultHelperSettings = { demoedPluginId };\n  await writeFile(join(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}\\n`, 'utf-8');\n}\n\n// Names the version on the archived `README.md`'s heading, so the vault says which release it demonstrates\n// However far it travels from the release page it was downloaded from.\n//\n// Entry-only, for the same reason `injectAppJson` is: the committed README is a tracked, hand-authored\n// File and `updateVersion` archives after it has already pushed.\n//\n// A vault that ships no README, or one opening on something other than an `# H1`, is left alone rather\n// Than corrected. The demo-vault coverage suite exempts `README.md` from its H1 check, so neither shape\n// Is a defect \u2014 and a release is the wrong moment to start failing on one.\nfunction injectReadmeVersion(params: InjectReadmeVersionParams): void {\n  const {\n    entries,\n    rootFolderName,\n    version\n  } = params;\n\n  const entryName = join(rootFolderName, README_FILE_NAME);\n  const entry = entries.get(entryName);\n  if (!entry) {\n    return;\n  }\n\n  const content = entry.toString('utf-8');\n  const versionedContent = content.replace(OPENING_HEADING_REG_EXP, (heading) => `${heading} v${version}`);\n  if (versionedContent === content) {\n    return;\n  }\n\n  entries.set(entryName, Buffer.from(versionedContent, 'utf-8'));\n}\n\n// Reads the demo vault's committed `.obsidian/app.json`, refusing the settings this package owns.\n//\n// Those settings are injected into the archive, so a committed one is a second source of truth that\n// Nothing keeps in step. The demo-vault coverage suite already fails on it, which means reaching here\n// Means that gate was skipped \u2014 so this refuses rather than overwriting a value somebody chose on purpose.\nasync function readCommittedAppJson(): Promise<DemoVaultAppJson> {\n  const appJsonPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DemoVault, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson)\n  });\n  const content = existsSync(appJsonPath) ? await readFile(appJsonPath, 'utf-8') : null;\n  const appJson = parseDemoVaultAppJson({ content, path: appJsonPath });\n\n  const ownedSettings = findOwnedDemoVaultAppJsonSettings({ appJson });\n  if (ownedSettings.length > 0) {\n    throw new Error(\n      `${appJsonPath} sets ${ownedSettings.join(', ')}, which obsidian-dev-utils owns and writes into the archived demo vault. Settings it owns must not be committed.`\n    );\n  }\n\n  return appJson;\n}\n\n// Reads every file in the demo vault as an archive entry, under the single top-level folder the archive\n// Sits in.\n//\n// Only FILES become entries. Git cannot track an empty folder, so a committed demo vault has none \u2014 and\n// `extractZipArchive` creates an entry's parent folders whether or not the archive declared them, so a\n// Folder entry would earn nothing even if one could exist.\nasync function readDemoVaultEntries(params: ReadDemoVaultEntriesParams): Promise<DemoVaultZipEntries> {\n  const {\n    demoVaultPath,\n    rootFolderName\n  } = params;\n\n  const entries: DemoVaultZipEntries = new Map<string, Buffer>();\n  for (const dirent of await readdirPosix(demoVaultPath, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = join(dirent.parentPath, dirent.name);\n    entries.set(join(rootFolderName, relative(demoVaultPath, path)), await readFile(path));\n  }\n\n  return entries;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsCA,oBAAwB;AACxB,qBAA2B;AAC3B,sBAKO;AAKP,+BAGO;AACP,wCAAwC;AACxC,kBAIO;AACP,iCAIO;AACP,gBAA6B;AAC7B,2CAA0C;AAC1C,kBAGO;AAtEP,IAAI,oBAAoB,WAAW,iBAAiB,MAAM,MAAM;AAC1D,MAAI,OAAO,eAAe,UAAU;AAClC,UAAM,eAAe;AACrB,UAAM,MAAM,aAAa,UAAU;AACnC,QAAI,OAAO,IAAI,kBAAkB,YAAY;AAC3C,aAAO,IAAI,cAAc,UAAU,EAAE;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,aAAa,SAAS;AAAA,EAC/B;AAGA,SAAO;AACT,GAAG;AAyDP,MAAM,8BAA8B;AACpC,MAAM,sBAAsB;AAC5B,MAAM,mBAAmB;AACzB,MAAM,mBAAmB;AAIzB,MAAM,0BAA0B;AA0FhC,eAAsB,yBAAiD;AACrE,QAAM,oBAAgB,qCAAwB,EAAE,MAAM,0DAAwB,UAAU,CAAC;AACzF,MAAI,KAAC,2BAAW,aAAa,GAAG;AAC9B,WAAO;AAAA,EACT;AAEA,QAAM,mBAAe,qCAAwB,EAAE,MAAM,0DAAwB,aAAa,CAAC;AAC3F,QAAM,WAAW,KAAK,MAAM,UAAM,0BAAS,cAAc,OAAO,CAAC;AAEjE,QAAM,mBAAe,qCAAwB;AAAA,IAC3C,UAAM;AAAA,MACJ,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,SAAS;AAAA,IACX;AAAA,EACF,CAAC;AACD,YAAM,uBAAM,cAAc,EAAE,WAAW,KAAK,CAAC;AAE7C,QAAM,oBAAgB,qCAAwB,EAAE,MAAM,0DAAwB,UAAU,CAAC;AACzF,YAAM,oBAAG,eAAe,cAAc,EAAE,WAAW,KAAK,CAAC;AAEzD,QAAM,sBAAsB,SAAS,EAAE;AAEvC,QAAM,cAAU,qCAAwB;AAAA,IACtC,UAAM,kBAAK,0DAAwB,eAAW,sDAA4B,SAAS,EAAE,CAAC;AAAA,EACxF,CAAC;AACD,QAAM,qBAAiB,iDAAuB;AAAA,IAC5C,UAAU,SAAS;AAAA,IACnB,SAAS,SAAS;AAAA,EACpB,CAAC;AACD,QAAM,UAAU,MAAM,qBAAqB;AAAA,IACzC;AAAA,IACA;AAAA,EACF,CAAC;AACD,gBAAc;AAAA,IACZ,SAAS,MAAM,qBAAqB;AAAA,IACpC;AAAA,IACA;AAAA,EACF,CAAC;AACD,sBAAoB;AAAA,IAClB;AAAA,IACA;AAAA,IACA,SAAS,SAAS;AAAA,EACpB,CAAC;AAKD,YAAM,2BAAU,aAAS,uBAAQ,OAAO,YAAY,OAAO,CAAC,CAAC;AAC7D,SAAO;AACT;AAKA,SAAS,cAAc,QAAmC;AACxD,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,gBAAY,kBAAK,gBAAgB,0DAAwB,aAAa,0DAAwB,OAAO;AAC3G,UAAQ,IAAI,WAAW,OAAO,SAAK,iEAAqC,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC;AAChG;AAQA,eAAe,sBAAsB,gBAAuC;AAC1E,QAAM,oBAAgB,+BAAc,2BAAc,iBAAe,CAAC;AAClE,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI,MAAM,iGAAiG;AAAA,EACnH;AAEA,QAAM,uBAAmB,kBAAK,eAAe,+DAA0B,mBAAmB;AAC1F,QAAM,mBAAe,qCAAwB;AAAA,IAC3C,UAAM;AAAA,MACJ,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB,0DAAwB;AAAA,MACxB;AAAA,IACF;AAAA,EACF,CAAC;AACD,YAAM,uBAAM,cAAc,EAAE,WAAW,KAAK,CAAC;AAC7C,YAAM,oBAAG,kBAAkB,cAAc,EAAE,WAAW,KAAK,CAAC;AAE5D,QAAM,WAAoC,EAAE,eAAe;AAC3D,YAAM,+BAAU,kBAAK,cAAc,mBAAmB,GAAG,GAAG,KAAK,UAAU,UAAU,MAAM,gBAAgB,CAAC;AAAA,GAAM,OAAO;AAC3H;AAWA,SAAS,oBAAoB,QAAyC;AACpE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,gBAAY,kBAAK,gBAAgB,gBAAgB;AACvD,QAAM,QAAQ,QAAQ,IAAI,SAAS;AACnC,MAAI,CAAC,OAAO;AACV;AAAA,EACF;AAEA,QAAM,UAAU,MAAM,SAAS,OAAO;AACtC,QAAM,mBAAmB,QAAQ,QAAQ,yBAAyB,CAAC,YAAY,GAAG,OAAO,KAAK,OAAO,EAAE;AACvG,MAAI,qBAAqB,SAAS;AAChC;AAAA,EACF;AAEA,UAAQ,IAAI,WAAW,OAAO,KAAK,kBAAkB,OAAO,CAAC;AAC/D;AAOA,eAAe,uBAAkD;AAC/D,QAAM,kBAAc,qCAAwB;AAAA,IAC1C,UAAM,kBAAK,0DAAwB,WAAW,0DAAwB,aAAa,0DAAwB,OAAO;AAAA,EACpH,CAAC;AACD,QAAM,cAAU,2BAAW,WAAW,IAAI,UAAM,0BAAS,aAAa,OAAO,IAAI;AACjF,QAAM,cAAU,kDAAsB,EAAE,SAAS,MAAM,YAAY,CAAC;AAEpE,QAAM,oBAAgB,8DAAkC,EAAE,QAAQ,CAAC;AACnE,MAAI,cAAc,SAAS,GAAG;AAC5B,UAAM,IAAI;AAAA,MACR,GAAG,WAAW,SAAS,cAAc,KAAK,IAAI,CAAC;AAAA,IACjD;AAAA,EACF;AAEA,SAAO;AACT;AAQA,eAAe,qBAAqB,QAAkE;AACpG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,UAA+B,oBAAI,IAAoB;AAC7D,aAAW,UAAU,UAAM,wBAAa,eAAe,EAAE,WAAW,MAAM,eAAe,KAAK,CAAC,GAAG;AAChG,QAAI,CAAC,OAAO,OAAO,GAAG;AACpB;AAAA,IACF;AAEA,UAAM,WAAO,kBAAK,OAAO,YAAY,OAAO,IAAI;AAChD,YAAQ,QAAI,kBAAK,oBAAgB,sBAAS,eAAe,IAAI,CAAC,GAAG,UAAM,0BAAS,IAAI,CAAC;AAAA,EACvF;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -93,7 +93,7 @@ export { DEFAULT_NS, initI18N, t } from './obsidian/i18n/i18n.mjs';
 export { en } from './obsidian/i18n/locales/en.mjs';
 export { DEFAULT_LANGUAGE, defaultTranslationsMap } from './obsidian/i18n/locales/translations-map.mjs';
 export { isInObsidian } from './obsidian/is-in-obsidian.mjs';
-export { convertLink, editBacklinks, editLinks, editLinksInContent, extractLinkFile, fixFrontmatterMarkdownLinks, generateMarkdownLink, generateRawMarkdownLink, getGenerateMarkdownLinkDefaultParamsFns, hasAngleBrackets, hasEmbedSyntax, hasLeadingDot, hasLeadingSlash, hasWikilinkSyntax, LinkPathStyle, LinkStyle, shouldResetAlias, splitSubpath, updateFileUrlLinksInContent, updateFileUrlLinksInFile, updateLink, updateLinksInContent, updateLinksInFile } from './obsidian/link.mjs';
+export { buildBacklinksSnapshot, convertLink, editBacklinks, editBacklinksSnapshot, editLinks, editLinksInContent, extractLinkFile, fixFrontmatterMarkdownLinks, generateMarkdownLink, generateRawMarkdownLink, getGenerateMarkdownLinkDefaultParamsFns, hasAngleBrackets, hasEmbedSyntax, hasLeadingDot, hasLeadingSlash, hasWikilinkSyntax, LinkPathStyle, LinkStyle, shouldResetAlias, splitSubpath, updateFileUrlLinksInContent, updateFileUrlLinksInFile, updateLink, updateLinksInContent, updateLinksInFile } from './obsidian/link.mjs';
 export { invokeAsyncAndLog } from './obsidian/logger.mjs';
 export { loop } from './obsidian/loop.mjs';
 export { PluginMarkdownCodeBlockProcessorRegistrar } from './obsidian/markdown-code-block-processor-registrar.mjs';