obsidian-dev-utils 97.0.0 → 98.0.0

package/dist/lib/esm/obsidian/trusted-input.d.mts

@@ -0,0 +1,126 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Trusted input helpers that work on **either platform** — the documented entry point for keystrokes,
+ * pointer moves and clicks that Obsidian actually believes.
+ *
+ * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,
+ * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises
+ * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets
+ * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection
+ * round-tripped through the harness's host channel on mobile.
+ *
+ * This module **internalizes that split** (see the project `AGENTS.md` **L6**): it stays
+ * cross-platform-loadable — no platform-only module is on its import graph — and each helper defers to a
+ * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes
+ * `await clickElement({ element })` once and never a platform check.
+ *
+ * The arms remain importable directly, for a caller making a deliberate platform commitment:
+ * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and
+ * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.
+ *
+ * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's
+ * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has
+ * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane
+ * does not have to be rewritten.
+ *
+ * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on
+ * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw
+ * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.
+ * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+export type { ClickElementParams, ClickMouseParams, HoverElementParams, MouseButton, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
+/**
+ * Clicks the center of an element using **trusted** input — Electron's `sendInputEvent` on desktop, a CDP
+ * touch tap in the WebView on mobile.
+ *
+ * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /
+ * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the
+ * element's center — the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside
+ * `.cm-sizer`, so no element's center lands on it.
+ *
+ * @param params - The element to click, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickElement(params: ClickElementParams): Promise<void>;
+/**
+ * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real
+ * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.
+ *
+ * The low-level primitive: one click at one point, with no waiting for any effect — callers poll their own
+ * readiness signal. Prefer {@link clickElement} for element-relative clicks.
+ *
+ * A real context menu actually opens, so a suite driving a right click must close it (or remove the
+ * leftover `.menu` element) before the next test.
+ *
+ * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the
+ * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and
+ * `'middle'` throws.
+ *
+ * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickMouse(params: ClickMouseParams): Promise<void>;
+/**
+ * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the
+ * element actually matches `:hover`.
+ *
+ * **Desktop only** — it throws on mobile, where `:hover` has no touch equivalent.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that resolves once the element matches `:hover`.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules
+ * genuinely apply.
+ *
+ * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer
+ * {@link hoverElement} / {@link unhoverElement} for element-relative moves.
+ *
+ * **Desktop only** — it throws on mobile, which has no persistent pointer to move.
+ *
+ * @param params - The viewport coordinates to move to.
+ * @returns A {@link Promise} that resolves once the move has been injected.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real
+ * key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then
+ * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the
+ * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable
+ * characters — anything else throws rather than pressing nothing.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the key press has been injected.
+ */
+export declare function pressKey(params: PressKeyParams): Promise<void>;
+/**
+ * Types text into a CodeMirror editor using **trusted** keyboard input.
+ *
+ * Focuses the editor (caret to the end) and presses every code point of the text — the same trusted
+ * sequence a real user produces — so the text reaches the document **only if the editor genuinely holds
+ * focus**. Then it polls until the document reflects the input, or a bounded timeout elapses (the expected
+ * outcome when the editor is read-only or focus was stolen).
+ *
+ * @param params - The editor to type into and the text to type.
+ * @returns A {@link Promise} that resolves once the keystrokes have settled.
+ */
+export declare function typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;
+/**
+ * Moves the pointer to a point just outside an element's bounding box using a **trusted** pointer move,
+ * then polls until the element no longer matches `:hover`.
+ *
+ * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box
+ * is reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.
+ *
+ * **Desktop only** — it throws on mobile, for the same reason {@link hoverElement} does.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;

package/dist/lib/esm/obsidian/trusted-input.mjs

@@ -0,0 +1,85 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureBrowserProcess();
+})();
+})();
+
+import { Platform } from "obsidian";
+async function clickElement(params) {
+  const arm = await loadArm();
+  await arm.clickElement(params);
+}
+async function clickMouse(params) {
+  const arm = await loadArm();
+  await arm.clickMouse(params);
+}
+async function hoverElement(params) {
+  const arm = await loadArm();
+  await arm.hoverElement(params);
+}
+async function moveMouse(params) {
+  const arm = await loadArm();
+  await arm.moveMouse(params);
+}
+async function pressKey(params) {
+  const arm = await loadArm();
+  await arm.pressKey(params);
+}
+async function typeIntoEditor(params) {
+  const arm = await loadArm();
+  await arm.typeIntoEditor(params);
+}
+async function unhoverElement(params) {
+  const arm = await loadArm();
+  await arm.unhoverElement(params);
+}
+async function loadArm() {
+  return Platform.isDesktopApp ? await import("./desktop-trusted-input.mjs") : await import("./mobile-trusted-input.mjs");
+}
+export {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Trusted input helpers that work on **either platform** \u2014 the documented entry point for keystrokes,\n * pointer moves and clicks that Obsidian actually believes.\n *\n * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,\n * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises\n * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets\n * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection\n * round-tripped through the harness's host channel on mobile.\n *\n * This module **internalizes that split** (see the project `AGENTS.md` **L6**): it stays\n * cross-platform-loadable \u2014 no platform-only module is on its import graph \u2014 and each helper defers to a\n * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes\n * `await clickElement({ element })` once and never a platform check.\n *\n * The arms remain importable directly, for a caller making a deliberate platform commitment:\n * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and\n * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.\n *\n * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's\n * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has\n * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane\n * does not have to be rewritten.\n *\n * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on\n * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw\n * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.\n * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.\n */\n\nimport { Platform } from 'obsidian';\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MouseButton,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\n// The seven helpers both arms export, with identical signatures. Typed off the mobile arm because it\n// Exports nothing else; the desktop arm additionally exports the parameter contracts both share.\ntype TrustedInputArm = typeof import('./mobile-trusted-input.ts');\n\n/**\n * Clicks the center of an element using **trusted** input \u2014 Electron's `sendInputEvent` on desktop, a CDP\n * touch tap in the WebView on mobile.\n *\n * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /\n * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the\n * element's center \u2014 the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside\n * `.cm-sizer`, so no element's center lands on it.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.clickElement(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real\n * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * The low-level primitive: one click at one point, with no waiting for any effect \u2014 callers poll their own\n * readiness signal. Prefer {@link clickElement} for element-relative clicks.\n *\n * A real context menu actually opens, so a suite driving a right click must close it (or remove the\n * leftover `.menu` element) before the next test.\n *\n * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the\n * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and\n * `'middle'` throws.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.clickMouse(params);\n}\n\n/**\n * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the\n * element actually matches `:hover`.\n *\n * **Desktop only** \u2014 it throws on mobile, where `:hover` has no touch equivalent.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.hoverElement(params);\n}\n\n/**\n * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules\n * genuinely apply.\n *\n * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer\n * {@link hoverElement} / {@link unhoverElement} for element-relative moves.\n *\n * **Desktop only** \u2014 it throws on mobile, which has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.moveMouse(params);\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real\n * key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then\n * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the\n * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable\n * characters \u2014 anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.pressKey(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input.\n *\n * Focuses the editor (caret to the end) and presses every code point of the text \u2014 the same trusted\n * sequence a real user produces \u2014 so the text reaches the document **only if the editor genuinely holds\n * focus**. Then it polls until the document reflects the input, or a bounded timeout elapses (the expected\n * outcome when the editor is read-only or focus was stolen).\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.typeIntoEditor(params);\n}\n\n/**\n * Moves the pointer to a point just outside an element's bounding box using a **trusted** pointer move,\n * then polls until the element no longer matches `:hover`.\n *\n * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box\n * is reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * **Desktop only** \u2014 it throws on mobile, for the same reason {@link hoverElement} does.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.unhoverElement(params);\n}\n\nasync function loadArm(): Promise<TrustedInputArm> {\n  // Conditional import of the platform-only arm, at call time: neither arm is on the other platform's\n  // Load path, and the specifiers stay literal so esbuild bundles both.\n  return Platform.isDesktopApp ? await import('./desktop-trusted-input.ts') : await import('./mobile-trusted-input.ts');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAS,gBAAgB;AAuCzB,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAmBA,eAAsB,WAAW,QAAyC;AACxE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,WAAW,MAAM;AAC7B;AAWA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAcA,eAAsB,UAAU,QAAwC;AACtE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,UAAU,MAAM;AAC5B;AAcA,eAAsB,SAAS,QAAuC;AACpE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,SAAS,MAAM;AAC3B;AAaA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAcA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAEA,eAAe,UAAoC;AAGjD,SAAO,SAAS,eAAe,MAAM,OAAO,4BAA4B,IAAI,MAAM,OAAO,2BAA2B;AACtH;",
  "names": []
}


