@sanity/cli-test 0.0.2-alpha.1 → 0.0.2-alpha.11

package/dist/test/mockSanityCommand.js

@@ -0,0 +1,68 @@
+import { convertToSystemPath } from '../utils/paths.js';
+import { createTestToken } from './createTestToken.js';
+/**
+ * Creates a testable subclass of a command with mocked SanityCommand dependencies.
+ *
+ * @public
+ *
+ * @example
+ * ```ts
+ * // Basic config mocking
+ * const TestAdd = mockSanityCommand(Add, {
+ *   cliConfig: { api: { projectId: 'test-project' } }
+ * })
+ *
+ * // With mock API client
+ * const mockClient = {
+ *   getDocument: vi.fn().mockResolvedValue({ _id: 'doc1', title: 'Test' }),
+ *   fetch: vi.fn().mockResolvedValue([]),
+ * }
+ * const TestGet = mockSanityCommand(GetDocumentCommand, {
+ *   cliConfig: { api: { projectId: 'test-project', dataset: 'production' } },
+ *   projectApiClient: mockClient,
+ * })
+ *
+ * const {stdout} = await testCommand(TestGet, ['doc1'])
+ * expect(mockClient.getDocument).toHaveBeenCalledWith('doc1')
+ * ```
+ */ export function mockSanityCommand(CommandClass, options = {}) {
+    if (options.token) {
+        createTestToken(options.token);
+    }
+    // Auto-convert paths in projectRoot to platform-appropriate format
+    let projectRoot = options.projectRoot;
+    if (projectRoot) {
+        projectRoot = {
+            ...projectRoot,
+            directory: convertToSystemPath(projectRoot.directory),
+            path: convertToSystemPath(projectRoot.path)
+        };
+    }
+    // Create a subclass that overrides methods when mocks are provided
+    // Note: we use @ts-expect-error because TypeScript can't properly infer
+    // the relationship between the generic CommandClass and SanityCommand
+    // @ts-expect-error - TypeScript struggles with abstract class subclassing
+    class MockedCommand extends CommandClass {
+        getCliConfig() {
+            if (options.cliConfig) {
+                return Promise.resolve(options.cliConfig);
+            }
+            return super.getCliConfig();
+        }
+        getProjectRoot() {
+            if (options.projectRoot) {
+                return Promise.resolve(options.projectRoot);
+            }
+            return super.getProjectRoot();
+        }
+        resolveIsInteractive() {
+            if (options.isInteractive !== undefined) {
+                return options.isInteractive;
+            }
+            return super.resolveIsInteractive();
+        }
+    }
+    return MockedCommand;
+}
+
+//# sourceMappingURL=mockSanityCommand.js.map

