@sanity/cli-test 0.0.0-20260410130107

package/dist/index.d.ts

@@ -0,0 +1,531 @@
+import { CliConfig } from "@sanity/cli-core";
+import { ClientConfig } from "@sanity/client";
+import { CLITelemetryStore } from "@sanity/cli-core";
+import { Command } from "@oclif/core";
+import { Config } from "@oclif/core";
+import { Errors } from "@oclif/core";
+import { Hook } from "@oclif/core/hooks";
+import { Hooks } from "@oclif/core/hooks";
+import nock from "nock";
+import { ProjectRootResult } from "@sanity/cli-core";
+import { SanityClient } from "@sanity/client";
+import { SanityCommand } from "@sanity/cli-core";
+import { TestProject } from "vitest/node";
+import { vi } from "vitest";
+
+declare interface CaptureOptions {
+  /**
+   * Whether to print the output to the console
+   */
+  print?: boolean;
+  /**
+   * Whether to strip ANSI escape codes from the output
+   */
+  stripAnsi?: boolean;
+  testNodeEnv?: string;
+}
+
+declare interface CaptureResult<T = unknown> {
+  stderr: string;
+  stdout: string;
+  error?: Error & Partial<Errors.CLIError>;
+  result?: T;
+}
+
+declare type CommandClass = (new (argv: string[], config: Config) => Command) &
+  typeof Command;
+
+/**
+ * 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 declare function convertToSystemPath(pathStr: string): string;
+
+/**
+ * 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 declare function createTestClient(options: CreateTestClientOptions): {
+  client: SanityClient;
+  request: ReturnType<typeof vi.fn>;
+};
+
+/**
+ * Options for createTestClient
+ *
+ * @public
+ */
+export declare interface CreateTestClientOptions extends ClientConfig {
+  /**
+   * API version for the client
+   */
+  apiVersion: string;
+  /**
+   * Authentication token
+   */
+  token?: string;
+}
+
+/**
+ * Creates a test token for the Sanity CLI
+ *
+ * @public
+ *
+ * @param token - The token to create
+ * @returns void
+ */
+export declare function createTestToken(token: string): void;
+
+/**
+ * Default fixtures bundled with the package and their options.
+ *
+ * @public
+ */
+export declare const DEFAULT_FIXTURES: Record<FixtureName, FixtureOptions>;
+
+/**
+ * @deprecated Use {@link FixtureName} instead. This type alias will be removed in a future release.
+ * @public
+ */
+export declare type ExampleName = FixtureName;
+
+/**
+ * Valid fixture name type.
+ * @public
+ */
+export declare type FixtureName =
+  | "basic-app"
+  | "basic-functions"
+  | "basic-studio"
+  | "federated-studio"
+  | "graphql-studio"
+  | "multi-workspace-studio"
+  | "prebuilt-app"
+  | "prebuilt-studio"
+  | "worst-case-studio";
+
+/**
+ * Options for each fixture.
+ * @public
+ */
+export declare interface FixtureOptions {
+  includeDist?: boolean;
+}
+
+/**
+ * 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 declare function getCurrentDrive(): string;
+
+/**
+ * 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 declare function getFixturesPath(): string;
+
+/**
+ * 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 declare function getTempPath(customTempDir?: string): string;
+
+/**
+ * Mocks the API calls, add some defaults so it doesn't cause too much friction
+ *
+ * @internal
+ */
+export declare function mockApi({
+  apiHost,
+  apiVersion,
+  includeQueryTag,
+  method,
+  projectId,
+  query,
+  uri,
+}: MockApiOptions): nock.Interceptor;
+
+/**
+ * @internal
+ */
+export declare interface MockApiOptions {
+  /**
+   * Uri to mock
+   */
+  uri: string;
+  /**
+   * Api host to mock, defaults to `https://api.sanity.io`
+   */
+  apiHost?: string;
+  /**
+   * Api version to mock, defaults to `v2025-05-14`
+   */
+  apiVersion?: string;
+  /**
+   * Whether to include `tag: 'sanity.cli'` in query parameters.
+   * Defaults to `true`. Set to `false` for endpoints that don't use CLI tagging.
+   */
+  includeQueryTag?: boolean;
+  /**
+   * HTTP method to mock
+   *
+   * Defaults to 'get'
+   */
+  method?: "delete" | "get" | "patch" | "post" | "put";
+  /**
+   * Project ID to mock. When provided, constructs apiHost as `https://{projectId}.api.sanity.io`
+   * Takes precedence over apiHost if both are provided.
+   */
+  projectId?: string;
+  /**
+   * Query parameters to mock
+   */
+  query?: Record<string, string>;
+}
+
+/**
+ * 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 declare function mockSanityCommand<
+  T extends typeof SanityCommand<typeof Command>,
+>(CommandClass: T, options?: MockSanityCommandOptions): T;
+
+/**
+ * @public
+ */
+export declare interface MockSanityCommandOptions {
+  /**
+   * Mock CLI config (required if command uses getCliConfig or getProjectId)
+   */
+  cliConfig?: CliConfig;
+  /**
+   * When provided, getCliConfig() will throw this error instead of returning a config.
+   * Useful for simulating running outside a project directory.
+   */
+  cliConfigError?: Error;
+  /**
+   * Mock whether the terminal is interactive (used by isUnattended)
+   */
+  isInteractive?: boolean;
+  /**
+   * Mock project root result (required if command uses getProjectRoot)
+   */
+  projectRoot?: ProjectRootResult;
+  /**
+   * Mock authentication token (passed to API clients, bypasses getCliToken)
+   */
+  token?: string;
+}
+
+/**
+ * @public
+ * @param options - Options for mocking the telemetry store.
+ * @returns The mocked telemetry store.
+ */
+export declare const mockTelemetry: (
+  options?: MockTelemetryOptions,
+) => CLITelemetryStore;
+
+/**
+ * @public
+ */
+export declare interface MockTelemetryOptions {
+  trace?: () => void;
+  updateUserProperties?: () => void;
+}
+
+declare interface Options {
+  config: Config;
+  Command?: Command.Class;
+  context?: Hook.Context;
+}
+
+/**
+ * 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 declare function setup(
+  _: TestProject,
+  options?: SetupTestFixturesOptions,
+): Promise<void>;
+
+/**
+ * Options for setupTestFixtures
+ *
+ * @public
+ */
+export declare interface SetupTestFixturesOptions {
+  /**
+   * Glob patterns for additional fixture directories to set up.
+   *
+   * Each pattern is matched against directories in the current working directory.
+   * Only directories containing a `package.json` file are included.
+   *
+   * @example
+   * ```typescript
+   * ['fixtures/*', 'dev/*']
+   * ```
+   */
+  additionalFixtures?: string[];
+  /**
+   * Custom temp directory path. Defaults to process.cwd()/tmp
+   */
+  tempDir?: string;
+}
+
+/**
+ * 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 declare function teardown(
+  options?: TeardownTestFixturesOptions,
+): Promise<void>;
+
+/**
+ * Options for teardownTestFixtures
+ *
+ * @public
+ */
+export declare interface TeardownTestFixturesOptions {
+  /**
+   * Custom temp directory path. Defaults to process.cwd()/tmp
+   */
+  tempDir?: string;
+}
+
+/**
+ * @public
+ */
+export declare function testCommand(
+  command: CommandClass,
+  args?: string[],
+  options?: TestCommandOptions,
+): Promise<CaptureResult<unknown>>;
+
+/**
+ * @public
+ */
+export declare interface TestCommandOptions {
+  /**
+   * Options for capturing output
+   */
+  capture?: CaptureOptions;
+  /**
+   * Partial oclif config overrides
+   */
+  config?: Partial<Config>;
+  /**
+   * Mock options for SanityCommand dependencies (config, project root, API clients).
+   * When provided, the command is automatically wrapped with mockSanityCommand.
+   */
+  mocks?: MockSanityCommandOptions & MockTelemetryOptions;
+}
+
+/**
+ * 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 declare function testCopyDirectory(
+  srcDir: string,
+  destDir: string,
+  skip?: string[],
+): Promise<void>;
+
+/**
+ * @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 declare function testExample(
+  exampleName: FixtureName | (string & {}),
+  options?: TestFixtureOptions,
+): Promise<string>;
+
+/**
+ * @deprecated Use {@link TestFixtureOptions} instead. This type alias will be removed in a future release.
+ * @public
+ */
+export declare type TestExampleOptions = TestFixtureOptions;
+
+/**
+ * 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 declare function testFixture(
+  fixtureName: FixtureName | (string & {}),
+  options?: TestFixtureOptions,
+): Promise<string>;
+
+/**
+ * @public
+ */
+export declare interface TestFixtureOptions {
+  /**
+   * Custom temp directory. Defaults to process.cwd()/tmp
+   */
+  tempDir?: string;
+}
+
+/**
+ * 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 declare function testHook<T extends keyof Hooks>(
+  hook: Hook<T>,
+  options: Options,
+): Promise<CaptureResult<Hooks[T]["return"]>>;
+
+export {};

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './test/constants.js';
+export * from './test/createTestClient.js';
+export * from './test/createTestToken.js';
+export * from './test/mockApi.js';
+export * from './test/mockSanityCommand.js';
+export * from './test/mockTelemetry.js';
+export * from './test/setupFixtures.js';
+export * from './test/testCommand.js';
+export * from './test/testFixture.js';
+export * from './test/testHook.js';
+export * from './utils/paths.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './test/constants.js'\nexport * from './test/createTestClient.js'\nexport * from './test/createTestToken.js'\nexport * from './test/mockApi.js'\nexport * from './test/mockSanityCommand.js'\nexport * from './test/mockTelemetry.js'\nexport * from './test/setupFixtures.js'\nexport * from './test/testCommand.js'\nexport * from './test/testFixture.js'\nexport * from './test/testHook.js'\nexport * from './utils/paths.js'\n"],"names":[],"mappings":"AAAA,cAAc,sBAAqB;AACnC,cAAc,6BAA4B;AAC1C,cAAc,4BAA2B;AACzC,cAAc,oBAAmB;AACjC,cAAc,8BAA6B;AAC3C,cAAc,0BAAyB;AACvC,cAAc,0BAAyB;AACvC,cAAc,wBAAuB;AACrC,cAAc,wBAAuB;AACrC,cAAc,qBAAoB;AAClC,cAAc,mBAAkB"}

package/dist/test/captureOutput.js

@@ -0,0 +1,83 @@
+import ansis from 'ansis';
+/**
+ * Capture the output of a command and return the result
+ *
+ * @param fn - The function to capture the output of
+ * @param opts - The options for the capture
+ * @returns The result of the command
+ * @internal
+ *
+ * Credits to oclif for the original implementation:
+ * https://github.com/oclif/test/blob/2a5407e6fc80d388043d10f6b7b8eaa586483015/src/index.ts
+ *
+ * We are not using the library directly since it does not support mocking code inside of the command
+ * possibly because the commands run in a different thread
+ */ export async function captureOutput(fn, opts) {
+    const print = opts?.print ?? false;
+    const stripAnsi = opts?.stripAnsi ?? true;
+    const testNodeEnv = opts?.testNodeEnv || 'test';
+    const originals = {
+        NODE_ENV: process.env.NODE_ENV,
+        stderrWrite: process.stderr.write,
+        stdoutWrite: process.stdout.write
+    };
+    const output = {
+        stderr: [],
+        stdout: []
+    };
+    const toString = (str)=>stripAnsi ? ansis.strip(str.toString()) : str.toString();
+    const getStderr = ()=>output.stderr.map((b)=>toString(b)).join('');
+    const getStdout = ()=>output.stdout.map((b)=>toString(b)).join('');
+    const mockWrite = (std)=>(chunk, encodingOrCb, cb)=>{
+            output[std].push(chunk.toString());
+            if (print) {
+                let callback = cb;
+                let encoding;
+                if (typeof encodingOrCb === 'function') {
+                    callback = encodingOrCb;
+                } else {
+                    encoding = encodingOrCb;
+                }
+                originals[`${std}Write`].apply(process[std], [
+                    chunk,
+                    encoding,
+                    callback
+                ]);
+            } else if (typeof cb === 'function') {
+                cb();
+            } else if (typeof encodingOrCb === 'function') {
+                encodingOrCb();
+            }
+            return true;
+        };
+    process.stdout.write = mockWrite('stdout');
+    process.stderr.write = mockWrite('stderr');
+    process.env.NODE_ENV = testNodeEnv;
+    try {
+        const result = await fn();
+        return {
+            result,
+            stderr: getStderr(),
+            stdout: getStdout()
+        };
+    } catch (error) {
+        // Check if it's an oclif CLIError or a regular error
+        const processedError = error instanceof Error // Check if it's an Error (this includes CLIError)
+         ? Object.assign(error, {
+            message: toString(error.message)
+        }) // If so, process its message
+         : new Error(toString(String(error))) // Otherwise, create a new Error from string representation
+        ;
+        return {
+            error: processedError,
+            stderr: getStderr(),
+            stdout: getStdout()
+        };
+    } finally{
+        process.stdout.write = originals.stdoutWrite;
+        process.stderr.write = originals.stderrWrite;
+        process.env.NODE_ENV = originals.NODE_ENV;
+    }
+}
+
+//# sourceMappingURL=captureOutput.js.map

