@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/esm/test-runners/index.mjs

@@ -3,12 +3,22 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import * as coverage_badge_cli from "./coverage-badge-cli.mjs";
+import * as coverage_badge from "./coverage-badge.mjs";
+import * as e2e_runner_support from "./e2e-runner-support.mjs";
 import * as integration_test_plugin from "./integration-test-plugin.mjs";
+import * as obsidian_test_runner from "./obsidian-test-runner.mjs";
 import * as performance_eval_cap from "./performance-eval-cap.mjs";
 import * as vitest_config from "./vitest-config.mjs";
+import * as wdio_obsidian from "./wdio-obsidian.mjs";
 export {
+  coverage_badge as "coverage-badge",
+  coverage_badge_cli as "coverage-badge-cli",
+  e2e_runner_support as "e2e-runner-support",
   integration_test_plugin as "integration-test-plugin",
+  obsidian_test_runner as "obsidian-test-runner",
   performance_eval_cap as "performance-eval-cap",
-  vitest_config as "vitest-config"
+  vitest_config as "vitest-config",
+  wdio_obsidian as "wdio-obsidian"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdpbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbicgZnJvbSAnLi9pbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAncGVyZm9ybWFuY2UtZXZhbC1jYXAnIGZyb20gJy4vcGVyZm9ybWFuY2UtZXZhbC1jYXAudHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVlBLDZCQUErQjtBQUMzQyxZQUFZQywwQkFBNEI7QUFDeEMsWUFBWUMsbUJBQXFCOyIsCiAgIm5hbWVzIjogWyJpbnRlZ3JhdGlvbi10ZXN0LXBsdWdpbiIsICJwZXJmb3JtYW5jZS1ldmFsLWNhcCIsICJ2aXRlc3QtY29uZmlnIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdjb3ZlcmFnZS1iYWRnZS1jbGknIGZyb20gJy4vY292ZXJhZ2UtYmFkZ2UtY2xpLnRzJztcbmV4cG9ydCAqIGFzICdjb3ZlcmFnZS1iYWRnZScgZnJvbSAnLi9jb3ZlcmFnZS1iYWRnZS50cyc7XG5leHBvcnQgKiBhcyAnZTJlLXJ1bm5lci1zdXBwb3J0JyBmcm9tICcuL2UyZS1ydW5uZXItc3VwcG9ydC50cyc7XG5leHBvcnQgKiBhcyAnaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4nIGZyb20gJy4vaW50ZWdyYXRpb24tdGVzdC1wbHVnaW4udHMnO1xuZXhwb3J0ICogYXMgJ29ic2lkaWFuLXRlc3QtcnVubmVyJyBmcm9tICcuL29ic2lkaWFuLXRlc3QtcnVubmVyLnRzJztcbmV4cG9ydCAqIGFzICdwZXJmb3JtYW5jZS1ldmFsLWNhcCcgZnJvbSAnLi9wZXJmb3JtYW5jZS1ldmFsLWNhcC50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0LWNvbmZpZycgZnJvbSAnLi92aXRlc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICd3ZGlvLW9ic2lkaWFuJyBmcm9tICcuL3dkaW8tb2JzaWRpYW4udHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZQSx3QkFBMEI7QUFDdEMsWUFBWUMsb0JBQXNCO0FBQ2xDLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZQyw2QkFBK0I7QUFDM0MsWUFBWUMsMEJBQTRCO0FBQ3hDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyxtQkFBcUI7QUFDakMsWUFBWUMsbUJBQXFCOyIsCiAgIm5hbWVzIjogWyJjb3ZlcmFnZS1iYWRnZS1jbGkiLCAiY292ZXJhZ2UtYmFkZ2UiLCAiZTJlLXJ1bm5lci1zdXBwb3J0IiwgImludGVncmF0aW9uLXRlc3QtcGx1Z2luIiwgIm9ic2lkaWFuLXRlc3QtcnVubmVyIiwgInBlcmZvcm1hbmNlLWV2YWwtY2FwIiwgInZpdGVzdC1jb25maWciLCAid2Rpby1vYnNpZGlhbiJdCn0K

package/dist/lib/esm/test-runners/obsidian-test-runner.d.mts

@@ -0,0 +1,42 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @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/esm/test-runners/obsidian-test-runner.mjs

@@ -0,0 +1,52 @@
+/*
+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();
+})();
+
+import { execFromRoot } from "@mnaoumov/typescript-dev-toolkit/root";
+import {
+  assertProjectPackagesInstalled,
+  DEFAULT_END_TO_END_SPECS
+} from "./e2e-runner-support.mjs";
+async function testEndToEndWithObsidianTest(options = {}) {
+  assertProjectPackagesInstalled({ packageNames: ["obsidian-test"], requester: "testEndToEndWithObsidianTest()" });
+  await execFromRoot([
+    "obsidian-test",
+    "--testPattern",
+    options.testPattern ?? 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 });
+}
+export {
+  testEndToEndWithObsidianTest
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/wdio-obsidian.d.mts

@@ -0,0 +1,199 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * End-to-end tests with `wdio-obsidian-service`: WebdriverIO drives a sandboxed copy of Obsidian, downloaded per
+ * version into a cache, with the plugin installed into a copy of the test vault.
+ *
+ * {@link defineWdioObsidianConfig} derives the `wdio.conf.mts` from the project's layout, and
+ * {@link testEndToEndWithWdioObsidian} is the `test:e2e` script: a production build, then `wdio run`.
+ *
+ * The config is typed structurally rather than through `@wdio/types`, so this module costs a project that does not
+ * use WebdriverIO nothing, and the returned object is assignable to `WebdriverIO.Config` in one that does.
+ */
+/**
+ * The per-test timeout {@link defineWdioObsidianConfig} gives mocha by default, in milliseconds. Obsidian is
+ * started once per spec file, which a single test's budget has to absorb.
+ */
+export declare const DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * The config files {@link testEndToEndWithWdioObsidian} looks for, in order.
+ */
+export declare const WDIO_CONFIG_FILE_NAMES: readonly string[];
+/**
+ * Options for {@link defineWdioObsidianConfig}.
+ */
+export interface DefineWdioObsidianConfigOptions {
+    /**
+     * The Obsidian app versions to test, one capability each: a version such as `1.8.10`, `latest`, `latest-beta`, or
+     * `earliest` (the `minAppVersion` of `manifest.json`). Defaults to `['latest']`; `['earliest', 'latest']` tests
+     * both ends of the supported range.
+     */
+    readonly appVersions?: readonly string[];
+    /**
+     * The folder Obsidian versions are downloaded into, relative to the project root. Defaults to `.obsidian-cache`,
+     * which belongs in `.gitignore`.
+     */
+    readonly cacheFolder?: string;
+    /**
+     * The Obsidian installer (Electron) version, `earliest` or `latest` compatible with each app version, or an exact
+     * one. Defaults to the service's own choice.
+     */
+    readonly installerVersion?: string;
+    /**
+     * How many Obsidian instances run in parallel. Defaults to WebdriverIO's.
+     */
+    readonly maxInstances?: number;
+    /**
+     * The folder holding the built plugin (`main.js`, `manifest.json`, `styles.css`), relative to the project root.
+     * Defaults to `dist/build`, where the production build writes it.
+     */
+    readonly pluginFolder?: string;
+    /**
+     * The spec files, relative to the project root. Defaults to {@link DEFAULT_END_TO_END_SPECS}.
+     */
+    readonly specs?: readonly string[];
+    /**
+     * The per-test timeout, in milliseconds. Defaults to {@link DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS}.
+     */
+    readonly testTimeoutInMilliseconds?: number;
+    /**
+     * The vault every test starts from, relative to the project root. The service opens a COPY of it, so the tests
+     * never change the folder. Defaults to the plugin's demo vault (`demo-vault`) when the project has one, and to an
+     * empty vault otherwise; `false` forces the empty vault.
+     */
+    readonly vault?: false | string;
+}
+/**
+ * Options for {@link testEndToEndWithWdioObsidian}.
+ */
+export interface TestEndToEndWithWdioObsidianOptions {
+    /**
+     * The WebdriverIO config file, relative to the project root. Defaults to the first of
+     * {@link WDIO_CONFIG_FILE_NAMES} that exists.
+     */
+    readonly configPath?: string;
+    /**
+     * Whether to run the production build first, so the tests load the current `dist/build`. Defaults to `true`.
+     */
+    readonly shouldBuild?: boolean;
+}
+/**
+ * A `wdio-obsidian-service` capability: one Obsidian version to run the specs against.
+ */
+export interface WdioObsidianCapability {
+    /**
+     * Always `obsidian`, which is what routes the capability to the service.
+     */
+    'browserName': 'obsidian';
+    /**
+     * The Obsidian app version.
+     */
+    'browserVersion': string;
+    /**
+     * The service's own options for this capability.
+     */
+    'wdio:obsidianOptions': WdioObsidianCapabilityOptions;
+}
+/**
+ * The `wdio:obsidianOptions` of a {@link WdioObsidianCapability}.
+ */
+export interface WdioObsidianCapabilityOptions {
+    /**
+     * The Obsidian installer version.
+     */
+    readonly installerVersion?: string;
+    /**
+     * The plugin folders to install into the vault.
+     */
+    readonly plugins: string[];
+    /**
+     * The vault to open a copy of.
+     */
+    readonly vault?: string;
+}
+/**
+ * The WebdriverIO configuration {@link defineWdioObsidianConfig} returns. Every field is plain data, so a project
+ * changes any of them by spreading the result: `{ ...defineWdioObsidianConfig(), logLevel: 'info' }`.
+ */
+export interface WdioObsidianConfig {
+    /**
+     * Where Obsidian versions are downloaded.
+     */
+    cacheDir: string;
+    /**
+     * One capability per Obsidian version.
+     */
+    capabilities: WdioObsidianCapability[];
+    /**
+     * The test framework.
+     */
+    framework: 'mocha';
+    /**
+     * WebdriverIO's log level.
+     */
+    logLevel: 'debug' | 'error' | 'info' | 'silent' | 'trace' | 'warn';
+    /**
+     * How many Obsidian instances run in parallel.
+     */
+    maxInstances?: number;
+    /**
+     * Mocha's options.
+     */
+    mochaOpts: WdioObsidianMochaOptions;
+    /**
+     * The reporters. `obsidian` is the spec reporter, naming the Obsidian version instead of Chromium's.
+     */
+    reporters: string[];
+    /**
+     * Where the specs run.
+     */
+    runner: 'local';
+    /**
+     * The services. `obsidian` is `wdio-obsidian-service`.
+     */
+    services: string[];
+    /**
+     * The spec files.
+     */
+    specs: string[];
+}
+/**
+ * The `mochaOpts` of a {@link WdioObsidianConfig}.
+ */
+export interface WdioObsidianMochaOptions {
+    /**
+     * The per-test timeout, in milliseconds.
+     */
+    readonly timeout: number;
+    /**
+     * The interface the specs are written in.
+     */
+    readonly ui: 'bdd';
+}
+/**
+ * Builds the WebdriverIO configuration for end-to-end tests with `wdio-obsidian-service`, derived from the plugin's
+ * layout: the production build in `dist/build` is the plugin under test, the demo vault (when there is one) is the
+ * vault, and the specs live in `e2e/`.
+ *
+ * `wdio.conf.mts`:
+ *
+ * ```ts
+ * import { defineWdioObsidianConfig } from '@mnaoumov/obsidian-dev-toolkit/test-runners/wdio-obsidian';
+ *
+ * export const config: WebdriverIO.Config = defineWdioObsidianConfig({ appVersions: ['earliest', 'latest'] });
+ * ```
+ *
+ * @param options - The {@link DefineWdioObsidianConfigOptions}.
+ * @returns The configuration, to export as `config`.
+ */
+export declare function defineWdioObsidianConfig(options?: DefineWdioObsidianConfigOptions): WdioObsidianConfig;
+/**
+ * Runs the end-to-end tests with `wdio-obsidian-service`: the production build, then `wdio run <config>`. It is the
+ * body of a plugin's `test:e2e` script.
+ *
+ * @param options - The {@link TestEndToEndWithWdioObsidianOptions}.
+ * @returns A {@link Promise} that resolves once the tests pass.
+ * @throws When a package is missing, no config file is found, the build fails or a test fails.
+ */
+export declare function testEndToEndWithWdioObsidian(options?: TestEndToEndWithWdioObsidianOptions): Promise<void>;

package/dist/lib/esm/test-runners/wdio-obsidian.mjs

@@ -0,0 +1,110 @@
+/*
+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();
+})();
+
+import { npmRun } from "@mnaoumov/typescript-dev-toolkit/npm-run";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "@mnaoumov/typescript-dev-toolkit/root";
+import { existsSync } from "node:fs";
+import { ObsidianPluginRepoPaths } from "../obsidian-plugin-repo-paths.mjs";
+import {
+  assertProjectPackagesInstalled,
+  DEFAULT_END_TO_END_SPECS
+} from "./e2e-runner-support.mjs";
+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 = resolvePathFromRootSafe({ path: options.pluginFolder ?? 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: 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 ?? [DEFAULT_END_TO_END_SPECS]]
+  };
+}
+async function testEndToEndWithWdioObsidian(options = {}) {
+  assertProjectPackagesInstalled({ packageNames: WDIO_OBSIDIAN_PACKAGES, requester: "testEndToEndWithWdioObsidian()" });
+  const configPath = options.configPath ?? findWdioConfigFile();
+  if (options.shouldBuild ?? true) {
+    await npmRun("build");
+  }
+  await execFromRoot(["wdio", "run", configPath], { isInteractive: true });
+}
+function findWdioConfigFile() {
+  const configFileName = WDIO_CONFIG_FILE_NAMES.find((fileName) => existsSync(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 resolvePathFromRootSafe({ path: vault });
+  }
+  const demoVaultPath = resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.DemoVault });
+  return existsSync(demoVaultPath) ? demoVaultPath : void 0;
+}
+export {
+  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,SAAS,cAAc;AACvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAE3B,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;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,eAAe,wBAAwB,EAAE,MAAM,QAAQ,gBAAgB,wBAAwB,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,UAAU,wBAAwB,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,wBAAwB,CAAC;AAAA,EACxD;AACF;AAUA,eAAsB,6BAA6B,UAA+C,CAAC,GAAkB;AACnH,iCAA+B,EAAE,cAAc,wBAAwB,WAAW,iCAAiC,CAAC;AACpH,QAAM,aAAa,QAAQ,cAAc,mBAAmB;AAC5D,MAAI,QAAQ,eAAe,MAAM;AAC/B,UAAM,OAAO,OAAO;AAAA,EACtB;AACA,QAAM,aAAa,CAAC,QAAQ,OAAO,UAAU,GAAG,EAAE,eAAe,KAAK,CAAC;AACzE;AAEA,SAAS,qBAA6B;AACpC,QAAM,iBAAiB,uBAAuB,KAAK,CAAC,aAAa,WAAW,wBAAwB,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,WAAO,wBAAwB,EAAE,MAAM,MAAM,CAAC;AAAA,EAChD;AACA,QAAM,gBAAgB,wBAAwB,EAAE,MAAM,wBAAwB,UAAU,CAAC;AACzF,SAAO,WAAW,aAAa,IAAI,gBAAgB;AACrD;","names":[]}