@mnaoumov/obsidian-dev-toolkit 2.0.0 → 3.0.0

package/dist/lib/cjs/test-runners/e2e-runner-support.d.cts

@@ -0,0 +1,36 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * What the end-to-end runners share: where the specs live, and the check that the packages a runner drives are
+ * installed in the project, so a missing one is reported with the `npm install` line that fixes it instead of as a
+ * shell's `command not found`.
+ */
+/**
+ * The spec files the end-to-end runners run by default.
+ */
+export declare const DEFAULT_END_TO_END_SPECS = "./e2e/**/*.spec.ts";
+/**
+ * Parameters for {@link assertProjectPackagesInstalled}.
+ */
+export interface AssertProjectPackagesInstalledParams {
+    /**
+     * The packages the runner needs.
+     */
+    readonly packageNames: readonly string[];
+    /**
+     * The folder whose `node_modules` the packages are resolved from. Defaults to the project root.
+     */
+    readonly projectFolder?: string;
+    /**
+     * What needs the packages, as the error message names it, e.g. `testEndToEndWithWdioObsidian()`.
+     */
+    readonly requester: string;
+}
+/**
+ * Throws when any of the packages is not installed in the project, naming the `npm install` line.
+ *
+ * @param params - The {@link AssertProjectPackagesInstalledParams}.
+ * @throws When a package is missing.
+ */
+export declare function assertProjectPackagesInstalled(params: AssertProjectPackagesInstalledParams): void;

package/dist/lib/cjs/test-runners/index.cjs

@@ -107,18 +107,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var test_runners_exports = {};
 __export(test_runners_exports, {
+  "coverage-badge": () => coverage_badge,
+  "coverage-badge-cli": () => coverage_badge_cli,
+  "e2e-runner-support": () => e2e_runner_support,
   "integration-test-plugin": () => integration_test_plugin,
+  "obsidian-test-runner": () => obsidian_test_runner,
   "performance-eval-cap": () => performance_eval_cap,
-  "vitest-config": () => vitest_config
+  "vitest-config": () => vitest_config,
+  "wdio-obsidian": () => wdio_obsidian
 });
 module.exports = __toCommonJS(test_runners_exports);
+var coverage_badge_cli = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./coverage-badge-cli.cjs')), 1);
+var coverage_badge = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./coverage-badge.cjs')), 1);
+var e2e_runner_support = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./e2e-runner-support.cjs')), 1);
 var integration_test_plugin = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./integration-test-plugin.cjs')), 1);
+var obsidian_test_runner = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./obsidian-test-runner.cjs')), 1);
 var performance_eval_cap = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./performance-eval-cap.cjs')), 1);
 var vitest_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./vitest-config.cjs')), 1);
+var wdio_obsidian = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./wdio-obsidian.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  "coverage-badge": null,
+  "coverage-badge-cli": null,
+  "e2e-runner-support": null,
   "integration-test-plugin": null,
+  "obsidian-test-runner": null,
   "performance-eval-cap": null,