package/dist/test/captureOutput.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/captureOutput.ts"],"sourcesContent":["import {type Errors} from '@oclif/core'\nimport ansis from 'ansis'\n\nexport interface CaptureOptions {\n  /**\n   * Whether to print the output to the console\n   */\n  print?: boolean\n  /**\n   * Whether to strip ANSI escape codes from the output\n   */\n  stripAnsi?: boolean\n  testNodeEnv?: string\n}\n\nexport interface CaptureResult<T = unknown> {\n  stderr: string\n  stdout: string\n\n  error?: Error & Partial<Errors.CLIError>\n  result?: T\n}\n\n/**\n * Capture the output of a command and return the result\n *\n * @param fn - The function to capture the output of\n * @param opts - The options for the capture\n * @returns The result of the command\n * @internal\n *\n * Credits to oclif for the original implementation:\n * https://github.com/oclif/test/blob/2a5407e6fc80d388043d10f6b7b8eaa586483015/src/index.ts\n *\n * We are not using the library directly since it does not support mocking code inside of the command\n * possibly because the commands run in a different thread\n */\nexport async function captureOutput<T>(\n  fn: () => Promise<T>,\n  opts?: CaptureOptions,\n): Promise<CaptureResult<T>> {\n  const print = opts?.print ?? false\n  const stripAnsi = opts?.stripAnsi ?? true\n  const testNodeEnv = opts?.testNodeEnv || 'test'\n\n  const originals = {\n    NODE_ENV: process.env.NODE_ENV,\n    stderrWrite: process.stderr.write,\n    stdoutWrite: process.stdout.write,\n  }\n\n  const output: Record<'stderr' | 'stdout', string[]> = {\n    stderr: [],\n    stdout: [],\n  }\n\n  const toString = (str: string | Uint8Array): string =>\n    stripAnsi ? ansis.strip(str.toString()) : str.toString()\n\n  const getStderr = (): string => output.stderr.map((b) => toString(b)).join('')\n  const getStdout = (): string => output.stdout.map((b) => toString(b)).join('')\n\n  const mockWrite =\n    (std: 'stderr' | 'stdout'): typeof process.stderr.write =>\n    (\n      chunk: string | Uint8Array,\n      encodingOrCb?: ((err?: Error | null) => void) | BufferEncoding,\n      cb?: (err?: Error | null) => void,\n    ) => {\n      output[std].push(chunk.toString())\n\n      if (print) {\n        let callback: ((err?: Error | null) => void) | undefined = cb\n        let encoding: BufferEncoding | undefined\n        if (typeof encodingOrCb === 'function') {\n          callback = encodingOrCb\n        } else {\n          encoding = encodingOrCb\n        }\n        originals[`${std}Write`].apply(process[std], [chunk, encoding, callback])\n      } else if (typeof cb === 'function') {\n        cb()\n      } else if (typeof encodingOrCb === 'function') {\n        encodingOrCb()\n      }\n      return true\n    }\n\n  process.stdout.write = mockWrite('stdout')\n  process.stderr.write = mockWrite('stderr')\n  process.env.NODE_ENV = testNodeEnv\n\n  try {\n    const result = await fn()\n    return {\n      result,\n      stderr: getStderr(),\n      stdout: getStdout(),\n    }\n  } catch (error) {\n    // Check if it's an oclif CLIError or a regular error\n    const processedError =\n      error instanceof Error // Check if it's an Error (this includes CLIError)\n        ? Object.assign(error, {message: toString(error.message)}) // If so, process its message\n        : new Error(toString(String(error))) // Otherwise, create a new Error from string representation\n\n    return {\n      error: processedError,\n      stderr: getStderr(),\n      stdout: getStdout(),\n    }\n  } finally {\n    process.stdout.write = originals.stdoutWrite\n    process.stderr.write = originals.stderrWrite\n    process.env.NODE_ENV = originals.NODE_ENV\n  }\n}\n"],"names":["ansis","captureOutput","fn","opts","print","stripAnsi","testNodeEnv","originals","NODE_ENV","process","env","stderrWrite","stderr","write","stdoutWrite","stdout","output","toString","str","strip","getStderr","map","b","join","getStdout","mockWrite","std","chunk","encodingOrCb","cb","push","callback","encoding","apply","result","error","processedError","Error","Object","assign","message","String"],"mappings":"AACA,OAAOA,WAAW,QAAO;AAsBzB;;;;;;;;;;;;;CAaC,GACD,OAAO,eAAeC,cACpBC,EAAoB,EACpBC,IAAqB;IAErB,MAAMC,QAAQD,MAAMC,SAAS;IAC7B,MAAMC,YAAYF,MAAME,aAAa;IACrC,MAAMC,cAAcH,MAAMG,eAAe;IAEzC,MAAMC,YAAY;QAChBC,UAAUC,QAAQC,GAAG,CAACF,QAAQ;QAC9BG,aAAaF,QAAQG,MAAM,CAACC,KAAK;QACjCC,aAAaL,QAAQM,MAAM,CAACF,KAAK;IACnC;IAEA,MAAMG,SAAgD;QACpDJ,QAAQ,EAAE;QACVG,QAAQ,EAAE;IACZ;IAEA,MAAME,WAAW,CAACC,MAChBb,YAAYL,MAAMmB,KAAK,CAACD,IAAID,QAAQ,MAAMC,IAAID,QAAQ;IAExD,MAAMG,YAAY,IAAcJ,OAAOJ,MAAM,CAACS,GAAG,CAAC,CAACC,IAAML,SAASK,IAAIC,IAAI,CAAC;IAC3E,MAAMC,YAAY,IAAcR,OAAOD,MAAM,CAACM,GAAG,CAAC,CAACC,IAAML,SAASK,IAAIC,IAAI,CAAC;IAE3E,MAAME,YACJ,CAACC,MACD,CACEC,OACAC,cACAC;YAEAb,MAAM,CAACU,IAAI,CAACI,IAAI,CAACH,MAAMV,QAAQ;YAE/B,IAAIb,OAAO;gBACT,IAAI2B,WAAuDF;gBAC3D,IAAIG;gBACJ,IAAI,OAAOJ,iBAAiB,YAAY;oBACtCG,WAAWH;gBACb,OAAO;oBACLI,WAAWJ;gBACb;gBACArB,SAAS,CAAC,GAAGmB,IAAI,KAAK,CAAC,CAAC,CAACO,KAAK,CAACxB,OAAO,CAACiB,IAAI,EAAE;oBAACC;oBAAOK;oBAAUD;iBAAS;YAC1E,OAAO,IAAI,OAAOF,OAAO,YAAY;gBACnCA;YACF,OAAO,IAAI,OAAOD,iBAAiB,YAAY;gBAC7CA;YACF;YACA,OAAO;QACT;IAEFnB,QAAQM,MAAM,CAACF,KAAK,GAAGY,UAAU;IACjChB,QAAQG,MAAM,CAACC,KAAK,GAAGY,UAAU;IACjChB,QAAQC,GAAG,CAACF,QAAQ,GAAGF;IAEvB,IAAI;QACF,MAAM4B,SAAS,MAAMhC;QACrB,OAAO;YACLgC;YACAtB,QAAQQ;YACRL,QAAQS;QACV;IACF,EAAE,OAAOW,OAAO;QACd,qDAAqD;QACrD,MAAMC,iBACJD,iBAAiBE,MAAM,kDAAkD;WACrEC,OAAOC,MAAM,CAACJ,OAAO;YAACK,SAASvB,SAASkB,MAAMK,OAAO;QAAC,GAAG,6BAA6B;WACtF,IAAIH,MAAMpB,SAASwB,OAAON,SAAS,2DAA2D;;QAEpG,OAAO;YACLA,OAAOC;YACPxB,QAAQQ;YACRL,QAAQS;QACV;IACF,SAAU;QACRf,QAAQM,MAAM,CAACF,KAAK,GAAGN,UAAUO,WAAW;QAC5CL,QAAQG,MAAM,CAACC,KAAK,GAAGN,UAAUI,WAAW;QAC5CF,QAAQC,GAAG,CAACF,QAAQ,GAAGD,UAAUC,QAAQ;IAC3C;AACF"}

package/dist/test/constants.js

@@ -0,0 +1,24 @@
+/**
+ * Options for each fixture.
+ * @public
+ */ /**
+ * Default fixtures bundled with the package and their options.
+ *
+ * @public
+ */ export const DEFAULT_FIXTURES = {
+    'basic-app': {},
+    'basic-functions': {},
+    'basic-studio': {},
+    'federated-studio': {},
+    'graphql-studio': {},
+    'multi-workspace-studio': {},
+    'prebuilt-app': {
+        includeDist: true
+    },
+    'prebuilt-studio': {
+        includeDist: true
+    },
+    'worst-case-studio': {}
+};
+
+//# sourceMappingURL=constants.js.map

package/dist/test/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/test/constants.ts"],"sourcesContent":["/**\n * Options for each fixture.\n * @public\n */\nexport interface FixtureOptions {\n  includeDist?: boolean\n}\n\n/**\n * Default fixtures bundled with the package and their options.\n *\n * @public\n */\nexport const DEFAULT_FIXTURES: Record<FixtureName, FixtureOptions> = {\n  'basic-app': {},\n  'basic-functions': {},\n  'basic-studio': {},\n  'federated-studio': {},\n  'graphql-studio': {},\n  'multi-workspace-studio': {},\n  'prebuilt-app': {includeDist: true},\n  'prebuilt-studio': {includeDist: true},\n  'worst-case-studio': {},\n} as const\n\n/**\n * Valid fixture name type.\n * @public\n */\nexport type FixtureName =\n  | 'basic-app'\n  | 'basic-functions'\n  | 'basic-studio'\n  | 'federated-studio'\n  | 'graphql-studio'\n  | 'multi-workspace-studio'\n  | 'prebuilt-app'\n  | 'prebuilt-studio'\n  | 'worst-case-studio'\n\n/**\n * @deprecated Use {@link FixtureName} instead. This type alias will be removed in a future release.\n * @public\n */\nexport type ExampleName = FixtureName\n"],"names":["DEFAULT_FIXTURES","includeDist"],"mappings":"AAAA;;;CAGC,GAKD;;;;CAIC,GACD,OAAO,MAAMA,mBAAwD;IACnE,aAAa,CAAC;IACd,mBAAmB,CAAC;IACpB,gBAAgB,CAAC;IACjB,oBAAoB,CAAC;IACrB,kBAAkB,CAAC;IACnB,0BAA0B,CAAC;IAC3B,gBAAgB;QAACC,aAAa;IAAI;IAClC,mBAAmB;QAACA,aAAa;IAAI;IACrC,qBAAqB,CAAC;AACxB,EAAU"}