@sanity/cli-test 0.0.0-20260410130107

package/dist/test/createTestClient.js

@@ -0,0 +1,53 @@
+import { createClient } from '@sanity/client';
+import { vi } from 'vitest';
+/**
+ * Creates a real Sanity client instance for testing that makes actual HTTP requests.
+ * Use with mockApi() to intercept and mock the HTTP calls.
+ *
+ * @public
+ *
+ * @example
+ * ```typescript
+ * // Mock getGlobalCliClient to return a test client
+ * vi.mock('@sanity/cli-core', async (importOriginal) => {
+ *   const actual = await importOriginal<typeof import('@sanity/cli-core')>()
+ *   const {createTestClient} = await import('@sanity/cli-test')
+ *
+ *   return {
+ *     ...actual,
+ *     getGlobalCliClient: vi.fn().mockImplementation((opts) => {
+ *       return Promise.resolve(createTestClient({
+ *         apiVersion: opts.apiVersion,
+ *       }))
+ *     }),
+ *   }
+ * })
+ *
+ * // Then use mockApi to intercept requests
+ * mockApi({
+ *   apiVersion: 'v2025-02-19',
+ *   method: 'get',
+ *   uri: '/media-libraries',
+ * }).reply(200, {data: [...]})
+ * ```
+ */ export function createTestClient(options) {
+    const { apiVersion, projectId, token, ...rest } = options;
+    const client = createClient({
+        apiVersion,
+        projectId,
+        requestTagPrefix: 'sanity.cli',
+        token,
+        useCdn: false,
+        useProjectHostname: projectId ? true : false,
+        ...rest
+    });
+    /**
+   * Mock the request method of the client to return the actual response from the client
+   */ const request = vi.fn((...args)=>client.request(...args));
+    return {
+        client,
+        request
+    };
+}
+
+//# sourceMappingURL=createTestClient.js.map

package/dist/test/createTestClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/createTestClient.ts"],"sourcesContent":["import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'\nimport {vi} from 'vitest'\n\n/**\n * Options for createTestClient\n *\n * @public\n */\nexport interface CreateTestClientOptions extends ClientConfig {\n  /**\n   * API version for the client\n   */\n  apiVersion: string\n\n  /**\n   * Authentication token\n   */\n  token?: string\n}\n\n/**\n * Creates a real Sanity client instance for testing that makes actual HTTP requests.\n * Use with mockApi() to intercept and mock the HTTP calls.\n *\n * @public\n *\n * @example\n * ```typescript\n * // Mock getGlobalCliClient to return a test client\n * vi.mock('@sanity/cli-core', async (importOriginal) => {\n *   const actual = await importOriginal<typeof import('@sanity/cli-core')>()\n *   const {createTestClient} = await import('@sanity/cli-test')\n *\n *   return {\n *     ...actual,\n *     getGlobalCliClient: vi.fn().mockImplementation((opts) => {\n *       return Promise.resolve(createTestClient({\n *         apiVersion: opts.apiVersion,\n *       }))\n *     }),\n *   }\n * })\n *\n * // Then use mockApi to intercept requests\n * mockApi({\n *   apiVersion: 'v2025-02-19',\n *   method: 'get',\n *   uri: '/media-libraries',\n * }).reply(200, {data: [...]})\n * ```\n */\nexport function createTestClient(options: CreateTestClientOptions): {\n  client: SanityClient\n  request: ReturnType<typeof vi.fn>\n} {\n  const {apiVersion, projectId, token, ...rest} = options\n\n  const client = createClient({\n    apiVersion,\n    projectId,\n    requestTagPrefix: 'sanity.cli',\n    token,\n    useCdn: false,\n    useProjectHostname: projectId ? true : false,\n    ...rest,\n  })\n\n  /**\n   * Mock the request method of the client to return the actual response from the client\n   */\n  const request = vi.fn((...args: Parameters<typeof client.request>) => client.request(...args))\n\n  return {\n    client,\n    request,\n  }\n}\n"],"names":["createClient","vi","createTestClient","options","apiVersion","projectId","token","rest","client","requestTagPrefix","useCdn","useProjectHostname","request","fn","args"],"mappings":"AAAA,SAA2BA,YAAY,QAA0B,iBAAgB;AACjF,SAAQC,EAAE,QAAO,SAAQ;AAmBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BC,GACD,OAAO,SAASC,iBAAiBC,OAAgC;IAI/D,MAAM,EAACC,UAAU,EAAEC,SAAS,EAAEC,KAAK,EAAE,GAAGC,MAAK,GAAGJ;IAEhD,MAAMK,SAASR,aAAa;QAC1BI;QACAC;QACAI,kBAAkB;QAClBH;QACAI,QAAQ;QACRC,oBAAoBN,YAAY,OAAO;QACvC,GAAGE,IAAI;IACT;IAEA;;GAEC,GACD,MAAMK,UAAUX,GAAGY,EAAE,CAAC,CAAC,GAAGC,OAA4CN,OAAOI,OAAO,IAAIE;IAExF,OAAO;QACLN;QACAI;IACF;AACF"}

