obsidian-integration-testing 9.0.0 → 9.1.0

package/dist/lib/esm/vault-path-match.d.mts

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * Pure matching of a probed vault base path against a requested vault path.
+ *
+ * The desktop CDP transport routes an `evalInObsidian` call to the correct
+ * Obsidian window by probing each target's `app.vault.adapter.getBasePath()` and
+ * comparing it to the requested vault path. That comparison must tolerate benign
+ * formatting differences between the renderer-reported base path and the
+ * Node-side path (path-separator flavor, and case on case-insensitive
+ * filesystems), so it lives here as a pure, unit-tested helper rather than as a
+ * raw `===` inside the integration-only transport module (which is excluded from
+ * unit tests).
+ */
+/**
+ * Normalizes a vault path for comparison: unifies path separators to `/`, strips
+ * any trailing separators, and (on a case-insensitive filesystem) lowercases it.
+ *
+ * @param path - The path to normalize.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns The normalized path.
+ */
+export declare function normalizeVaultPathForComparison(path: string, isCaseInsensitive?: boolean): string;
+/**
+ * Whether a probed base path and a requested vault path refer to the same vault,
+ * comparing via {@link normalizeVaultPathForComparison} so separator-flavor and
+ * (on case-insensitive filesystems) case differences do not cause a false miss.
+ *
+ * @param basePath - The base path probed from an Obsidian target.
+ * @param vaultPath - The requested vault path.
+ * @param isCaseInsensitive - Whether to compare case-insensitively. Defaults to
+ *   the host filesystem's behavior (case-insensitive on Windows).
+ * @returns `true` when the two paths refer to the same vault.
+ */
+export declare function vaultPathsMatch(basePath: string, vaultPath: string, isCaseInsensitive?: boolean): boolean;

package/dist/lib/esm/vault-path-match.mjs