-  "vitest-config": null
+  "vitest-config": null,
+  "wdio-obsidian": null
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90ZXN0LXJ1bm5lcnMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdpbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbicgZnJvbSAnLi9pbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAncGVyZm9ybWFuY2UtZXZhbC1jYXAnIGZyb20gJy4vcGVyZm9ybWFuY2UtZXZhbC1jYXAudHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBLG1DQUFBQTtBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx1QkFBQUM7QUFBQTtBQUFBO0FBRUEsSUFBQUYsMEJBQTJDO0FBQzNDLElBQUFDLHVCQUF3QztBQUN4QyxJQUFBQyxnQkFBaUM7IiwibmFtZXMiOlsiaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4iLCJwZXJmb3JtYW5jZS1ldmFsLWNhcCIsInZpdGVzdC1jb25maWciXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90ZXN0LXJ1bm5lcnMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdjb3ZlcmFnZS1iYWRnZS1jbGknIGZyb20gJy4vY292ZXJhZ2UtYmFkZ2UtY2xpLnRzJztcbmV4cG9ydCAqIGFzICdjb3ZlcmFnZS1iYWRnZScgZnJvbSAnLi9jb3ZlcmFnZS1iYWRnZS50cyc7XG5leHBvcnQgKiBhcyAnZTJlLXJ1bm5lci1zdXBwb3J0JyBmcm9tICcuL2UyZS1ydW5uZXItc3VwcG9ydC50cyc7XG5leHBvcnQgKiBhcyAnaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4nIGZyb20gJy4vaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ29ic2lkaWFuLXRlc3QtcnVubmVyJyBmcm9tICcuL29ic2lkaWFuLXRlc3QtcnVubmVyLnRzJztcbmV4cG9ydCAqIGFzICdwZXJmb3JtYW5jZS1ldmFsLWNhcCcgZnJvbSAnLi9wZXJmb3JtYW5jZS1ldmFsLWNhcC50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0LWNvbmZpZycgZnJvbSAnLi92aXRlc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICd3ZGlvLW9ic2lkaWFuJyBmcm9tICcuL3dkaW8tb2JzaWRpYW4udHMnO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQSwwQkFBQUE7QUFBQSxFQUFBLDRCQUFBQztBQUFBLEVBQUEsNEJBQUFDO0FBQUEsRUFBQSxpQ0FBQUM7QUFBQSxFQUFBLDhCQUFBQztBQUFBLEVBQUEsOEJBQUFDO0FBQUEsRUFBQSx1QkFBQUM7QUFBQSxFQUFBLHVCQUFBQztBQUFBO0FBQUE7QUFFQSxJQUFBTixxQkFBc0M7QUFDdEMsSUFBQUQsaUJBQWtDO0FBQ2xDLElBQUFFLHFCQUFzQztBQUN0QyxJQUFBQywwQkFBMkM7QUFDM0MsSUFBQUMsdUJBQXdDO0FBQ3hDLElBQUFDLHVCQUF3QztBQUN4QyxJQUFBQyxnQkFBaUM7QUFDakMsSUFBQUMsZ0JBQWlDOyIsIm5hbWVzIjpbImNvdmVyYWdlLWJhZGdlIiwiY292ZXJhZ2UtYmFkZ2UtY2xpIiwiZTJlLXJ1bm5lci1zdXBwb3J0IiwiaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4iLCJvYnNpZGlhbi10ZXN0LXJ1bm5lciIsInBlcmZvcm1hbmNlLWV2YWwtY2FwIiwidml0ZXN0LWNvbmZpZyIsIndkaW8tb2JzaWRpYW4iXX0=

package/dist/lib/cjs/test-runners/index.d.cts

@@ -1,4 +1,9 @@
 /// <reference path="../library-references.d.cts" />
+export * as 'coverage-badge-cli' from './coverage-badge-cli.cjs';
+export * as 'coverage-badge' from './coverage-badge.cjs';
+export * as 'e2e-runner-support' from './e2e-runner-support.cjs';
 export * as 'integration-test-plugin' from './integration-test-plugin.cjs';
+export * as 'obsidian-test-runner' from './obsidian-test-runner.cjs';
 export * as 'performance-eval-cap' from './performance-eval-cap.cjs';
 export * as 'vitest-config' from './vitest-config.cjs';
+export * as 'wdio-obsidian' from './wdio-obsidian.cjs';

package/dist/lib/cjs/test-runners/obsidian-test-runner.cjs