package/dist/test/createTestToken.js

@@ -0,0 +1,13 @@
+import { vi } from 'vitest';
+/**
+ * Creates a test token for the Sanity CLI
+ *
+ * @public
+ *
+ * @param token - The token to create
+ * @returns void
+ */ export function createTestToken(token) {
+    vi.stubEnv('SANITY_AUTH_TOKEN', token);
+}
+
+//# sourceMappingURL=createTestToken.js.map

package/dist/test/createTestToken.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/createTestToken.ts"],"sourcesContent":["import {vi} from 'vitest'\n\n/**\n * Creates a test token for the Sanity CLI\n *\n * @public\n *\n * @param token - The token to create\n * @returns void\n */\nexport function createTestToken(token: string) {\n  vi.stubEnv('SANITY_AUTH_TOKEN', token)\n}\n"],"names":["vi","createTestToken","token","stubEnv"],"mappings":"AAAA,SAAQA,EAAE,QAAO,SAAQ;AAEzB;;;;;;;CAOC,GACD,OAAO,SAASC,gBAAgBC,KAAa;IAC3CF,GAAGG,OAAO,CAAC,qBAAqBD;AAClC"}

package/dist/test/mockApi.js

@@ -0,0 +1,16 @@
+import nock from 'nock';
+/**
+ * Mocks the API calls, add some defaults so it doesn't cause too much friction
+ *
+ * @internal
+ */ export function mockApi({ apiHost = 'https://api.sanity.io', apiVersion = 'v2025-05-14', includeQueryTag = true, method = 'get', projectId, query = {}, uri }) {
+    const version = apiVersion.startsWith('v') ? apiVersion : `v${apiVersion}`;
+    const host = projectId ? `https://${projectId}.api.sanity.io` : apiHost;
+    const queryParams = includeQueryTag ? {
+        tag: 'sanity.cli',
+        ...query
+    } : query;
+    return nock(host)[method](`/${version}${uri}`).query(queryParams);
+}
+
+//# sourceMappingURL=mockApi.js.map

