obsidian-integration-testing 1.0.0

package/dist/lib/cjs/obsidian-config.d.cts

@@ -0,0 +1,25 @@
+/**
+ * @packageDocumentation
+ *
+ * Reads and queries Obsidian's local configuration (`obsidian.json`).
+ */
+/**
+ * Returns the hex vault ID for a given vault path from Obsidian's registry.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns The vault ID, or `undefined` if the vault is not registered.
+ */
+export declare function getVaultId(vaultPath: string): string | undefined;
+/**
+ * Checks whether the Obsidian CLI is enabled in Obsidian's settings.
+ *
+ * @returns `true` if the CLI is enabled, `false` otherwise.
+ */
+export declare function isCliEnabled(): boolean;
+/**
+ * Checks whether a vault path is registered in Obsidian's vault registry.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns `true` if the vault is registered, `false` otherwise.
+ */
+export declare function isVaultRegistered(vaultPath: string): boolean;

package/dist/lib/cjs/temp-vault.cjs

@@ -0,0 +1,96 @@
+"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 temp_vault_exports = {};
+__export(temp_vault_exports, {
+  TempVault: () => TempVault
+});
+module.exports = __toCommonJS(temp_vault_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_vault_registry = require("./vault-registry.cjs");
+const RM_RETRY_DELAY_MS = 500;
+const RM_RETRY_TIMEOUT_MS = 1e4;
+class TempVault {
+  /**
+   * The absolute path to the temporary vault.
+   */
+  path;
+  /**
+   * Creates a new temp vault, optionally pre-populated with files.
+   *
+   * @param params - Configuration for the vault.
+   */
+  constructor(params = {}) {
+    this.path = params.path ?? (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "temp-vault-"));
+    for (const [filePath, content] of Object.entries(params.files ?? {})) {
+      const fullPath = (0, import_node_path.join)(this.path, filePath);
+      if (filePath.endsWith("/")) {
+        if (content !== "") {
+          throw new Error(`Folder path "${filePath}" must have empty content`);
+        }
+        (0, import_node_fs.mkdirSync)(fullPath, { recursive: true });
+      } else {
+        (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(fullPath), { recursive: true });
+        (0, import_node_fs.writeFileSync)(fullPath, content);
+      }
+    }
+  }
+  /**
+   * Unregisters the vault from Obsidian and deletes the temp directory.
+   */
+  async dispose() {
+    await (0, import_vault_registry.unregisterVault)(this.path);
+    await retryRm(this.path);
+  }
+  /**
+   * Registers this vault in the running Obsidian instance so the CLI can target it.
+   */
+  async register() {
+    await (0, import_vault_registry.registerVault)(this.path);
+  }
+  /**
+   * Async disposable support for `await using`.
+   *
+   * @returns A promise that resolves when the vault is disposed.
+   */
+  async [Symbol.asyncDispose]() {
+    return this.dispose();
+  }
+}
+async function retryRm(path) {
+  const deadline = Date.now() + RM_RETRY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      await (0, import_promises.rm)(path, { force: true, recursive: true });
+      return;
+    } catch {
+      await new Promise((resolve) => {
+        setTimeout(resolve, RM_RETRY_DELAY_MS);
+      });
+    }
+  }
+  await (0, import_promises.rm)(path, { force: true, recursive: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TempVault
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/temp-vault.d.cts

@@ -0,0 +1,47 @@
+/**
+ * Parameters for the {@link TempVault} constructor.
+ */
+export interface TempVaultParams {
+    /**
+     * Map of file paths to content. Parent directories are created automatically.
+     *
+     * To create an empty folder, use a path ending with `/` and an empty string as content.
+     */
+    files?: Record<string, string>;
+    /**
+     * An explicit vault path. If omitted, a temp directory is created.
+     */
+    path?: string;
+}
+/**
+ * A temporary Obsidian vault for integration tests.
+ *
+ * Creates a temp directory and registers it in the running Obsidian instance
+ * so that the Obsidian CLI can target it via `cwd`.
+ */
+export declare class TempVault {
+    /**
+     * The absolute path to the temporary vault.
+     */
+    readonly path: string;
+    /**
+     * Creates a new temp vault, optionally pre-populated with files.
+     *
+     * @param params - Configuration for the vault.
+     */
+    constructor(params?: TempVaultParams);
+    /**
+     * Unregisters the vault from Obsidian and deletes the temp directory.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Registers this vault in the running Obsidian instance so the CLI can target it.
+     */
+    register(): Promise<void>;
+    /**
+     * Async disposable support for `await using`.
+     *
+     * @returns A promise that resolves when the vault is disposed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/lib/cjs/type-guards.cjs

@@ -0,0 +1,42 @@
+"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 type_guards_exports = {};
+__export(type_guards_exports, {
+  assertNonNullable: () => assertNonNullable,
+  ensureNonNullable: () => ensureNonNullable
+});
+module.exports = __toCommonJS(type_guards_exports);
+function assertNonNullable(value, errorOrMessage) {
+  if (value !== null && value !== void 0) {
+    return;
+  }
+  errorOrMessage ??= value === null ? "Value is null" : "Value is undefined";
+  const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  throw error;
+}
+function ensureNonNullable(value, errorOrMessage) {
+  assertNonNullable(value, errorOrMessage);
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertNonNullable,
+  ensureNonNullable
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/type-guards.d.cts

@@ -0,0 +1,30 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for type guards.
+ */
+type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+/**
+ * Asserts that a value is not `null` or `undefined`, narrowing its type in place.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T>;
+/**
+ * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @returns The value with `null` and `undefined` excluded from its type.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T>;
+export {};

package/dist/lib/cjs/vault-registry.cjs

@@ -0,0 +1,89 @@
+"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 vault_registry_exports = {};
+__export(vault_registry_exports, {
+  registerVault: () => registerVault,
+  unregisterVault: () => unregisterVault
+});
+module.exports = __toCommonJS(vault_registry_exports);
+var import_obsidian_cli = require("./obsidian-cli.cjs");
+const POLL_INTERVAL_MS = 500;
+const POLL_TIMEOUT_MS = 3e4;
+const CLOSE_DELAY_MS = 1e3;
+async function registerVault(vaultPath) {
+  await (0, import_obsidian_cli.evalInObsidian)({
+    args: { vaultPath },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    fn({ vaultPath: vaultPath2 }) {
+      window.electron.ipcRenderer.sendSync("vault-open", vaultPath2, false);
+    },
+    shouldSkipPreflightChecks: true
+  });
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const basePath = await (0, import_obsidian_cli.evalInObsidian)({
+        fn({ app }) {
+          return app.vault.adapter.getBasePath();
+        },
+        shouldSkipPreflightChecks: true,
+        vaultPath
+      });
+      if (basePath === vaultPath) {
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => {
+      setTimeout(r, POLL_INTERVAL_MS);
+    });
+  }
+  throw new Error(`Vault at ${vaultPath} did not become ready within ${String(POLL_TIMEOUT_MS)}ms`);
+}
+async function unregisterVault(vaultPath) {
+  try {
+    await (0, import_obsidian_cli.evalInObsidian)({
+      fn() {
+        setTimeout(() => {
+          window.electron.remote?.getCurrentWindow().destroy();
+        }, 0);
+      },
+      shouldSkipPreflightChecks: true,
+      vaultPath
+    });
+  } catch {
+  }
+  await new Promise((r) => {
+    setTimeout(r, CLOSE_DELAY_MS);
+  });
+  await (0, import_obsidian_cli.evalInObsidian)({
+    args: { vaultPath },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    fn({ vaultPath: vaultPath2 }) {
+      window.electron.ipcRenderer.sendSync("vault-remove", vaultPath2);
+    },
+    shouldSkipPreflightChecks: true
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerVault,
+  unregisterVault
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/vault-registry.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Registers a vault path in the running Obsidian instance so the CLI can target it via `cwd`.
+ *
+ * Uses the `vault-open` IPC to register and open the vault, then polls until
+ * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ */
+export declare function registerVault(vaultPath: string): Promise<void>;
+/**
+ * Unregisters a vault path from the running Obsidian instance.
+ *
+ * Schedules the vault window to close, waits for it, then removes
+ * the vault from the registry via `vault-remove` IPC.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ */
+export declare function unregisterVault(vaultPath: string): Promise<void>;

package/dist/lib/esm/context-id.d.mts

@@ -0,0 +1,57 @@
+/**
+ * @packageDocumentation
+ *
+ * Typed context identifiers for persisting non-serializable values
+ * across {@link evalInObsidian} calls.
+ */
+/**
+ * Wraps a {@link ContextOf} extraction into an object with a `context` property.
+ */
+export interface ContextArgs<TContextId extends ContextId<unknown> | undefined = undefined> {
+    context: ContextOf<TContextId>;
+}
+/**
+ * Extracts the context type from a {@link ContextId}.
+ */
+export type ContextOf<T> = T extends ContextId<infer Context> ? Context : never;
+/**
+ * A typed context identifier for persisting non-serializable values
+ * across {@link evalInObsidian} calls.
+ *
+ * The context is a persistent object stored on `window` in the Obsidian process.
+ * All calls sharing the same `ContextId` share the same context object,
+ * allowing non-serializable values (e.g. `TFile`, `Editor`) to survive across calls.
+ *
+ * Implements `AsyncDisposable` for use with `await using`.
+ */
+export declare class ContextId<_Context> implements AsyncDisposable {
+    private readonly id;
+    /**
+     * Creates a new context id.
+     */
+    constructor();
+    /**
+     * Removes this context from the Obsidian process.
+     *
+     * @param vaultPath - The path to the Obsidian vault. Defaults to `process.cwd()`.
+     */
+    dispose(vaultPath?: string): Promise<void>;
+    /**
+     * Disposes this context id.
+     *
+     * @returns A promise that resolves when the context id is disposed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Returns the JSON representation of the context id.
+     *
+     * @returns The JSON representation of the context id.
+     */
+    toJSON(): string;
+    /**
+     * Returns the string representation of the context id.
+     *
+     * @returns The string representation of the context id.
+     */
+    toString(): string;
+}

package/dist/lib/esm/context-id.mjs

@@ -0,0 +1,59 @@
+import { evalInObsidian } from "./obsidian-cli.mjs";
+class ContextId {
+  id;
+  /**
+   * Creates a new context id.
+   */
+  constructor() {
+    const SLICE_START = 2;
+    this.id = `__ctx_${String(Math.random()).slice(SLICE_START)}`;
+  }
+  /**
+   * Removes this context from the Obsidian process.
+   *
+   * @param vaultPath - The path to the Obsidian vault. Defaults to `process.cwd()`.
+   */
+  async dispose(vaultPath) {
+    await evalInObsidian({
+      args: { id: this.id },
+      /* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process. Covered by integration tests. */
+      fn({ id }) {
+        const holder = window;
+        if (holder.__obsidianContexts__) {
+          delete holder.__obsidianContexts__[id];
+        }
+      },
+      /* v8 ignore stop */
+      shouldSkipPreflightChecks: true,
+      ...vaultPath === void 0 ? {} : { vaultPath }
+    });
+  }
+  /**
+   * Disposes this context id.
+   *
+   * @returns A promise that resolves when the context id is disposed.
+   */
+  async [Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+  /**
+   * Returns the JSON representation of the context id.
+   *
+   * @returns The JSON representation of the context id.
+   */
+  toJSON() {
+    return this.id;
+  }
+  /**
+   * Returns the string representation of the context id.
+   *
+   * @returns The string representation of the context id.
+   */
+  toString() {
+    return this.id;
+  }
+}
+export {
+  ContextId
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/exec.d.mts

@@ -0,0 +1,108 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for executing commands.
+ */
+/**
+ * A command part: either a plain string or an {@link ExecArg} with batched arguments.
+ */
+export type CommandPart = ExecArg | string;
+/**
+ * A command argument that contains a list of args to be batched.
+ * If the expanded command exceeds the platform's max command length,
+ * the batched args are split into sequential executions.
+ */
+export interface ExecArg {
+    /**
+     * The arguments to batch.
+     */
+    batchedArgs: string[];
+}
+/**
+ * Options for {@link exec} that return detailed results.
+ */
+export interface ExecDetailedOptions extends ExecOption {
+    /**
+     * Must be `true` to receive detailed results.
+     */
+    withDetails: true;
+}
+/**
+ * Options for executing a command.
+ */
+export interface ExecOption {
+    /**
+     * A current working folder for the command execution.
+     */
+    readonly cwd?: string;
+    /**
+     * If `true`, suppresses the output of the command.
+     */
+    readonly isQuiet?: boolean;
+    /**
+     * If `true`, ignores the exit code of the command.
+     */
+    readonly shouldIgnoreExitCode?: boolean;
+    /**
+     * If `true`, returns detailed results.
+     */
+    readonly shouldIncludeDetails?: boolean;
+    /**
+     * An input to be passed to the command.
+     */
+    readonly stdin?: string;
+}
+/**
+ * A result of {@link exec}.
+ */
+export interface ExecResult {
+    /**
+     * An exit code of the command. A value of `null` indicates that the process did not exit normally.
+     */
+    exitCode: null | number;
+    /**
+     * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
+     */
+    exitSignal: NodeJS.Signals | null;
+    /**
+     * A standard error output from the command.
+     */
+    stderr: string;
+    /**
+     * A standard output from the command.
+     */
+    stdout: string;
+}
+/**
+ * Options for {@link exec} that return only stdout.
+ */
+export interface ExecSimpleOptions extends ExecOption {
+    /**
+     * Must be `false` or omitted to receive only stdout.
+     */
+    withDetails?: false;
+}
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with the output of the command.
+ */
+export declare function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with ExecResult object.
+ */
+export declare function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;
+/**
+ * Converts an array of command-line arguments into a single command-line string
+ * using the `CommandLineToArgvW` convention.
+ *
+ * @param args - The array of command-line arguments to convert.
+ * @returns A string representing the command-line invocation.
+ */
+export declare function toCommandLine(args: string[]): string;