obsidian-e2e 0.0.0-next.0

package/README.md

@@ -0,0 +1,432 @@
+# obsidian-e2e
+
+Vitest-first end-to-end test utilities for Obsidian plugins.
+
+`obsidian-e2e` is a thin testing library around a live Obsidian vault and the
+globally installed `obsidian` CLI. It stays plugin-agnostic on purpose: you get
+generic fixtures for Obsidian, vault access, and per-test sandboxes, then opt
+into plugin-specific behavior through `obsidian.plugin(id)`.
+
+## Install
+
+```bash
+pnpm add -D obsidian-e2e
+```
+
+Requirements:
+
+- Obsidian must be installed locally.
+- The `obsidian` CLI must already be available on `PATH`.
+- Your target vault must be open and reachable from the CLI.
+
+## Public Entry Points
+
+- `obsidian-e2e`
+  - low-level client and shared types
+- `obsidian-e2e/vitest`
+  - `createObsidianTest()`
+  - `createPluginTest()`
+- `obsidian-e2e/matchers`
+  - optional `expect` matchers for vault and sandbox assertions
+
+## Setup
+
+`tests/setup.ts`
+
+```ts
+import { createObsidianTest } from "obsidian-e2e/vitest";
+import "obsidian-e2e/matchers";
+
+export const test = createObsidianTest({
+  vault: "dev",
+  bin: process.env.OBSIDIAN_BIN ?? "obsidian",
+  sandboxRoot: "__obsidian_e2e__",
+  timeoutMs: 5_000,
+});
+```
+
+`vite.config.ts`
+
+```ts
+import { defineConfig } from "vite-plus";
+
+export default defineConfig({
+  test: {
+    fileParallelism: false,
+    maxWorkers: 1,
+  },
+});
+```
+
+Run Obsidian-backed tests serially. A live Obsidian app and shared vault are
+not safe to hit from multiple Vitest workers at once, so `fileParallelism: false`
+and `maxWorkers: 1` should be treated as the default, not as an optimization.
+
+## Writing Tests
+
+```ts
+import { expect } from "vite-plus/test";
+import { test } from "./setup";
+
+test("reloads a plugin after patching its data file", async ({ obsidian, vault, sandbox }) => {
+  const plugin = obsidian.plugin("my-plugin");
+
+  await sandbox.write("tpl.md", "template body");
+  await vault.write("notes/source.md", "existing");
+
+  await plugin.data<{ enabled: boolean }>().patch((draft) => {
+    draft.enabled = true;
+  });
+
+  await plugin.reload();
+
+  await expect(sandbox).toHaveFile("tpl.md");
+  await expect(vault).toHaveFileContaining("notes/source.md", "existing");
+});
+```
+
+Fixture summary:
+
+- `obsidian`
+  - low-level access to `app`, `command(id)`, `commands()`, `exec`, `execText`,
+    `execJson`, `waitFor`, `vaultPath`, and `plugin(id)`
+- `vault`
+  - reads and writes anywhere in the vault rooted at the active Obsidian vault
+- `sandbox`
+  - a per-test disposable directory under `sandboxRoot`; automatically cleaned
+    up after each test
+
+Plugin data mutations are snapshotted on first write and restored automatically
+after each test. Sandbox files are also cleaned up automatically.
+
+## Plugin Test Helper
+
+If you are testing one plugin repeatedly, `createPluginTest()` gives you a
+first-class `plugin` fixture and optional seed helpers for vault files and
+plugin data:
+
+```ts
+import { createPluginTest } from "obsidian-e2e/vitest";
+
+export const test = createPluginTest({
+  vault: "dev",
+  pluginId: "quickadd",
+  pluginFilter: "community",
+  seedPluginData: { enabled: true },
+  seedVault: {
+    "fixtures/template.md": "template body",
+    "fixtures/state.json": { json: { ready: true } },
+  },
+});
+```
+
+`createPluginTest()`:
+
+- injects `plugin` alongside `obsidian`, `vault`, and `sandbox`
+- enables the target plugin for the test when needed and restores the prior
+  enabled/disabled state afterward
+- seeds vault files before each test and restores the original files afterward
+- seeds `data.json` through the normal plugin snapshot/restore path
+- supports the same opt-in failure artifact capture as `createObsidianTest()`
+
+Example:
+
+```ts
+import { expect } from "vite-plus/test";
+import { test } from "./setup";
+
+test("runs against a seeded plugin fixture", async ({ plugin, vault }) => {
+  await expect(plugin.data<{ enabled: boolean }>().read()).resolves.toEqual({
+    enabled: true,
+  });
+  await expect(vault.read("fixtures/template.md")).resolves.toBe("template body");
+
+  await plugin.reload();
+});
+```
+
+## Failure Artifacts
+
+Both fixture families support opt-in artifact capture:
+
+- `createObsidianTest({ artifactsDir, captureOnFailure })`
+- `createPluginTest({ artifactsDir, captureOnFailure, ... })`
+
+Example:
+
+```ts
+import { createObsidianTest, createPluginTest } from "obsidian-e2e/vitest";
+
+export const test = createObsidianTest({
+  vault: "dev",
+  captureOnFailure: true,
+});
+
+export const pluginTest = createPluginTest({
+  vault: "dev",
+  pluginId: "quickadd",
+  artifactsDir: ".artifacts",
+  captureOnFailure: {
+    screenshot: false,
+  },
+});
+```
+
+When `captureOnFailure` is enabled, failed tests write artifacts under
+`.obsidian-e2e-artifacts` by default, or under `artifactsDir` if you set one.
+Each failed test gets its own directory named from the test name plus a stable
+task-id suffix, for example:
+
+```txt
+.obsidian-e2e-artifacts/
+  writes-useful-artifacts-abcdef12/
+```
+
+`createObsidianTest()` captures:
+
+- `active-file.json`
+- `dom.txt`
+- `editor.json`
+- `tabs.json`
+- `workspace.json`
+- `screenshot.png` when screenshot capture succeeds
+
+`createPluginTest()` adds:
+
+- `<pluginId>-data.json`
+
+Artifact collection is best-effort. If a specific capture fails, the test still
+fails for its original reason and the framework writes a neighboring
+`*.error.txt` file instead. Screenshot capture is the most environment-sensitive
+part of the set: desktop permissions, display availability, or Obsidian state
+can prevent `screenshot.png` from being produced, in which case you should
+expect `screenshot.error.txt` instead.
+
+## Maintainer CI And Releases
+
+This repo now ships with a hardened CI and release flow built around Vite+
+workflow setup, Changesets release orchestration, and npm trusted publishing
+through GitHub OIDC.
+
+At a high level:
+
+- CI installs the toolchain with `setup-vp`, then runs `vp check`,
+  `vp test`, and `vp pack`.
+- When CI fails after artifact capture is enabled in tests, it uploads
+  `.obsidian-e2e-artifacts` so maintainers can inspect the same failure
+  snapshots produced locally.
+- Releases go through Changesets PRs. Merge the version PR that
+  Changesets opens, then let the release workflow publish to npm.
+
+Maintainer setup notes:
+
+- Configure npm trusted publishing for this package and repository so the
+  GitHub release workflow can publish without a long-lived npm token.
+- Grant the publish job `id-token: write` so GitHub can mint the OIDC token npm
+  expects, and keep the release workflow permissions aligned with the write
+  actions it needs, such as `contents: write` and `pull-requests: write` for
+  Changesets automation.
+- If you protect publishing behind a GitHub environment, attach that
+  environment to the release job and allow the workflow to use it.
+
+## Matchers
+
+Import `obsidian-e2e/matchers` once in your test setup to register:
+
+- `toHaveActiveFile(path)`
+- `toHaveCommand(commandId)`
+- `toHaveEditorTextContaining(needle)`
+- `toHaveFile(path)`
+- `toHaveFileContaining(path, needle)`
+- `toHaveJsonFile(path)`
+- `toHaveOpenTab(title, viewType?)`
+- `toHavePluginData(expected)`
+- `toHaveWorkspaceNode(label)`
+
+Example:
+
+```ts
+import { expect } from "vite-plus/test";
+import { test } from "./setup";
+
+test("writes valid JSON into the sandbox", async ({ sandbox }) => {
+  await sandbox.json("config.json").write({ enabled: true });
+
+  await expect(sandbox).toHaveJsonFile("config.json");
+});
+
+test("asserts active Obsidian state", async ({ obsidian, plugin }) => {
+  await expect(obsidian).toHaveCommand("quickadd:run-choice");
+  await expect(obsidian).toHaveActiveFile("Inbox/Today.md");
+  await expect(obsidian).toHaveEditorTextContaining("Today");
+  await expect(obsidian).toHaveOpenTab("Today", "markdown");
+  await expect(obsidian).toHaveWorkspaceNode("main");
+  await expect(plugin).toHavePluginData({ enabled: true });
+});
+```
+
+## Low-Level Client
+
+If you need to work below the fixture layer:
+
+```ts
+import { createObsidianClient } from "obsidian-e2e";
+
+const obsidian = createObsidianClient({
+  vault: "dev",
+  bin: "obsidian",
+});
+
+await obsidian.verify();
+await obsidian.exec("plugin:reload", { id: "my-plugin" });
+```
+
+## App And Commands
+
+The client now exposes app-level helpers and command helpers that map directly
+to the real `obsidian` CLI:
+
+- `obsidian.app.version()`
+- `obsidian.app.reload()`
+- `obsidian.app.restart()`
+- `obsidian.app.waitUntilReady()`
+- `obsidian.commands({ filter? })`
+- `obsidian.command(id).exists()`
+- `obsidian.command(id).run()`
+- `obsidian.dev.dom({ ... })`
+- `obsidian.dev.eval(code)`
+- `obsidian.dev.screenshot(path)`
+- `obsidian.tabs()`
+- `obsidian.workspace()`
+- `obsidian.open({ file? | path?, newTab? })`
+- `obsidian.openTab({ file?, group?, view? })`
+
+Example:
+
+```ts
+import { expect } from "vite-plus/test";
+import { test } from "./setup";
+
+test("reloads the app and runs a plugin command when it becomes available", async ({
+  obsidian,
+}) => {
+  await obsidian.app.waitUntilReady();
+
+  const commandId = "quickadd:run-choice";
+
+  if (await obsidian.command(commandId).exists()) {
+    await obsidian.command(commandId).run();
+  }
+
+  await obsidian.app.reload();
+
+  await expect(obsidian.commands({ filter: "quickadd:" })).resolves.toContain(commandId);
+});
+```
+
+`obsidian.app.restart()` waits for the app to come back by default. Pass
+`{ waitUntilReady: false }` if you need to manage readiness explicitly.
+
+Workspace and tab readers return parsed structures, so you can inspect layout
+state without writing custom parsers in every test:
+
+```ts
+test("opens a note into a new tab and finds it in the workspace", async ({ obsidian }) => {
+  await obsidian.open({
+    newTab: true,
+    path: "Inbox/Today.md",
+  });
+
+  const tabs = await obsidian.tabs();
+  const workspace = await obsidian.workspace();
+
+  expect(tabs.some((tab) => tab.title === "Today")).toBe(true);
+  expect(workspace.some((node) => node.label === "main")).toBe(true);
+});
+```
+
+For deeper UI inspection, the `dev` namespace exposes the desktop developer
+commands:
+
+```ts
+test("inspects live UI state", async ({ obsidian }) => {
+  const titles = await obsidian.dev.dom({
+    all: true,
+    selector: ".workspace-tab-header-inner-title",
+    text: true,
+  });
+
+  expect(titles).toContain("Today");
+
+  await obsidian.dev.screenshot("artifacts/today.png");
+});
+```
+
+`obsidian.dev.eval()` is the low-level escape hatch, while `dev.dom()` and
+`dev.screenshot()` give you safer wrappers around the built-in developer CLI
+commands. Screenshot behavior depends on the active desktop environment, so
+start by validating it locally before relying on it in automation.
+
+## End-To-End Workflow
+
+Putting it together, a realistic plugin test usually looks like this:
+
+```ts
+import { expect } from "vite-plus/test";
+import { createPluginTest } from "obsidian-e2e/vitest";
+import "obsidian-e2e/matchers";
+
+const test = createPluginTest({
+  vault: "dev",
+  pluginId: "quickadd",
+  pluginFilter: "community",
+  seedPluginData: {
+    macros: [],
+  },
+  seedVault: {
+    "fixtures/template.md": "Hello from template",
+    "Inbox/Today.md": "# Today\n",
+  },
+});
+
+test("runs a seeded workflow end to end", async ({ obsidian, plugin, vault }) => {
+  await expect(obsidian).toHaveCommand("quickadd:run-choice");
+  await expect(plugin).toHavePluginData({
+    macros: [],
+  });
+
+  if (await obsidian.command("quickadd:run-choice").exists()) {
+    await obsidian.command("quickadd:run-choice").run();
+  }
+
+  await obsidian.open({
+    path: "Inbox/Today.md",
+  });
+
+  await expect(obsidian).toHaveActiveFile("Inbox/Today.md");
+  await expect(vault).toHaveFile("fixtures/template.md");
+
+  const headers = await obsidian.dev.dom({
+    all: true,
+    selector: ".workspace-tab-header-inner-title",
+    text: true,
+  });
+
+  expect(headers).toContain("Today");
+});
+```
+
+That pattern keeps tests readable:
+
+- use `createPluginTest()` when one plugin is the main subject under test
+- seed only the files and plugin data needed for that case
+- prefer Obsidian-aware matchers over ad hoc CLI parsing
+- drop to `obsidian.dev.*` only when filesystem and command assertions are not enough
+
+## Notes
+
+- This package is a testing library, not a custom runner.
+- It is designed for real Obsidian-backed integration and e2e flows, not for
+  mocked unit tests.
+- Headless CI for desktop Obsidian is environment-specific; start by getting
+  tests reliable locally before automating them.