@@ -0,0 +1,14 @@
+import process from "node:process";
+const IS_CASE_INSENSITIVE_FILESYSTEM = process.platform === "win32";
+function normalizeVaultPathForComparison(path, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  const unifiedSeparators = path.replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return isCaseInsensitive ? unifiedSeparators.toLowerCase() : unifiedSeparators;
+}
+function vaultPathsMatch(basePath, vaultPath, isCaseInsensitive = IS_CASE_INSENSITIVE_FILESYSTEM) {
+  return normalizeVaultPathForComparison(basePath, isCaseInsensitive) === normalizeVaultPathForComparison(vaultPath, isCaseInsensitive);
+}
+export {
+  normalizeVaultPathForComparison,
+  vaultPathsMatch
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vitest/global-setup.d.mts

@@ -13,6 +13,13 @@ import { TempVault } from '../temp-vault.mjs';
  * Options for {@link createSetup}.
  */
 export interface CreateSetupOptions {
+    /**
+     * Community-plugin ids to enable in the vault in addition to the plugin-under-test,
+     * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each
+     * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)
+     * so the enable finds them on disk.
+     */
+    readonly enableCommunityPlugins?: readonly string[];
     /**
      * Whether to install and enable the built plugin in the temp vault. Defaults
      * to `true`. Set to `false` for a **non-plugin** consumer that only needs a
@@ -56,8 +63,8 @@ export declare function getTempVault(): TempVault;
 /**
  * Vitest global setup function (no pre-population).
  *
- * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,
- * and provides `tempVaultPath` to tests.
+ * Copies the built plugin into a temporary vault, enables it via a renderer eval
+ * over the transport, and provides `tempVaultPath` to tests.
  *
  * @param project - The Vitest project.
  * @returns A promise that resolves when setup completes.

package/dist/lib/esm/vitest/global-setup.mjs

@@ -20,7 +20,12 @@ function createSetup(options) {
     const transportOptions = environmentOptions?.["obsidianTransport"];
     const label = transportOptions?.type ?? "obsidian-cdp";
     try {
-      setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });
+      setupResult = await coreSetup({
+        enableCommunityPlugins: options?.enableCommunityPlugins,
+        installPlugin: options?.installPlugin,
+        populate: options?.populate?.(),
+        transportOptions
+      });
     } catch (error) {
       log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);
       project.provide("setupError", errorToString(error));
@@ -50,4 +55,4 @@ export {
   setup,
   teardown
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport { errorToString } from '../error-to-string.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { log } from '../log.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('tempVaultPath'));\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({ installPlugin: options?.installPlugin, populate: options?.populate?.(), transportOptions });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run.\n      // Individual tests in this project will fail with the stored error\n      // When they try to inject the temp vault path.\n      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);\n      project.provide('setupError', errorToString(error));\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('tempVaultPath', setupResult.tempVault.path);\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = inject('tempVaultPath');\n  const setupErrorMessage = inject('setupError');\n  if (setupErrorMessage) {\n    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);\n  }\n  return new TempVault(tempVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and provides `tempVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n"],
  "mappings": "AAaA,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,iBAAiB;AAE1B,4BAA4B,MAAM,OAAO,mBAAmB,CAAC;AAC7D,qBAAqB,MAAM,OAAO,eAAe,CAAC;AA0C3C,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,MAAM,UAAU,EAAE,eAAe,SAAS,eAAe,UAAU,SAAS,WAAW,GAAG,iBAAiB,CAAC;AAAA,IAC5H,SAAS,OAAgB;AAIvB,UAAI,sBAAsB,KAAK,4DAA4D,cAAc,KAAK,CAAC,EAAE;AACjH,cAAQ,QAAQ,cAAc,cAAc,KAAK,CAAC;AAClD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,iBAAiB,YAAY,UAAU,IAAI;AAAA,EAC7D;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,OAAO,eAAe;AAC5C,QAAM,oBAAoB,OAAO,YAAY;AAC7C,MAAI,mBAAmB;AACrB,UAAM,IAAI,MAAM,0DAAqD,iBAAiB,EAAE;AAAA,EAC1F;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/vitest/global-setup.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Vitest global setup and teardown adapter.\n *\n * Delegates to the framework-agnostic core and bridges context\n * to test workers via Vitest's `project.provide` / `inject`.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { inject } from 'vitest';\n\nimport type { CoreSetupResult } from '../global-setup-core.mjs';\nimport type { PopulateFilesParams } from '../temp-vault.mjs';\nimport type { ObsidianTransportOptions } from '../transport-options.mjs';\n\nimport {\n  setTransportOptionsResolver,\n  setVaultPathResolver\n} from '../context-provider.mjs';\nimport { errorToString } from '../error-to-string.mjs';\nimport {\n  coreSetup,\n  coreTeardown\n} from '../global-setup-core.mjs';\nimport { log } from '../log.mjs';\nimport { TempVault } from '../temp-vault.mjs';\n\nsetTransportOptionsResolver(() => inject('obsidianTransport'));\nsetVaultPathResolver(() => inject('tempVaultPath'));\n\n/**\n * Options for {@link createSetup}.\n */\nexport interface CreateSetupOptions {\n  /**\n   * Community-plugin ids to enable in the vault in addition to the plugin-under-test,\n   * after it is enabled (see {@link CoreSetupParams.enableCommunityPlugins}). Seed each\n   * plugin's built files via {@link CreateSetupOptions.populate} (e.g. with `buildDemoVaultPopulate`)\n   * so the enable finds them on disk.\n   */\n  readonly enableCommunityPlugins?: readonly string[];\n\n  /**\n   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer that only needs a\n   * registered, empty vault to `evalInObsidian` against \u2014 the owned instance is\n   * still launched and its endpoint published to workers, so re-exporting\n   * `createSetup({ installPlugin: false })` reuses the same attach wiring with no\n   * plugin copy/enable. See {@link CoreSetupParams.installPlugin}.\n   */\n  readonly installPlugin?: boolean;\n\n  /**\n   * Returns files/folders to write into the vault before Obsidian opens it (see\n   * {@link CoreSetupParams.populate}). A thunk so large fixtures are built lazily,\n   * once, in the setup process.\n   */\n  populate?(this: void): PopulateFilesParams;\n}\n\n/**\n * A Vitest `globalSetup` module's `setup` / `teardown` pair.\n */\nexport interface VitestGlobalSetup {\n  setup(this: void, project: TestProject): Promise<void>;\n  teardown(this: void): Promise<void>;\n}\n\n/**\n * Creates a Vitest global setup/teardown pair, optionally pre-populating the vault\n * before Obsidian opens it \u2014 use this for a dedicated large-vault/performance\n * project. The plain {@link setup} / {@link teardown} exports are the no-populate\n * case (`createSetup()`). Pass `{ installPlugin: false }` for a non-plugin consumer\n * that only needs a registered, empty vault (see {@link CreateSetupOptions.installPlugin}).\n *\n * @param options - Setup options.\n * @returns The `setup` and `teardown` functions to re-export from a `globalSetup` module.\n */\nexport function createSetup(options?: CreateSetupOptions): VitestGlobalSetup {\n  let setupResult: CoreSetupResult | undefined;\n\n  return { setup, teardown };\n\n  async function setup(project: TestProject): Promise<void> {\n    const environmentOptions = project.config.environmentOptions as Record<string, unknown> | undefined;\n    const transportOptions = environmentOptions?.['obsidianTransport'] as ObsidianTransportOptions | undefined;\n    const label = transportOptions?.type ?? 'obsidian-cdp';\n\n    try {\n      setupResult = await coreSetup({\n        enableCommunityPlugins: options?.enableCommunityPlugins,\n        installPlugin: options?.installPlugin,\n        populate: options?.populate?.(),\n        transportOptions\n      });\n    } catch (error: unknown) {\n      // Catch setup errors so that other projects' tests can still run.\n      // Individual tests in this project will fail with the stored error\n      // When they try to inject the temp vault path.\n      log(`[integration-setup:${label}] Setup failed (tests for this project will be skipped): ${errorToString(error)}`);\n      project.provide('setupError', errorToString(error));\n      return;\n    }\n\n    project.provide('obsidianTransport', setupResult.transportOptions);\n    project.provide('tempVaultPath', setupResult.tempVault.path);\n  }\n\n  async function teardown(): Promise<void> {\n    await coreTeardown(setupResult);\n  }\n}\n\n/**\n * Returns the temporary vault provided by the global setup.\n *\n * @returns The temporary vault.\n */\nexport function getTempVault(): TempVault {\n  const tempVaultPath = inject('tempVaultPath');\n  const setupErrorMessage = inject('setupError');\n  if (setupErrorMessage) {\n    throw new Error(`Integration setup failed \u2014 cannot get temp vault: ${setupErrorMessage}`);\n  }\n  return new TempVault(tempVaultPath);\n}\n\nconst defaultGlobalSetup = createSetup();\n\n/**\n * Vitest global setup function (no pre-population).\n *\n * Copies the built plugin into a temporary vault, enables it via a renderer eval\n * over the transport, and provides `tempVaultPath` to tests.\n *\n * @param project - The Vitest project.\n * @returns A promise that resolves when setup completes.\n */\nexport const setup = defaultGlobalSetup.setup;\n\n/**\n * Vitest global teardown function.\n *\n * Removes the temporary vault created during setup.\n *\n * @returns A promise that resolves when teardown completes.\n */\nexport const teardown = defaultGlobalSetup.teardown;\n"],
  "mappings": "AAaA,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,iBAAiB;AAE1B,4BAA4B,MAAM,OAAO,mBAAmB,CAAC;AAC7D,qBAAqB,MAAM,OAAO,eAAe,CAAC;AAkD3C,SAAS,YAAY,SAAiD;AAC3E,MAAI;AAEJ,SAAO,EAAE,OAAAA,QAAO,UAAAC,UAAS;AAEzB,iBAAeD,OAAM,SAAqC;AACxD,UAAM,qBAAqB,QAAQ,OAAO;AAC1C,UAAM,mBAAmB,qBAAqB,mBAAmB;AACjE,UAAM,QAAQ,kBAAkB,QAAQ;AAExC,QAAI;AACF,oBAAc,MAAM,UAAU;AAAA,QAC5B,wBAAwB,SAAS;AAAA,QACjC,eAAe,SAAS;AAAA,QACxB,UAAU,SAAS,WAAW;AAAA,QAC9B;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAgB;AAIvB,UAAI,sBAAsB,KAAK,4DAA4D,cAAc,KAAK,CAAC,EAAE;AACjH,cAAQ,QAAQ,cAAc,cAAc,KAAK,CAAC;AAClD;AAAA,IACF;AAEA,YAAQ,QAAQ,qBAAqB,YAAY,gBAAgB;AACjE,YAAQ,QAAQ,iBAAiB,YAAY,UAAU,IAAI;AAAA,EAC7D;AAEA,iBAAeC,YAA0B;AACvC,UAAM,aAAa,WAAW;AAAA,EAChC;AACF;AAOO,SAAS,eAA0B;AACxC,QAAM,gBAAgB,OAAO,eAAe;AAC5C,QAAM,oBAAoB,OAAO,YAAY;AAC7C,MAAI,mBAAmB;AACrB,UAAM,IAAI,MAAM,0DAAqD,iBAAiB,EAAE;AAAA,EAC1F;AACA,SAAO,IAAI,UAAU,aAAa;AACpC;AAEA,MAAM,qBAAqB,YAAY;AAWhC,MAAM,QAAQ,mBAAmB;AASjC,MAAM,WAAW,mBAAmB;",
  "names": ["setup", "teardown"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",