@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/test-runners/integration-test-plugin.mjs

@@ -0,0 +1,94 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { getRootFolder } from "@mnaoumov/typescript-dev-toolkit/root";
+import {
+  getFolderName,
+  join
+} from "@mnaoumov/typescript-lib/path";
+import { readFileSync } from "node:fs";
+import { registerLibResolver } from "obsidian-integration-testing";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+const OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID = "obsidian-dev-utils-integration-test";
+function getIntegrationTestPluginPopulate() {
+  const packageFolder = getRootFolder(getFolderName(import.meta.url));
+  if (!packageFolder) {
+    throw new Error("Could not resolve the obsidian-dev-utils package folder to seed the integration-test harness plugin.");
+  }
+  const pluginSourceFolder = join(packageFolder, ObsidianPluginRepoPaths.DistIntegrationTestPlugin);
+  const pluginVaultFolder = join(
+    ObsidianPluginRepoPaths.DotObsidian,
+    ObsidianPluginRepoPaths.Plugins,
+    OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID
+  );
+  const populate = {};
+  for (const fileName of [ObsidianPluginRepoPaths.MainJs, ObsidianPluginRepoPaths.ManifestJson]) {
+    const sourcePath = join(pluginSourceFolder, fileName);
+    let content;
+    try {
+      content = readFileSync(sourcePath);
+    } catch (error) {
+      throw new Error(
+        `Could not read ${sourcePath}. The integration-test harness plugin is missing from the installed obsidian-dev-utils package \u2014 run \`npm run build\` in obsidian-dev-utils, or reinstall it.`,
+        { cause: error }
+      );
+    }
+    populate[join(pluginVaultFolder, fileName)] = content;
+  }
+  return populate;
+}
+function registerIntegrationTestLibResolver() {
+  registerLibResolver(() => {
+    const obsidianDevUtilsModule = window.__obsidianDevUtilsModule;
+    if (!obsidianDevUtilsModule) {
+      throw new Error(
+        "The obsidian-dev-utils module is not exposed on `window`. Is the obsidian-dev-utils integration-test harness plugin installed and enabled in the test vault? See `obsidian-dev-utils/integration-test-vitest-global-setup`."
+      );
+    }
+    return obsidianDevUtilsModule.__merged;
+  });
+}
+export {
+  OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID,
+  getIntegrationTestPluginPopulate,
+  registerIntegrationTestLibResolver
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/integration-test-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Wires the shipped integration-test harness plugin into a consumer plugin's integration tests, so every\n * library helper is reachable as `lib.<helper>` inside an `evalInObsidian` closure.\n *\n * Two halves, and both must be wired or `lib.<helper>` fails:\n *\n * - {@link getIntegrationTestPluginPopulate} puts the harness plugin's binaries in the test vault. The\n *   harness plugin is what publishes the library on `window.__obsidianDevUtilsModule`; in this repo's own\n *   suite it IS the plugin-under-test, but in a consumer's suite the plugin-under-test is the consumer's own\n *   plugin, so the harness has to ride along as a second, test-only community plugin \u2014 seeded here, and\n *   turned on by `obsidian-integration-testing`'s `createSetup({ enableCommunityPlugins })`.\n * - {@link registerIntegrationTestLibResolver} registers the renderer-side resolver that reads that global.\n *\n * `obsidian-dev-utils/integration-test-vitest-global-setup` and\n * `obsidian-dev-utils/integration-test-setup` are the turnkey endpoints that call these for you.\n */\n\nimport { getRootFolder } from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  getFolderName,\n  join\n} from '@mnaoumov/typescript-lib/path';\nimport { readFileSync } from 'node:fs';\nimport { registerLibResolver } from 'obsidian-integration-testing';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\n\n/**\n * The id of the integration-test harness plugin \u2014 the folder name it is seeded into, and the value to pass\n * to `createSetup({ enableCommunityPlugins })` so the harness enables it after the plugin-under-test.\n */\nexport const OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID = 'obsidian-dev-utils-integration-test';\n\n/**\n * The flat library barrel the harness plugin publishes.\n */\ninterface ObsidianDevUtilsModule {\n  __merged: object;\n}\n\n/**\n * The shape the harness plugin publishes on the renderer's `window`.\n */\ninterface ObsidianDevUtilsModuleWindow {\n  __obsidianDevUtilsModule: ObsidianDevUtilsModule;\n}\n\n/**\n * Builds the vault-relative file map that installs the shipped integration-test harness plugin, ready to\n * hand to a global setup's `populate` (or to merge into a larger map the consumer already builds).\n *\n * The result is a `Record<string, Uint8Array>`, which is assignable to `obsidian-integration-testing`'s\n * `PopulateFilesParams` \u2014 so it composes with `buildDemoVaultPopulate` and friends.\n *\n * @returns The map of vault-relative paths to file contents.\n * @throws If the harness plugin was not built into this package \u2014 i.e. `npm run build` never ran.\n */\nexport function getIntegrationTestPluginPopulate(): Record<string, Uint8Array> {\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 seed the integration-test harness plugin.');\n  }\n\n  const pluginSourceFolder = join(packageFolder, ObsidianPluginRepoPaths.DistIntegrationTestPlugin);\n  const pluginVaultFolder = join(\n    ObsidianPluginRepoPaths.DotObsidian,\n    ObsidianPluginRepoPaths.Plugins,\n    OBSIDIAN_DEV_UTILS_INTEGRATION_TEST_PLUGIN_ID\n  );\n\n  const populate: Record<string, Uint8Array> = {};\n\n  for (const fileName of [ObsidianPluginRepoPaths.MainJs, ObsidianPluginRepoPaths.ManifestJson]) {\n    const sourcePath = join(pluginSourceFolder, fileName);\n    let content: Uint8Array;\n    try {\n      content = readFileSync(sourcePath);\n    } catch (error: unknown) {\n      throw new Error(\n        `Could not read ${sourcePath}. The integration-test harness plugin is missing from the installed `\n          + 'obsidian-dev-utils package \u2014 run `npm run build` in obsidian-dev-utils, or reinstall it.',\n        { cause: error }\n      );\n    }\n    populate[join(pluginVaultFolder, fileName)] = content;\n  }\n\n  return populate;\n}\n\n/**\n * Registers the renderer-side resolver that merges the whole library into the `lib` argument of every\n * `evalInObsidian` callback, reading it from the global the harness plugin publishes.\n *\n * Call once per test worker \u2014 the published `obsidian-dev-utils/integration-test-setup` endpoint does it\n * for you when listed in `setupFiles`. Registration is idempotent (the harness dedupes resolvers by source\n * text), so calling it more than once is safe.\n */\nexport function registerIntegrationTestLibResolver(): void {\n  registerLibResolver((): object => {\n    const obsidianDevUtilsModule = (window as Partial<ObsidianDevUtilsModuleWindow>).__obsidianDevUtilsModule;\n    if (!obsidianDevUtilsModule) {\n      throw new Error(\n        'The obsidian-dev-utils module is not exposed on `window`. Is the obsidian-dev-utils integration-test '\n          + 'harness plugin installed and enabled in the test vault? See '\n          + '`obsidian-dev-utils/integration-test-vitest-global-setup`.'\n      );\n    }\n    return obsidianDevUtilsModule.__merged;\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,oBAAoB;AAC7B,SAAS,2BAA2B;AAEpC,SAAS,+BAA+B;AAMjC,MAAM,gDAAgD;AA0BtD,SAAS,mCAA+D;AAC7E,QAAM,gBAAgB,cAAc,cAAc,YAAY,GAAG,CAAC;AAClE,MAAI,CAAC,eAAe;AAClB,UAAM,IAAI,MAAM,sGAAsG;AAAA,EACxH;AAEA,QAAM,qBAAqB,KAAK,eAAe,wBAAwB,yBAAyB;AAChG,QAAM,oBAAoB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB;AAAA,EACF;AAEA,QAAM,WAAuC,CAAC;AAE9C,aAAW,YAAY,CAAC,wBAAwB,QAAQ,wBAAwB,YAAY,GAAG;AAC7F,UAAM,aAAa,KAAK,oBAAoB,QAAQ;AACpD,QAAI;AACJ,QAAI;AACF,gBAAU,aAAa,UAAU;AAAA,IACnC,SAAS,OAAgB;AACvB,YAAM,IAAI;AAAA,QACR,kBAAkB,UAAU;AAAA,QAE5B,EAAE,OAAO,MAAM;AAAA,MACjB;AAAA,IACF;AACA,aAAS,KAAK,mBAAmB,QAAQ,CAAC,IAAI;AAAA,EAChD;AAEA,SAAO;AACT;AAUO,SAAS,qCAA2C;AACzD,sBAAoB,MAAc;AAChC,UAAM,yBAA0B,OAAiD;AACjF,QAAI,CAAC,wBAAwB;AAC3B,YAAM,IAAI;AAAA,QACR;AAAA,MAGF;AAAA,IACF;AACA,WAAO,uBAAuB;AAAA,EAChC,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/test-runners/performance-eval-cap.d.mts

@@ -0,0 +1,27 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * The per-eval cap of the `integration-tests:desktop-performance` project, and the file suffix that
+ * project collects.
+ *
+ * Both live here, rather than in `vitest-config.ts`, because the `no-over-cap-wait-in-eval-in-obsidian`
+ * ESLint rule reads them too, and the shared ESLint config loads that rule in every consuming repo:
+ * importing `vitest-config.ts` from the rule would load `vitest/config` at lint time for nothing.
+ */
+/**
+ * The per-eval cap the `integration-tests:desktop-performance` project gives its CDP transport, in
+ * milliseconds.
+ *
+ * Every other project keeps the transport's own `DEFAULT_EVAL_CAP_IN_MILLISECONDS` (30 000), and a repo
+ * that raises its desktop cap above that is setting a BACKSTOP, not a budget a closure may spend. The
+ * performance project is the one exception, and a deliberate one: its whole measurement is one long
+ * in-page `Runtime.evaluate` over a vault of tens of thousands of notes, and its files run on no other
+ * project. A cross-platform suite gains nothing from any desktop raise, because Appium caps it at
+ * 30 000 whatever the desktop project says.
+ */
+export declare const PERFORMANCE_EVAL_CAP_IN_MILLISECONDS = 600000;
+/**
+ * The file-name suffix of a suite the `integration-tests:desktop-performance` project collects.
+ */
+export declare const DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX = ".desktop-performance.integration.test.ts";

package/dist/lib/esm/test-runners/performance-eval-cap.mjs

@@ -0,0 +1,48 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+const PERFORMANCE_EVAL_CAP_IN_MILLISECONDS = 6e5;
+const DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX = ".desktop-performance.integration.test.ts";
+export {
+  DESKTOP_PERFORMANCE_TEST_FILE_SUFFIX,
+  PERFORMANCE_EVAL_CAP_IN_MILLISECONDS
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/stale-build-global-setup.d.mts

@@ -0,0 +1,86 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Vitest global setup that refuses to start an integration project whose plugin build is stale.
+ *
+ * The integration harness enables the plugin from its BUILD, `dist/build/main.js`, and a plugin's
+ * `test:integration*` scripts call vitest directly, so nothing on that path builds first. A session that
+ * edits `src/` and then runs one integration project tests the last build, however old it is, and the
+ * suite reports the old code as a behavior difference, not as a stale artifact. One such run cost a CDP
+ * probe into Obsidian's own link resolution, a wrong cache-race theory, and a harness change that was
+ * made and then reverted before anyone noticed that the build was three days old. `npm run gate` avoided
+ * the problem only because it happens to build before it runs `test:integration`.
+ *
+ * The setup refuses to start rather than building. A build inside a global setup would run once per
+ * project in a multi-project aggregate, and it would slow down a deliberate re-run of an unchanged build.
+ * A refusal is cheap, and it says what to run.
+ *
+ * Test files are not build inputs. Editing an integration case and re-running it is exactly the loop that
+ * must not force a rebuild, so `*.test.ts` files and `src/test-helpers/` are ignored. A dependency bump
+ * is not detected either: only files in the repo are compared, not `node_modules`.
+ */
+import type { TestProject } from 'vitest/node';
+/**
+ * Parameters for {@link findStaleBuild}.
+ */
+export interface FindStaleBuildParams {
+    /**
+     * The root folder of the plugin repo.
+     */
+    readonly rootFolder: string;
+}
+/**
+ * The build does not exist at all.
+ */
+export interface MissingBuild {
+    /**
+     * The discriminant.
+     */
+    readonly kind: 'missing';
+}
+/**
+ * The build exists but is older than one of its inputs.
+ */
+export interface OutdatedBuild {
+    /**
+     * The modification time of `dist/build/main.js`.
+     */
+    readonly buildModifiedAt: Date;
+    /**
+     * The discriminant.
+     */
+    readonly kind: 'outdated';
+    /**
+     * The modification time of {@link OutdatedBuild.newestInputPath}.
+     */
+    readonly newestInputModifiedAt: Date;
+    /**
+     * The newest build input, relative to the root folder.
+     */
+    readonly newestInputPath: string;
+}
+/**
+ * Why the build cannot be tested, as returned by {@link findStaleBuild}.
+ */
+export type StaleBuild = MissingBuild | OutdatedBuild;
+/**
+ * Checks whether `dist/build/main.js` is missing, or older than one of the files it is built from.
+ *
+ * @param params - The parameters.
+ * @returns `null` when the build is current; otherwise a description of the problem.
+ */
+export declare function findStaleBuild(params: FindStaleBuildParams): null | StaleBuild;
+/**
+ * Formats a {@link StaleBuild} as the message the setup throws.
+ *
+ * @param staleBuild - The stale build.
+ * @returns The message.
+ */
+export declare function formatStaleBuildMessage(staleBuild: StaleBuild): string;
+/**
+ * Vitest global setup: throws when the plugin build is missing or stale.
+ *
+ * @param project - The Vitest test project.
+ */
+export declare function setup(project: TestProject): void;

package/dist/lib/esm/test-runners/stale-build-global-setup.mjs

@@ -0,0 +1,115 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toPosixPath } from "@mnaoumov/typescript-lib/path";
+import {
+  existsSync,
+  readdirSync,
+  statSync
+} from "node:fs";
+import {
+  join,
+  relative,
+  sep
+} from "node:path";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+const BUILD_PATH = `${ObsidianPluginRepoPaths.DistBuild}/${ObsidianPluginRepoPaths.MainJs}`;
+const ROOT_BUILD_INPUTS = [ObsidianPluginRepoPaths.ManifestJson, ObsidianPluginRepoPaths.StylesCss];
+const TEST_FILE_SUFFIX = ObsidianPluginRepoPaths.AnyTestTs.slice(1);
+function findStaleBuild(params) {
+  const buildPath = join(params.rootFolder, BUILD_PATH);
+  if (!existsSync(buildPath)) {
+    return { kind: "missing" };
+  }
+  const buildModifiedAt = statSync(buildPath).mtime;
+  let newestInputPath = null;
+  let newestInputModifiedAt = buildModifiedAt;
+  for (const inputPath of getBuildInputPaths(params.rootFolder)) {
+    const modifiedAt = statSync(inputPath).mtime;
+    if (modifiedAt <= newestInputModifiedAt) {
+      continue;
+    }
+    newestInputPath = inputPath;
+    newestInputModifiedAt = modifiedAt;
+  }
+  if (newestInputPath === null) {
+    return null;
+  }
+  return {
+    buildModifiedAt,
+    kind: "outdated",
+    newestInputModifiedAt,
+    newestInputPath: toPosixPath(relative(params.rootFolder, newestInputPath))
+  };
+}
+function formatStaleBuildMessage(staleBuild) {
+  return staleBuild.kind === "missing" ? `${BUILD_PATH} does not exist, so there is no plugin for the integration tests to load. Run \`npm run build\` first.` : `${BUILD_PATH} is older than ${staleBuild.newestInputPath} (built ${staleBuild.buildModifiedAt.toISOString()}, changed ${staleBuild.newestInputModifiedAt.toISOString()}), so the integration tests would run the previous build instead of the current source. Run \`npm run build\` first.`;
+}
+function setup(project) {
+  const staleBuild = findStaleBuild({ rootFolder: project.config.root });
+  if (staleBuild !== null) {
+    throw new Error(formatStaleBuildMessage(staleBuild));
+  }
+}
+function getBuildInputPaths(rootFolder) {
+  const paths = ROOT_BUILD_INPUTS.map((rootInput) => join(rootFolder, rootInput)).filter((path) => existsSync(path));
+  const srcFolder = join(rootFolder, ObsidianPluginRepoPaths.Src);
+  if (!existsSync(srcFolder)) {
+    return paths;
+  }
+  const testHelpersFolderPrefix = join(rootFolder, ObsidianPluginRepoPaths.Mocks) + sep;
+  for (const entry of readdirSync(srcFolder, { recursive: true, withFileTypes: true })) {
+    if (!entry.isFile() || entry.name.endsWith(TEST_FILE_SUFFIX)) {
+      continue;
+    }
+    const path = join(entry.parentPath, entry.name);
+    if (!path.startsWith(testHelpersFolderPrefix)) {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+export {
+  findStaleBuild,
+  formatStaleBuildMessage,
+  setup
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/stale-build-global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup that refuses to start an integration project whose plugin build is stale.\n *\n * The integration harness enables the plugin from its BUILD, `dist/build/main.js`, and a plugin's\n * `test:integration*` scripts call vitest directly, so nothing on that path builds first. A session that\n * edits `src/` and then runs one integration project tests the last build, however old it is, and the\n * suite reports the old code as a behavior difference, not as a stale artifact. One such run cost a CDP\n * probe into Obsidian's own link resolution, a wrong cache-race theory, and a harness change that was\n * made and then reverted before anyone noticed that the build was three days old. `npm run gate` avoided\n * the problem only because it happens to build before it runs `test:integration`.\n *\n * The setup refuses to start rather than building. A build inside a global setup would run once per\n * project in a multi-project aggregate, and it would slow down a deliberate re-run of an unchanged build.\n * A refusal is cheap, and it says what to run.\n *\n * Test files are not build inputs. Editing an integration case and re-running it is exactly the loop that\n * must not force a rebuild, so `*.test.ts` files and `src/test-helpers/` are ignored. A dependency bump\n * is not detected either: only files in the repo are compared, not `node_modules`.\n */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { toPosixPath } from '@mnaoumov/typescript-lib/path';\nimport {\n  existsSync,\n  readdirSync,\n  statSync\n} from 'node:fs';\nimport {\n  join,\n  relative,\n  sep\n} from 'node:path';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\n\n/**\n * Parameters for {@link findStaleBuild}.\n */\nexport interface FindStaleBuildParams {\n  /**\n   * The root folder of the plugin repo.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * The build does not exist at all.\n */\nexport interface MissingBuild {\n  /**\n   * The discriminant.\n   */\n  readonly kind: 'missing';\n}\n\n/**\n * The build exists but is older than one of its inputs.\n */\nexport interface OutdatedBuild {\n  /**\n   * The modification time of `dist/build/main.js`.\n   */\n  readonly buildModifiedAt: Date;\n\n  /**\n   * The discriminant.\n   */\n  readonly kind: 'outdated';\n\n  /**\n   * The modification time of {@link OutdatedBuild.newestInputPath}.\n   */\n  readonly newestInputModifiedAt: Date;\n\n  /**\n   * The newest build input, relative to the root folder.\n   */\n  readonly newestInputPath: string;\n}\n\n/**\n * Why the build cannot be tested, as returned by {@link findStaleBuild}.\n */\nexport type StaleBuild = MissingBuild | OutdatedBuild;\n\nconst BUILD_PATH = `${ObsidianPluginRepoPaths.DistBuild}/${ObsidianPluginRepoPaths.MainJs}`;\nconst ROOT_BUILD_INPUTS = [ObsidianPluginRepoPaths.ManifestJson, ObsidianPluginRepoPaths.StylesCss];\nconst TEST_FILE_SUFFIX = ObsidianPluginRepoPaths.AnyTestTs.slice(1);\n\n/**\n * Checks whether `dist/build/main.js` is missing, or older than one of the files it is built from.\n *\n * @param params - The parameters.\n * @returns `null` when the build is current; otherwise a description of the problem.\n */\nexport function findStaleBuild(params: FindStaleBuildParams): null | StaleBuild {\n  const buildPath = join(params.rootFolder, BUILD_PATH);\n  if (!existsSync(buildPath)) {\n    return { kind: 'missing' };\n  }\n\n  const buildModifiedAt = statSync(buildPath).mtime;\n  let newestInputPath: null | string = null;\n  let newestInputModifiedAt = buildModifiedAt;\n\n  for (const inputPath of getBuildInputPaths(params.rootFolder)) {\n    const modifiedAt = statSync(inputPath).mtime;\n    if (modifiedAt <= newestInputModifiedAt) {\n      continue;\n    }\n\n    newestInputPath = inputPath;\n    newestInputModifiedAt = modifiedAt;\n  }\n\n  if (newestInputPath === null) {\n    return null;\n  }\n\n  return {\n    buildModifiedAt,\n    kind: 'outdated',\n    newestInputModifiedAt,\n    newestInputPath: toPosixPath(relative(params.rootFolder, newestInputPath))\n  };\n}\n\n/**\n * Formats a {@link StaleBuild} as the message the setup throws.\n *\n * @param staleBuild - The stale build.\n * @returns The message.\n */\nexport function formatStaleBuildMessage(staleBuild: StaleBuild): string {\n  return staleBuild.kind === 'missing'\n    ? `${BUILD_PATH} does not exist, so there is no plugin for the integration tests to load. Run \\`npm run build\\` first.`\n    : `${BUILD_PATH} is older than ${staleBuild.newestInputPath} (built ${staleBuild.buildModifiedAt.toISOString()}, `\n      + `changed ${staleBuild.newestInputModifiedAt.toISOString()}), so the integration tests would run the previous build `\n      + 'instead of the current source. Run `npm run build` first.';\n}\n\n/**\n * Vitest global setup: throws when the plugin build is missing or stale.\n *\n * @param project - The Vitest test project.\n */\nexport function setup(project: TestProject): void {\n  const staleBuild = findStaleBuild({ rootFolder: project.config.root });\n  if (staleBuild !== null) {\n    throw new Error(formatStaleBuildMessage(staleBuild));\n  }\n}\n\nfunction getBuildInputPaths(rootFolder: string): string[] {\n  const paths = ROOT_BUILD_INPUTS.map((rootInput) => join(rootFolder, rootInput)).filter((path) => existsSync(path));\n\n  const srcFolder = join(rootFolder, ObsidianPluginRepoPaths.Src);\n  if (!existsSync(srcFolder)) {\n    return paths;\n  }\n\n  const testHelpersFolderPrefix = join(rootFolder, ObsidianPluginRepoPaths.Mocks) + sep;\n  for (const entry of readdirSync(srcFolder, { recursive: true, withFileTypes: true })) {\n    if (!entry.isFile() || entry.name.endsWith(TEST_FILE_SUFFIX)) {\n      continue;\n    }\n\n    const path = join(entry.parentPath, entry.name);\n    if (!path.startsWith(testHelpersFolderPrefix)) {\n      paths.push(path);\n    }\n  }\n\n  return paths;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,mBAAmB;AAC5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,+BAA+B;AAoDxC,MAAM,aAAa,GAAG,wBAAwB,SAAS,IAAI,wBAAwB,MAAM;AACzF,MAAM,oBAAoB,CAAC,wBAAwB,cAAc,wBAAwB,SAAS;AAClG,MAAM,mBAAmB,wBAAwB,UAAU,MAAM,CAAC;AAQ3D,SAAS,eAAe,QAAiD;AAC9E,QAAM,YAAY,KAAK,OAAO,YAAY,UAAU;AACpD,MAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,WAAO,EAAE,MAAM,UAAU;AAAA,EAC3B;AAEA,QAAM,kBAAkB,SAAS,SAAS,EAAE;AAC5C,MAAI,kBAAiC;AACrC,MAAI,wBAAwB;AAE5B,aAAW,aAAa,mBAAmB,OAAO,UAAU,GAAG;AAC7D,UAAM,aAAa,SAAS,SAAS,EAAE;AACvC,QAAI,cAAc,uBAAuB;AACvC;AAAA,IACF;AAEA,sBAAkB;AAClB,4BAAwB;AAAA,EAC1B;AAEA,MAAI,oBAAoB,MAAM;AAC5B,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA,iBAAiB,YAAY,SAAS,OAAO,YAAY,eAAe,CAAC;AAAA,EAC3E;AACF;AAQO,SAAS,wBAAwB,YAAgC;AACtE,SAAO,WAAW,SAAS,YACvB,GAAG,UAAU,2GACb,GAAG,UAAU,kBAAkB,WAAW,eAAe,WAAW,WAAW,gBAAgB,YAAY,CAAC,aAC/F,WAAW,sBAAsB,YAAY,CAAC;AAEjE;AAOO,SAAS,MAAM,SAA4B;AAChD,QAAM,aAAa,eAAe,EAAE,YAAY,QAAQ,OAAO,KAAK,CAAC;AACrE,MAAI,eAAe,MAAM;AACvB,UAAM,IAAI,MAAM,wBAAwB,UAAU,CAAC;AAAA,EACrD;AACF;AAEA,SAAS,mBAAmB,YAA8B;AACxD,QAAM,QAAQ,kBAAkB,IAAI,CAAC,cAAc,KAAK,YAAY,SAAS,CAAC,EAAE,OAAO,CAAC,SAAS,WAAW,IAAI,CAAC;AAEjH,QAAM,YAAY,KAAK,YAAY,wBAAwB,GAAG;AAC9D,MAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,WAAO;AAAA,EACT;AAEA,QAAM,0BAA0B,KAAK,YAAY,wBAAwB,KAAK,IAAI;AAClF,aAAW,SAAS,YAAY,WAAW,EAAE,WAAW,MAAM,eAAe,KAAK,CAAC,GAAG;AACpF,QAAI,CAAC,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,gBAAgB,GAAG;AAC5D;AAAA,IACF;AAEA,UAAM,OAAO,KAAK,MAAM,YAAY,MAAM,IAAI;AAC9C,QAAI,CAAC,KAAK,WAAW,uBAAuB,GAAG;AAC7C,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -0,0 +1,200 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Shared vitest configuration for Obsidian plugins.
+ *
+ * Every plugin in the workspace declares the same five vitest projects — `unit-tests` plus the
+ * `integration-tests:{no-app,desktop,desktop-performance,android}` family — with the same timeouts,
+ * `setupFiles`, and `globalSetup` wiring. Maintaining that per repo means a convention change costs one
+ * near-identical edit per plugin, and any repo that is missed drifts silently. This module owns that
+ * configuration once, so a plugin's `scripts/vitest-config.ts` collapses to a single call.
+ *
+ * The seam mirrors {@link https://www.npmjs.com/package/obsidian-dev-utils | the ESLint one}
+ * (`defineEslintConfigs`): the factory builds a context holding the standard projects, the caller edits
+ * it in place through {@link DefineObsidianPluginVitestConfigOptions.editContext}, and appends any
+ * project the base does not know about through
+ * {@link DefineObsidianPluginVitestConfigOptions.customProjects}.
+ */
+import type { VitestReporter } from '@mnaoumov/typescript-dev-toolkit/test-runners/vitest-config';
+import type { TestProjectConfiguration, TestProjectInlineConfiguration, ViteUserConfig } from 'vitest/config';
+import { DEFAULT_VITEST_REPORTERS } from '@mnaoumov/typescript-dev-toolkit/test-runners/vitest-config';
+/**
+ * The `test` section of a single vitest project entry.
+ */
+export type ObsidianPluginVitestProjectConfig = NonNullable<TestProjectInlineConfiguration['test']>;
+/**
+ * One entry of a vitest `reporters` list: the name of a built-in reporter or a reporter instance. The same shape as
+ * the library configuration's {@link VitestReporter}.
+ */
+export type ObsidianPluginVitestReporter = VitestReporter;
+export { DEFAULT_VITEST_REPORTERS };
+/**
+ * The per-test budget of the regular integration projects, in milliseconds.
+ *
+ * Exported because a repo that assembles its vitest projects by hand instead of through
+ * {@link defineObsidianPluginVitestConfig} still needs the same relationship to the per-eval cap, and
+ * restating the number there is how the two drift apart.
+ */
+export declare const INTEGRATION_TEST_TIMEOUT_IN_MILLISECONDS: number;
+/**
+ * The options for defining a plugin's vitest configuration.
+ */
+export interface DefineObsidianPluginVitestConfigOptions {
+    /**
+     * A function that builds projects the base configuration does not know about, such as a plugin's own
+     * `integration-tests:demo-vault` project. The returned projects are appended after the standard five.
+     *
+     * @param context - The vitest configuration context.
+     * @returns The extra projects.
+     */
+    readonly customProjects?: (context: ObsidianPluginVitestConfigContext) => TestProjectConfiguration[];
+    /**
+     * A function that edits the vitest configuration context before it is assembled into a configuration.
+     *
+     * @param context - The vitest configuration context.
+     */
+    readonly editContext?: (context: ObsidianPluginVitestConfigContext) => void;
+}
+/**
+ * The context for defining a plugin's vitest configuration.
+ *
+ * Every member is live: the arrays and objects it exposes are the very ones the assembled configuration
+ * is built from, so editing them in place through
+ * {@link DefineObsidianPluginVitestConfigOptions.editContext} is what customizes the result.
+ */
+export declare class ObsidianPluginVitestConfigContext {
+    /**
+     * The `integration-tests:android` project, running the mobile-only and cross-platform suites against an
+     * Android emulator through Appium.
+     */
+    readonly android: ObsidianPluginVitestProjectConfig;
+    /**
+     * The per-test budget of the Android integration project, in milliseconds. Booting an emulator and
+     * driving it over Appium is slower than the desktop path, hence its own constant.
+     *
+     * @default `60000`
+     */
+    readonly androidTimeoutInMilliseconds = 60000;
+    /**
+     * The per-test budget of the regular integration projects, in milliseconds.
+     *
+     * It deliberately CLEARS the transports' per-eval cap rather than matching it, so that a closure which
+     * outruns the cap fails with the harness's `EvalCapExceededError` — naming the cap and the remedy —
+     * instead of with vitest's anonymous timeout. Lowering it to the cap restores that blind spot.
+     *
+     * @default `45000`
+     */
+    readonly bigTimeoutInMilliseconds: number;
+    /**
+     * 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[];
+    /**
+     * The `integration-tests:desktop` project, running the desktop-only and cross-platform suites against a
+     * real desktop Obsidian over CDP.
+     */
+    readonly desktop: ObsidianPluginVitestProjectConfig;
+    /**
+     * The `integration-tests:desktop-performance` project, running the at-scale suites. It is declared for
+     * every plugin even when there is no such suite yet — `passWithNoTests` makes an empty project free,
+     * and the matching `test:integration:desktop:performance` script exists in every plugin built on this library.
+     *
+     * A plugin's `test:integration` aggregate leaves this project out on purpose, and it stays out even on a
+     * machine with a desktop Obsidian set up. The reason is the fixture rather than the cost: a perf suite
+     * needs its own generated, populated vault, sized through env vars, and the aggregate's small temporary
+     * vault is the wrong one. The 600 s below is a timeout, not a duration — measured end to end, most perf
+     * suites finish in seconds, and only one that generates tens of thousands of notes takes minutes.
+     *
+     * Its CDP transport's per-eval cap is raised to 600 s as well (the budget clears it by the usual
+     * margin), because a perf suite's whole measurement is typically ONE long in-page evaluation, which the
+     * transport's 30 s default killed as a bare `CDP command timed out … Runtime.evaluate` naming neither the
+     * wait nor the assertion. Three plugins had each hand-written this raise in their own `editContext`
+     * before it moved here. Unlike a raised desktop cap, which is a backstop rather than a budget a closure
+     * may spend, this one IS a budget: `no-over-cap-wait-in-eval-in-obsidian` reads it for these files and
+     * for no other.
+     *
+     * No routine command runs them, but something does: a weekly sweep runs every plugin's
+     * `test:integration:desktop:performance`, which is also how to reach them by hand. Adding them to that
+     * aggregate is drift, not a gap to close.
+     */
+    readonly desktopPerformance: ObsidianPluginVitestProjectConfig;
+    /**
+     * The unit test files that redefine `window`, `document`, `location` or `top`, which the `unit-tests`
+     * project's VM pool cannot run.
+     *
+     * Under `pool: 'vmThreads'` those four are non-configurable properties of the VM global, so
+     * `vi.stubGlobal('window', …)` or `Object.defineProperty(window, 'location', …)` throws
+     * `Cannot redefine property`. That is JS semantics, not a bug to route around. Every other global stays
+     * configurable and stubs normally.
+     *
+     * Push a file here and it leaves `unit-tests` for a sibling `unit-tests:global-stubs` project that is
+     * identical except for the pool, which is the default one. A plugin's `test` and `test:coverage` scripts
+     * name `unit-tests`, which also selects every `unit-tests:*` project, so the sibling runs and is covered
+     * without a script change. It is emitted only when this list is non-empty.
+     *
+     * To keep a whole suite on the default pool instead, set `unitTests.pool` to `'forks'` and say why.
+     */
+    readonly globalStubTestFiles: string[];
+    /**
+     * The multiplier applied to a project's test budget to get its hook budget. A hook typically populates
+     * and opens a vault, so it needs several times what a single test does.
+     *
+     * @default `4`
+     */
+    readonly hookTimeoutMultiplier = 4;
+    /**
+     * The `integration-tests:no-app` project, running the suites that need no Obsidian instance at all.
+     */
+    readonly noApp: ObsidianPluginVitestProjectConfig;
+    /**
+     * The per-eval cap the performance integration project gives its CDP transport, in milliseconds.
+     *
+     * @default `600000`
+     */
+    readonly performanceEvalCapInMilliseconds = 600000;
+    /**
+     * The per-test budget of the performance integration project, in milliseconds. A performance vault is
+     * pre-populated with tens of thousands of notes before Obsidian opens, so both its setup and its tests
+     * need far more time than the regular integration projects.
+     *
+     * Like the regular budget, it CLEARS the project's per-eval cap
+     * ({@link ObsidianPluginVitestConfigContext.performanceEvalCapInMilliseconds}) rather than matching it,
+     * so an evaluation that outruns the cap reports itself instead of dying as vitest's anonymous timeout.
+     *
+     * @default `615000`
+     */
+    readonly performanceTimeoutInMilliseconds: number;
+    /**
+     * The reporters the run prints through.
+     *
+     * Pinned rather than left to vitest, which resolves an unset `reporters` differently for a developer
+     * and for an AI coding session — see {@link DEFAULT_VITEST_REPORTERS} for the whole of why, and for
+     * what it deliberately leaves to vitest 5 itself.
+     *
+     * Push onto it to add a reporter beside the pinned one.
+     *
+     * @default {@link DEFAULT_VITEST_REPORTERS}
+     */
+    readonly reporters: ObsidianPluginVitestReporter[];
+    /**
+     * The `unit-tests` project, running the mocked-Obsidian suites in `jsdom`.
+     */
+    readonly unitTests: ObsidianPluginVitestProjectConfig;
+    /**
+     * Creates a new context seeded with the standard projects.
+     */
+    constructor();
+}
+/**
+ * Defines the vitest configuration for an Obsidian plugin.
+ *
+ * @param options - The options for defining the configuration.
+ * @returns The vitest configuration.
+ */
+export declare function defineObsidianPluginVitestConfig(options?: DefineObsidianPluginVitestConfigOptions): ViteUserConfig;