package/dist/index.d.mts

@@ -0,0 +1,22 @@
+import { C as WaitForOptions, E as WorkspaceTab, S as VaultApi, T as WorkspaceOptions, _ as PluginHandle, a as DevDomResult, b as SandboxApi, c as JsonFile, d as ObsidianArg, f as ObsidianClient, g as OpenTabOptions, h as OpenFileOptions, i as DevDomQueryOptions, l as JsonFileUpdater, m as ObsidianDevHandle, n as CommandTransport, o as ExecOptions, p as ObsidianCommandHandle, r as CreateObsidianClientOptions, s as ExecResult, t as CommandListOptions, u as ObsidianAppHandle, w as WorkspaceNode, x as TabsOptions, y as RestartAppOptions } from "./types-5UxOZM7r.mjs";
+
+//#region src/core/client.d.ts
+declare function createObsidianClient(options: CreateObsidianClientOptions): ObsidianClient;
+//#endregion
+//#region src/vault/sandbox.d.ts
+interface CreateSandboxApiOptions {
+  obsidian: ObsidianClient;
+  sandboxRoot: string;
+  testName: string;
+}
+declare function createSandboxApi(options: CreateSandboxApiOptions): Promise<SandboxApi>;
+//#endregion
+//#region src/vault/vault.d.ts
+interface CreateVaultApiOptions {
+  obsidian: ObsidianClient;
+  root?: string;
+}
+declare function createVaultApi(options: CreateVaultApiOptions): VaultApi;
+//#endregion
+export { type CommandListOptions, type CommandTransport, type CreateObsidianClientOptions, type DevDomQueryOptions, type DevDomResult, type ExecOptions, type ExecResult, type JsonFile, type JsonFileUpdater, type ObsidianAppHandle, type ObsidianArg, type ObsidianClient, type ObsidianCommandHandle, type ObsidianDevHandle, type OpenFileOptions, type OpenTabOptions, type PluginHandle, type RestartAppOptions, type SandboxApi, type TabsOptions, type VaultApi, type WaitForOptions, type WorkspaceNode, type WorkspaceOptions, type WorkspaceTab, createObsidianClient, createSandboxApi, createVaultApi };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as createVaultApi, r as createObsidianClient, t as createSandboxApi } from "./sandbox-BhesE1S4.mjs";
+export { createObsidianClient, createSandboxApi, createVaultApi };

