obsidian-dev-utils 94.3.0 → 94.4.0

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

@@ -0,0 +1,249 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import {
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import { evalInObsidian } from "obsidian-integration-testing";
+import { getTemporaryVault } from "obsidian-integration-testing/vitest-global-setup-plugin";
+import {
+  beforeAll,
+  describe,
+  expect,
+  it
+} from "vitest";
+import { getRootFolder } from "./root.mjs";
+const CODE_SCRIPT_TOOLKIT_PLUGIN_ID = "fix-require-modules";
+const DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS = 15e3;
+const DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS = 2e4;
+const POLL_INTERVAL_IN_MILLISECONDS = 100;
+const OUTPUT_EXCERPT_LENGTH = 400;
+const DEFAULT_EXCLUDED_NOTES = ["README.md"];
+const CODE_BUTTON_FENCE_REG_EXP = /^\s*```code-button/gm;
+function formatFailures(noteName, failures) {
+  if (failures.length === 0) {
+    return "";
+  }
+  const details = failures.map((failure) => `  - "${failure.caption}" [${failure.status}]: ${failure.output.replaceAll(/\s+/g, " ").trim()}`).join("\n");
+  return `${String(failures.length)} button(s) in ${noteName} did not run cleanly:
+${details}`;
+}
+function listNotesWithButtons(demoVaultPath, excludedNotes) {
+  return readdirSync(demoVaultPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md") && !excludedNotes.has(entry.name)).map((entry) => entry.name).sort().map((name) => ({
+    buttonCount: (readFileSync(join(demoVaultPath, name), "utf-8").match(CODE_BUTTON_FENCE_REG_EXP) ?? []).length,
+    name
+  })).filter((note) => note.buttonCount > 0);
+}
+function registerDemoVaultButtonSuite(options = {}) {
+  const rootFolder = options.rootFolder ?? getRootFolder() ?? process.cwd();
+  const demoVaultPath = join(rootFolder, "demo-vault");
+  const excludedNotes = new Set(options.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);
+  const settleTimeoutInMilliseconds = options.settleTimeoutInMilliseconds ?? DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS;
+  const buttonResultTimeoutInMilliseconds = options.buttonResultTimeoutInMilliseconds ?? DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS;
+  const notes = listNotesWithButtons(demoVaultPath, excludedNotes);
+  describe("demo-vault buttons", () => {
+    beforeAll(async () => {
+      const isCodeScriptToolkitLoaded = await checkCodeScriptToolkitLoaded(settleTimeoutInMilliseconds);
+      expect(isCodeScriptToolkitLoaded, "CodeScript Toolkit did not load, so no button could render").toBe(true);
+    });
+    it("has at least one note with a code button", () => {
+      expect(notes.length).toBeGreaterThan(0);
+    });
+    for (const note of notes) {
+      it(`runs every code button in ${note.name}`, async () => {
+        const captions = await openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds);
+        expect(captions.length, `${note.name} declares ${String(note.buttonCount)} button(s) but only ${String(captions.length)} rendered`).toBeGreaterThanOrEqual(note.buttonCount);
+        const failures = [];
+        for (const caption of captions) {
+          const result = await clickButton(note.name, caption, {
+            buttonResultTimeoutInMilliseconds,
+            settleTimeoutInMilliseconds
+          });
+          if (result.status !== "ok") {
+            failures.push(result);
+          }
+        }
+        expect(failures, formatFailures(note.name, failures)).toEqual([]);
+      });
+    }
+  });
+}
+async function checkCodeScriptToolkitLoaded(timeoutInMilliseconds) {
+  return evalInObsidian({
+    async callback({ app, codeScriptToolkitPluginId, intervalInMilliseconds, lib: { waitUntil }, timeoutInMilliseconds: timeout }) {
+      if (typeof app.plugins.isEnabled === "function" && !app.plugins.isEnabled()) {
+        await app.plugins.setEnable(true);
+      }
+      if (!app.plugins.getPlugin(codeScriptToolkitPluginId)) {
+        await app.plugins.enablePlugin(codeScriptToolkitPluginId);
+      }
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: "CodeScript Toolkit never loaded",
+          predicate: () => app.plugins.getPlugin(codeScriptToolkitPluginId) !== null,
+          timeoutInMilliseconds: timeout
+        });
+      } catch {
+        return false;
+      }
+      return true;
+    },
+    input: {
+      codeScriptToolkitPluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      timeoutInMilliseconds
+    },
+    vaultPath: getTemporaryVault().path
+  });
+}
+async function clickButton(notePath, buttonCaption, timeouts) {
+  return evalInObsidian({
+    async callback({
+      app,
+      buttonResultTimeoutInMilliseconds,
+      caption,
+      intervalInMilliseconds,
+      lib: { waitUntil },
+      obsidianModule,
+      outputExcerptLength,
+      settleTimeoutInMilliseconds
+    }) {
+      function view() {
+        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
+      }
+      function previewEl() {
+        return view()?.containerEl.querySelector(":scope .markdown-preview-view") ?? null;
+      }
+      function buttons() {
+        return [...view()?.containerEl.querySelectorAll(":scope .block-language-code-button button.mod-cta") ?? []];
+      }
+      function findButton() {
+        return buttons().find((candidate) => candidate.textContent === caption);
+      }
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `code button "${caption}" never rendered`,
+          predicate: () => {
+            const scroller = previewEl();
+            if (scroller) {
+              scroller.scrollTop = scroller.scrollHeight;
+            }
+            return findButton() !== void 0;
+          },
+          timeoutInMilliseconds: settleTimeoutInMilliseconds
+        });
+      } catch {
+        return { caption, output: "", status: "timeout" };
+      }
+      const button = findButton();
+      if (!button) {
+        return { caption, output: "", status: "timeout" };
+      }
+      const block = button.closest(".block-language-code-button") ?? button.parentElement;
+      button.scrollIntoView();
+      button.click();
+      let status;
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `button "${caption}" never reported a result`,
+          predicate: () => /Executed (?:successfully|with error)/.test(block?.textContent ?? ""),
+          timeoutInMilliseconds: buttonResultTimeoutInMilliseconds
+        });
+        const text = block?.textContent ?? "";
+        if (text.includes("Executed with error")) {
+          status = "error";
+        } else if (text.includes("Executed successfully")) {
+          status = "ok";
+        } else {
+          status = "unknown";
+        }
+      } catch {
+        status = "timeout";
+      }
+      return { caption, output: (block?.textContent ?? "").slice(0, outputExcerptLength), status };
+    },
+    input: {
+      buttonResultTimeoutInMilliseconds: timeouts.buttonResultTimeoutInMilliseconds,
+      caption: buttonCaption,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      notePath,
+      outputExcerptLength: OUTPUT_EXCERPT_LENGTH,
+      settleTimeoutInMilliseconds: timeouts.settleTimeoutInMilliseconds
+    },
+    vaultPath: getTemporaryVault().path
+  });
+}
+async function openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds) {
+  return evalInObsidian({
+    async callback({ app, expectedButtonCount, intervalInMilliseconds, lib: { waitUntil }, notePath, obsidianModule, timeoutInMilliseconds }) {
+      function view() {
+        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
+      }
+      function previewEl() {
+        return view()?.containerEl.querySelector(":scope .markdown-preview-view") ?? null;
+      }
+      function captions() {
+        const rendered = [...view()?.containerEl.querySelectorAll(":scope .block-language-code-button button.mod-cta") ?? []].map((button) => button.textContent).filter((caption) => caption !== "");
+        return [...new Set(rendered)];
+      }
+      await app.workspace.openLinkText(notePath.replace(/\.md$/, ""), "", false);
+      await app.workspace.getLeaf(false).setViewState({ state: { file: notePath, mode: "preview" }, type: "markdown" });
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `"${notePath}" never mounted all ${String(expectedButtonCount)} of its buttons`,
+          predicate: () => {
+            const scroller = previewEl();
+            if (scroller) {
+              scroller.scrollTop = scroller.scrollHeight;
+            }
+            return captions().length >= expectedButtonCount;
+          },
+          timeoutInMilliseconds
+        });
+      } catch {
+      }
+      return captions();
+    },
+    input: {
+      expectedButtonCount: note.buttonCount,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      notePath: note.name,
+      timeoutInMilliseconds: settleTimeoutInMilliseconds
+    },
+    vaultPath: getTemporaryVault().path
+  });
+}
+export {
+  CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+  formatFailures,
+  listNotesWithButtons,
+  registerDemoVaultButtonSuite
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault-buttons.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A vitest suite that opens every note of a plugin's in-repo `demo-vault/`, clicks each `code-button`\n * in it against a real Obsidian, and fails on any button that errors or never reports a result.\n *\n * A demo vault's buttons are the one part of it no other gate can check. `lint:md` reads the markdown,\n * the coverage suite ({@link ./demo-vault-coverage.ts | `registerDemoVaultCoverageSuite`}) checks the\n * authoring conventions, and neither executes anything \u2014 a button whose `require('/demoSetup.ts')` path\n * is wrong, or that calls an API that has since changed shape, fails at click time and nowhere else.\n *\n * The companion half \u2014 seeding the temp vault with the demo-vault tree, its `.obsidian` config, and the\n * CodeScript Toolkit binary that turns ```` ```code-button ```` fences into buttons \u2014 is\n * `buildDemoVaultPopulate` in `obsidian-integration-testing`; hand its result to the project's\n * `globalSetup` and name CodeScript Toolkit in `enableCommunityPlugins`.\n */\n\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { evalInObsidian } from 'obsidian-integration-testing';\nimport { getTemporaryVault } from 'obsidian-integration-testing/vitest-global-setup-plugin';\nimport {\n  beforeAll,\n  describe,\n  expect,\n  it\n} from 'vitest';\n\nimport { getRootFolder } from './root.ts';\n\n/**\n * CodeScript Toolkit's manifest id. It is still the plugin's original `fix-require-modules` id, which\n * no longer matches its name \u2014 the id is published, so it cannot be changed.\n */\nexport const CODE_SCRIPT_TOOLKIT_PLUGIN_ID = 'fix-require-modules';\n\n/**\n * The outcome of clicking one button.\n */\nexport interface DemoVaultButtonResult {\n  /**\n   * The button's caption, as rendered.\n   */\n  readonly caption: string;\n\n  /**\n   * The result line CodeScript Toolkit printed under the button, truncated.\n   */\n  readonly output: string;\n\n  /**\n   * Whether the button reported success, reported an error, or never reported at all.\n   */\n  readonly status: 'error' | 'ok' | 'timeout' | 'unknown';\n}\n\n/**\n * One demo-vault note and how many buttons its source declares.\n */\nexport interface DemoVaultNote {\n  /**\n   * How many `code-button` fences the note's source declares.\n   */\n  readonly buttonCount: number;\n\n  /**\n   * The note's file name, relative to the demo vault root.\n   */\n  readonly name: string;\n}\n\n/**\n * The options for {@link registerDemoVaultButtonSuite}.\n */\nexport interface RegisterDemoVaultButtonSuiteOptions {\n  /**\n   * How long, in milliseconds, to wait for a clicked button to report a result.\n   *\n   * @default `15000`\n   */\n  readonly buttonResultTimeoutInMilliseconds?: number;\n\n  /**\n   * Note file names (relative to the demo vault root) to skip.\n   *\n   * @default `['README.md']`\n   */\n  readonly excludedNotes?: readonly string[];\n\n  /**\n   * The repository root holding `demo-vault/`.\n   *\n   * @default the resolved repo root, falling back to `process.cwd()`.\n   */\n  readonly rootFolder?: string;\n\n  /**\n   * How long, in milliseconds, to wait for a note's preview and its buttons to mount.\n   *\n   * @default `20000`\n   */\n  readonly settleTimeoutInMilliseconds?: number;\n}\n\n/**\n * The waiting budgets a single button click is allowed.\n */\ninterface ClickButtonTimeouts {\n  /**\n   * How long to wait for the clicked button to report a result.\n   */\n  readonly buttonResultTimeoutInMilliseconds: number;\n\n  /**\n   * How long to wait for the button itself to mount.\n   */\n  readonly settleTimeoutInMilliseconds: number;\n}\n\nconst DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS = 15_000;\nconst DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS = 20_000;\nconst POLL_INTERVAL_IN_MILLISECONDS = 100;\nconst OUTPUT_EXCERPT_LENGTH = 400;\n\n// `README.md` is the repo-facing page GitHub renders, not a walkthrough. `00 Start.md` is deliberately\n// NOT excluded: since T478 the landing notes carry buttons of their own.\nconst DEFAULT_EXCLUDED_NOTES = ['README.md'];\n\nconst CODE_BUTTON_FENCE_REG_EXP = /^\\s*```code-button/gm;\n\n// The rendered-button selector is `:scope .block-language-code-button button.mod-cta`. It is written\n// Out at each use site rather than held in a constant here: every closure below is serialized with\n// `toString()` and evaluated inside Obsidian, where nothing from this module's scope exists.\n\n/**\n * Builds the assertion message for a note's failing buttons.\n *\n * The captured output is included because a button's failure is a runtime one \u2014 the stack CodeScript\n * Toolkit prints under it is the only diagnosis there is.\n *\n * @param noteName - The note the buttons belong to.\n * @param failures - The failing buttons.\n * @returns The message.\n */\nexport function formatFailures(noteName: string, failures: readonly DemoVaultButtonResult[]): string {\n  if (failures.length === 0) {\n    return '';\n  }\n\n  const details = failures\n    .map((failure) => `  - \"${failure.caption}\" [${failure.status}]: ${failure.output.replaceAll(/\\s+/g, ' ').trim()}`)\n    .join('\\n');\n  return `${String(failures.length)} button(s) in ${noteName} did not run cleanly:\\n${details}`;\n}\n\n/**\n * Lists the demo vault's top-level notes that declare at least one `code-button`.\n *\n * Only the vault root is walked: `Materials/` holds fixtures the walkthroughs act on, not walkthroughs.\n *\n * @param demoVaultPath - The demo vault root.\n * @param excludedNotes - Note file names to skip.\n * @returns The notes, sorted by name.\n */\nexport function listNotesWithButtons(demoVaultPath: string, excludedNotes: ReadonlySet<string>): DemoVaultNote[] {\n  return readdirSync(demoVaultPath, { withFileTypes: true })\n    .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && !excludedNotes.has(entry.name))\n    .map((entry) => entry.name)\n    .sort()\n    .map((name) => ({\n      buttonCount: (readFileSync(join(demoVaultPath, name), 'utf-8').match(CODE_BUTTON_FENCE_REG_EXP) ?? []).length,\n      name\n    }))\n    .filter((note) => note.buttonCount > 0);\n}\n\n/* v8 ignore start -- Every assertion below runs against a real Obsidian over CDP, driven by closures this process serializes and another executes. The testable parts are listNotesWithButtons and formatFailures, which have their own unit tests. */\n/**\n * Registers a vitest suite that clicks every `code-button` in the repo's demo vault.\n *\n * One `it` per note, and one `evalInObsidian` per button: a single closure runs as one CDP\n * `Runtime.evaluate`, which the harness caps at 30 s, so a note with a dozen buttons would otherwise\n * time out as a whole rather than reporting which button failed.\n *\n * @param options - The {@link RegisterDemoVaultButtonSuiteOptions}.\n */\nexport function registerDemoVaultButtonSuite(options: RegisterDemoVaultButtonSuiteOptions = {}): void {\n  const rootFolder = options.rootFolder ?? getRootFolder() ?? process.cwd();\n  const demoVaultPath = join(rootFolder, 'demo-vault');\n  const excludedNotes = new Set(options.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);\n  const settleTimeoutInMilliseconds = options.settleTimeoutInMilliseconds ?? DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS;\n  const buttonResultTimeoutInMilliseconds = options.buttonResultTimeoutInMilliseconds ?? DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS;\n\n  const notes = listNotesWithButtons(demoVaultPath, excludedNotes);\n\n  describe('demo-vault buttons', () => {\n    beforeAll(async () => {\n      const isCodeScriptToolkitLoaded = await checkCodeScriptToolkitLoaded(settleTimeoutInMilliseconds);\n      // Without it every `code-button` fence stays a plain code block, so every note below would report\n      // Zero buttons and pass vacuously. Fail here instead, once, with the reason.\n      expect(isCodeScriptToolkitLoaded, 'CodeScript Toolkit did not load, so no button could render').toBe(true);\n    });\n\n    // A vault whose notes declare no buttons is a real failure of G98's interactive half, not a reason\n    // To register nothing and report green.\n    it('has at least one note with a code button', () => {\n      expect(notes.length).toBeGreaterThan(0);\n    });\n\n    for (const note of notes) {\n      it(`runs every code button in ${note.name}`, async () => {\n        const captions = await openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds);\n        // Reading view mounts a note's leading sections more than once while it settles, so the DOM can\n        // Hold several elements per fence. The captions are deduplicated, and the assertion is that at\n        // Least as many DISTINCT buttons rendered as the source declares \u2014 a fence that silently stayed\n        // A plain code block is the failure this catches.\n        expect(captions.length, `${note.name} declares ${String(note.buttonCount)} button(s) but only ${String(captions.length)} rendered`)\n          .toBeGreaterThanOrEqual(note.buttonCount);\n\n        const failures: DemoVaultButtonResult[] = [];\n        for (const caption of captions) {\n          const result = await clickButton(note.name, caption, {\n            buttonResultTimeoutInMilliseconds,\n            settleTimeoutInMilliseconds\n          });\n          if (result.status !== 'ok') {\n            failures.push(result);\n          }\n        }\n\n        expect(failures, formatFailures(note.name, failures)).toEqual([]);\n      });\n    }\n  });\n}\n\n/* v8 ignore stop */\n\n/* v8 ignore start -- Drives a real Obsidian over CDP: the closure is serialized here and executed in another process, so it cannot be exercised by a unit test. */\n/**\n * Turns restricted mode off and enables CodeScript Toolkit, whose binary the global setup seeded.\n *\n * @param timeoutInMilliseconds - How long to wait for it to load.\n * @returns Whether CodeScript Toolkit is loaded.\n */\nasync function checkCodeScriptToolkitLoaded(timeoutInMilliseconds: number): Promise<boolean> {\n  return evalInObsidian({\n    async callback({ app, codeScriptToolkitPluginId, intervalInMilliseconds, lib: { waitUntil }, timeoutInMilliseconds: timeout }): Promise<boolean> {\n      if (typeof app.plugins.isEnabled === 'function' && !app.plugins.isEnabled()) {\n        await app.plugins.setEnable(true);\n      }\n      if (!app.plugins.getPlugin(codeScriptToolkitPluginId)) {\n        await app.plugins.enablePlugin(codeScriptToolkitPluginId);\n      }\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: 'CodeScript Toolkit never loaded',\n          predicate: (): boolean => app.plugins.getPlugin(codeScriptToolkitPluginId) !== null,\n          timeoutInMilliseconds: timeout\n        });\n      } catch {\n        return false;\n      }\n      return true;\n    },\n    input: {\n      codeScriptToolkitPluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      timeoutInMilliseconds\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/* v8 ignore stop */\n\n/* v8 ignore start -- Drives a real Obsidian over CDP: the closure is serialized here and executed in another process, so it cannot be exercised by a unit test. */\n/**\n * Clicks one button and reads the result line CodeScript Toolkit writes under it.\n *\n * A button that re-renders its own note (a settings change, a reload) detaches the block it lives in,\n * so the block element is captured BEFORE the click and read afterwards \u2014 CodeScript Toolkit writes the\n * result into that same element even once it is detached.\n *\n * @param notePath - The note holding the button.\n * @param buttonCaption - The button's rendered caption, which is how it is addressed.\n * @param timeouts - The render and result budgets.\n * @returns The {@link DemoVaultButtonResult}.\n */\nasync function clickButton(\n  notePath: string,\n  buttonCaption: string,\n  timeouts: ClickButtonTimeouts\n): Promise<DemoVaultButtonResult> {\n  return evalInObsidian({\n    async callback({\n      app,\n      buttonResultTimeoutInMilliseconds,\n      caption,\n      intervalInMilliseconds,\n      lib: { waitUntil },\n      obsidianModule,\n      outputExcerptLength,\n      settleTimeoutInMilliseconds\n    }): Promise<DemoVaultButtonResult> {\n      function view(): InstanceType<typeof obsidianModule.MarkdownView> | null {\n        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);\n      }\n      function previewEl(): HTMLElement | null {\n        return view()?.containerEl.querySelector<HTMLElement>(':scope .markdown-preview-view') ?? null;\n      }\n      function buttons(): HTMLButtonElement[] {\n        return [...view()?.containerEl.querySelectorAll<HTMLButtonElement>(':scope .block-language-code-button button.mod-cta') ?? []];\n      }\n\n      function findButton(): HTMLButtonElement | undefined {\n        return buttons().find((candidate) => candidate.textContent === caption);\n      }\n\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `code button \"${caption}\" never rendered`,\n          predicate: (): boolean => {\n            const scroller = previewEl();\n            if (scroller) {\n              scroller.scrollTop = scroller.scrollHeight;\n            }\n            return findButton() !== undefined;\n          },\n          timeoutInMilliseconds: settleTimeoutInMilliseconds\n        });\n      } catch {\n        return { caption, output: '', status: 'timeout' };\n      }\n\n      const button = findButton();\n      if (!button) {\n        return { caption, output: '', status: 'timeout' };\n      }\n\n      const block = button.closest<HTMLElement>('.block-language-code-button') ?? button.parentElement;\n      button.scrollIntoView();\n      button.click();\n\n      let status: DemoVaultButtonResult['status'];\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `button \"${caption}\" never reported a result`,\n          predicate: (): boolean => /Executed (?:successfully|with error)/.test(block?.textContent ?? ''),\n          timeoutInMilliseconds: buttonResultTimeoutInMilliseconds\n        });\n        const text = block?.textContent ?? '';\n        if (text.includes('Executed with error')) {\n          status = 'error';\n        } else if (text.includes('Executed successfully')) {\n          status = 'ok';\n        } else {\n          status = 'unknown';\n        }\n      } catch {\n        status = 'timeout';\n      }\n\n      return { caption, output: (block?.textContent ?? '').slice(0, outputExcerptLength), status };\n    },\n    input: {\n      buttonResultTimeoutInMilliseconds: timeouts.buttonResultTimeoutInMilliseconds,\n      caption: buttonCaption,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      notePath,\n      outputExcerptLength: OUTPUT_EXCERPT_LENGTH,\n      settleTimeoutInMilliseconds: timeouts.settleTimeoutInMilliseconds\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/**\n * Opens a note in reading view and lists the captions of the buttons that mounted, deduplicated and in\n * document order.\n *\n * Two quirks of reading view shape this. It renders lazily and unmounts sections far off-screen, so the\n * preview is scrolled to the bottom while waiting or a note's last buttons never mount at all. And\n * while it settles it can hold SEVERAL elements per fence \u2014 the same button was observed rendered twice\n * \u2014 so the captions are deduplicated; clicking by caption then addresses each button once however many\n * copies of it the DOM is holding.\n *\n * @param note - The note to open.\n * @param settleTimeoutInMilliseconds - How long to wait for the buttons to mount.\n * @returns The distinct button captions.\n */\nasync function openNoteAndListButtonCaptions(note: DemoVaultNote, settleTimeoutInMilliseconds: number): Promise<string[]> {\n  return evalInObsidian({\n    async callback({ app, expectedButtonCount, intervalInMilliseconds, lib: { waitUntil }, notePath, obsidianModule, timeoutInMilliseconds }): Promise<string[]> {\n      function view(): InstanceType<typeof obsidianModule.MarkdownView> | null {\n        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);\n      }\n      function previewEl(): HTMLElement | null {\n        return view()?.containerEl.querySelector<HTMLElement>(':scope .markdown-preview-view') ?? null;\n      }\n      function captions(): string[] {\n        const rendered = [...view()?.containerEl.querySelectorAll<HTMLButtonElement>(':scope .block-language-code-button button.mod-cta') ?? []]\n          .map((button) => button.textContent)\n          .filter((caption) => caption !== '');\n        return [...new Set(rendered)];\n      }\n\n      await app.workspace.openLinkText(notePath.replace(/\\.md$/, ''), '', false);\n      await app.workspace.getLeaf(false).setViewState({ state: { file: notePath, mode: 'preview' }, type: 'markdown' });\n\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `\"${notePath}\" never mounted all ${String(expectedButtonCount)} of its buttons`,\n          predicate: (): boolean => {\n            const scroller = previewEl();\n            if (scroller) {\n              scroller.scrollTop = scroller.scrollHeight;\n            }\n            return captions().length >= expectedButtonCount;\n          },\n          timeoutInMilliseconds\n        });\n      } catch {\n        // The captions are returned either way; the caller asserts on them and reports the shortfall.\n      }\n\n      return captions();\n    },\n    input: {\n      expectedButtonCount: note.buttonCount,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      notePath: note.name,\n      timeoutInMilliseconds: settleTimeoutInMilliseconds\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -6,6 +6,7 @@ export * as 'cli-utils' from './cli-utils.mjs';
 export * as 'code-generator' from './code-generator.mjs';
 export * as 'commitlint-config' from './commitlint-config.mjs';
 export * as 'demo-vault-app-json' from './demo-vault-app-json.mjs';