package/dist/test/mockSanityCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/mockSanityCommand.ts"],"sourcesContent":["import {type Command} from '@oclif/core'\nimport {type CliConfig, type ProjectRootResult, SanityCommand} from '@sanity/cli-core'\n\nimport {convertToSystemPath} from '../utils/paths.js'\nimport {createTestToken} from './createTestToken.js'\n\n/**\n * @public\n */\nexport interface MockSanityCommandOptions {\n  /**\n   * Mock CLI config (required if command uses getCliConfig or getProjectId)\n   */\n  cliConfig?: CliConfig\n  /**\n   * Mock whether the terminal is interactive (used by isUnattended)\n   */\n  isInteractive?: boolean\n  /**\n   * Mock project root result (required if command uses getProjectRoot)\n   */\n  projectRoot?: ProjectRootResult\n  /**\n   * Mock authentication token (passed to API clients, bypasses getCliToken)\n   */\n  token?: string\n}\n\n/**\n * Creates a testable subclass of a command with mocked SanityCommand dependencies.\n *\n * @public\n *\n * @example\n * ```ts\n * // Basic config mocking\n * const TestAdd = mockSanityCommand(Add, {\n *   cliConfig: { api: { projectId: 'test-project' } }\n * })\n *\n * // With mock API client\n * const mockClient = {\n *   getDocument: vi.fn().mockResolvedValue({ _id: 'doc1', title: 'Test' }),\n *   fetch: vi.fn().mockResolvedValue([]),\n * }\n * const TestGet = mockSanityCommand(GetDocumentCommand, {\n *   cliConfig: { api: { projectId: 'test-project', dataset: 'production' } },\n *   projectApiClient: mockClient,\n * })\n *\n * const {stdout} = await testCommand(TestGet, ['doc1'])\n * expect(mockClient.getDocument).toHaveBeenCalledWith('doc1')\n * ```\n */\nexport function mockSanityCommand<T extends typeof SanityCommand<typeof Command>>(\n  CommandClass: T,\n  options: MockSanityCommandOptions = {},\n): T {\n  if (options.token) {\n    createTestToken(options.token)\n  }\n\n  // Auto-convert paths in projectRoot to platform-appropriate format\n  let projectRoot = options.projectRoot\n  if (projectRoot) {\n    projectRoot = {\n      ...projectRoot,\n      directory: convertToSystemPath(projectRoot.directory),\n      path: convertToSystemPath(projectRoot.path),\n    }\n  }\n\n  // Create a subclass that overrides methods when mocks are provided\n  // Note: we use @ts-expect-error because TypeScript can't properly infer\n  // the relationship between the generic CommandClass and SanityCommand\n  // @ts-expect-error - TypeScript struggles with abstract class subclassing\n  class MockedCommand extends CommandClass {\n    protected getCliConfig(): Promise<CliConfig> {\n      if (options.cliConfig) {\n        return Promise.resolve(options.cliConfig)\n      }\n      return super.getCliConfig()\n    }\n\n    protected getProjectRoot(): Promise<ProjectRootResult> {\n      if (options.projectRoot) {\n        return Promise.resolve(options.projectRoot)\n      }\n      return super.getProjectRoot()\n    }\n\n    protected resolveIsInteractive(): boolean {\n      if (options.isInteractive !== undefined) {\n        return options.isInteractive\n      }\n      return super.resolveIsInteractive()\n    }\n  }\n\n  return MockedCommand as T\n}\n"],"names":["convertToSystemPath","createTestToken","mockSanityCommand","CommandClass","options","token","projectRoot","directory","path","MockedCommand","getCliConfig","cliConfig","Promise","resolve","getProjectRoot","resolveIsInteractive","isInteractive","undefined"],"mappings":"AAGA,SAAQA,mBAAmB,QAAO,oBAAmB;AACrD,SAAQC,eAAe,QAAO,uBAAsB;AAwBpD;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,SAASC,kBACdC,YAAe,EACfC,UAAoC,CAAC,CAAC;IAEtC,IAAIA,QAAQC,KAAK,EAAE;QACjBJ,gBAAgBG,QAAQC,KAAK;IAC/B;IAEA,mEAAmE;IACnE,IAAIC,cAAcF,QAAQE,WAAW;IACrC,IAAIA,aAAa;QACfA,cAAc;YACZ,GAAGA,WAAW;YACdC,WAAWP,oBAAoBM,YAAYC,SAAS;YACpDC,MAAMR,oBAAoBM,YAAYE,IAAI;QAC5C;IACF;IAEA,mEAAmE;IACnE,wEAAwE;IACxE,sEAAsE;IACtE,0EAA0E;IAC1E,MAAMC,sBAAsBN;QAChBO,eAAmC;YAC3C,IAAIN,QAAQO,SAAS,EAAE;gBACrB,OAAOC,QAAQC,OAAO,CAACT,QAAQO,SAAS;YAC1C;YACA,OAAO,KAAK,CAACD;QACf;QAEUI,iBAA6C;YACrD,IAAIV,QAAQE,WAAW,EAAE;gBACvB,OAAOM,QAAQC,OAAO,CAACT,QAAQE,WAAW;YAC5C;YACA,OAAO,KAAK,CAACQ;QACf;QAEUC,uBAAgC;YACxC,IAAIX,QAAQY,aAAa,KAAKC,WAAW;gBACvC,OAAOb,QAAQY,aAAa;YAC9B;YACA,OAAO,KAAK,CAACD;QACf;IACF;IAEA,OAAON;AACT"}

package/dist/test/mockTelemetry.js

@@ -0,0 +1,22 @@
+import { vi } from 'vitest';
+/**
+ * @public
+ * @param options - Options for mocking the telemetry store.
+ * @returns The mocked telemetry store.
+ */ export const mockTelemetry = (options = {})=>{
+    const telemetry = {
+        trace: vi.fn().mockReturnValue({
+            complete: vi.fn(),
+            error: vi.fn(),
+            log: vi.fn(),
+            newContext: vi.fn(),
+            start: vi.fn()
+        }),
+        updateUserProperties: vi.fn(),
+        ...options
+    };
+    globalThis[Symbol.for('sanity.cli.telemetry')] = telemetry;
+    return telemetry;
+};
+
+//# sourceMappingURL=mockTelemetry.js.map

package/dist/test/mockTelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/mockTelemetry.ts"],"sourcesContent":["import {type CLITelemetryStore} from '@sanity/cli-core'\nimport {vi} from 'vitest'\n\n/**\n * @public\n */\nexport interface MockTelemetryOptions {\n  trace?: () => void\n  updateUserProperties?: () => void\n}\n\n/**\n * @public\n * @param options - Options for mocking the telemetry store.\n * @returns The mocked telemetry store.\n */\nexport const mockTelemetry = (options: MockTelemetryOptions = {}): CLITelemetryStore => {\n  const telemetry = {\n    trace: vi.fn().mockReturnValue({\n      complete: vi.fn(),\n      error: vi.fn(),\n      log: vi.fn(),\n      newContext: vi.fn(),\n      start: vi.fn(),\n    }),\n    updateUserProperties: vi.fn(),\n    ...options,\n  } as unknown as CLITelemetryStore\n\n  // We are not using the export from @sanity/cli-core because\n  // This can be used where `@sanity/cli-core` is mocked and vitest will run into issues.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ;(globalThis as any)[Symbol.for('sanity.cli.telemetry')] = telemetry\n\n  return telemetry\n}\n"],"names":["vi","mockTelemetry","options","telemetry","trace","fn","mockReturnValue","complete","error","log","newContext","start","updateUserProperties","globalThis","Symbol","for"],"mappings":"AACA,SAAQA,EAAE,QAAO,SAAQ;AAUzB;;;;CAIC,GACD,OAAO,MAAMC,gBAAgB,CAACC,UAAgC,CAAC,CAAC;IAC9D,MAAMC,YAAY;QAChBC,OAAOJ,GAAGK,EAAE,GAAGC,eAAe,CAAC;YAC7BC,UAAUP,GAAGK,EAAE;YACfG,OAAOR,GAAGK,EAAE;YACZI,KAAKT,GAAGK,EAAE;YACVK,YAAYV,GAAGK,EAAE;YACjBM,OAAOX,GAAGK,EAAE;QACd;QACAO,sBAAsBZ,GAAGK,EAAE;QAC3B,GAAGH,OAAO;IACZ;IAKEW,UAAkB,CAACC,OAAOC,GAAG,CAAC,wBAAwB,GAAGZ;IAE3D,OAAOA;AACT,EAAC"}

package/dist/test/setupFixtures.js

@@ -0,0 +1,138 @@
+import { exec as execNode } from 'node:child_process';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { promisify } from 'node:util';
+import ora from 'ora';
+import { glob } from 'tinyglobby';
+import { fileExists } from '../utils/fileExists.js';
+import { getFixturesPath, getTempPath } from '../utils/paths.js';
+import { DEFAULT_FIXTURES } from './constants.js';
+import { testCopyDirectory } from './testFixture.js';
+const exec = promisify(execNode);
+async function getAdditionalFixturePaths(fixtures) {
+    const paths = await glob(fixtures, {
+        absolute: true,
+        ignore: [
+            '**/node_modules/**',
+            '**/dist/**'
+        ],
+        onlyDirectories: true
+    });
+    const additionalFixtures = [];
+    for (const path of paths){
+        if (await fileExists(join(`${path}/package.json`))) {
+            additionalFixtures.push({
+                fixture: basename(path),
+                fromPath: path,
+                includeDist: false
+            });
+        }
+    }
+    return additionalFixtures;
+}
+/**
+ * Global setup function for initializing test fixtures.
+ *
+ * Copies fixtures from the bundled location to a temp directory
+ * and installs dependencies.
+ *
+ * Note: Fixtures are NOT built during setup. Tests that need built
+ * fixtures should build them as part of the test.
+ *
+ * This function is designed to be used with vitest globalSetup.
+ *
+ * @public
+ *
+ * @param options - Configuration options
+ * @example
+ * ```typescript
+ * // In vitest.config.ts
+ * export default defineConfig({
+ *   test: {
+ *     globalSetup: ['@sanity/cli-test/vitest']
+ *   }
+ * })
+ * ```
+ */ export async function setup(_, options = {}) {
+    const { additionalFixtures, tempDir } = options;
+    const spinner = ora({
+        // Without this, the watch mode input is discarded
+        discardStdin: false,
+        text: 'Initializing test environment...'
+    }).start();
+    try {
+        const fixturesDir = getFixturesPath();
+        const tempDirectory = getTempPath(tempDir);
+        const allFixturePaths = [];
+        // Add the default fixtures
+        for (const [fixture, options] of Object.entries(DEFAULT_FIXTURES)){
+            allFixturePaths.push({
+                fixture,
+                fromPath: join(fixturesDir, fixture),
+                includeDist: 'includeDist' in options && options.includeDist ? options.includeDist : false
+            });
+        }
+        // Add the additional fixtures
+        if (additionalFixtures && additionalFixtures.length > 0) {
+            const additionalFixturePaths = await getAdditionalFixturePaths(additionalFixtures);
+            if (additionalFixturePaths.length > 0) {
+                allFixturePaths.push(...additionalFixturePaths);
+            } else {
+                spinner.warn(`No additional fixtures found, check the glob pattern: ${additionalFixtures.join(', ')}`);
+            }
+        }
+        for (const { fixture, fromPath, includeDist } of allFixturePaths){
+            const toPath = join(tempDirectory, `fixture-${fixture}`);
+            // Copy the fixture, excluding node_modules and dist
+            await testCopyDirectory(fromPath, toPath, [
+                'node_modules',
+                ...includeDist ? [] : [
+                    'dist'
+                ]
+            ]);
+            // Replace the package.json name with a temp name
+            const packageJsonPath = join(toPath, 'package.json');
+            const packageJson = await readFile(packageJsonPath, 'utf8');
+            const packageJsonData = JSON.parse(packageJson);
+            packageJsonData.name = `${packageJsonData.name}-test`;
+            await writeFile(packageJsonPath, JSON.stringify(packageJsonData, null, 2));
+            // Run pnpm install --no-lockfile in the temp directory
+            try {
+                await exec(`pnpm install --prefer-offline --no-lockfile`, {
+                    cwd: toPath
+                });
+            } catch (error) {
+                const execError = error;
+                spinner.fail('Failed to install dependencies');
+                console.error(execError.stderr || execError.stdout || execError.message);
+                throw new Error(`Error installing dependencies in ${toPath}: ${execError.stderr || execError.stdout || execError.message}`);
+            }
+        }
+        spinner.succeed('Test environment initialized');
+    } catch (error) {
+        spinner.fail('Failed to initialize test environment');
+        throw error;
+    }
+}
+/**
+ * Teardown function to clean up test fixtures.
+ *
+ * Removes the temp directory created by setupTestFixtures.
+ *
+ * This function is designed to be used with vitest globalSetup.
+ *
+ * @public
+ *
+ * @param options - Configuration options
+ */ export async function teardown(options = {}) {
+    const { tempDir } = options;
+    const tempDirectory = getTempPath(tempDir);
+    // Remove the tmp directory
+    await rm(tempDirectory, {
+        force: true,
+        maxRetries: 3,
+        recursive: true
+    }).catch(()=>{});
+}
+
+//# sourceMappingURL=setupFixtures.js.map

package/dist/test/setupFixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/setupFixtures.ts"],"sourcesContent":["import {exec as execNode} from 'node:child_process'\nimport {readFile, rm, writeFile} from 'node:fs/promises'\nimport {basename, join} from 'node:path'\nimport {promisify} from 'node:util'\n\nimport ora from 'ora'\nimport {glob} from 'tinyglobby'\nimport {type TestProject} from 'vitest/node'\n\nimport {fileExists} from '../utils/fileExists.js'\nimport {getFixturesPath, getTempPath} from '../utils/paths.js'\nimport {DEFAULT_FIXTURES} from './constants.js'\nimport {testCopyDirectory} from './testFixture.js'\n\nconst exec = promisify(execNode)\n\n/**\n * Options for setupTestFixtures\n *\n * @public\n */\nexport interface SetupTestFixturesOptions {\n  /**\n   * Glob patterns for additional fixture directories to set up.\n   *\n   * Each pattern is matched against directories in the current working directory.\n   * Only directories containing a `package.json` file are included.\n   *\n   * @example\n   * ```typescript\n   * ['fixtures/*', 'dev/*']\n   * ```\n   */\n  additionalFixtures?: string[]\n\n  /**\n   * Custom temp directory path. Defaults to process.cwd()/tmp\n   */\n  tempDir?: string\n}\n\nasync function getAdditionalFixturePaths(fixtures: string[]): Promise<FixtureDetails[]> {\n  const paths = await glob(fixtures, {\n    absolute: true,\n    ignore: ['**/node_modules/**', '**/dist/**'],\n    onlyDirectories: true,\n  })\n\n  const additionalFixtures: FixtureDetails[] = []\n\n  for (const path of paths) {\n    if (await fileExists(join(`${path}/package.json`))) {\n      additionalFixtures.push({\n        fixture: basename(path),\n        fromPath: path,\n        includeDist: false,\n      })\n    }\n  }\n\n  return additionalFixtures\n}\n\ninterface FixtureDetails {\n  fixture: string\n  fromPath: string\n  includeDist: boolean\n}\n\n/**\n * Global setup function for initializing test fixtures.\n *\n * Copies fixtures from the bundled location to a temp directory\n * and installs dependencies.\n *\n * Note: Fixtures are NOT built during setup. Tests that need built\n * fixtures should build them as part of the test.\n *\n * This function is designed to be used with vitest globalSetup.\n *\n * @public\n *\n * @param options - Configuration options\n * @example\n * ```typescript\n * // In vitest.config.ts\n * export default defineConfig({\n *   test: {\n *     globalSetup: ['@sanity/cli-test/vitest']\n *   }\n * })\n * ```\n */\nexport async function setup(_: TestProject, options: SetupTestFixturesOptions = {}): Promise<void> {\n  const {additionalFixtures, tempDir} = options\n\n  const spinner = ora({\n    // Without this, the watch mode input is discarded\n    discardStdin: false,\n    text: 'Initializing test environment...',\n  }).start()\n\n  try {\n    const fixturesDir = getFixturesPath()\n    const tempDirectory = getTempPath(tempDir)\n\n    const allFixturePaths: FixtureDetails[] = []\n\n    // Add the default fixtures\n    for (const [fixture, options] of Object.entries(DEFAULT_FIXTURES)) {\n      allFixturePaths.push({\n        fixture,\n        fromPath: join(fixturesDir, fixture),\n        includeDist: 'includeDist' in options && options.includeDist ? options.includeDist : false,\n      })\n    }\n\n    // Add the additional fixtures\n    if (additionalFixtures && additionalFixtures.length > 0) {\n      const additionalFixturePaths = await getAdditionalFixturePaths(additionalFixtures)\n\n      if (additionalFixturePaths.length > 0) {\n        allFixturePaths.push(...additionalFixturePaths)\n      } else {\n        spinner.warn(\n          `No additional fixtures found, check the glob pattern: ${additionalFixtures.join(', ')}`,\n        )\n      }\n    }\n\n    for (const {fixture, fromPath, includeDist} of allFixturePaths) {\n      const toPath = join(tempDirectory, `fixture-${fixture}`)\n      // Copy the fixture, excluding node_modules and dist\n      await testCopyDirectory(fromPath, toPath, ['node_modules', ...(includeDist ? [] : ['dist'])])\n\n      // Replace the package.json name with a temp name\n      const packageJsonPath = join(toPath, 'package.json')\n      const packageJson = await readFile(packageJsonPath, 'utf8')\n      const packageJsonData = JSON.parse(packageJson)\n      packageJsonData.name = `${packageJsonData.name}-test`\n      await writeFile(packageJsonPath, JSON.stringify(packageJsonData, null, 2))\n\n      // Run pnpm install --no-lockfile in the temp directory\n      try {\n        await exec(`pnpm install --prefer-offline --no-lockfile`, {\n          cwd: toPath,\n        })\n      } catch (error) {\n        const execError = error as {message: string; stderr?: string; stdout?: string}\n        spinner.fail('Failed to install dependencies')\n        console.error(execError.stderr || execError.stdout || execError.message)\n        throw new Error(\n          `Error installing dependencies in ${toPath}: ${execError.stderr || execError.stdout || execError.message}`,\n        )\n      }\n    }\n\n    spinner.succeed('Test environment initialized')\n  } catch (error) {\n    spinner.fail('Failed to initialize test environment')\n    throw error\n  }\n}\n\n/**\n * Options for teardownTestFixtures\n *\n * @public\n */\nexport interface TeardownTestFixturesOptions {\n  /**\n   * Custom temp directory path. Defaults to process.cwd()/tmp\n   */\n  tempDir?: string\n}\n\n/**\n * Teardown function to clean up test fixtures.\n *\n * Removes the temp directory created by setupTestFixtures.\n *\n * This function is designed to be used with vitest globalSetup.\n *\n * @public\n *\n * @param options - Configuration options\n */\nexport async function teardown(options: TeardownTestFixturesOptions = {}): Promise<void> {\n  const {tempDir} = options\n  const tempDirectory = getTempPath(tempDir)\n\n  // Remove the tmp directory\n  await rm(tempDirectory, {force: true, maxRetries: 3, recursive: true}).catch(() => {})\n}\n"],"names":["exec","execNode","readFile","rm","writeFile","basename","join","promisify","ora","glob","fileExists","getFixturesPath","getTempPath","DEFAULT_FIXTURES","testCopyDirectory","getAdditionalFixturePaths","fixtures","paths","absolute","ignore","onlyDirectories","additionalFixtures","path","push","fixture","fromPath","includeDist","setup","_","options","tempDir","spinner","discardStdin","text","start","fixturesDir","tempDirectory","allFixturePaths","Object","entries","length","additionalFixturePaths","warn","toPath","packageJsonPath","packageJson","packageJsonData","JSON","parse","name","stringify","cwd","error","execError","fail","console","stderr","stdout","message","Error","succeed","teardown","force","maxRetries","recursive","catch"],"mappings":"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"}

package/dist/test/snapshotSerializer.js

@@ -0,0 +1,12 @@
+/**
+ * Serializer for snapshot tests to normalize line endings and Windows ^ to Unix `\`
+ * @public
+ */ export const snapshotSerializer = {
+    serialize: (val)=>{
+        const normalized = val.replaceAll(/(\^|\\)(\s*\n)/g, '\\\n');
+        return `"${normalized}"`;
+    },
+    test: (val)=>typeof val === 'string'
+};
+
+//# sourceMappingURL=snapshotSerializer.js.map

package/dist/test/snapshotSerializer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/snapshotSerializer.ts"],"sourcesContent":["/**\n * Serializer for snapshot tests to normalize line endings and Windows ^ to Unix `\\`\n * @public\n */\nexport const snapshotSerializer = {\n  serialize: (val: string) => {\n    const normalized = val.replaceAll(/(\\^|\\\\)(\\s*\\n)/g, '\\\\\\n')\n    return `\"${normalized}\"`\n  },\n  test: (val: unknown) => typeof val === 'string',\n}\n"],"names":["snapshotSerializer","serialize","val","normalized","replaceAll","test"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,qBAAqB;IAChCC,WAAW,CAACC;QACV,MAAMC,aAAaD,IAAIE,UAAU,CAAC,mBAAmB;QACrD,OAAO,CAAC,CAAC,EAAED,WAAW,CAAC,CAAC;IAC1B;IACAE,MAAM,CAACH,MAAiB,OAAOA,QAAQ;AACzC,EAAC"}

package/dist/test/testCommand.js

@@ -1,9 +1,16 @@
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { captureOutput } from './captureOutput.js';
-export async function testCommand(command, args, options) {
-    const commandInstancePromise = ()=>command.run(args || [], {
-            root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli'),
+import { mockSanityCommand } from './mockSanityCommand.js';
+import { mockTelemetry } from './mockTelemetry.js';
+/**
+ * @public
+ */ export async function testCommand(command, args, options) {
+    // Mock the global telemetry store so we don't crash.
+    mockTelemetry(options?.mocks);
+    // If mocks provided, wrap the command with mockSanityCommand
+    const CommandToRun = options?.mocks ? mockSanityCommand(command, options.mocks) : command;
+    const commandInstancePromise = ()=>CommandToRun.run(args || [], {
+            root: fileURLToPath(import.meta.url),
             ...options?.config
         });
     return captureOutput(commandInstancePromise, options?.capture);

package/dist/test/testCommand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/test/testCommand.ts"],"sourcesContent":["import path from 'node:path'\nimport {fileURLToPath} from 'node:url'\n\nimport {Command, Config} from '@oclif/core'\n\nimport {type CaptureOptions, captureOutput, type CaptureResult} from './captureOutput.js'\n\nexport async function testCommand(\n  command: (new (argv: string[], config: Config) => Command) & typeof Command,\n  args?: string[],\n  options?: {capture?: CaptureOptions; config?: Partial<Config>},\n): Promise<CaptureResult<unknown>> {\n  const commandInstancePromise = () =>\n    command.run(args || [], {\n      root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli'),\n      ...options?.config,\n    })\n\n  return captureOutput(commandInstancePromise, options?.capture)\n}\n"],"names":["path","fileURLToPath","captureOutput","testCommand","command","args","options","commandInstancePromise","run","root","resolve","url","config","capture"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAC5B,SAAQC,aAAa,QAAO,WAAU;AAItC,SAA6BC,aAAa,QAA2B,qBAAoB;AAEzF,OAAO,eAAeC,YACpBC,OAA2E,EAC3EC,IAAe,EACfC,OAA8D;IAE9D,MAAMC,yBAAyB,IAC7BH,QAAQI,GAAG,CAACH,QAAQ,EAAE,EAAE;YACtBI,MAAMT,KAAKU,OAAO,CAACT,cAAc,YAAYU,GAAG,GAAG;YACnD,GAAGL,SAASM,MAAM;QACpB;IAEF,OAAOV,cAAcK,wBAAwBD,SAASO;AACxD"}
+{"version":3,"sources":["../../src/test/testCommand.ts"],"sourcesContent":["import {fileURLToPath} from 'node:url'\n\nimport {Command, Config} from '@oclif/core'\n\nimport {type CaptureOptions, captureOutput, type CaptureResult} from './captureOutput.js'\nimport {mockSanityCommand, type MockSanityCommandOptions} from './mockSanityCommand.js'\nimport {mockTelemetry, type MockTelemetryOptions} from './mockTelemetry.js'\n\ntype CommandClass = (new (argv: string[], config: Config) => Command) & typeof Command\n\n/**\n * @public\n */\nexport interface TestCommandOptions {\n  /**\n   * Options for capturing output\n   */\n  capture?: CaptureOptions\n  /**\n   * Partial oclif config overrides\n   */\n  config?: Partial<Config>\n  /**\n   * Mock options for SanityCommand dependencies (config, project root, API clients).\n   * When provided, the command is automatically wrapped with mockSanityCommand.\n   */\n  mocks?: MockSanityCommandOptions & MockTelemetryOptions\n}\n\n/**\n * @public\n */\nexport async function testCommand(\n  command: CommandClass,\n  args?: string[],\n  options?: TestCommandOptions,\n): Promise<CaptureResult<unknown>> {\n  // Mock the global telemetry store so we don't crash.\n  mockTelemetry(options?.mocks)\n\n  // If mocks provided, wrap the command with mockSanityCommand\n  const CommandToRun = options?.mocks\n    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (mockSanityCommand(command as any, options.mocks) as CommandClass)\n    : command\n\n  const commandInstancePromise = () =>\n    CommandToRun.run(args || [], {\n      root: fileURLToPath(import.meta.url),\n      ...options?.config,\n    })\n\n  return captureOutput(commandInstancePromise, options?.capture)\n}\n"],"names":["fileURLToPath","captureOutput","mockSanityCommand","mockTelemetry","testCommand","command","args","options","mocks","CommandToRun","commandInstancePromise","run","root","url","config","capture"],"mappings":"AAAA,SAAQA,aAAa,QAAO,WAAU;AAItC,SAA6BC,aAAa,QAA2B,qBAAoB;AACzF,SAAQC,iBAAiB,QAAsC,yBAAwB;AACvF,SAAQC,aAAa,QAAkC,qBAAoB;AAuB3E;;CAEC,GACD,OAAO,eAAeC,YACpBC,OAAqB,EACrBC,IAAe,EACfC,OAA4B;IAE5B,qDAAqD;IACrDJ,cAAcI,SAASC;IAEvB,6DAA6D;IAC7D,MAAMC,eAAeF,SAASC,QAEzBN,kBAAkBG,SAAgBE,QAAQC,KAAK,IAChDH;IAEJ,MAAMK,yBAAyB,IAC7BD,aAAaE,GAAG,CAACL,QAAQ,EAAE,EAAE;YAC3BM,MAAMZ,cAAc,YAAYa,GAAG;YACnC,GAAGN,SAASO,MAAM;QACpB;IAEF,OAAOb,cAAcS,wBAAwBH,SAASQ;AACxD"}

package/dist/test/testFixture.js

@@ -0,0 +1,112 @@
+import { randomBytes } from 'node:crypto';
+import { copyFile, mkdir, readdir, readFile, stat, symlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getFixturesPath, getTempPath } from '../utils/paths.js';
+import { DEFAULT_FIXTURES } from './constants.js';
+/**
+ * Recursively copy a directory, skipping specified folders.
+ *
+ * @param srcDir - Source directory to copy from
+ * @param destDir - Destination directory to copy to
+ * @param skip - Array of directory/file names to skip (e.g., ['node_modules', 'dist'])
+ * @internal
+ */ export async function testCopyDirectory(srcDir, destDir, skip = []) {
+    await mkdir(destDir, {
+        recursive: true
+    });
+    const entries = await readdir(srcDir);
+    for (const entry of entries){
+        if (skip.includes(entry)) {
+            continue;
+        }
+        const srcPath = join(srcDir, entry);
+        const destPath = join(destDir, entry);
+        const stats = await stat(srcPath);
+        await (stats.isDirectory() ? testCopyDirectory(srcPath, destPath, skip) : copyFile(srcPath, destPath));
+    }
+}
+/**
+ * Clones a fixture directory into a temporary directory with an isolated copy.
+ *
+ * The function creates a unique temporary copy of the specified fixture with:
+ * - A random unique ID to avoid conflicts between parallel tests
+ * - Symlinked node_modules for performance (from the global setup version)
+ * - Modified package.json name to prevent conflicts
+ *
+ * The fixture is first looked up in the temp directory (if global setup ran),
+ * otherwise it falls back to the bundled fixtures in the package.
+ *
+ * @param fixtureName - The name of the fixture to clone (e.g., 'basic-app', 'basic-studio')
+ * @param options - Configuration options
+ * @returns The absolute path to the temporary directory containing the fixture
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * import {testFixture} from '@sanity/cli-test'
+ * import {describe, test} from 'vitest'
+ *
+ * describe('my test suite', () => {
+ *   test('should work with basic-studio', async () => {
+ *     const cwd = await testFixture('basic-studio')
+ *     // ... run your tests in this directory
+ *   })
+ * })
+ * ```
+ */ export async function testFixture(fixtureName, options = {}) {
+    const { tempDir } = options;
+    const { includeDist = false } = fixtureName in DEFAULT_FIXTURES ? DEFAULT_FIXTURES[fixtureName] : {};
+    const tempDirectory = getTempPath(tempDir);
+    // Fixtures are cloned in the tmp directory by the setup function
+    let tempFixturePath = join(tempDirectory, `fixture-${fixtureName}`);
+    try {
+        const stats = await stat(tempFixturePath);
+        if (!stats.isDirectory()) {
+            throw new Error(`${tempFixturePath} is not a directory`);
+        }
+    } catch (err) {
+        // If the cloned fixture doesn't exist, copy from the bundled fixtures
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            tempFixturePath = join(getFixturesPath(), fixtureName);
+        } else {
+            throw err;
+        }
+    }
+    const tempId = randomBytes(8).toString('hex');
+    const tempPath = join(tempDirectory, `fixture-${fixtureName}-${tempId}`);
+    // Always skip node_modules (will be symlinked), tmp and (unless specifically included) dist
+    const skipDirs = [
+        'node_modules',
+        'tmp',
+        ...includeDist ? [] : [
+            'dist'
+        ]
+    ];
+    // Copy the fixture to the temp directory
+    await testCopyDirectory(tempFixturePath, tempPath, skipDirs);
+    // Symlink the node_modules directory for performance
+    await symlink(join(tempFixturePath, 'node_modules'), join(tempPath, 'node_modules'));
+    // Replace the package.json name with a temp name
+    const packageJsonPath = join(tempPath, 'package.json');
+    const packageJson = await readFile(packageJsonPath, 'utf8');
+    const packageJsonData = JSON.parse(packageJson);
+    packageJsonData.name = `${packageJsonData.name}-${tempId}`;
+    await writeFile(packageJsonPath, JSON.stringify(packageJsonData, null, 2));
+    return tempPath;
+}
+/**
+ * @deprecated Use {@link testFixture} instead. This function will be removed in a future release.
+ *
+ * Clones an example (now called fixture) directory into a temporary directory with an isolated copy.
+ *
+ * @param exampleName - The name of the example/fixture to clone (e.g., 'basic-app', 'basic-studio')
+ * @param options - Configuration options
+ * @returns The absolute path to the temporary directory containing the example/fixture
+ *
+ * @public
+ */ export async function testExample(exampleName, options = {}) {
+    return testFixture(exampleName, options);
+}
+
+//# sourceMappingURL=testFixture.js.map

package/dist/test/testFixture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/testFixture.ts"],"sourcesContent":["import {randomBytes} from 'node:crypto'\nimport {copyFile, mkdir, readdir, readFile, stat, symlink, writeFile} from 'node:fs/promises'\nimport {join} from 'node:path'\n\nimport {getFixturesPath, getTempPath} from '../utils/paths.js'\nimport {DEFAULT_FIXTURES, type FixtureName} from './constants.js'\n\n/**\n * @deprecated Use {@link TestFixtureOptions} instead. This type alias will be removed in a future release.\n * @public\n */\nexport type TestExampleOptions = TestFixtureOptions\n\n/**\n * Recursively copy a directory, skipping specified folders.\n *\n * @param srcDir - Source directory to copy from\n * @param destDir - Destination directory to copy to\n * @param skip - Array of directory/file names to skip (e.g., ['node_modules', 'dist'])\n * @internal\n */\nexport async function testCopyDirectory(\n  srcDir: string,\n  destDir: string,\n  skip: string[] = [],\n): Promise<void> {\n  await mkdir(destDir, {recursive: true})\n\n  const entries = await readdir(srcDir)\n\n  for (const entry of entries) {\n    if (skip.includes(entry)) {\n      continue\n    }\n\n    const srcPath = join(srcDir, entry)\n    const destPath = join(destDir, entry)\n\n    const stats = await stat(srcPath)\n\n    await (stats.isDirectory()\n      ? testCopyDirectory(srcPath, destPath, skip)\n      : copyFile(srcPath, destPath))\n  }\n}\n\n/**\n * @public\n */\nexport interface TestFixtureOptions {\n  /**\n   * Custom temp directory. Defaults to process.cwd()/tmp\n   */\n  tempDir?: string\n}\n\n/**\n * Clones a fixture directory into a temporary directory with an isolated copy.\n *\n * The function creates a unique temporary copy of the specified fixture with:\n * - A random unique ID to avoid conflicts between parallel tests\n * - Symlinked node_modules for performance (from the global setup version)\n * - Modified package.json name to prevent conflicts\n *\n * The fixture is first looked up in the temp directory (if global setup ran),\n * otherwise it falls back to the bundled fixtures in the package.\n *\n * @param fixtureName - The name of the fixture to clone (e.g., 'basic-app', 'basic-studio')\n * @param options - Configuration options\n * @returns The absolute path to the temporary directory containing the fixture\n *\n * @public\n *\n * @example\n * ```typescript\n * import {testFixture} from '@sanity/cli-test'\n * import {describe, test} from 'vitest'\n *\n * describe('my test suite', () => {\n *   test('should work with basic-studio', async () => {\n *     const cwd = await testFixture('basic-studio')\n *     // ... run your tests in this directory\n *   })\n * })\n * ```\n */\nexport async function testFixture(\n  fixtureName: FixtureName | (string & {}),\n  options: TestFixtureOptions = {},\n): Promise<string> {\n  const {tempDir} = options\n  const {includeDist = false} =\n    fixtureName in DEFAULT_FIXTURES ? DEFAULT_FIXTURES[fixtureName as FixtureName] : {}\n\n  const tempDirectory = getTempPath(tempDir)\n\n  // Fixtures are cloned in the tmp directory by the setup function\n  let tempFixturePath = join(tempDirectory, `fixture-${fixtureName}`)\n\n  try {\n    const stats = await stat(tempFixturePath)\n    if (!stats.isDirectory()) {\n      throw new Error(`${tempFixturePath} is not a directory`)\n    }\n  } catch (err: unknown) {\n    // If the cloned fixture doesn't exist, copy from the bundled fixtures\n    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {\n      tempFixturePath = join(getFixturesPath(), fixtureName)\n    } else {\n      throw err\n    }\n  }\n\n  const tempId = randomBytes(8).toString('hex')\n  const tempPath = join(tempDirectory, `fixture-${fixtureName}-${tempId}`)\n\n  // Always skip node_modules (will be symlinked), tmp and (unless specifically included) dist\n  const skipDirs = ['node_modules', 'tmp', ...(includeDist ? [] : ['dist'])]\n\n  // Copy the fixture to the temp directory\n  await testCopyDirectory(tempFixturePath, tempPath, skipDirs)\n\n  // Symlink the node_modules directory for performance\n  await symlink(join(tempFixturePath, 'node_modules'), join(tempPath, 'node_modules'))\n\n  // Replace the package.json name with a temp name\n  const packageJsonPath = join(tempPath, 'package.json')\n  const packageJson = await readFile(packageJsonPath, 'utf8')\n  const packageJsonData = JSON.parse(packageJson)\n  packageJsonData.name = `${packageJsonData.name}-${tempId}`\n  await writeFile(packageJsonPath, JSON.stringify(packageJsonData, null, 2))\n\n  return tempPath\n}\n\n/**\n * @deprecated Use {@link testFixture} instead. This function will be removed in a future release.\n *\n * Clones an example (now called fixture) directory into a temporary directory with an isolated copy.\n *\n * @param exampleName - The name of the example/fixture to clone (e.g., 'basic-app', 'basic-studio')\n * @param options - Configuration options\n * @returns The absolute path to the temporary directory containing the example/fixture\n *\n * @public\n */\nexport async function testExample(\n  exampleName: FixtureName | (string & {}),\n  options: TestFixtureOptions = {},\n): Promise<string> {\n  return testFixture(exampleName, options)\n}\n"],"names":["randomBytes","copyFile","mkdir","readdir","readFile","stat","symlink","writeFile","join","getFixturesPath","getTempPath","DEFAULT_FIXTURES","testCopyDirectory","srcDir","destDir","skip","recursive","entries","entry","includes","srcPath","destPath","stats","isDirectory","testFixture","fixtureName","options","tempDir","includeDist","tempDirectory","tempFixturePath","Error","err","code","tempId","toString","tempPath","skipDirs","packageJsonPath","packageJson","packageJsonData","JSON","parse","name","stringify","testExample","exampleName"],"mappings":"AAAA,SAAQA,WAAW,QAAO,cAAa;AACvC,SAAQC,QAAQ,EAAEC,KAAK,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,OAAO,EAAEC,SAAS,QAAO,mBAAkB;AAC7F,SAAQC,IAAI,QAAO,YAAW;AAE9B,SAAQC,eAAe,EAAEC,WAAW,QAAO,oBAAmB;AAC9D,SAAQC,gBAAgB,QAAyB,iBAAgB;AAQjE;;;;;;;CAOC,GACD,OAAO,eAAeC,kBACpBC,MAAc,EACdC,OAAe,EACfC,OAAiB,EAAE;IAEnB,MAAMb,MAAMY,SAAS;QAACE,WAAW;IAAI;IAErC,MAAMC,UAAU,MAAMd,QAAQU;IAE9B,KAAK,MAAMK,SAASD,QAAS;QAC3B,IAAIF,KAAKI,QAAQ,CAACD,QAAQ;YACxB;QACF;QAEA,MAAME,UAAUZ,KAAKK,QAAQK;QAC7B,MAAMG,WAAWb,KAAKM,SAASI;QAE/B,MAAMI,QAAQ,MAAMjB,KAAKe;QAEzB,MAAOE,CAAAA,MAAMC,WAAW,KACpBX,kBAAkBQ,SAASC,UAAUN,QACrCd,SAASmB,SAASC,SAAQ;IAChC;AACF;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BC,GACD,OAAO,eAAeG,YACpBC,WAAwC,EACxCC,UAA8B,CAAC,CAAC;IAEhC,MAAM,EAACC,OAAO,EAAC,GAAGD;IAClB,MAAM,EAACE,cAAc,KAAK,EAAC,GACzBH,eAAed,mBAAmBA,gBAAgB,CAACc,YAA2B,GAAG,CAAC;IAEpF,MAAMI,gBAAgBnB,YAAYiB;IAElC,iEAAiE;IACjE,IAAIG,kBAAkBtB,KAAKqB,eAAe,CAAC,QAAQ,EAAEJ,aAAa;IAElE,IAAI;QACF,MAAMH,QAAQ,MAAMjB,KAAKyB;QACzB,IAAI,CAACR,MAAMC,WAAW,IAAI;YACxB,MAAM,IAAIQ,MAAM,GAAGD,gBAAgB,mBAAmB,CAAC;QACzD;IACF,EAAE,OAAOE,KAAc;QACrB,sEAAsE;QACtE,IAAIA,eAAeD,SAAS,UAAUC,OAAOA,IAAIC,IAAI,KAAK,UAAU;YAClEH,kBAAkBtB,KAAKC,mBAAmBgB;QAC5C,OAAO;YACL,MAAMO;QACR;IACF;IAEA,MAAME,SAASlC,YAAY,GAAGmC,QAAQ,CAAC;IACvC,MAAMC,WAAW5B,KAAKqB,eAAe,CAAC,QAAQ,EAAEJ,YAAY,CAAC,EAAES,QAAQ;IAEvE,4FAA4F;IAC5F,MAAMG,WAAW;QAAC;QAAgB;WAAWT,cAAc,EAAE,GAAG;YAAC;SAAO;KAAE;IAE1E,yCAAyC;IACzC,MAAMhB,kBAAkBkB,iBAAiBM,UAAUC;IAEnD,qDAAqD;IACrD,MAAM/B,QAAQE,KAAKsB,iBAAiB,iBAAiBtB,KAAK4B,UAAU;IAEpE,iDAAiD;IACjD,MAAME,kBAAkB9B,KAAK4B,UAAU;IACvC,MAAMG,cAAc,MAAMnC,SAASkC,iBAAiB;IACpD,MAAME,kBAAkBC,KAAKC,KAAK,CAACH;IACnCC,gBAAgBG,IAAI,GAAG,GAAGH,gBAAgBG,IAAI,CAAC,CAAC,EAAET,QAAQ;IAC1D,MAAM3B,UAAU+B,iBAAiBG,KAAKG,SAAS,CAACJ,iBAAiB,MAAM;IAEvE,OAAOJ;AACT;AAEA;;;;;;;;;;CAUC,GACD,OAAO,eAAeS,YACpBC,WAAwC,EACxCpB,UAA8B,CAAC,CAAC;IAEhC,OAAOF,YAAYsB,aAAapB;AAClC"}

package/dist/test/testHook.js

@@ -1,11 +1,27 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Config } from '@oclif/core';
 import { captureOutput } from './captureOutput.js';
-export async function testHook(hook, options) {
-    const config = await Config.load({
-        root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli')
-    });
+/**
+ * Test an oclif hook
+ *
+ * @public
+ *
+ * @example
+ * ```ts
+ * const result = await testHook(hook, {
+ *   Command: Command.loadable,
+ *   context: {
+ *     config: Config.load({
+ *      // CLI root is the directory of the package that contains the hook.
+ *       root: path.resolve(fileURLToPath(import.meta.url), '../../../root'),
+ *     }),
+ *   },
+ * })
+ * ```
+ *
+ * @param hook - The hook to test
+ * @param options - The options for the hook
+ * @returns The result of the hook
+ */ export async function testHook(hook, options) {
+    const { config } = options;
     const contextDefault = {
         config,
         debug: console.log,

package/dist/test/testHook.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/test/testHook.ts"],"sourcesContent":["import path from 'node:path'\nimport {fileURLToPath} from 'node:url'\n\nimport {Command, Config} from '@oclif/core'\nimport {type Hook, type Hooks} from '@oclif/core/hooks'\n\nimport {captureOutput} from './captureOutput.js'\n\ninterface Options {\n  Command?: Command.Loadable\n  context?: Hook.Context\n}\n\nexport async function testHook<T extends keyof Hooks>(hook: Hook<T>, options?: Options) {\n  const config = await Config.load({\n    root: path.resolve(fileURLToPath(import.meta.url), '../../../../cli'),\n  })\n\n  const contextDefault = {\n    config,\n    debug: console.log,\n    error: console.error,\n    exit: process.exit,\n    log: console.log,\n    warn: console.warn,\n  }\n\n  const {Command, context = contextDefault} = options ?? {}\n\n  const commandInstancePromise = () =>\n    hook.call(context, {\n      argv: [],\n      Command,\n      config,\n      context,\n    })\n\n  return captureOutput(commandInstancePromise)\n}\n"],"names":["path","fileURLToPath","Config","captureOutput","testHook","hook","options","config","load","root","resolve","url","contextDefault","debug","console","log","error","exit","process","warn","Command","context","commandInstancePromise","call","argv"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAC5B,SAAQC,aAAa,QAAO,WAAU;AAEtC,SAAiBC,MAAM,QAAO,cAAa;AAG3C,SAAQC,aAAa,QAAO,qBAAoB;AAOhD,OAAO,eAAeC,SAAgCC,IAAa,EAAEC,OAAiB;IACpF,MAAMC,SAAS,MAAML,OAAOM,IAAI,CAAC;QAC/BC,MAAMT,KAAKU,OAAO,CAACT,cAAc,YAAYU,GAAG,GAAG;IACrD;IAEA,MAAMC,iBAAiB;QACrBL;QACAM,OAAOC,QAAQC,GAAG;QAClBC,OAAOF,QAAQE,KAAK;QACpBC,MAAMC,QAAQD,IAAI;QAClBF,KAAKD,QAAQC,GAAG;QAChBI,MAAML,QAAQK,IAAI;IACpB;IAEA,MAAM,EAACC,OAAO,EAAEC,UAAUT,cAAc,EAAC,GAAGN,WAAW,CAAC;IAExD,MAAMgB,yBAAyB,IAC7BjB,KAAKkB,IAAI,CAACF,SAAS;YACjBG,MAAM,EAAE;YACRJ;YACAb;YACAc;QACF;IAEF,OAAOlB,cAAcmB;AACvB"}
+{"version":3,"sources":["../../src/test/testHook.ts"],"sourcesContent":["import {Command, Config} from '@oclif/core'\nimport {type Hook, type Hooks} from '@oclif/core/hooks'\n\nimport {captureOutput} from './captureOutput.js'\n\ninterface Options {\n  config: Config\n\n  Command?: Command.Class\n  context?: Hook.Context\n}\n\n/**\n * Test an oclif hook\n *\n * @public\n *\n * @example\n * ```ts\n * const result = await testHook(hook, {\n *   Command: Command.loadable,\n *   context: {\n *     config: Config.load({\n *      // CLI root is the directory of the package that contains the hook.\n *       root: path.resolve(fileURLToPath(import.meta.url), '../../../root'),\n *     }),\n *   },\n * })\n * ```\n *\n * @param hook - The hook to test\n * @param options - The options for the hook\n * @returns The result of the hook\n */\nexport async function testHook<T extends keyof Hooks>(hook: Hook<T>, options: Options) {\n  const {config} = options\n\n  const contextDefault = {\n    config,\n    debug: console.log,\n    error: console.error,\n    exit: process.exit,\n    log: console.log,\n    warn: console.warn,\n  }\n\n  const {Command, context = contextDefault} = options ?? {}\n\n  const commandInstancePromise = () =>\n    hook.call(context, {\n      argv: [],\n      Command,\n      config,\n      context,\n    })\n\n  return captureOutput(commandInstancePromise)\n}\n"],"names":["captureOutput","testHook","hook","options","config","contextDefault","debug","console","log","error","exit","process","warn","Command","context","commandInstancePromise","call","argv"],"mappings":"AAGA,SAAQA,aAAa,QAAO,qBAAoB;AAShD;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,eAAeC,SAAgCC,IAAa,EAAEC,OAAgB;IACnF,MAAM,EAACC,MAAM,EAAC,GAAGD;IAEjB,MAAME,iBAAiB;QACrBD;QACAE,OAAOC,QAAQC,GAAG;QAClBC,OAAOF,QAAQE,KAAK;QACpBC,MAAMC,QAAQD,IAAI;QAClBF,KAAKD,QAAQC,GAAG;QAChBI,MAAML,QAAQK,IAAI;IACpB;IAEA,MAAM,EAACC,OAAO,EAAEC,UAAUT,cAAc,EAAC,GAAGF,WAAW,CAAC;IAExD,MAAMY,yBAAyB,IAC7Bb,KAAKc,IAAI,CAACF,SAAS;YACjBG,MAAM,EAAE;YACRJ;YACAT;YACAU;QACF;IAEF,OAAOd,cAAce;AACvB"}

package/dist/utils/fileExists.js

@@ -0,0 +1,13 @@
+import { access } from 'node:fs/promises';
+/**
+ * Checks if a file exists and can be "accessed".
+ * Prone to race conditions, but good enough for our use cases.
+ *
+ * @param filePath - The path to the file to check
+ * @returns A promise that resolves to true if the file exists, false otherwise
+ * @internal
+ */ export function fileExists(filePath) {
+    return access(filePath).then(()=>true, ()=>false);
+}
+
+//# sourceMappingURL=fileExists.js.map

package/dist/utils/fileExists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/fileExists.ts"],"sourcesContent":["import {access} from 'node:fs/promises'\n\n/**\n * Checks if a file exists and can be \"accessed\".\n * Prone to race conditions, but good enough for our use cases.\n *\n * @param filePath - The path to the file to check\n * @returns A promise that resolves to true if the file exists, false otherwise\n * @internal\n */\nexport function fileExists(filePath: string): Promise<boolean> {\n  return access(filePath).then(\n    () => true,\n    () => false,\n  )\n}\n"],"names":["access","fileExists","filePath","then"],"mappings":"AAAA,SAAQA,MAAM,QAAO,mBAAkB;AAEvC;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,QAAgB;IACzC,OAAOF,OAAOE,UAAUC,IAAI,CAC1B,IAAM,MACN,IAAM;AAEV"}

package/dist/utils/paths.js

@@ -0,0 +1,66 @@
+import { resolve } from 'node:path';
+// Capture the initial working directory before any tests change it
+const INITIAL_CWD = process.cwd();
+/**
+ * Gets the path to the fixtures directory bundled with this package.
+ *
+ * The fixtures are copied during build and bundled with the published package.
+ * This function works the same whether the package is used in a monorepo
+ * or installed from npm.
+ *
+ * @returns Absolute path to the fixtures directory
+ * @internal
+ */ export function getFixturesPath() {
+    // From dist/utils/paths.js -> ../../fixtures
+    return resolve(import.meta.dirname, '../../fixtures');
+}
+/**
+ * Gets the path to the temporary directory for test fixtures.
+ *
+ * Uses the initial working directory captured when this module was first loaded,
+ * not process.cwd() which may change during test execution.
+ *
+ * @param customTempDir - Optional custom temp directory path
+ * @returns Absolute path to temp directory (default: initial cwd/tmp)
+ * @internal
+ */ export function getTempPath(customTempDir) {
+    return customTempDir || resolve(INITIAL_CWD, 'tmp');
+}
+/**
+ * Gets the current Windows drive letter from process.cwd().
+ * Falls back to 'C:\\' if detection fails.
+ *
+ * @returns Drive letter with backslash (e.g., 'C:\\', 'D:\\') or empty string on Unix
+ * @internal
+ */ export function getCurrentDrive() {
+    if (process.platform !== 'win32') {
+        return '';
+    }
+    const cwd = process.cwd();
+    const match = cwd.match(/^([A-Z]:)[\\/]/);
+    return match ? match[1] + '\\' : 'C:\\';
+}
+/**
+ * Converts Unix-style paths to platform-appropriate paths.
+ * On Windows:
+ *   - Absolute paths starting with '/': adds drive letter and converts to backslashes
+ *   - Relative/partial paths: converts forward slashes to backslashes
+ * On Unix: keeps paths as-is.
+ *
+ * @param pathStr - Unix-style path (e.g., '/test/path' or '.config/file.json')
+ * @returns Platform-appropriate path
+ * @internal
+ */ export function convertToSystemPath(pathStr) {
+    if (process.platform === 'win32') {
+        if (pathStr.startsWith('/')) {
+            // Absolute Unix path - add drive letter
+            const drive = getCurrentDrive();
+            return `${drive}${pathStr.slice(1).replaceAll('/', '\\')}`;
+        }
+        // Relative/partial path - just convert separators
+        return pathStr.replaceAll('/', '\\');
+    }
+    return pathStr;
+}
+
+//# sourceMappingURL=paths.js.map

package/dist/utils/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/paths.ts"],"sourcesContent":["import {resolve} from 'node:path'\n\n// Capture the initial working directory before any tests change it\nconst INITIAL_CWD = process.cwd()\n\n/**\n * Gets the path to the fixtures directory bundled with this package.\n *\n * The fixtures are copied during build and bundled with the published package.\n * This function works the same whether the package is used in a monorepo\n * or installed from npm.\n *\n * @returns Absolute path to the fixtures directory\n * @internal\n */\nexport function getFixturesPath(): string {\n  // From dist/utils/paths.js -> ../../fixtures\n  return resolve(import.meta.dirname, '../../fixtures')\n}\n\n/**\n * Gets the path to the temporary directory for test fixtures.\n *\n * Uses the initial working directory captured when this module was first loaded,\n * not process.cwd() which may change during test execution.\n *\n * @param customTempDir - Optional custom temp directory path\n * @returns Absolute path to temp directory (default: initial cwd/tmp)\n * @internal\n */\nexport function getTempPath(customTempDir?: string): string {\n  return customTempDir || resolve(INITIAL_CWD, 'tmp')\n}\n\n/**\n * Gets the current Windows drive letter from process.cwd().\n * Falls back to 'C:\\\\' if detection fails.\n *\n * @returns Drive letter with backslash (e.g., 'C:\\\\', 'D:\\\\') or empty string on Unix\n * @internal\n */\nexport function getCurrentDrive(): string {\n  if (process.platform !== 'win32') {\n    return ''\n  }\n  const cwd = process.cwd()\n  const match = cwd.match(/^([A-Z]:)[\\\\/]/)\n  return match ? match[1] + '\\\\' : 'C:\\\\'\n}\n\n/**\n * Converts Unix-style paths to platform-appropriate paths.\n * On Windows:\n *   - Absolute paths starting with '/': adds drive letter and converts to backslashes\n *   - Relative/partial paths: converts forward slashes to backslashes\n * On Unix: keeps paths as-is.\n *\n * @param pathStr - Unix-style path (e.g., '/test/path' or '.config/file.json')\n * @returns Platform-appropriate path\n * @internal\n */\nexport function convertToSystemPath(pathStr: string): string {\n  if (process.platform === 'win32') {\n    if (pathStr.startsWith('/')) {\n      // Absolute Unix path - add drive letter\n      const drive = getCurrentDrive()\n      return `${drive}${pathStr.slice(1).replaceAll('/', '\\\\')}`\n    }\n    // Relative/partial path - just convert separators\n    return pathStr.replaceAll('/', '\\\\')\n  }\n  return pathStr\n}\n"],"names":["resolve","INITIAL_CWD","process","cwd","getFixturesPath","dirname","getTempPath","customTempDir","getCurrentDrive","platform","match","convertToSystemPath","pathStr","startsWith","drive","slice","replaceAll"],"mappings":"AAAA,SAAQA,OAAO,QAAO,YAAW;AAEjC,mEAAmE;AACnE,MAAMC,cAAcC,QAAQC,GAAG;AAE/B;;;;;;;;;CASC,GACD,OAAO,SAASC;IACd,6CAA6C;IAC7C,OAAOJ,QAAQ,YAAYK,OAAO,EAAE;AACtC;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASC,YAAYC,aAAsB;IAChD,OAAOA,iBAAiBP,QAAQC,aAAa;AAC/C;AAEA;;;;;;CAMC,GACD,OAAO,SAASO;IACd,IAAIN,QAAQO,QAAQ,KAAK,SAAS;QAChC,OAAO;IACT;IACA,MAAMN,MAAMD,QAAQC,GAAG;IACvB,MAAMO,QAAQP,IAAIO,KAAK,CAAC;IACxB,OAAOA,QAAQA,KAAK,CAAC,EAAE,GAAG,OAAO;AACnC;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASC,oBAAoBC,OAAe;IACjD,IAAIV,QAAQO,QAAQ,KAAK,SAAS;QAChC,IAAIG,QAAQC,UAAU,CAAC,MAAM;YAC3B,wCAAwC;YACxC,MAAMC,QAAQN;YACd,OAAO,GAAGM,QAAQF,QAAQG,KAAK,CAAC,GAAGC,UAAU,CAAC,KAAK,OAAO;QAC5D;QACA,kDAAkD;QAClD,OAAOJ,QAAQI,UAAU,CAAC,KAAK;IACjC;IACA,OAAOJ;AACT"}