package/dist/matchers.d.mts

@@ -0,0 +1,26 @@
+//#region src/matchers.d.ts
+declare module "vite-plus/test" {
+  interface Assertion<T = any> {
+    toHaveActiveFile(path: string): Promise<T>;
+    toHaveCommand(commandId: string): Promise<T>;
+    toHaveEditorTextContaining(needle: string): Promise<T>;
+    toHaveFile(path: string): Promise<T>;
+    toHaveFileContaining(path: string, needle: string): Promise<T>;
+    toHaveJsonFile(path: string): Promise<T>;
+    toHaveOpenTab(title: string, viewType?: string): Promise<T>;
+    toHavePluginData(expected: unknown): Promise<T>;
+    toHaveWorkspaceNode(label: string): Promise<T>;
+  }
+  interface AsymmetricMatchersContaining {
+    toHaveActiveFile(path: string): void;
+    toHaveCommand(commandId: string): void;
+    toHaveEditorTextContaining(needle: string): void;
+    toHaveFile(path: string): void;
+    toHaveFileContaining(path: string, needle: string): void;
+    toHaveJsonFile(path: string): void;
+    toHaveOpenTab(title: string, viewType?: string): void;
+    toHavePluginData(expected: unknown): void;
+    toHaveWorkspaceNode(label: string): void;
+  }
+}
+//# sourceMappingURL=matchers.d.mts.map