package/dist/test/mockApi.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/mockApi.ts"],"sourcesContent":["import nock from 'nock'\n\n/**\n * @internal\n */\nexport interface MockApiOptions {\n  /**\n   * Uri to mock\n   */\n  uri: string\n\n  /**\n   * Api host to mock, defaults to `https://api.sanity.io`\n   */\n  apiHost?: string\n\n  /**\n   * Api version to mock, defaults to `v2025-05-14`\n   */\n  apiVersion?: string\n\n  /**\n   * Whether to include `tag: 'sanity.cli'` in query parameters.\n   * Defaults to `true`. Set to `false` for endpoints that don't use CLI tagging.\n   */\n  includeQueryTag?: boolean\n\n  /**\n   * HTTP method to mock\n   *\n   * Defaults to 'get'\n   */\n  method?: 'delete' | 'get' | 'patch' | 'post' | 'put'\n\n  /**\n   * Project ID to mock. When provided, constructs apiHost as `https://{projectId}.api.sanity.io`\n   * Takes precedence over apiHost if both are provided.\n   */\n  projectId?: string\n\n  /**\n   * Query parameters to mock\n   */\n  query?: Record<string, string>\n}\n\n/**\n * Mocks the API calls, add some defaults so it doesn't cause too much friction\n *\n * @internal\n */\nexport function mockApi({\n  apiHost = 'https://api.sanity.io',\n  apiVersion = 'v2025-05-14',\n  includeQueryTag = true,\n  method = 'get',\n  projectId,\n  query = {},\n  uri,\n}: MockApiOptions) {\n  const version = apiVersion.startsWith('v') ? apiVersion : `v${apiVersion}`\n  const host = projectId ? `https://${projectId}.api.sanity.io` : apiHost\n  const queryParams = includeQueryTag ? {tag: 'sanity.cli', ...query} : query\n\n  return nock(host)[method](`/${version}${uri}`).query(queryParams)\n}\n"],"names":["nock","mockApi","apiHost","apiVersion","includeQueryTag","method","projectId","query","uri","version","startsWith","host","queryParams","tag"],"mappings":"AAAA,OAAOA,UAAU,OAAM;AA8CvB;;;;CAIC,GACD,OAAO,SAASC,QAAQ,EACtBC,UAAU,uBAAuB,EACjCC,aAAa,aAAa,EAC1BC,kBAAkB,IAAI,EACtBC,SAAS,KAAK,EACdC,SAAS,EACTC,QAAQ,CAAC,CAAC,EACVC,GAAG,EACY;IACf,MAAMC,UAAUN,WAAWO,UAAU,CAAC,OAAOP,aAAa,CAAC,CAAC,EAAEA,YAAY;IAC1E,MAAMQ,OAAOL,YAAY,CAAC,QAAQ,EAAEA,UAAU,cAAc,CAAC,GAAGJ;IAChE,MAAMU,cAAcR,kBAAkB;QAACS,KAAK;QAAc,GAAGN,KAAK;IAAA,IAAIA;IAEtE,OAAOP,KAAKW,KAAK,CAACN,OAAO,CAAC,CAAC,CAAC,EAAEI,UAAUD,KAAK,EAAED,KAAK,CAACK;AACvD"}

package/dist/test/mockSanityCommand.js