@@ -0,0 +1,147 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  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;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var obsidian_test_runner_exports = {};
+__export(obsidian_test_runner_exports, {
+  testEndToEndWithObsidianTest: () => testEndToEndWithObsidianTest
+});
+module.exports = __toCommonJS(obsidian_test_runner_exports);
+var import_root = require('@mnaoumov/typescript-dev-toolkit/root');
+var import_e2e_runner_support = require('./e2e-runner-support.cjs');
+async function testEndToEndWithObsidianTest(options = {}) {
+  (0, import_e2e_runner_support.assertProjectPackagesInstalled)({ packageNames: ["obsidian-test"], requester: "testEndToEndWithObsidianTest()" });
+  await (0, import_root.execFromRoot)([
+    "obsidian-test",
+    "--testPattern",
+    options.testPattern ?? import_e2e_runner_support.DEFAULT_END_TO_END_SPECS,
+    ...options.vaultPath === void 0 ? [] : ["--vault-path", options.vaultPath],
+    ...options.obsidianCommand === void 0 ? [] : ["--obsidian-cmd", options.obsidianCommand],
+    ...options.shouldUseCache ?? true ? [] : ["--force"]
+  ], { isInteractive: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  testEndToEndWithObsidianTest
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/test-runners/obsidian-test-runner.d.cts

@@ -0,0 +1,42 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * End-to-end tests with `obsidian-test`: it bundles the plugin together with the test files, installs it into a
+ * temporary vault, launches the installed Obsidian and runs the tests inside it with `node:test`.
+ *
+ * {@link testEndToEndWithObsidianTest} is the `test:e2e` script.
+ */
+/**
+ * Options for {@link testEndToEndWithObsidianTest}.
+ */
+export interface TestEndToEndWithObsidianTestOptions {
+    /**
+     * The command that launches Obsidian. Defaults to `obsidian-test`'s own, `obsidian`; point it at the executable
+     * when `obsidian` is not on `PATH`.
+     */
+    readonly obsidianCommand?: string;
+    /**
+     * Whether `obsidian-test` may replay its cached results when the plugin, the tests and Obsidian are unchanged.
+     * Defaults to `true`; `false` passes `--force`.
+     */
+    readonly shouldUseCache?: boolean;
+    /**
+     * The glob of the test files, relative to the project root. Defaults to {@link DEFAULT_END_TO_END_SPECS}.
+     * `obsidian-test`'s own default also matches every `*.test.ts`, which would bundle the unit tests into Obsidian.
+     */
+    readonly testPattern?: string;
+    /**
+     * The vault to run in, relative to the project root. `obsidian-test` installs the plugin INTO it, so it must be a
+     * scratch vault, never the demo vault. Defaults to a temporary vault.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Runs the end-to-end tests with `obsidian-test`. It is the body of a plugin's `test:e2e` script.
+ *
+ * @param options - The {@link TestEndToEndWithObsidianTestOptions}.
+ * @returns A {@link Promise} that resolves once the tests pass.
+ * @throws When `obsidian-test` is missing or a test fails.
+ */
+export declare function testEndToEndWithObsidianTest(options?: TestEndToEndWithObsidianTestOptions): Promise<void>;

package/dist/lib/cjs/test-runners/wdio-obsidian.cjs

@@ -0,0 +1,205 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  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;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wdio_obsidian_exports = {};
+__export(wdio_obsidian_exports, {
+  DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS,
+  WDIO_CONFIG_FILE_NAMES: () => WDIO_CONFIG_FILE_NAMES,
+  defineWdioObsidianConfig: () => defineWdioObsidianConfig,
+  testEndToEndWithWdioObsidian: () => testEndToEndWithWdioObsidian
+});
+module.exports = __toCommonJS(wdio_obsidian_exports);
+var import_npm_run = require('@mnaoumov/typescript-dev-toolkit/npm-run');
+var import_root = require('@mnaoumov/typescript-dev-toolkit/root');
+var import_node_fs = require('node:fs');
+var import_obsidian_plugin_repo_paths = require('../obsidian-plugin-repo-paths.cjs');
+var import_e2e_runner_support = require('./e2e-runner-support.cjs');
+const DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS = 6e4;
+const WDIO_CONFIG_FILE_NAMES = ["wdio.conf.mts", "wdio.conf.ts"];
+const WDIO_OBSIDIAN_PACKAGES = ["@wdio/cli", "@wdio/local-runner", "@wdio/mocha-framework", "wdio-obsidian-reporter", "wdio-obsidian-service"];
+function defineWdioObsidianConfig(options = {}) {
+  const pluginFolder = (0, import_root.resolvePathFromRootSafe)({ path: options.pluginFolder ?? import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DistBuild });
+  const vault = resolveVault(options.vault);
+  const capabilityOptions = {
+    plugins: [pluginFolder],
+    ...options.installerVersion !== void 0 && { installerVersion: options.installerVersion },
+    ...vault !== void 0 && { vault }
+  };
+  return {
+    // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.
+    cacheDir: (0, import_root.resolvePathFromRootSafe)({ path: options.cacheFolder ?? ".obsidian-cache" }),
+    capabilities: (options.appVersions ?? ["latest"]).map((appVersion) => ({
+      "browserName": "obsidian",
+      "browserVersion": appVersion,
+      "wdio:obsidianOptions": { ...capabilityOptions, plugins: [...capabilityOptions.plugins] }
+    })),
+    framework: "mocha",
+    logLevel: "warn",
+    ...options.maxInstances !== void 0 && { maxInstances: options.maxInstances },
+    // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.
+    mochaOpts: {
+      timeout: options.testTimeoutInMilliseconds ?? DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS,
+      ui: "bdd"
+    },
+    reporters: ["obsidian"],
+    runner: "local",
+    services: ["obsidian"],
+    specs: [...options.specs ?? [import_e2e_runner_support.DEFAULT_END_TO_END_SPECS]]
+  };
+}
+async function testEndToEndWithWdioObsidian(options = {}) {
+  (0, import_e2e_runner_support.assertProjectPackagesInstalled)({ packageNames: WDIO_OBSIDIAN_PACKAGES, requester: "testEndToEndWithWdioObsidian()" });
+  const configPath = options.configPath ?? findWdioConfigFile();
+  if (options.shouldBuild ?? true) {
+    await (0, import_npm_run.npmRun)("build");
+  }
+  await (0, import_root.execFromRoot)(["wdio", "run", configPath], { isInteractive: true });
+}
+function findWdioConfigFile() {
+  const configFileName = WDIO_CONFIG_FILE_NAMES.find((fileName) => (0, import_node_fs.existsSync)((0, import_root.resolvePathFromRootSafe)({ path: fileName })));
+  if (configFileName === void 0) {
+    throw new Error(
+      `testEndToEndWithWdioObsidian() found no WebdriverIO config (${WDIO_CONFIG_FILE_NAMES.join(", ")}) in the project root. Create wdio.conf.mts exporting \`config = defineWdioObsidianConfig()\`, or pass \`configPath\`.`
+    );
+  }
+  return configFileName;
+}
+function resolveVault(vault) {
+  if (vault === false) {
+    return void 0;
+  }
+  if (vault !== void 0) {
+    return (0, import_root.resolvePathFromRootSafe)({ path: vault });
+  }
+  const demoVaultPath = (0, import_root.resolvePathFromRootSafe)({ path: import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DemoVault });
+  return (0, import_node_fs.existsSync)(demoVaultPath) ? demoVaultPath : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS,
+  WDIO_CONFIG_FILE_NAMES,
+  defineWdioObsidianConfig,
+  testEndToEndWithWdioObsidian
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/test-runners/wdio-obsidian.ts"],"sourcesContent":["/**\n * @file\n *\n * End-to-end tests with `wdio-obsidian-service`: WebdriverIO drives a sandboxed copy of Obsidian, downloaded per\n * version into a cache, with the plugin installed into a copy of the test vault.\n *\n * {@link defineWdioObsidianConfig} derives the `wdio.conf.mts` from the project's layout, and\n * {@link testEndToEndWithWdioObsidian} is the `test:e2e` script: a production build, then `wdio run`.\n *\n * The config is typed structurally rather than through `@wdio/types`, so this module costs a project that does not\n * use WebdriverIO nothing, and the returned object is assignable to `WebdriverIO.Config` in one that does.\n */\n\nimport { npmRun } from '@mnaoumov/typescript-dev-toolkit/npm-run';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '@mnaoumov/typescript-dev-toolkit/root';\nimport { existsSync } from 'node:fs';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian-plugin-repo-paths.ts';\nimport {\n  assertProjectPackagesInstalled,\n  DEFAULT_END_TO_END_SPECS\n} from './e2e-runner-support.ts';\n\n/**\n * The per-test timeout {@link defineWdioObsidianConfig} gives mocha by default, in milliseconds. Obsidian is\n * started once per spec file, which a single test's budget has to absorb.\n */\nexport const DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS = 60_000;\n\n/**\n * The config files {@link testEndToEndWithWdioObsidian} looks for, in order.\n */\nexport const WDIO_CONFIG_FILE_NAMES: readonly string[] = ['wdio.conf.mts', 'wdio.conf.ts'];\n\n/**\n * The packages a `wdio-obsidian-service` setup needs in the project.\n */\nconst WDIO_OBSIDIAN_PACKAGES: readonly string[] = ['@wdio/cli', '@wdio/local-runner', '@wdio/mocha-framework', 'wdio-obsidian-reporter', 'wdio-obsidian-service'];\n\n/**\n * Options for {@link defineWdioObsidianConfig}.\n */\nexport interface DefineWdioObsidianConfigOptions {\n  /**\n   * The Obsidian app versions to test, one capability each: a version such as `1.8.10`, `latest`, `latest-beta`, or\n   * `earliest` (the `minAppVersion` of `manifest.json`). Defaults to `['latest']`; `['earliest', 'latest']` tests\n   * both ends of the supported range.\n   */\n  readonly appVersions?: readonly string[];\n\n  /**\n   * The folder Obsidian versions are downloaded into, relative to the project root. Defaults to `.obsidian-cache`,\n   * which belongs in `.gitignore`.\n   */\n  readonly cacheFolder?: string;\n\n  /**\n   * The Obsidian installer (Electron) version, `earliest` or `latest` compatible with each app version, or an exact\n   * one. Defaults to the service's own choice.\n   */\n  readonly installerVersion?: string;\n\n  /**\n   * How many Obsidian instances run in parallel. Defaults to WebdriverIO's.\n   */\n  readonly maxInstances?: number;\n\n  /**\n   * The folder holding the built plugin (`main.js`, `manifest.json`, `styles.css`), relative to the project root.\n   * Defaults to `dist/build`, where the production build writes it.\n   */\n  readonly pluginFolder?: string;\n\n  /**\n   * The spec files, relative to the project root. Defaults to {@link DEFAULT_END_TO_END_SPECS}.\n   */\n  readonly specs?: readonly string[];\n\n  /**\n   * The per-test timeout, in milliseconds. Defaults to {@link DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS}.\n   */\n  readonly testTimeoutInMilliseconds?: number;\n\n  /**\n   * The vault every test starts from, relative to the project root. The service opens a COPY of it, so the tests\n   * never change the folder. Defaults to the plugin's demo vault (`demo-vault`) when the project has one, and to an\n   * empty vault otherwise; `false` forces the empty vault.\n   */\n  readonly vault?: false | string;\n}\n\n/**\n * Options for {@link testEndToEndWithWdioObsidian}.\n */\nexport interface TestEndToEndWithWdioObsidianOptions {\n  /**\n   * The WebdriverIO config file, relative to the project root. Defaults to the first of\n   * {@link WDIO_CONFIG_FILE_NAMES} that exists.\n   */\n  readonly configPath?: string;\n\n  /**\n   * Whether to run the production build first, so the tests load the current `dist/build`. Defaults to `true`.\n   */\n  readonly shouldBuild?: boolean;\n}\n\n/**\n * A `wdio-obsidian-service` capability: one Obsidian version to run the specs against.\n */\nexport interface WdioObsidianCapability {\n  /**\n   * Always `obsidian`, which is what routes the capability to the service.\n   */\n  'browserName': 'obsidian';\n\n  /**\n   * The Obsidian app version.\n   */\n  'browserVersion': string;\n\n  /**\n   * The service's own options for this capability.\n   */\n  'wdio:obsidianOptions': WdioObsidianCapabilityOptions;\n}\n\n/**\n * The `wdio:obsidianOptions` of a {@link WdioObsidianCapability}.\n */\nexport interface WdioObsidianCapabilityOptions {\n  /**\n   * The Obsidian installer version.\n   */\n  readonly installerVersion?: string;\n\n  /**\n   * The plugin folders to install into the vault.\n   */\n  readonly plugins: string[];\n\n  /**\n   * The vault to open a copy of.\n   */\n  readonly vault?: string;\n}\n\n/**\n * The WebdriverIO configuration {@link defineWdioObsidianConfig} returns. Every field is plain data, so a project\n * changes any of them by spreading the result: `{ ...defineWdioObsidianConfig(), logLevel: 'info' }`.\n */\nexport interface WdioObsidianConfig {\n  /**\n   * Where Obsidian versions are downloaded.\n   */\n  // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.\n  cacheDir: string;\n\n  /**\n   * One capability per Obsidian version.\n   */\n  capabilities: WdioObsidianCapability[];\n\n  /**\n   * The test framework.\n   */\n  framework: 'mocha';\n\n  /**\n   * WebdriverIO's log level.\n   */\n  logLevel: 'debug' | 'error' | 'info' | 'silent' | 'trace' | 'warn';\n\n  /**\n   * How many Obsidian instances run in parallel.\n   */\n  maxInstances?: number;\n\n  /**\n   * Mocha's options.\n   */\n  // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.\n  mochaOpts: WdioObsidianMochaOptions;\n\n  /**\n   * The reporters. `obsidian` is the spec reporter, naming the Obsidian version instead of Chromium's.\n   */\n  reporters: string[];\n\n  /**\n   * Where the specs run.\n   */\n  runner: 'local';\n\n  /**\n   * The services. `obsidian` is `wdio-obsidian-service`.\n   */\n  services: string[];\n\n  /**\n   * The spec files.\n   */\n  specs: string[];\n}\n\n/**\n * The `mochaOpts` of a {@link WdioObsidianConfig}.\n */\nexport interface WdioObsidianMochaOptions {\n  /**\n   * The per-test timeout, in milliseconds.\n   */\n  readonly timeout: number;\n\n  /**\n   * The interface the specs are written in.\n   */\n  readonly ui: 'bdd';\n}\n\n/**\n * Builds the WebdriverIO configuration for end-to-end tests with `wdio-obsidian-service`, derived from the plugin's\n * layout: the production build in `dist/build` is the plugin under test, the demo vault (when there is one) is the\n * vault, and the specs live in `e2e/`.\n *\n * `wdio.conf.mts`:\n *\n * ```ts\n * import { defineWdioObsidianConfig } from '@mnaoumov/obsidian-dev-toolkit/test-runners/wdio-obsidian';\n *\n * export const config: WebdriverIO.Config = defineWdioObsidianConfig({ appVersions: ['earliest', 'latest'] });\n * ```\n *\n * @param options - The {@link DefineWdioObsidianConfigOptions}.\n * @returns The configuration, to export as `config`.\n */\nexport function defineWdioObsidianConfig(options: DefineWdioObsidianConfigOptions = {}): WdioObsidianConfig {\n  const pluginFolder = resolvePathFromRootSafe({ path: options.pluginFolder ?? ObsidianPluginRepoPaths.DistBuild });\n  const vault = resolveVault(options.vault);\n  const capabilityOptions: WdioObsidianCapabilityOptions = {\n    plugins: [pluginFolder],\n    ...(options.installerVersion !== undefined && { installerVersion: options.installerVersion }),\n    ...(vault !== undefined && { vault })\n  };\n\n  return {\n    // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.\n    cacheDir: resolvePathFromRootSafe({ path: options.cacheFolder ?? '.obsidian-cache' }),\n    capabilities: (options.appVersions ?? ['latest']).map((appVersion) => ({\n      'browserName': 'obsidian',\n      'browserVersion': appVersion,\n      'wdio:obsidianOptions': { ...capabilityOptions, plugins: [...capabilityOptions.plugins] }\n    })),\n    framework: 'mocha',\n    logLevel: 'warn',\n    ...(options.maxInstances !== undefined && { maxInstances: options.maxInstances }),\n    // eslint-disable-next-line unicorn/name-replacements -- WebdriverIO's own option name.\n    mochaOpts: {\n      timeout: options.testTimeoutInMilliseconds ?? DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS,\n      ui: 'bdd'\n    },\n    reporters: ['obsidian'],\n    runner: 'local',\n    services: ['obsidian'],\n    specs: [...options.specs ?? [DEFAULT_END_TO_END_SPECS]]\n  };\n}\n\n/**\n * Runs the end-to-end tests with `wdio-obsidian-service`: the production build, then `wdio run <config>`. It is the\n * body of a plugin's `test:e2e` script.\n *\n * @param options - The {@link TestEndToEndWithWdioObsidianOptions}.\n * @returns A {@link Promise} that resolves once the tests pass.\n * @throws When a package is missing, no config file is found, the build fails or a test fails.\n */\nexport async function testEndToEndWithWdioObsidian(options: TestEndToEndWithWdioObsidianOptions = {}): Promise<void> {\n  assertProjectPackagesInstalled({ packageNames: WDIO_OBSIDIAN_PACKAGES, requester: 'testEndToEndWithWdioObsidian()' });\n  const configPath = options.configPath ?? findWdioConfigFile();\n  if (options.shouldBuild ?? true) {\n    await npmRun('build');\n  }\n  await execFromRoot(['wdio', 'run', configPath], { isInteractive: true });\n}\n\nfunction findWdioConfigFile(): string {\n  const configFileName = WDIO_CONFIG_FILE_NAMES.find((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })));\n  if (configFileName === undefined) {\n    throw new Error(\n      `testEndToEndWithWdioObsidian() found no WebdriverIO config (${WDIO_CONFIG_FILE_NAMES.join(', ')}) in the project root. `\n        + 'Create wdio.conf.mts exporting `config = defineWdioObsidianConfig()`, or pass `configPath`.'\n    );\n  }\n  return configFileName;\n}\n\nfunction resolveVault(vault: DefineWdioObsidianConfigOptions['vault']): string | undefined {\n  if (vault === false) {\n    return undefined;\n  }\n  if (vault !== undefined) {\n    return resolvePathFromRootSafe({ path: vault });\n  }\n  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });\n  return existsSync(demoVaultPath) ? demoVaultPath : undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAAuB;AACvB,kBAGO;AACP,qBAA2B;AAE3B,wCAAwC;AACxC,gCAGO;AAMA,MAAM,qDAAqD;AAK3D,MAAM,yBAA4C,CAAC,iBAAiB,cAAc;AAKzF,MAAM,yBAA4C,CAAC,aAAa,sBAAsB,yBAAyB,0BAA0B,uBAAuB;AAuMzJ,SAAS,yBAAyB,UAA2C,CAAC,GAAuB;AAC1G,QAAM,mBAAe,qCAAwB,EAAE,MAAM,QAAQ,gBAAgB,0DAAwB,UAAU,CAAC;AAChH,QAAM,QAAQ,aAAa,QAAQ,KAAK;AACxC,QAAM,oBAAmD;AAAA,IACvD,SAAS,CAAC,YAAY;AAAA,IACtB,GAAI,QAAQ,qBAAqB,UAAa,EAAE,kBAAkB,QAAQ,iBAAiB;AAAA,IAC3F,GAAI,UAAU,UAAa,EAAE,MAAM;AAAA,EACrC;AAEA,SAAO;AAAA;AAAA,IAEL,cAAU,qCAAwB,EAAE,MAAM,QAAQ,eAAe,kBAAkB,CAAC;AAAA,IACpF,eAAe,QAAQ,eAAe,CAAC,QAAQ,GAAG,IAAI,CAAC,gBAAgB;AAAA,MACrE,eAAe;AAAA,MACf,kBAAkB;AAAA,MAClB,wBAAwB,EAAE,GAAG,mBAAmB,SAAS,CAAC,GAAG,kBAAkB,OAAO,EAAE;AAAA,IAC1F,EAAE;AAAA,IACF,WAAW;AAAA,IACX,UAAU;AAAA,IACV,GAAI,QAAQ,iBAAiB,UAAa,EAAE,cAAc,QAAQ,aAAa;AAAA;AAAA,IAE/E,WAAW;AAAA,MACT,SAAS,QAAQ,6BAA6B;AAAA,MAC9C,IAAI;AAAA,IACN;AAAA,IACA,WAAW,CAAC,UAAU;AAAA,IACtB,QAAQ;AAAA,IACR,UAAU,CAAC,UAAU;AAAA,IACrB,OAAO,CAAC,GAAG,QAAQ,SAAS,CAAC,kDAAwB,CAAC;AAAA,EACxD;AACF;AAUA,eAAsB,6BAA6B,UAA+C,CAAC,GAAkB;AACnH,gEAA+B,EAAE,cAAc,wBAAwB,WAAW,iCAAiC,CAAC;AACpH,QAAM,aAAa,QAAQ,cAAc,mBAAmB;AAC5D,MAAI,QAAQ,eAAe,MAAM;AAC/B,cAAM,uBAAO,OAAO;AAAA,EACtB;AACA,YAAM,0BAAa,CAAC,QAAQ,OAAO,UAAU,GAAG,EAAE,eAAe,KAAK,CAAC;AACzE;AAEA,SAAS,qBAA6B;AACpC,QAAM,iBAAiB,uBAAuB,KAAK,CAAC,iBAAa,+BAAW,qCAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC;AACxH,MAAI,mBAAmB,QAAW;AAChC,UAAM,IAAI;AAAA,MACR,+DAA+D,uBAAuB,KAAK,IAAI,CAAC;AAAA,IAElG;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,aAAa,OAAqE;AACzF,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACT;AACA,MAAI,UAAU,QAAW;AACvB,eAAO,qCAAwB,EAAE,MAAM,MAAM,CAAC;AAAA,EAChD;AACA,QAAM,oBAAgB,qCAAwB,EAAE,MAAM,0DAAwB,UAAU,CAAC;AACzF,aAAO,2BAAW,aAAa,IAAI,gBAAgB;AACrD;","names":[]}