package/dist/lib/esm/script-utils/build.d.mts

@@ -23,7 +23,12 @@ export declare function buildCompile(): Promise<void>;
 /**
  * Compiles the Svelte code.
  *
+ * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig
+ * `include` patterns and filtering that list would never match: `include` lists TypeScript globs
+ * (`./src/**\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.
+ *
  * @returns A {@link Promise} that resolves when the code compiles successfully.
+ * @throws If the project has Svelte files but does not declare `svelte-check`.
  */
 export declare function buildCompileSvelte(): Promise<void>;
 /**

package/dist/lib/esm/script-utils/build.mjs

@@ -61,7 +61,9 @@ import {
   npmRunOptional,
   NpmRunOptionalResult
 } from "./npm-run.mjs";
+import { readPackageJson } from "./npm.mjs";
 import { ObsidianDevUtilsRepoPaths } from "./obsidian-dev-utils-repo-paths.mjs";
+import { resolveToolCommand } from "./package-manager.mjs";
 import {
   execFromRoot,
   getRootFolder,
@@ -81,16 +83,25 @@ async function buildCompile() {
 async function buildCompileSvelte() {
   const tsConfigPath = resolvePathFromRootSafe({ path: ObsidianDevUtilsRepoPaths.TsConfigJson });
   const tsConfig = await readJson(tsConfigPath);
-  const allFiles = await toArray(glob(tsConfig.include ?? [], { exclude: tsConfig.exclude ?? [] }));
-  const svelteFiles = allFiles.filter((file) => file.endsWith(".svelte") || file.endsWith(".svelte.js") || file.endsWith(".svelte.ts"));
-  if (svelteFiles.length === 0) {
+  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {
+    cwd: resolvePathFromRootSafe({ path: ObsidianDevUtilsRepoPaths.CurrentFolder }),
+    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]
+  }));
+  const [firstSvelteFile] = svelteFiles;
+  if (firstSvelteFile === void 0) {
     getLibDebugger("build:buildCompileSvelte")("No Svelte files found in the project, skipping Svelte compilation");
     return;
   }
-  await execFromRoot(["npx", "svelte-check", "--tsconfig", ObsidianDevUtilsRepoPaths.TsConfigJson]);
+  const packageJson = await readPackageJson();
+  if (!checkSvelteCheckDeclared(packageJson)) {
+    throw new Error(
+      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \`${SVELTE_CHECK_PACKAGE_NAME}\` is not declared in package.json. Add \`${SVELTE_CHECK_PACKAGE_NAME}\` as a devDependency to type-check the Svelte code.`
+    );
+  }
+  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), "--tsconfig", ObsidianDevUtilsRepoPaths.TsConfigJson]);
 }
 async function buildCompileTypeScript() {
-  await execFromRoot(["npx", "tsc", "--build", "--force"]);
+  await execFromRoot([...resolveToolCommand({ tool: "tsc" }), "--build", "--force"]);
   if (!areProjectTypesValid()) {
     throw new Error("TypeScript declaration validation failed.");
   }
@@ -110,6 +121,16 @@ async function buildTemplates() {
 }
 const TEMPLATE_FILE_SUFFIX = ".template";
 const NODE_MODULES_SEGMENT = "/node_modules/";
+const SVELTE_CHECK_PACKAGE_NAME = "svelte-check";
+const SVELTE_FILE_PATTERNS = [
+  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte`,
+  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte.js`,
+  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte.ts`
+];
+const SVELTE_FILE_EXCLUDE_PATTERNS = [
+  `${ObsidianDevUtilsRepoPaths.AnyPath}/${ObsidianDevUtilsRepoPaths.NodeModules}/${ObsidianDevUtilsRepoPaths.AnyPath}`,
+  `${ObsidianDevUtilsRepoPaths.AnyPath}/${ObsidianDevUtilsRepoPaths.Dist}/${ObsidianDevUtilsRepoPaths.AnyPath}`
+];
 function areProjectTypesValid() {
   const root = getRootFolder();
   if (!root) {
@@ -123,6 +144,9 @@ function areProjectTypesValid() {
     shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })
   });
 }
+function checkSvelteCheckDeclared(packageJson) {
+  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies].some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== void 0);
+}
 function shouldKeepProjectFile(params) {
   const { fileName, rootCanonical } = params;
   return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);
@@ -134,4 +158,4 @@ export {
   buildCompileTypeScript,
   buildTemplates
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/build.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type { TsConfigJson } from 'type-fest';\n\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport { toArray } from '../async.ts';\nimport { getLibDebugger } from '../debug.ts';\nimport { join } from '../path.ts';\nimport { trimStart } from '../string.ts';\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(ObsidianDevUtilsRepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: ObsidianDevUtilsRepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const allFiles = await toArray(glob(tsConfig.include ?? [], { exclude: tsConfig.exclude ?? [] }));\n  const svelteFiles = allFiles.filter((file) => file.endsWith('.svelte') || file.endsWith('.svelte.js') || file.endsWith('.svelte.ts'));\n\n  if (svelteFiles.length === 0) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  await execFromRoot(['npx', 'svelte-check', '--tsconfig', ObsidianDevUtilsRepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot(['npx', 'tsc', '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link ObsidianDevUtilsRepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(ObsidianDevUtilsRepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${ObsidianDevUtilsRepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(ObsidianDevUtilsRepoPaths.Templates, path), join(ObsidianDevUtilsRepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, ObsidianDevUtilsRepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/build.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport { toArray } from '../async.ts';\nimport { getLibDebugger } from '../debug.ts';\nimport { join } from '../path.ts';\nimport { trimStart } from '../string.ts';\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { ObsidianDevUtilsRepoPaths } from './obsidian-dev-utils-repo-paths.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(ObsidianDevUtilsRepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, \u2026), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: ObsidianDevUtilsRepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: ObsidianDevUtilsRepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', ObsidianDevUtilsRepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link ObsidianDevUtilsRepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(ObsidianDevUtilsRepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${ObsidianDevUtilsRepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(ObsidianDevUtilsRepoPaths.Templates, path), join(ObsidianDevUtilsRepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte`,\n  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte.js`,\n  `${ObsidianDevUtilsRepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${ObsidianDevUtilsRepoPaths.AnyPath}/${ObsidianDevUtilsRepoPaths.NodeModules}/${ObsidianDevUtilsRepoPaths.AnyPath}`,\n  `${ObsidianDevUtilsRepoPaths.AnyPath}/${ObsidianDevUtilsRepoPaths.Dist}/${ObsidianDevUtilsRepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, ObsidianDevUtilsRepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim \u2014 the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/script-utils/demo-vault.d.mts

@@ -6,22 +6,26 @@
  *
  * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. At release time this
  * module installs the freshly built plugin into that vault's `.obsidian/plugins/<id>/` folder and
- * zips the whole vault into `dist/build/<plugin-id>-demo-vault-<version>.zip`, so the existing
- * GitHub-release step (which uploads every file in `dist/build/`) attaches it automatically. The
- * archive name carries the plugin id (so several plugins' demo vaults never collide) and the version
- * (so each release ships its own distinctly named artifact).
+ * zips the whole vault into `dist/build/<plugin-id>-demo-vault.zip`, so the existing GitHub-release
+ * step (which uploads every file in `dist/build/`) attaches it automatically.
+ *
+ * The version is deliberately absent from that name and lives INSIDE the archive instead — see
+ * `obsidian/demo-vault-naming.ts` for why — in the two places a person actually meets it: the vault
+ * sits under a single `<plugin-id>-demo-vault-<version>/` folder, so unzipping several releases by hand
+ * into one folder neither collides nor produces anonymous directories, and the vault's `README.md`
+ * heading gains the version it demonstrates.
  *
  * The archived copy also carries the `.obsidian/app.json` settings this package owns (see
- * `demo-vault-app-json.ts`). They are written into the ZIP ENTRY and never into the repo folder: the
- * committed `app.json` is a tracked file, and `updateVersion` archives after it has already pushed, so
- * an in-place write would leave an uncommitted change behind a published release.
+ * `demo-vault-app-json.ts`). Those settings and the README heading are written into the ZIP ENTRY and
+ * never into the repo folder: both files are tracked, and `updateVersion` archives after it has already
+ * pushed, so an in-place write would leave an uncommitted change behind a published release.
  */
 /**
  * Archives the plugin's demo vault (`demo-vault/` in the repo root) as a release artifact.
  *
  * Installs the freshly built plugin from `dist/build/` into the vault's
  * `.obsidian/plugins/<id>/` folder, then zips the whole vault to
- * `dist/build/<plugin-id>-demo-vault-<version>.zip`.
+ * `dist/build/<plugin-id>-demo-vault.zip`, under a single `<plugin-id>-demo-vault-<version>/` folder.
  *
  * @returns A {@link Promise} that resolves to the absolute path of the created zip archive, or
  * `null` if the repo has no `demo-vault/` folder.

package/dist/lib/esm/script-utils/demo-vault.mjs

@@ -49,6 +49,10 @@ import {
   readFile,
   writeFile
 } from "node:fs/promises";
+import {
+  getDemoVaultArchiveFileName,
+  getDemoVaultFolderName
+} from "../obsidian/demo-vault-naming.mjs";
 import { ObsidianPluginRepoPaths } from "../obsidian/plugin/obsidian-plugin-repo-paths.mjs";
 import {
   getFolderName,
@@ -67,6 +71,8 @@ import {
 const DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
 const DATA_JSON_FILE_NAME = "data.json";
 const DATA_JSON_INDENT = 2;
+const README_FILE_NAME = "README.md";
+const OPENING_HEADING_REG_EXP = /^# .*/;
 async function archivePluginDemoVault() {
   const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });
   if (!existsSync(demoVaultPath)) {
@@ -87,16 +93,21 @@ async function archivePluginDemoVault() {
   await cp(distBuildPath, pluginFolder, { recursive: true });
   await injectDemoVaultHelper(manifest.id);
   const zipPath = resolvePathFromRootSafe({
-    path: join(ObsidianPluginRepoPaths.DistBuild, `${manifest.id}-demo-vault-${manifest.version}.zip`)
+    path: join(ObsidianPluginRepoPaths.DistBuild, getDemoVaultArchiveFileName(manifest.id))
+  });
+  const rootFolderName = getDemoVaultFolderName({
+    pluginId: manifest.id,
+    version: manifest.version
   });
   const zip = new AdmZip();
-  zip.addLocalFolder(demoVaultPath);
-  injectAppJson(zip, await readCommittedAppJson());
+  zip.addLocalFolder(demoVaultPath, rootFolderName);
+  injectAppJson(zip, await readCommittedAppJson(), rootFolderName);
+  injectReadmeVersion(zip, rootFolderName, manifest.version);
   await zip.writeZipPromise(zipPath);
   return zipPath;
 }
-function injectAppJson(zip, appJson) {
-  const entryName = join(ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);
+function injectAppJson(zip, appJson, rootFolderName) {
+  const entryName = join(rootFolderName, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson);
   const content = Buffer.from(buildArchivedDemoVaultAppJsonContent({ appJson }), "utf-8");
   const entry = zip.getEntry(entryName);
   if (entry) {
@@ -125,6 +136,18 @@ async function injectDemoVaultHelper(demoedPluginId) {
   await writeFile(join(helperFolder, DATA_JSON_FILE_NAME), `${JSON.stringify(settings, null, DATA_JSON_INDENT)}
 `, "utf-8");
 }
+function injectReadmeVersion(zip, rootFolderName, version) {
+  const entry = zip.getEntry(join(rootFolderName, README_FILE_NAME));
+  if (!entry) {
+    return;
+  }
+  const content = entry.getData().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"));
+}
 async function readCommittedAppJson() {
   const appJsonPath = resolvePathFromRootSafe({
     path: join(ObsidianPluginRepoPaths.DemoVault, ObsidianPluginRepoPaths.DotObsidian, ObsidianPluginRepoPaths.AppJson)
@@ -142,4 +165,4 @@ async function readCommittedAppJson() {
 export {
   archivePluginDemoVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault.ts"],
  "sourcesContent": ["/**\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-<version>.zip`, so the existing\n * GitHub-release step (which uploads every file in `dist/build/`) attaches it automatically. The\n * archive name carries the plugin id (so several plugins' demo vaults never collide) and the version\n * (so each release ships its own distinctly named artifact).\n *\n * The archived copy also carries the `.obsidian/app.json` settings this package owns (see\n * `demo-vault-app-json.ts`). They are written into the ZIP ENTRY and never into the repo folder: the\n * committed `app.json` is a tracked file, and `updateVersion` archives after it has already pushed, so\n * 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 { 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;\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 file name.\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-<version>.zip`.\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  // Archive name is hand-synced with the runtime `openDemoVault` opener, which downloads this exact asset name.\n  const zipPath = resolvePathFromRootSafe({\n    path: join(ObsidianPluginRepoPaths.DistBuild, `${manifest.id}-demo-vault-${manifest.version}.zip`)\n  });\n  const zip = new AdmZip();\n  zip.addLocalFolder(demoVaultPath);\n  injectAppJson(zip, await readCommittedAppJson());\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): void {\n  const entryName = join(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// 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": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault.ts"],
  "sourcesContent": ["/**\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": []
}