@@ -0,0 +1,71 @@
+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
+    const projectRoot = options.projectRoot ? {
+        ...options.projectRoot,
+        directory: convertToSystemPath(options.projectRoot.directory),
+        path: convertToSystemPath(options.projectRoot.path)
+    } : undefined;
+    // 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.cliConfigError) {
+                return Promise.reject(options.cliConfigError);
+            }
+            if (options.cliConfig) {
+                return Promise.resolve(options.cliConfig);
+            }
+            return super.getCliConfig();
+        }
+        getProjectRoot() {
+            if (options.cliConfigError && 'name' in options.cliConfigError && options.cliConfigError.name === 'ProjectRootNotFoundError') {
+                return Promise.reject(options.cliConfigError);
+            }
+            if (projectRoot) {
+                return Promise.resolve(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   * When provided, getCliConfig() will throw this error instead of returning a config.\n   * Useful for simulating running outside a project directory.\n   */\n  cliConfigError?: Error\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  const projectRoot = options.projectRoot\n    ? {\n        ...options.projectRoot,\n        directory: convertToSystemPath(options.projectRoot.directory),\n        path: convertToSystemPath(options.projectRoot.path),\n      }\n    : undefined\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.cliConfigError) {\n        return Promise.reject(options.cliConfigError)\n      }\n      if (options.cliConfig) {\n        return Promise.resolve(options.cliConfig)\n      }\n      return super.getCliConfig()\n    }\n\n    protected getProjectRoot(): Promise<ProjectRootResult> {\n      if (\n        options.cliConfigError &&\n        'name' in options.cliConfigError &&\n        options.cliConfigError.name === 'ProjectRootNotFoundError'\n      ) {\n        return Promise.reject(options.cliConfigError)\n      }\n      if (projectRoot) {\n        return Promise.resolve(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","undefined","MockedCommand","getCliConfig","cliConfigError","Promise","reject","cliConfig","resolve","getProjectRoot","name","resolveIsInteractive","isInteractive"],"mappings":"AAGA,SAAQA,mBAAmB,QAAO,oBAAmB;AACrD,SAAQC,eAAe,QAAO,uBAAsB;AA6BpD;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,SAASC,kBACdC,YAAe,EACfC,UAAoC,CAAC,CAAC;IAEtC,IAAIA,QAAQC,KAAK,EAAE;QACjBJ,gBAAgBG,QAAQC,KAAK;IAC/B;IAEA,mEAAmE;IACnE,MAAMC,cAAcF,QAAQE,WAAW,GACnC;QACE,GAAGF,QAAQE,WAAW;QACtBC,WAAWP,oBAAoBI,QAAQE,WAAW,CAACC,SAAS;QAC5DC,MAAMR,oBAAoBI,QAAQE,WAAW,CAACE,IAAI;IACpD,IACAC;IAEJ,mEAAmE;IACnE,wEAAwE;IACxE,sEAAsE;IACtE,0EAA0E;IAC1E,MAAMC,sBAAsBP;QAChBQ,eAAmC;YAC3C,IAAIP,QAAQQ,cAAc,EAAE;gBAC1B,OAAOC,QAAQC,MAAM,CAACV,QAAQQ,cAAc;YAC9C;YACA,IAAIR,QAAQW,SAAS,EAAE;gBACrB,OAAOF,QAAQG,OAAO,CAACZ,QAAQW,SAAS;YAC1C;YACA,OAAO,KAAK,CAACJ;QACf;QAEUM,iBAA6C;YACrD,IACEb,QAAQQ,cAAc,IACtB,UAAUR,QAAQQ,cAAc,IAChCR,QAAQQ,cAAc,CAACM,IAAI,KAAK,4BAChC;gBACA,OAAOL,QAAQC,MAAM,CAACV,QAAQQ,cAAc;YAC9C;YACA,IAAIN,aAAa;gBACf,OAAOO,QAAQG,OAAO,CAACV;YACzB;YACA,OAAO,KAAK,CAACW;QACf;QAEUE,uBAAgC;YACxC,IAAIf,QAAQgB,aAAa,KAAKX,WAAW;gBACvC,OAAOL,QAAQgB,aAAa;YAC9B;YACA,OAAO,KAAK,CAACD;QACf;IACF;IAEA,OAAOT;AACT"}

package/dist/test/mockTelemetry.js

@@ -0,0 +1,24 @@
+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')] = {
+        logger: 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')] = {logger: telemetry}\n\n  return telemetry\n}\n"],"names":["vi","mockTelemetry","options","telemetry","trace","fn","mockReturnValue","complete","error","log","newContext","start","updateUserProperties","globalThis","Symbol","for","logger"],"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,GAAG;QAACC,QAAQb;IAAS;IAE7E,OAAOA;AACT,EAAC"}

package/dist/test/setupFixtures.js

@@ -0,0 +1,140 @@
+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}`, {
+                    cause: error
+                });
+            }
+        }
+        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          {cause: error},\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","cause","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

@@ -0,0 +1,19 @@
+import { fileURLToPath } from 'node:url';
+import { captureOutput } from './captureOutput.js';
+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);
+}
+
+//# sourceMappingURL=testCommand.js.map

package/dist/test/testCommand.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,43 @@
+import { captureOutput } from './captureOutput.js';
+/**
+ * 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,
+        error: console.error,
+        exit: process.exit,
+        log: console.log,
+        warn: console.warn
+    };
+    const { Command, context = contextDefault } = options ?? {};
+    const commandInstancePromise = ()=>hook.call(context, {
+            argv: [],
+            Command,
+            config,
+            context
+        });
+    return captureOutput(commandInstancePromise);
+}
+
+//# sourceMappingURL=testHook.js.map

package/dist/test/testHook.js.map

@@ -0,0 +1 @@
+{"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"}