+export * as 'demo-vault-buttons' from './demo-vault-buttons.mjs';
 export * as 'demo-vault-coverage' from './demo-vault-coverage.mjs';
 export * as 'demo-vault' from './demo-vault.mjs';
 export * as 'env-toggle' from './env-toggle.mjs';

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

@@ -28,6 +28,7 @@ import * as cli_utils from "./cli-utils.mjs";
 import * as code_generator from "./code-generator.mjs";
 import * as commitlint_config from "./commitlint-config.mjs";
 import * as demo_vault_app_json from "./demo-vault-app-json.mjs";
+import * as demo_vault_buttons from "./demo-vault-buttons.mjs";
 import * as demo_vault_coverage from "./demo-vault-coverage.mjs";
 import * as demo_vault from "./demo-vault.mjs";
 import * as env_toggle from "./env-toggle.mjs";
@@ -56,6 +57,7 @@ export {
   commitlint_config as "commitlint-config",
   demo_vault as "demo-vault",
   demo_vault_app_json as "demo-vault-app-json",
+  demo_vault_buttons as "demo-vault-buttons",
   demo_vault_coverage as "demo-vault-coverage",
   env_toggle as "env-toggle",
   exec,
@@ -75,4 +77,4 @@ export {
   version,
   warnings_as_errors as "warnings-as-errors"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/test-runners/vitest-config.d.mts

@@ -68,6 +68,11 @@ export declare class ObsidianPluginVitestConfigContext {
     readonly bigTimeoutInMilliseconds = 30000;
     /**
      * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.
+     *
+     * Declaration files are excluded by default because the coverage `include` below is `src/**\/*.ts`,
+     * which a `.d.ts` matches. A declaration file emits no runtime code, so it reports 0% and no test can
+     * ever raise it — a plugin that grows one under `src/` silently loses its 100% gate, and the usual
+     * remedy of an inline `v8 ignore` comment does not apply to a type-only file.
      */
     readonly coverageExclude: string[];
     /**

package/dist/lib/esm/script-utils/test-runners/vitest-config.mjs

@@ -29,6 +29,7 @@ const HOOK_TIMEOUT_MULTIPLIER = 4;
 const PERFORMANCE_TIMEOUT_IN_MILLISECONDS = 6e5;
 const ANDROID_TEST_FILES = "src/**/*.android.integration.test.ts";
 const CROSS_PLATFORM_TEST_FILES = "src/**/*.cross-platform.integration.test.ts";
+const DECLARATION_FILES = "src/**/*.d.ts";
 const DESKTOP_PERFORMANCE_TEST_FILES = "src/**/*.desktop-performance.integration.test.ts";
 const DESKTOP_TEST_FILES = "src/**/*.desktop.integration.test.ts";
 const INTEGRATION_TEST_FILES = "src/**/*.integration.test.ts";
@@ -73,8 +74,13 @@ class ObsidianPluginVitestConfigContext {
   bigTimeoutInMilliseconds = BIG_TIMEOUT_IN_MILLISECONDS;
   /**
    * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.
+   *
+   * Declaration files are excluded by default because the coverage `include` below is `src/**\/*.ts`,
+   * which a `.d.ts` matches. A declaration file emits no runtime code, so it reports 0% and no test can
+   * ever raise it — a plugin that grows one under `src/` silently loses its 100% gate, and the usual
+   * remedy of an inline `v8 ignore` comment does not apply to a type-only file.
    */
-  coverageExclude = [UNIT_TEST_FILES];
+  coverageExclude = [UNIT_TEST_FILES, DECLARATION_FILES];
   /**
    * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a
    * real desktop Obsidian over CDP.
@@ -207,4 +213,4 @@ export {
   ObsidianPluginVitestConfigContext,
   defineObsidianPluginVitestConfig
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/test-runners/vitest-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared vitest configuration for Obsidian plugins.\n *\n * Every plugin in the workspace declares the same five vitest projects \u2014 `unit-tests` plus the\n * `integration-tests:{no-app,desktop,desktop-performance,android}` family \u2014 with the same timeouts,\n * `setupFiles`, and `globalSetup` wiring. Maintaining that per repo means a convention change costs one\n * near-identical edit per plugin, and any repo that is missed drifts silently. This module owns that\n * configuration once, so a plugin's `scripts/vitest-config.ts` collapses to a single call.\n *\n * The seam mirrors {@link https://www.npmjs.com/package/obsidian-dev-utils | the ESLint one}\n * (`defineEslintConfigs`): the factory builds a context holding the standard projects, the caller edits\n * it in place through {@link DefineObsidianPluginVitestConfigOptions.editContext}, and appends any\n * project the base does not know about through\n * {@link DefineObsidianPluginVitestConfigOptions.customProjects}.\n */\n\nimport type {\n  TestProjectConfiguration,\n  TestProjectInlineConfiguration,\n  ViteUserConfig\n} from 'vitest/config';\n\nimport process from 'node:process';\nimport { defineConfig } from 'vitest/config';\n\n/**\n * The `test` section of a single vitest project entry.\n */\nexport type ObsidianPluginVitestProjectConfig = NonNullable<TestProjectInlineConfiguration['test']>;\n\nconst ANDROID_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst BIG_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst HOOK_TIMEOUT_MULTIPLIER = 4;\nconst PERFORMANCE_TIMEOUT_IN_MILLISECONDS = 600_000;\n\nconst ANDROID_TEST_FILES = 'src/**/*.android.integration.test.ts';\nconst CROSS_PLATFORM_TEST_FILES = 'src/**/*.cross-platform.integration.test.ts';\nconst DESKTOP_PERFORMANCE_TEST_FILES = 'src/**/*.desktop-performance.integration.test.ts';\nconst DESKTOP_TEST_FILES = 'src/**/*.desktop.integration.test.ts';\nconst INTEGRATION_TEST_FILES = 'src/**/*.integration.test.ts';\nconst NO_APP_TEST_FILES = 'src/**/*.no-app.integration.test.ts';\nconst UNIT_TEST_FILES = 'src/**/*.test.ts';\n\nconst OBSIDIAN_VERSION_ENV_VARIABLE_NAME = 'OBSIDIAN_VERSION';\nconst SHARED_EXCLUDE = ['node_modules', 'dist'];\n\n/**\n * The options for defining a plugin's vitest configuration.\n */\nexport interface DefineObsidianPluginVitestConfigOptions {\n  /**\n   * A function that builds projects the base configuration does not know about, such as a plugin's own\n   * `integration-tests:demo-vault` project. The returned projects are appended after the standard five.\n   *\n   * @param context - The vitest configuration context.\n   * @returns The extra projects.\n   */\n  customProjects?(context: ObsidianPluginVitestConfigContext): TestProjectConfiguration[];\n\n  /**\n   * A function that edits the vitest configuration context before it is assembled into a configuration.\n   *\n   * @param context - The vitest configuration context.\n   */\n  editContext?(context: ObsidianPluginVitestConfigContext): void;\n}\n\n/**\n * The context for defining a plugin's vitest configuration.\n *\n * Every member is live: the arrays and objects it exposes are the very ones the assembled configuration\n * is built from, so editing them in place through\n * {@link DefineObsidianPluginVitestConfigOptions.editContext} is what customizes the result.\n */\nexport class ObsidianPluginVitestConfigContext {\n  /**\n   * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an\n   * Android emulator through Appium.\n   */\n  public readonly android: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    environmentOptions: {\n      obsidianTransport: {\n        appiumUrl: 'http://localhost:4723',\n        avdName: 'obsidian_test',\n        type: 'obsidian-android-appium'\n      }\n    },\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [ANDROID_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:android',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and\n   * driving it over Appium is slower than the desktop path, hence its own constant.\n   *\n   * @default `60000`\n   */\n  public readonly androidTimeoutInMilliseconds = ANDROID_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The per-test budget of the regular integration projects, in milliseconds.\n   *\n   * @default `30000`\n   */\n  public readonly bigTimeoutInMilliseconds = BIG_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.\n   */\n  public readonly coverageExclude: string[] = [UNIT_TEST_FILES];\n\n  /**\n   * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a\n   * real desktop Obsidian over CDP.\n   */\n  public readonly desktop: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [DESKTOP_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:desktop',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for\n   * every plugin even when there is no such suite yet \u2014 `passWithNoTests` makes an empty project free,\n   * and the matching `test:integration:desktop:performance` script exists fleet-wide.\n   */\n  public readonly desktopPerformance: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS,\n    include: [DESKTOP_PERFORMANCE_TEST_FILES],\n    name: 'integration-tests:desktop-performance',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates\n   * and opens a vault, so it needs several times what a single test does.\n   *\n   * @default `4`\n   */\n  public readonly hookTimeoutMultiplier = HOOK_TIMEOUT_MULTIPLIER;\n\n  /**\n   * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.\n   */\n  public readonly noApp: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [NO_APP_TEST_FILES],\n    name: 'integration-tests:no-app',\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the performance integration project, in milliseconds. A performance vault is\n   * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests\n   * need far more time than the regular integration projects.\n   *\n   * @default `600000`\n   */\n  public readonly performanceTimeoutInMilliseconds = PERFORMANCE_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.\n   */\n  public readonly unitTests: ObsidianPluginVitestProjectConfig = {\n    environment: 'jsdom',\n    exclude: [...SHARED_EXCLUDE, INTEGRATION_TEST_FILES],\n    execArgv: ['--no-webstorage'],\n    include: [UNIT_TEST_FILES],\n    name: 'unit-tests',\n    server: {\n      // eslint-disable-next-line unicorn/name-replacements -- `deps` is declared by `vitest`; renaming it here would not match the API.\n      deps: {\n        inline: ['@obsidian-typings', 'obsidian-dev-utils']\n      }\n    },\n    setupFiles: [\n      'obsidian-test-mocks/vitest-setup',\n      'obsidian-test-mocks/obsidian-typings/vitest-setup',\n      'obsidian-dev-utils/vitest-setup'\n    ]\n  };\n\n  /**\n   * Creates a new context seeded with the standard projects.\n   */\n  public constructor() {\n    const obsidianVersion = process.env[OBSIDIAN_VERSION_ENV_VARIABLE_NAME];\n\n    /*\n     * Support is the range [latest public, latest catalyst] and BOTH ends must work (G99), so the version\n     * is a knob rather than a constant. The key is added ONLY when the variable is set: an explicit\n     * `obsidianVersion` makes the harness resolve a concrete version and swap the asar, which is not what\n     * an unpinned run does, so seeding a default here would change the behavior of every plugin.\n     */\n    if (obsidianVersion !== undefined) {\n      this.desktop.environmentOptions = {\n        obsidianTransport: {\n          obsidianVersion,\n          type: 'obsidian-cdp'\n        }\n      };\n    }\n  }\n}\n\n/**\n * Defines the vitest configuration for an Obsidian plugin.\n *\n * @param options - The options for defining the configuration.\n * @returns The vitest configuration.\n */\nexport function defineObsidianPluginVitestConfig(options: DefineObsidianPluginVitestConfigOptions = {}): ViteUserConfig {\n  const context = new ObsidianPluginVitestConfigContext();\n\n  if (options.editContext) {\n    options.editContext(context);\n  }\n\n  const customProjects = options.customProjects?.(context) ?? [];\n\n  return defineConfig({\n    test: {\n      coverage: {\n        exclude: context.coverageExclude,\n        include: ['src/**/*.ts'],\n        provider: 'v8',\n        reporter: ['text', 'lcov', 'html'],\n        reportsDirectory: './coverage'\n      },\n      exclude: [...SHARED_EXCLUDE],\n      globals: false,\n      include: [UNIT_TEST_FILES],\n      passWithNoTests: true,\n      projects: [\n        {\n          resolve: {\n            alias: {\n              obsidian: 'obsidian-test-mocks/obsidian'\n            }\n          },\n          test: context.unitTests\n        },\n        { test: context.noApp },\n        { test: context.desktop },\n        { test: context.desktopPerformance },\n        { test: context.android },\n        ...customProjects\n      ]\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/test-runners/vitest-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared vitest configuration for Obsidian plugins.\n *\n * Every plugin in the workspace declares the same five vitest projects \u2014 `unit-tests` plus the\n * `integration-tests:{no-app,desktop,desktop-performance,android}` family \u2014 with the same timeouts,\n * `setupFiles`, and `globalSetup` wiring. Maintaining that per repo means a convention change costs one\n * near-identical edit per plugin, and any repo that is missed drifts silently. This module owns that\n * configuration once, so a plugin's `scripts/vitest-config.ts` collapses to a single call.\n *\n * The seam mirrors {@link https://www.npmjs.com/package/obsidian-dev-utils | the ESLint one}\n * (`defineEslintConfigs`): the factory builds a context holding the standard projects, the caller edits\n * it in place through {@link DefineObsidianPluginVitestConfigOptions.editContext}, and appends any\n * project the base does not know about through\n * {@link DefineObsidianPluginVitestConfigOptions.customProjects}.\n */\n\nimport type {\n  TestProjectConfiguration,\n  TestProjectInlineConfiguration,\n  ViteUserConfig\n} from 'vitest/config';\n\nimport process from 'node:process';\nimport { defineConfig } from 'vitest/config';\n\n/**\n * The `test` section of a single vitest project entry.\n */\nexport type ObsidianPluginVitestProjectConfig = NonNullable<TestProjectInlineConfiguration['test']>;\n\nconst ANDROID_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst BIG_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst HOOK_TIMEOUT_MULTIPLIER = 4;\nconst PERFORMANCE_TIMEOUT_IN_MILLISECONDS = 600_000;\n\nconst ANDROID_TEST_FILES = 'src/**/*.android.integration.test.ts';\nconst CROSS_PLATFORM_TEST_FILES = 'src/**/*.cross-platform.integration.test.ts';\nconst DECLARATION_FILES = 'src/**/*.d.ts';\nconst DESKTOP_PERFORMANCE_TEST_FILES = 'src/**/*.desktop-performance.integration.test.ts';\nconst DESKTOP_TEST_FILES = 'src/**/*.desktop.integration.test.ts';\nconst INTEGRATION_TEST_FILES = 'src/**/*.integration.test.ts';\nconst NO_APP_TEST_FILES = 'src/**/*.no-app.integration.test.ts';\nconst UNIT_TEST_FILES = 'src/**/*.test.ts';\n\nconst OBSIDIAN_VERSION_ENV_VARIABLE_NAME = 'OBSIDIAN_VERSION';\nconst SHARED_EXCLUDE = ['node_modules', 'dist'];\n\n/**\n * The options for defining a plugin's vitest configuration.\n */\nexport interface DefineObsidianPluginVitestConfigOptions {\n  /**\n   * A function that builds projects the base configuration does not know about, such as a plugin's own\n   * `integration-tests:demo-vault` project. The returned projects are appended after the standard five.\n   *\n   * @param context - The vitest configuration context.\n   * @returns The extra projects.\n   */\n  customProjects?(context: ObsidianPluginVitestConfigContext): TestProjectConfiguration[];\n\n  /**\n   * A function that edits the vitest configuration context before it is assembled into a configuration.\n   *\n   * @param context - The vitest configuration context.\n   */\n  editContext?(context: ObsidianPluginVitestConfigContext): void;\n}\n\n/**\n * The context for defining a plugin's vitest configuration.\n *\n * Every member is live: the arrays and objects it exposes are the very ones the assembled configuration\n * is built from, so editing them in place through\n * {@link DefineObsidianPluginVitestConfigOptions.editContext} is what customizes the result.\n */\nexport class ObsidianPluginVitestConfigContext {\n  /**\n   * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an\n   * Android emulator through Appium.\n   */\n  public readonly android: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    environmentOptions: {\n      obsidianTransport: {\n        appiumUrl: 'http://localhost:4723',\n        avdName: 'obsidian_test',\n        type: 'obsidian-android-appium'\n      }\n    },\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [ANDROID_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:android',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: ANDROID_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and\n   * driving it over Appium is slower than the desktop path, hence its own constant.\n   *\n   * @default `60000`\n   */\n  public readonly androidTimeoutInMilliseconds = ANDROID_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The per-test budget of the regular integration projects, in milliseconds.\n   *\n   * @default `30000`\n   */\n  public readonly bigTimeoutInMilliseconds = BIG_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The coverage `exclude` globs. Push onto it to drop more files from the coverage report.\n   *\n   * Declaration files are excluded by default because the coverage `include` below is `src/**\\/*.ts`,\n   * which a `.d.ts` matches. A declaration file emits no runtime code, so it reports 0% and no test can\n   * ever raise it \u2014 a plugin that grows one under `src/` silently loses its 100% gate, and the usual\n   * remedy of an inline `v8 ignore` comment does not apply to a type-only file.\n   */\n  public readonly coverageExclude: string[] = [UNIT_TEST_FILES, DECLARATION_FILES];\n\n  /**\n   * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a\n   * real desktop Obsidian over CDP.\n   */\n  public readonly desktop: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [DESKTOP_TEST_FILES, CROSS_PLATFORM_TEST_FILES],\n    name: 'integration-tests:desktop',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for\n   * every plugin even when there is no such suite yet \u2014 `passWithNoTests` makes an empty project free,\n   * and the matching `test:integration:desktop:performance` script exists fleet-wide.\n   */\n  public readonly desktopPerformance: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    globalSetup: ['obsidian-integration-testing/vitest-global-setup-plugin'],\n    hookTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS,\n    include: [DESKTOP_PERFORMANCE_TEST_FILES],\n    name: 'integration-tests:desktop-performance',\n    setupFiles: ['obsidian-integration-testing/vitest-setup'],\n    testTimeout: PERFORMANCE_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates\n   * and opens a vault, so it needs several times what a single test does.\n   *\n   * @default `4`\n   */\n  public readonly hookTimeoutMultiplier = HOOK_TIMEOUT_MULTIPLIER;\n\n  /**\n   * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.\n   */\n  public readonly noApp: ObsidianPluginVitestProjectConfig = {\n    environment: 'node',\n    fileParallelism: false,\n    hookTimeout: BIG_TIMEOUT_IN_MILLISECONDS * HOOK_TIMEOUT_MULTIPLIER,\n    include: [NO_APP_TEST_FILES],\n    name: 'integration-tests:no-app',\n    testTimeout: BIG_TIMEOUT_IN_MILLISECONDS\n  };\n\n  /**\n   * The per-test budget of the performance integration project, in milliseconds. A performance vault is\n   * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests\n   * need far more time than the regular integration projects.\n   *\n   * @default `600000`\n   */\n  public readonly performanceTimeoutInMilliseconds = PERFORMANCE_TIMEOUT_IN_MILLISECONDS;\n\n  /**\n   * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.\n   */\n  public readonly unitTests: ObsidianPluginVitestProjectConfig = {\n    environment: 'jsdom',\n    exclude: [...SHARED_EXCLUDE, INTEGRATION_TEST_FILES],\n    execArgv: ['--no-webstorage'],\n    include: [UNIT_TEST_FILES],\n    name: 'unit-tests',\n    server: {\n      // eslint-disable-next-line unicorn/name-replacements -- `deps` is declared by `vitest`; renaming it here would not match the API.\n      deps: {\n        inline: ['@obsidian-typings', 'obsidian-dev-utils']\n      }\n    },\n    setupFiles: [\n      'obsidian-test-mocks/vitest-setup',\n      'obsidian-test-mocks/obsidian-typings/vitest-setup',\n      'obsidian-dev-utils/vitest-setup'\n    ]\n  };\n\n  /**\n   * Creates a new context seeded with the standard projects.\n   */\n  public constructor() {\n    const obsidianVersion = process.env[OBSIDIAN_VERSION_ENV_VARIABLE_NAME];\n\n    /*\n     * Support is the range [latest public, latest catalyst] and BOTH ends must work (G99), so the version\n     * is a knob rather than a constant. The key is added ONLY when the variable is set: an explicit\n     * `obsidianVersion` makes the harness resolve a concrete version and swap the asar, which is not what\n     * an unpinned run does, so seeding a default here would change the behavior of every plugin.\n     */\n    if (obsidianVersion !== undefined) {\n      this.desktop.environmentOptions = {\n        obsidianTransport: {\n          obsidianVersion,\n          type: 'obsidian-cdp'\n        }\n      };\n    }\n  }\n}\n\n/**\n * Defines the vitest configuration for an Obsidian plugin.\n *\n * @param options - The options for defining the configuration.\n * @returns The vitest configuration.\n */\nexport function defineObsidianPluginVitestConfig(options: DefineObsidianPluginVitestConfigOptions = {}): ViteUserConfig {\n  const context = new ObsidianPluginVitestConfigContext();\n\n  if (options.editContext) {\n    options.editContext(context);\n  }\n\n  const customProjects = options.customProjects?.(context) ?? [];\n\n  return defineConfig({\n    test: {\n      coverage: {\n        exclude: context.coverageExclude,\n        include: ['src/**/*.ts'],\n        provider: 'v8',\n        reporter: ['text', 'lcov', 'html'],\n        reportsDirectory: './coverage'\n      },\n      exclude: [...SHARED_EXCLUDE],\n      globals: false,\n      include: [UNIT_TEST_FILES],\n      passWithNoTests: true,\n      projects: [\n        {\n          resolve: {\n            alias: {\n              obsidian: 'obsidian-test-mocks/obsidian'\n            }\n          },\n          test: context.unitTests\n        },\n        { test: context.noApp },\n        { test: context.desktop },\n        { test: context.desktopPerformance },\n        { test: context.android },\n        ...customProjects\n      ]\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "94.3.0",
+  "version": "94.4.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development.",
   "keywords": [
     "obsidian"
@@ -666,6 +666,7 @@
     "version": "jiti scripts/version.ts"
   },
   "overrides": {
+    "@puppeteer/browsers": "^3.2.0",
     "@typescript-eslint/eslint-plugin": "$@typescript-eslint/eslint-plugin",
     "@typescript-eslint/parser": "$@typescript-eslint/parser",
     "@vitest/coverage-v8": "$@vitest/coverage-v8",
@@ -713,7 +714,7 @@
     "eslint": "^10.8.1",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsdoc": "^64.1.0",
+    "eslint-plugin-jsdoc": "^64.2.0",
     "eslint-plugin-obsidianmd": "^0.4.1",
     "eslint-plugin-perfectionist": "^5.10.1",
     "eslint-plugin-tsdoc": "^0.5.2",
@@ -765,7 +766,7 @@
     "jsdom": "^30.0.1",
     "moment": "^2.30.1",
     "nano-staged": "^1.0.2",
-    "obsidian-integration-testing": "^10.0.0",
+    "obsidian-integration-testing": "^10.3.2",
     "obsidian-test-mocks": "^4.1.0",
     "satori": "^0.29.0",
     "starlight-github-alerts": "^0.4.0",

package/script-utils/demo-vault-buttons/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/script-utils/demo-vault-buttons.cjs",
+  "module": "../../dist/lib/esm/script-utils/demo-vault-buttons.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/script-utils/demo-vault-buttons.d.cts"
+}