package/dist/matchers.mjs

@@ -0,0 +1,94 @@
+import { expect } from "vite-plus/test";
+import { isDeepStrictEqual } from "node:util";
+//#region src/matchers.ts
+expect.extend({
+	async toHaveActiveFile(target, targetPath) {
+		const actual = await target.dev.eval("app.workspace.getActiveFile()?.path ?? null");
+		const pass = actual === targetPath;
+		return {
+			message: () => pass ? `Expected active file not to be "${targetPath}"` : `Expected active file to be "${targetPath}", received ${JSON.stringify(actual)}`,
+			pass
+		};
+	},
+	async toHaveCommand(target, commandId) {
+		const pass = await target.command(commandId).exists();
+		return {
+			message: () => pass ? `Expected Obsidian command not to exist: ${commandId}` : `Expected Obsidian command to exist: ${commandId}`,
+			pass
+		};
+	},
+	async toHaveFile(target, targetPath) {
+		const pass = await target.exists(targetPath);
+		return {
+			message: () => pass ? `Expected vault path not to exist: ${targetPath}` : `Expected vault path to exist: ${targetPath}`,
+			pass
+		};
+	},
+	async toHaveFileContaining(target, targetPath, needle) {
+		if (!await target.exists(targetPath)) return {
+			message: () => `Expected vault path to exist: ${targetPath}`,
+			pass: false
+		};
+		const pass = (await target.read(targetPath)).includes(needle);
+		return {
+			message: () => pass ? `Expected vault path "${targetPath}" not to contain "${needle}"` : `Expected vault path "${targetPath}" to contain "${needle}"`,
+			pass
+		};
+	},
+	async toHaveJsonFile(target, targetPath) {
+		if (!await target.exists(targetPath)) return {
+			message: () => `Expected JSON file to exist: ${targetPath}`,
+			pass: false
+		};
+		try {
+			await target.json(targetPath).read();
+			return {
+				message: () => `Expected JSON file "${targetPath}" not to be valid JSON`,
+				pass: true
+			};
+		} catch (error) {
+			return {
+				message: () => `Expected JSON file "${targetPath}" to be valid JSON, but parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+				pass: false
+			};
+		}
+	},
+	async toHaveOpenTab(target, title, viewType) {
+		const pass = (await target.tabs()).some((tab) => tab.title === title && (viewType === void 0 || tab.viewType === viewType));
+		return {
+			message: () => pass ? `Expected no open tab matching "${title}"${viewType ? ` with view type "${viewType}"` : ""}` : `Expected an open tab matching "${title}"${viewType ? ` with view type "${viewType}"` : ""}`,
+			pass
+		};
+	},
+	async toHavePluginData(target, expected) {
+		const actual = await target.data().read();
+		const pass = isDeepStrictEqual(actual, expected);
+		return {
+			message: () => pass ? `Expected plugin data not to equal ${JSON.stringify(expected)}` : `Expected plugin data to equal ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}`,
+			pass
+		};
+	},
+	async toHaveEditorTextContaining(target, needle) {
+		const actual = await target.dev.eval("app.workspace.activeLeaf?.view?.editor?.getValue?.() ?? null");
+		const pass = typeof actual === "string" && actual.includes(needle);
+		return {
+			message: () => pass ? `Expected editor text not to contain "${needle}"` : `Expected editor text to contain "${needle}", received ${JSON.stringify(actual)}`,
+			pass
+		};
+	},
+	async toHaveWorkspaceNode(target, label) {
+		const pass = hasWorkspaceNode(await target.workspace(), label);
+		return {
+			message: () => pass ? `Expected workspace not to contain node "${label}"` : `Expected workspace to contain node "${label}"`,
+			pass
+		};
+	}
+});
+function hasWorkspaceNode(nodes, label) {
+	for (const node of nodes) if (node.label === label || hasWorkspaceNode(node.children, label)) return true;
+	return false;
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=matchers.mjs.map

package/dist/matchers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.mjs","names":[],"sources":["../src/matchers.ts"],"sourcesContent":["import { isDeepStrictEqual } from \"node:util\";\n\nimport { expect } from \"vite-plus/test\";\n\nimport type { ObsidianClient, PluginHandle, SandboxApi, VaultApi } from \"./core/types\";\n\ntype FileMatcherTarget = SandboxApi | VaultApi;\n\nexpect.extend({\n  async toHaveActiveFile(target: ObsidianClient, targetPath: string) {\n    const actual = await target.dev.eval<string | null>(\n      \"app.workspace.getActiveFile()?.path ?? null\",\n    );\n    const pass = actual === targetPath;\n\n    return {\n      message: () =>\n        pass\n          ? `Expected active file not to be \"${targetPath}\"`\n          : `Expected active file to be \"${targetPath}\", received ${JSON.stringify(actual)}`,\n      pass,\n    };\n  },\n  async toHaveCommand(target: ObsidianClient, commandId: string) {\n    const pass = await target.command(commandId).exists();\n\n    return {\n      message: () =>\n        pass\n          ? `Expected Obsidian command not to exist: ${commandId}`\n          : `Expected Obsidian command to exist: ${commandId}`,\n      pass,\n    };\n  },\n  async toHaveFile(target: FileMatcherTarget, targetPath: string) {\n    const pass = await target.exists(targetPath);\n\n    return {\n      message: () =>\n        pass\n          ? `Expected vault path not to exist: ${targetPath}`\n          : `Expected vault path to exist: ${targetPath}`,\n      pass,\n    };\n  },\n  async toHaveFileContaining(target: FileMatcherTarget, targetPath: string, needle: string) {\n    const exists = await target.exists(targetPath);\n\n    if (!exists) {\n      return {\n        message: () => `Expected vault path to exist: ${targetPath}`,\n        pass: false,\n      };\n    }\n\n    const content = await target.read(targetPath);\n    const pass = content.includes(needle);\n\n    return {\n      message: () =>\n        pass\n          ? `Expected vault path \"${targetPath}\" not to contain \"${needle}\"`\n          : `Expected vault path \"${targetPath}\" to contain \"${needle}\"`,\n      pass,\n    };\n  },\n  async toHaveJsonFile(target: FileMatcherTarget, targetPath: string) {\n    const exists = await target.exists(targetPath);\n\n    if (!exists) {\n      return {\n        message: () => `Expected JSON file to exist: ${targetPath}`,\n        pass: false,\n      };\n    }\n\n    try {\n      await target.json(targetPath).read();\n      return {\n        message: () => `Expected JSON file \"${targetPath}\" not to be valid JSON`,\n        pass: true,\n      };\n    } catch (error) {\n      return {\n        message: () =>\n          `Expected JSON file \"${targetPath}\" to be valid JSON, but parsing failed: ${\n            error instanceof Error ? error.message : String(error)\n          }`,\n        pass: false,\n      };\n    }\n  },\n  async toHaveOpenTab(target: ObsidianClient, title: string, viewType?: string) {\n    const tabs = await target.tabs();\n    const pass = tabs.some(\n      (tab) => tab.title === title && (viewType === undefined || tab.viewType === viewType),\n    );\n\n    return {\n      message: () =>\n        pass\n          ? `Expected no open tab matching \"${title}\"${\n              viewType ? ` with view type \"${viewType}\"` : \"\"\n            }`\n          : `Expected an open tab matching \"${title}\"${\n              viewType ? ` with view type \"${viewType}\"` : \"\"\n            }`,\n      pass,\n    };\n  },\n  async toHavePluginData(target: PluginHandle, expected: unknown) {\n    const actual = await target.data().read();\n    const pass = isDeepStrictEqual(actual, expected);\n\n    return {\n      message: () =>\n        pass\n          ? `Expected plugin data not to equal ${JSON.stringify(expected)}`\n          : `Expected plugin data to equal ${JSON.stringify(expected)}, received ${JSON.stringify(\n              actual,\n            )}`,\n      pass,\n    };\n  },\n  async toHaveEditorTextContaining(target: ObsidianClient, needle: string) {\n    const actual = await target.dev.eval<string | null>(\n      \"app.workspace.activeLeaf?.view?.editor?.getValue?.() ?? null\",\n    );\n    const pass = typeof actual === \"string\" && actual.includes(needle);\n\n    return {\n      message: () =>\n        pass\n          ? `Expected editor text not to contain \"${needle}\"`\n          : `Expected editor text to contain \"${needle}\", received ${JSON.stringify(actual)}`,\n      pass,\n    };\n  },\n  async toHaveWorkspaceNode(target: ObsidianClient, label: string) {\n    const pass = hasWorkspaceNode(await target.workspace(), label);\n\n    return {\n      message: () =>\n        pass\n          ? `Expected workspace not to contain node \"${label}\"`\n          : `Expected workspace to contain node \"${label}\"`,\n      pass,\n    };\n  },\n});\n\ndeclare module \"vite-plus/test\" {\n  interface Assertion<T = any> {\n    toHaveActiveFile(path: string): Promise<T>;\n    toHaveCommand(commandId: string): Promise<T>;\n    toHaveEditorTextContaining(needle: string): Promise<T>;\n    toHaveFile(path: string): Promise<T>;\n    toHaveFileContaining(path: string, needle: string): Promise<T>;\n    toHaveJsonFile(path: string): Promise<T>;\n    toHaveOpenTab(title: string, viewType?: string): Promise<T>;\n    toHavePluginData(expected: unknown): Promise<T>;\n    toHaveWorkspaceNode(label: string): Promise<T>;\n  }\n\n  interface AsymmetricMatchersContaining {\n    toHaveActiveFile(path: string): void;\n    toHaveCommand(commandId: string): void;\n    toHaveEditorTextContaining(needle: string): void;\n    toHaveFile(path: string): void;\n    toHaveFileContaining(path: string, needle: string): void;\n    toHaveJsonFile(path: string): void;\n    toHaveOpenTab(title: string, viewType?: string): void;\n    toHavePluginData(expected: unknown): void;\n    toHaveWorkspaceNode(label: string): void;\n  }\n}\n\nexport {};\n\nfunction hasWorkspaceNode(\n  nodes: Awaited<ReturnType<ObsidianClient[\"workspace\"]>>,\n  label: string,\n): boolean {\n  for (const node of nodes) {\n    if (node.label === label || hasWorkspaceNode(node.children, label)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";;;AAQA,OAAO,OAAO;CACZ,MAAM,iBAAiB,QAAwB,YAAoB;EACjE,MAAM,SAAS,MAAM,OAAO,IAAI,KAC9B,8CACD;EACD,MAAM,OAAO,WAAW;AAExB,SAAO;GACL,eACE,OACI,mCAAmC,WAAW,KAC9C,+BAA+B,WAAW,cAAc,KAAK,UAAU,OAAO;GACpF;GACD;;CAEH,MAAM,cAAc,QAAwB,WAAmB;EAC7D,MAAM,OAAO,MAAM,OAAO,QAAQ,UAAU,CAAC,QAAQ;AAErD,SAAO;GACL,eACE,OACI,2CAA2C,cAC3C,uCAAuC;GAC7C;GACD;;CAEH,MAAM,WAAW,QAA2B,YAAoB;EAC9D,MAAM,OAAO,MAAM,OAAO,OAAO,WAAW;AAE5C,SAAO;GACL,eACE,OACI,qCAAqC,eACrC,iCAAiC;GACvC;GACD;;CAEH,MAAM,qBAAqB,QAA2B,YAAoB,QAAgB;AAGxF,MAAI,CAFW,MAAM,OAAO,OAAO,WAAW,CAG5C,QAAO;GACL,eAAe,iCAAiC;GAChD,MAAM;GACP;EAIH,MAAM,QADU,MAAM,OAAO,KAAK,WAAW,EACxB,SAAS,OAAO;AAErC,SAAO;GACL,eACE,OACI,wBAAwB,WAAW,oBAAoB,OAAO,KAC9D,wBAAwB,WAAW,gBAAgB,OAAO;GAChE;GACD;;CAEH,MAAM,eAAe,QAA2B,YAAoB;AAGlE,MAAI,CAFW,MAAM,OAAO,OAAO,WAAW,CAG5C,QAAO;GACL,eAAe,gCAAgC;GAC/C,MAAM;GACP;AAGH,MAAI;AACF,SAAM,OAAO,KAAK,WAAW,CAAC,MAAM;AACpC,UAAO;IACL,eAAe,uBAAuB,WAAW;IACjD,MAAM;IACP;WACM,OAAO;AACd,UAAO;IACL,eACE,uBAAuB,WAAW,0CAChC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;IAE1D,MAAM;IACP;;;CAGL,MAAM,cAAc,QAAwB,OAAe,UAAmB;EAE5E,MAAM,QADO,MAAM,OAAO,MAAM,EACd,MACf,QAAQ,IAAI,UAAU,UAAU,aAAa,KAAA,KAAa,IAAI,aAAa,UAC7E;AAED,SAAO;GACL,eACE,OACI,kCAAkC,MAAM,GACtC,WAAW,oBAAoB,SAAS,KAAK,OAE/C,kCAAkC,MAAM,GACtC,WAAW,oBAAoB,SAAS,KAAK;GAErD;GACD;;CAEH,MAAM,iBAAiB,QAAsB,UAAmB;EAC9D,MAAM,SAAS,MAAM,OAAO,MAAM,CAAC,MAAM;EACzC,MAAM,OAAO,kBAAkB,QAAQ,SAAS;AAEhD,SAAO;GACL,eACE,OACI,qCAAqC,KAAK,UAAU,SAAS,KAC7D,iCAAiC,KAAK,UAAU,SAAS,CAAC,aAAa,KAAK,UAC1E,OACD;GACP;GACD;;CAEH,MAAM,2BAA2B,QAAwB,QAAgB;EACvE,MAAM,SAAS,MAAM,OAAO,IAAI,KAC9B,+DACD;EACD,MAAM,OAAO,OAAO,WAAW,YAAY,OAAO,SAAS,OAAO;AAElE,SAAO;GACL,eACE,OACI,wCAAwC,OAAO,KAC/C,oCAAoC,OAAO,cAAc,KAAK,UAAU,OAAO;GACrF;GACD;;CAEH,MAAM,oBAAoB,QAAwB,OAAe;EAC/D,MAAM,OAAO,iBAAiB,MAAM,OAAO,WAAW,EAAE,MAAM;AAE9D,SAAO;GACL,eACE,OACI,2CAA2C,MAAM,KACjD,uCAAuC,MAAM;GACnD;GACD;;CAEJ,CAAC;AA8BF,SAAS,iBACP,OACA,OACS;AACT,MAAK,MAAM,QAAQ,MACjB,KAAI,KAAK,UAAU,SAAS,iBAAiB,KAAK,UAAU,MAAM,CAChE,QAAO;AAIX,QAAO"}