@sanity/cli-core 0.0.2-alpha.0

package/dist/config/cli/getCliConfig.js

@@ -0,0 +1,67 @@
+import { getTsconfig } from 'get-tsconfig';
+import { register } from 'tsx/esm/api';
+import { debug } from '../../debug.js';
+import { tsxWorkerTask } from '../../loaders/tsx/tsxWorkerTask.js';
+import { isRecord } from '../../util/isRecord.js';
+import { NotFoundError } from '../../util/NotFoundError.js';
+import { findPathForFiles } from '../util/findConfigsPaths.js';
+import { cliConfigSchema } from './schemas.js';
+/**
+ * Get the CLI config for a project, given the root path.
+ *
+ * We really want to avoid loading the CLI config in the main thread, as we'll need
+ * TypeScript loading logic, potentially with ts path aliases, syntax extensions and all
+ * sorts of nonsense. Thus, we _attempt_ to use a worker thread - but have to fall back
+ * to using the main thread if not possible. This can be the case if the configuration
+ * contains non-serializable properties, such as functions. This is unfortunately used
+ * by the vite config, for example.
+ *
+ * @param rootPath - Root path for the project, eg where `sanity.cli.(ts|js)` is located.
+ * @returns The CLI config
+ * @internal
+ */ export async function getCliConfig(rootPath) {
+    const paths = await findPathForFiles(rootPath, [
+        'sanity.cli.ts',
+        'sanity.cli.js'
+    ]);
+    const configPaths = paths.filter((path)=>path.exists);
+    if (configPaths.length === 0) {
+        throw new NotFoundError(`No CLI config found at ${rootPath}/sanity.cli.(ts|js)`);
+    }
+    if (configPaths.length > 1) {
+        throw new Error(`Multiple CLI config files found (${configPaths.map((path)=>path.path).join(', ')})`);
+    }
+    const configPath = configPaths[0].path;
+    let cliConfig;
+    try {
+        cliConfig = await tsxWorkerTask(new URL('getCliConfig.worker.js', import.meta.url), {
+            name: 'cliConfig',
+            rootPath,
+            workerData: {
+                configPath
+            }
+        });
+    } catch (err) {
+        debug('Failed to load CLI config in worker thread: %s', err);
+        // Assuming that didn't work because of unseriazable properties, so we'll try the
+        // main thread with tsx registered.
+        const tsconfig = getTsconfig(rootPath);
+        const tsx = register({
+            namespace: 'get-cli-config',
+            tsconfig: tsconfig?.path ?? undefined
+        });
+        // Ensure we get the default export (sometimes we get a bit of a mixed bag)
+        cliConfig = await tsx.import(configPath, import.meta.url);
+        cliConfig = isRecord(cliConfig) && 'default' in cliConfig ? cliConfig.default : cliConfig;
+        tsx.unregister();
+    }
+    const { data, error, success } = cliConfigSchema.safeParse(cliConfig);
+    if (!success) {
+        throw new Error(`Invalid CLI config: ${error.message}`);
+    }
+    // There is a minor difference here because of the `vite` property and how the types
+    // aren't as specific as our manually typed `CliConfig` type, thus the cast.
+    return data;
+}
+
+//# sourceMappingURL=getCliConfig.js.map

package/dist/config/cli/getCliConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/cli/getCliConfig.ts"],"sourcesContent":["import {getTsconfig} from 'get-tsconfig'\nimport {register} from 'tsx/esm/api'\n\nimport {debug} from '../../debug.js'\nimport {tsxWorkerTask} from '../../loaders/tsx/tsxWorkerTask.js'\nimport {isRecord} from '../../util/isRecord.js'\nimport {NotFoundError} from '../../util/NotFoundError.js'\nimport {findPathForFiles} from '../util/findConfigsPaths.js'\nimport {cliConfigSchema} from './schemas.js'\nimport {type CliConfig} from './types.js'\n\n/**\n * Get the CLI config for a project, given the root path.\n *\n * We really want to avoid loading the CLI config in the main thread, as we'll need\n * TypeScript loading logic, potentially with ts path aliases, syntax extensions and all\n * sorts of nonsense. Thus, we _attempt_ to use a worker thread - but have to fall back\n * to using the main thread if not possible. This can be the case if the configuration\n * contains non-serializable properties, such as functions. This is unfortunately used\n * by the vite config, for example.\n *\n * @param rootPath - Root path for the project, eg where `sanity.cli.(ts|js)` is located.\n * @returns The CLI config\n * @internal\n */\nexport async function getCliConfig(rootPath: string): Promise<CliConfig> {\n  const paths = await findPathForFiles(rootPath, ['sanity.cli.ts', 'sanity.cli.js'])\n  const configPaths = paths.filter((path) => path.exists)\n\n  if (configPaths.length === 0) {\n    throw new NotFoundError(`No CLI config found at ${rootPath}/sanity.cli.(ts|js)`)\n  }\n\n  if (configPaths.length > 1) {\n    throw new Error(\n      `Multiple CLI config files found (${configPaths.map((path) => path.path).join(', ')})`,\n    )\n  }\n\n  const configPath = configPaths[0].path\n\n  let cliConfig: CliConfig | undefined\n  try {\n    cliConfig = await tsxWorkerTask<CliConfig | undefined>(\n      new URL('getCliConfig.worker.js', import.meta.url),\n      {\n        name: 'cliConfig',\n        rootPath,\n        workerData: {configPath},\n      },\n    )\n  } catch (err) {\n    debug('Failed to load CLI config in worker thread: %s', err)\n\n    // Assuming that didn't work because of unseriazable properties, so we'll try the\n    // main thread with tsx registered.\n    const tsconfig = getTsconfig(rootPath)\n    const tsx = register({\n      namespace: 'get-cli-config',\n      tsconfig: tsconfig?.path ?? undefined,\n    })\n\n    // Ensure we get the default export (sometimes we get a bit of a mixed bag)\n    cliConfig = await tsx.import(configPath, import.meta.url)\n    cliConfig = (isRecord(cliConfig) && 'default' in cliConfig ? cliConfig.default : cliConfig) as\n      | CliConfig\n      | undefined\n\n    tsx.unregister()\n  }\n\n  const {data, error, success} = cliConfigSchema.safeParse(cliConfig)\n  if (!success) {\n    throw new Error(`Invalid CLI config: ${error.message}`)\n  }\n\n  // There is a minor difference here because of the `vite` property and how the types\n  // aren't as specific as our manually typed `CliConfig` type, thus the cast.\n  return data as CliConfig\n}\n"],"names":["getTsconfig","register","debug","tsxWorkerTask","isRecord","NotFoundError","findPathForFiles","cliConfigSchema","getCliConfig","rootPath","paths","configPaths","filter","path","exists","length","Error","map","join","configPath","cliConfig","URL","url","name","workerData","err","tsconfig","tsx","namespace","undefined","import","default","unregister","data","error","success","safeParse","message"],"mappings":"AAAA,SAAQA,WAAW,QAAO,eAAc;AACxC,SAAQC,QAAQ,QAAO,cAAa;AAEpC,SAAQC,KAAK,QAAO,iBAAgB;AACpC,SAAQC,aAAa,QAAO,qCAAoC;AAChE,SAAQC,QAAQ,QAAO,yBAAwB;AAC/C,SAAQC,aAAa,QAAO,8BAA6B;AACzD,SAAQC,gBAAgB,QAAO,8BAA6B;AAC5D,SAAQC,eAAe,QAAO,eAAc;AAG5C;;;;;;;;;;;;;CAaC,GACD,OAAO,eAAeC,aAAaC,QAAgB;IACjD,MAAMC,QAAQ,MAAMJ,iBAAiBG,UAAU;QAAC;QAAiB;KAAgB;IACjF,MAAME,cAAcD,MAAME,MAAM,CAAC,CAACC,OAASA,KAAKC,MAAM;IAEtD,IAAIH,YAAYI,MAAM,KAAK,GAAG;QAC5B,MAAM,IAAIV,cAAc,CAAC,uBAAuB,EAAEI,SAAS,mBAAmB,CAAC;IACjF;IAEA,IAAIE,YAAYI,MAAM,GAAG,GAAG;QAC1B,MAAM,IAAIC,MACR,CAAC,iCAAiC,EAAEL,YAAYM,GAAG,CAAC,CAACJ,OAASA,KAAKA,IAAI,EAAEK,IAAI,CAAC,MAAM,CAAC,CAAC;IAE1F;IAEA,MAAMC,aAAaR,WAAW,CAAC,EAAE,CAACE,IAAI;IAEtC,IAAIO;IACJ,IAAI;QACFA,YAAY,MAAMjB,cAChB,IAAIkB,IAAI,0BAA0B,YAAYC,GAAG,GACjD;YACEC,MAAM;YACNd;YACAe,YAAY;gBAACL;YAAU;QACzB;IAEJ,EAAE,OAAOM,KAAK;QACZvB,MAAM,kDAAkDuB;QAExD,iFAAiF;QACjF,mCAAmC;QACnC,MAAMC,WAAW1B,YAAYS;QAC7B,MAAMkB,MAAM1B,SAAS;YACnB2B,WAAW;YACXF,UAAUA,UAAUb,QAAQgB;QAC9B;QAEA,2EAA2E;QAC3ET,YAAY,MAAMO,IAAIG,MAAM,CAACX,YAAY,YAAYG,GAAG;QACxDF,YAAahB,SAASgB,cAAc,aAAaA,YAAYA,UAAUW,OAAO,GAAGX;QAIjFO,IAAIK,UAAU;IAChB;IAEA,MAAM,EAACC,IAAI,EAAEC,KAAK,EAAEC,OAAO,EAAC,GAAG5B,gBAAgB6B,SAAS,CAAChB;IACzD,IAAI,CAACe,SAAS;QACZ,MAAM,IAAInB,MAAM,CAAC,oBAAoB,EAAEkB,MAAMG,OAAO,EAAE;IACxD;IAEA,oFAAoF;IACpF,4EAA4E;IAC5E,OAAOJ;AACT"}

package/dist/config/cli/getCliConfig.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/cli/getCliConfig.worker.js

@@ -0,0 +1,14 @@
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { z } from 'zod';
+if (isMainThread || !parentPort) {
+    throw new Error('Should only be run in a worker!');
+}
+const { configPath } = z.object({
+    configPath: z.string()
+}).parse(workerData);
+const { default: loadedConfig } = await import(configPath);
+// This might throw on unserializable properties, but that's actually wanted in this
+// case, since we _need_ any unserializable props (such as vite config functions)
+parentPort.postMessage(loadedConfig);
+
+//# sourceMappingURL=getCliConfig.worker.js.map

package/dist/config/cli/getCliConfig.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/cli/getCliConfig.worker.ts"],"sourcesContent":["import {isMainThread, parentPort, workerData} from 'node:worker_threads'\n\nimport {z} from 'zod'\n\nif (isMainThread || !parentPort) {\n  throw new Error('Should only be run in a worker!')\n}\n\nconst {configPath} = z.object({configPath: z.string()}).parse(workerData)\n\nconst {default: loadedConfig} = await import(configPath)\n\n// This might throw on unserializable properties, but that's actually wanted in this\n// case, since we _need_ any unserializable props (such as vite config functions)\nparentPort.postMessage(loadedConfig)\n"],"names":["isMainThread","parentPort","workerData","z","Error","configPath","object","string","parse","default","loadedConfig","postMessage"],"mappings":"AAAA,SAAQA,YAAY,EAAEC,UAAU,EAAEC,UAAU,QAAO,sBAAqB;AAExE,SAAQC,CAAC,QAAO,MAAK;AAErB,IAAIH,gBAAgB,CAACC,YAAY;IAC/B,MAAM,IAAIG,MAAM;AAClB;AAEA,MAAM,EAACC,UAAU,EAAC,GAAGF,EAAEG,MAAM,CAAC;IAACD,YAAYF,EAAEI,MAAM;AAAE,GAAGC,KAAK,CAACN;AAE9D,MAAM,EAACO,SAASC,YAAY,EAAC,GAAG,MAAM,MAAM,CAACL;AAE7C,oFAAoF;AACpF,iFAAiF;AACjFJ,WAAWU,WAAW,CAACD"}

package/dist/config/cli/schemas.d.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+export declare const reactCompilerSchema: z.ZodOptional<z.ZodObject<{
+    compilationMode: z.ZodOptional<z.ZodEnum<["all", "annotation", "infer", "syntax"]>>;
+    panicThreshold: z.ZodOptional<z.ZodEnum<["ALL_ERRORS", "CRITICAL_ERRORS", "NONE"]>>;
+    /**
+     * @see https://react.dev/learn/react-compiler#existing-projects
+     */
+    sources: z.ZodOptional<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodString, "many">, z.ZodNull]>>;
+    /**
+     * The minimum major version of React that the compiler should emit code for. If the target is 19
+     * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On
+     * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide
+     * a userspace approximation of runtime APIs.
+     * @see https://react.dev/learn/react-compiler#using-react-compiler-with-react-17-or-18
+     */
+    target: z.ZodEnum<["18", "19"]>;
+}, "strip", z.ZodTypeAny, {
+    target: "18" | "19";
+    compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+    panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+    sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+}, {
+    target: "18" | "19";
+    compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+    panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+    sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+}>>;
+export declare const cliConfigSchema: z.ZodObject<{
+    /**
+     * API configuration
+     */
+    api: z.ZodOptional<z.ZodObject<{
+        dataset: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        dataset?: string | undefined;
+        projectId?: string | undefined;
+    }, {
+        dataset?: string | undefined;
+        projectId?: string | undefined;
+    }>>;
+    app: z.ZodOptional<z.ZodObject<{
+        entry: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        organizationId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        entry?: string | undefined;
+        id?: string | undefined;
+        organizationId?: string | undefined;
+    }, {
+        entry?: string | undefined;
+        id?: string | undefined;
+        organizationId?: string | undefined;
+    }>>;
+    autoUpdates: z.ZodOptional<z.ZodBoolean>;
+    graphql: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        filterSuffix: z.ZodOptional<z.ZodString>;
+        generation: z.ZodOptional<z.ZodEnum<["gen1", "gen2", "gen3"]>>;
+        id: z.ZodOptional<z.ZodString>;
+        nonNullDocumentFields: z.ZodOptional<z.ZodBoolean>;
+        playground: z.ZodOptional<z.ZodBoolean>;
+        source: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        filterSuffix?: string | undefined;
+        generation?: "gen1" | "gen2" | "gen3" | undefined;
+        nonNullDocumentFields?: boolean | undefined;
+        playground?: boolean | undefined;
+        source?: string | undefined;
+        tag?: string | undefined;
+        workspace?: string | undefined;
+    }, {
+        id?: string | undefined;
+        filterSuffix?: string | undefined;
+        generation?: "gen1" | "gen2" | "gen3" | undefined;
+        nonNullDocumentFields?: boolean | undefined;
+        playground?: boolean | undefined;
+        source?: string | undefined;
+        tag?: string | undefined;
+        workspace?: string | undefined;
+    }>, "many">>;
+    project: z.ZodOptional<z.ZodObject<{
+        basePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        basePath?: string | undefined;
+    }, {
+        basePath?: string | undefined;
+    }>>;
+    reactCompiler: z.ZodOptional<z.ZodObject<{
+        compilationMode: z.ZodOptional<z.ZodEnum<["all", "annotation", "infer", "syntax"]>>;
+        panicThreshold: z.ZodOptional<z.ZodEnum<["ALL_ERRORS", "CRITICAL_ERRORS", "NONE"]>>;
+        /**
+         * @see https://react.dev/learn/react-compiler#existing-projects
+         */
+        sources: z.ZodOptional<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodString, "many">, z.ZodNull]>>;
+        /**
+         * The minimum major version of React that the compiler should emit code for. If the target is 19
+         * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On
+         * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide
+         * a userspace approximation of runtime APIs.
+         * @see https://react.dev/learn/react-compiler#using-react-compiler-with-react-17-or-18
+         */
+        target: z.ZodEnum<["18", "19"]>;
+    }, "strip", z.ZodTypeAny, {
+        target: "18" | "19";
+        compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+        panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+        sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+    }, {
+        target: "18" | "19";
+        compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+        panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+        sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+    }>>;
+    reactStrictMode: z.ZodOptional<z.ZodBoolean>;
+    server: z.ZodOptional<z.ZodObject<{
+        hostname: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        hostname?: string | undefined;
+        port?: number | undefined;
+    }, {
+        hostname?: string | undefined;
+        port?: number | undefined;
+    }>>;
+    studioHost: z.ZodOptional<z.ZodString>;
+    vite: z.ZodOptional<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>>;
+}, "strip", z.ZodTypeAny, {
+    api?: {
+        dataset?: string | undefined;
+        projectId?: string | undefined;
+    } | undefined;
+    app?: {
+        entry?: string | undefined;
+        id?: string | undefined;
+        organizationId?: string | undefined;
+    } | undefined;
+    autoUpdates?: boolean | undefined;
+    graphql?: {
+        id?: string | undefined;
+        filterSuffix?: string | undefined;
+        generation?: "gen1" | "gen2" | "gen3" | undefined;
+        nonNullDocumentFields?: boolean | undefined;
+        playground?: boolean | undefined;
+        source?: string | undefined;
+        tag?: string | undefined;
+        workspace?: string | undefined;
+    }[] | undefined;
+    project?: {
+        basePath?: string | undefined;
+    } | undefined;
+    reactCompiler?: {
+        target: "18" | "19";
+        compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+        panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+        sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+    } | undefined;
+    reactStrictMode?: boolean | undefined;
+    server?: {
+        hostname?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    studioHost?: string | undefined;
+    vite?: ((...args: unknown[]) => unknown) | z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    api?: {
+        dataset?: string | undefined;
+        projectId?: string | undefined;
+    } | undefined;
+    app?: {
+        entry?: string | undefined;
+        id?: string | undefined;
+        organizationId?: string | undefined;
+    } | undefined;
+    autoUpdates?: boolean | undefined;
+    graphql?: {
+        id?: string | undefined;
+        filterSuffix?: string | undefined;
+        generation?: "gen1" | "gen2" | "gen3" | undefined;
+        nonNullDocumentFields?: boolean | undefined;
+        playground?: boolean | undefined;
+        source?: string | undefined;
+        tag?: string | undefined;
+        workspace?: string | undefined;
+    }[] | undefined;
+    project?: {
+        basePath?: string | undefined;
+    } | undefined;
+    reactCompiler?: {
+        target: "18" | "19";
+        compilationMode?: "all" | "annotation" | "infer" | "syntax" | undefined;
+        panicThreshold?: "ALL_ERRORS" | "CRITICAL_ERRORS" | "NONE" | undefined;
+        sources?: string[] | ((args_0: string, ...args: unknown[]) => boolean) | null | undefined;
+    } | undefined;
+    reactStrictMode?: boolean | undefined;
+    server?: {
+        hostname?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    studioHost?: string | undefined;
+    vite?: ((...args: unknown[]) => unknown) | z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}>;

package/dist/config/cli/schemas.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+export const reactCompilerSchema = z.object({
+    compilationMode: z.enum([
+        'all',
+        'annotation',
+        'infer',
+        'syntax'
+    ]).optional(),
+    panicThreshold: z.enum([
+        'ALL_ERRORS',
+        'CRITICAL_ERRORS',
+        'NONE'
+    ]).optional(),
+    /**
+     * @see https://react.dev/learn/react-compiler#existing-projects
+     */ sources: z.union([
+        z.function().args(z.string()).returns(z.boolean()),
+        z.array(z.string()),
+        z.null()
+    ]).optional(),
+    /**
+     * The minimum major version of React that the compiler should emit code for. If the target is 19
+     * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On
+     * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide
+     * a userspace approximation of runtime APIs.
+     * @see https://react.dev/learn/react-compiler#using-react-compiler-with-react-17-or-18
+     */ target: z.enum([
+        '18',
+        '19'
+    ])
+}).optional();
+export const cliConfigSchema = z.object({
+    /**
+   * API configuration
+   */ api: z.object({
+        dataset: z.string().optional(),
+        projectId: z.string().optional()
+    }, {
+        description: 'API configuration'
+    }).optional(),
+    app: z.object({
+        entry: z.string().optional(),
+        id: z.string().optional(),
+        organizationId: z.string().optional()
+    }).optional(),
+    autoUpdates: z.boolean().optional(),
+    graphql: z.array(z.object({
+        filterSuffix: z.string().optional(),
+        generation: z.enum([
+            'gen1',
+            'gen2',
+            'gen3'
+        ]).optional(),
+        id: z.string().optional(),
+        nonNullDocumentFields: z.boolean().optional(),
+        playground: z.boolean().optional(),
+        source: z.string().optional(),
+        tag: z.string().optional(),
+        workspace: z.string().optional()
+    })).optional(),
+    project: z.object({
+        basePath: z.string().optional()
+    }).optional(),
+    reactCompiler: reactCompilerSchema,
+    reactStrictMode: z.boolean().optional(),
+    server: z.object({
+        hostname: z.string().optional(),
+        port: z.number().optional()
+    }).optional(),
+    studioHost: z.string().optional(),
+    vite: z.union([
+        z.function(),
+        z.object({}).passthrough()
+    ]).optional()
+});
+
+//# sourceMappingURL=schemas.js.map

package/dist/config/cli/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/cli/schemas.ts"],"sourcesContent":["import {z} from 'zod'\n\nexport const reactCompilerSchema = z\n  .object({\n    compilationMode: z.enum(['all', 'annotation', 'infer', 'syntax']).optional(),\n    panicThreshold: z.enum(['ALL_ERRORS', 'CRITICAL_ERRORS', 'NONE']).optional(),\n    /**\n     * @see https://react.dev/learn/react-compiler#existing-projects\n     */\n    sources: z\n      .union([z.function().args(z.string()).returns(z.boolean()), z.array(z.string()), z.null()])\n      .optional(),\n    /**\n     * The minimum major version of React that the compiler should emit code for. If the target is 19\n     * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On\n     * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide\n     * a userspace approximation of runtime APIs.\n     * @see https://react.dev/learn/react-compiler#using-react-compiler-with-react-17-or-18\n     */\n    target: z.enum(['18', '19']),\n  })\n  .optional()\n\nexport const cliConfigSchema = z.object({\n  /**\n   * API configuration\n   */\n  api: z\n    .object(\n      {\n        dataset: z.string().optional(),\n        projectId: z.string().optional(),\n      },\n      {description: 'API configuration'},\n    )\n    .optional(),\n\n  app: z\n    .object({\n      entry: z.string().optional(),\n      id: z.string().optional(),\n      organizationId: z.string().optional(),\n    })\n    .optional(),\n\n  autoUpdates: z.boolean().optional(),\n\n  graphql: z\n    .array(\n      z.object({\n        filterSuffix: z.string().optional(),\n        generation: z.enum(['gen1', 'gen2', 'gen3']).optional(),\n        id: z.string().optional(),\n        nonNullDocumentFields: z.boolean().optional(),\n        playground: z.boolean().optional(),\n        source: z.string().optional(),\n        tag: z.string().optional(),\n        workspace: z.string().optional(),\n      }),\n    )\n    .optional(),\n\n  project: z\n    .object({\n      basePath: z.string().optional(),\n    })\n    .optional(),\n\n  reactCompiler: reactCompilerSchema,\n\n  reactStrictMode: z.boolean().optional(),\n\n  server: z\n    .object({\n      hostname: z.string().optional(),\n      port: z.number().optional(),\n    })\n    .optional(),\n\n  studioHost: z.string().optional(),\n\n  vite: z.union([z.function(), z.object({}).passthrough()]).optional(),\n})\n"],"names":["z","reactCompilerSchema","object","compilationMode","enum","optional","panicThreshold","sources","union","function","args","string","returns","boolean","array","null","target","cliConfigSchema","api","dataset","projectId","description","app","entry","id","organizationId","autoUpdates","graphql","filterSuffix","generation","nonNullDocumentFields","playground","source","tag","workspace","project","basePath","reactCompiler","reactStrictMode","server","hostname","port","number","studioHost","vite","passthrough"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAK;AAErB,OAAO,MAAMC,sBAAsBD,EAChCE,MAAM,CAAC;IACNC,iBAAiBH,EAAEI,IAAI,CAAC;QAAC;QAAO;QAAc;QAAS;KAAS,EAAEC,QAAQ;IAC1EC,gBAAgBN,EAAEI,IAAI,CAAC;QAAC;QAAc;QAAmB;KAAO,EAAEC,QAAQ;IAC1E;;KAEC,GACDE,SAASP,EACNQ,KAAK,CAAC;QAACR,EAAES,QAAQ,GAAGC,IAAI,CAACV,EAAEW,MAAM,IAAIC,OAAO,CAACZ,EAAEa,OAAO;QAAKb,EAAEc,KAAK,CAACd,EAAEW,MAAM;QAAKX,EAAEe,IAAI;KAAG,EACzFV,QAAQ;IACX;;;;;;KAMC,GACDW,QAAQhB,EAAEI,IAAI,CAAC;QAAC;QAAM;KAAK;AAC7B,GACCC,QAAQ,GAAE;AAEb,OAAO,MAAMY,kBAAkBjB,EAAEE,MAAM,CAAC;IACtC;;GAEC,GACDgB,KAAKlB,EACFE,MAAM,CACL;QACEiB,SAASnB,EAAEW,MAAM,GAAGN,QAAQ;QAC5Be,WAAWpB,EAAEW,MAAM,GAAGN,QAAQ;IAChC,GACA;QAACgB,aAAa;IAAmB,GAElChB,QAAQ;IAEXiB,KAAKtB,EACFE,MAAM,CAAC;QACNqB,OAAOvB,EAAEW,MAAM,GAAGN,QAAQ;QAC1BmB,IAAIxB,EAAEW,MAAM,GAAGN,QAAQ;QACvBoB,gBAAgBzB,EAAEW,MAAM,GAAGN,QAAQ;IACrC,GACCA,QAAQ;IAEXqB,aAAa1B,EAAEa,OAAO,GAAGR,QAAQ;IAEjCsB,SAAS3B,EACNc,KAAK,CACJd,EAAEE,MAAM,CAAC;QACP0B,cAAc5B,EAAEW,MAAM,GAAGN,QAAQ;QACjCwB,YAAY7B,EAAEI,IAAI,CAAC;YAAC;YAAQ;YAAQ;SAAO,EAAEC,QAAQ;QACrDmB,IAAIxB,EAAEW,MAAM,GAAGN,QAAQ;QACvByB,uBAAuB9B,EAAEa,OAAO,GAAGR,QAAQ;QAC3C0B,YAAY/B,EAAEa,OAAO,GAAGR,QAAQ;QAChC2B,QAAQhC,EAAEW,MAAM,GAAGN,QAAQ;QAC3B4B,KAAKjC,EAAEW,MAAM,GAAGN,QAAQ;QACxB6B,WAAWlC,EAAEW,MAAM,GAAGN,QAAQ;IAChC,IAEDA,QAAQ;IAEX8B,SAASnC,EACNE,MAAM,CAAC;QACNkC,UAAUpC,EAAEW,MAAM,GAAGN,QAAQ;IAC/B,GACCA,QAAQ;IAEXgC,eAAepC;IAEfqC,iBAAiBtC,EAAEa,OAAO,GAAGR,QAAQ;IAErCkC,QAAQvC,EACLE,MAAM,CAAC;QACNsC,UAAUxC,EAAEW,MAAM,GAAGN,QAAQ;QAC7BoC,MAAMzC,EAAE0C,MAAM,GAAGrC,QAAQ;IAC3B,GACCA,QAAQ;IAEXsC,YAAY3C,EAAEW,MAAM,GAAGN,QAAQ;IAE/BuC,MAAM5C,EAAEQ,KAAK,CAAC;QAACR,EAAES,QAAQ;QAAIT,EAAEE,MAAM,CAAC,CAAC,GAAG2C,WAAW;KAAG,EAAExC,QAAQ;AACpE,GAAE"}

package/dist/config/cli/types.d.ts

@@ -0,0 +1,13 @@
+import { type ConfigEnv, type InlineConfig } from 'vite';
+import { type z } from 'zod';
+import { type cliConfigSchema, type reactCompilerSchema } from './schemas.js';
+/**
+ * Until these types are on npm: https://github.com/facebook/react/blob/0bc30748730063e561d87a24a4617526fdd38349/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts#L39-L122
+ *
+ * @beta
+ */
+export type ReactCompilerConfig = z.infer<typeof reactCompilerSchema>;
+export type UserViteConfig = ((config: InlineConfig, env: ConfigEnv) => InlineConfig | Promise<InlineConfig>) | InlineConfig;
+export type CliConfig = z.infer<typeof cliConfigSchema> & {
+    vite?: UserViteConfig;
+};

package/dist/config/cli/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/config/cli/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/cli/types.ts"],"sourcesContent":["import {type ConfigEnv, type InlineConfig} from 'vite'\nimport {type z} from 'zod'\n\nimport {type cliConfigSchema, type reactCompilerSchema} from './schemas.js'\n\n/**\n * Until these types are on npm: https://github.com/facebook/react/blob/0bc30748730063e561d87a24a4617526fdd38349/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts#L39-L122\n *\n * @beta\n */\nexport type ReactCompilerConfig = z.infer<typeof reactCompilerSchema>\n\nexport type UserViteConfig =\n  | ((config: InlineConfig, env: ConfigEnv) => InlineConfig | Promise<InlineConfig>)\n  | InlineConfig\n\nexport type CliConfig = z.infer<typeof cliConfigSchema> & {\n  vite?: UserViteConfig\n}\n"],"names":[],"mappings":"AAgBA,WAEC"}

package/dist/config/findProjectRoot.d.ts

@@ -0,0 +1,14 @@
+import { type ProjectRootResult } from './util/recursivelyResolveProjectRoot.js';
+/**
+ * Resolve project root directory and type.
+ *
+ * Project root is:
+ * - `studio` - A pre-blueprints Sanity studio root (containing `sanity.config.(ts|js)`)
+ * - `app` - A Sanity app root (containing `sanity.cli.(ts|js)`)
+ *
+ * If a Sanity Studio v2/v1 root is found (containing `sanity.json` with `root: true`),
+ * an error is thrown, as v2/v1 is no longer supported.
+ *
+ * @internal
+ */
+export declare function findProjectRoot(cwd: string): Promise<ProjectRootResult>;

package/dist/config/findProjectRoot.js

@@ -0,0 +1,56 @@
+import { findAppConfigPath } from './util/findAppConfigPath.js';
+import { findStudioConfigPath } from './util/findStudioConfigPath.js';
+import { recursivelyResolveProjectRoot } from './util/recursivelyResolveProjectRoot.js';
+/**
+ * Resolve project root directory and type.
+ *
+ * Project root is:
+ * - `studio` - A pre-blueprints Sanity studio root (containing `sanity.config.(ts|js)`)
+ * - `app` - A Sanity app root (containing `sanity.cli.(ts|js)`)
+ *
+ * If a Sanity Studio v2/v1 root is found (containing `sanity.json` with `root: true`),
+ * an error is thrown, as v2/v1 is no longer supported.
+ *
+ * @internal
+ */ export async function findProjectRoot(cwd) {
+    try {
+        // First try to find a studio project root, looks for `sanity.config.(ts|js)`
+        const studioProjectRoot = await resolveProjectRootForStudio(cwd);
+        if (studioProjectRoot) {
+            return studioProjectRoot;
+        }
+        // Second try to find a app project root, looks for `sanity.cli.(ts|js)`
+        const appProjectRoot = await resolveProjectRootForApp(cwd);
+        if (appProjectRoot) {
+            return appProjectRoot;
+        }
+        // If nothing is found throw an error
+        throw new Error('No project root found');
+    } catch (err) {
+        const message = err instanceof Error ? err.message : `${err}`;
+        throw new Error(`Error occurred trying to resolve project root:\n${message}`);
+    }
+}
+/**
+ * Recursively searches for a project configuration file in the given directory and its parents.
+ * Throws if Sanity v2 studio root is found.
+ *
+ * @param basePath - The base path to start searching from
+ * @param iterations - Current iteration count, passed internally to prevent infinite recursion.
+ * @returns A promise that resolves to an object if config is found, false otherwise
+ * @internal
+ */ async function resolveProjectRootForStudio(basePath, iterations = 0) {
+    return recursivelyResolveProjectRoot(basePath, findStudioConfigPath, 'studio', iterations);
+}
+/**
+ * Recursively searches for a app project configuration file in the given directory and its parents.
+ *
+ * @param basePath - The base path to start searching from
+ * @param iterations - Current iteration count, passed internally to prevent infinite recursion.
+ * @returns A promise that resolves to an object if config is found, false otherwise
+ * @internal
+ */ async function resolveProjectRootForApp(basePath, iterations = 0) {
+    return recursivelyResolveProjectRoot(basePath, findAppConfigPath, 'app', iterations);
+}
+
+//# sourceMappingURL=findProjectRoot.js.map

package/dist/config/findProjectRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/findProjectRoot.ts"],"sourcesContent":["import {findAppConfigPath} from './util/findAppConfigPath.js'\nimport {findStudioConfigPath} from './util/findStudioConfigPath.js'\nimport {\n  type ProjectRootResult,\n  recursivelyResolveProjectRoot,\n} from './util/recursivelyResolveProjectRoot.js'\n\n/**\n * Resolve project root directory and type.\n *\n * Project root is:\n * - `studio` - A pre-blueprints Sanity studio root (containing `sanity.config.(ts|js)`)\n * - `app` - A Sanity app root (containing `sanity.cli.(ts|js)`)\n *\n * If a Sanity Studio v2/v1 root is found (containing `sanity.json` with `root: true`),\n * an error is thrown, as v2/v1 is no longer supported.\n *\n * @internal\n */\nexport async function findProjectRoot(cwd: string): Promise<ProjectRootResult> {\n  try {\n    // First try to find a studio project root, looks for `sanity.config.(ts|js)`\n    const studioProjectRoot = await resolveProjectRootForStudio(cwd)\n    if (studioProjectRoot) {\n      return studioProjectRoot\n    }\n\n    // Second try to find a app project root, looks for `sanity.cli.(ts|js)`\n    const appProjectRoot = await resolveProjectRootForApp(cwd)\n    if (appProjectRoot) {\n      return appProjectRoot\n    }\n\n    // If nothing is found throw an error\n    throw new Error('No project root found')\n  } catch (err: unknown) {\n    const message = err instanceof Error ? err.message : `${err}`\n    throw new Error(`Error occurred trying to resolve project root:\\n${message}`)\n  }\n}\n\n/**\n * Recursively searches for a project configuration file in the given directory and its parents.\n * Throws if Sanity v2 studio root is found.\n *\n * @param basePath - The base path to start searching from\n * @param iterations - Current iteration count, passed internally to prevent infinite recursion.\n * @returns A promise that resolves to an object if config is found, false otherwise\n * @internal\n */\nasync function resolveProjectRootForStudio(\n  basePath: string,\n  iterations = 0,\n): Promise<false | ProjectRootResult> {\n  return recursivelyResolveProjectRoot(basePath, findStudioConfigPath, 'studio', iterations)\n}\n\n/**\n * Recursively searches for a app project configuration file in the given directory and its parents.\n *\n * @param basePath - The base path to start searching from\n * @param iterations - Current iteration count, passed internally to prevent infinite recursion.\n * @returns A promise that resolves to an object if config is found, false otherwise\n * @internal\n */\nasync function resolveProjectRootForApp(\n  basePath: string,\n  iterations = 0,\n): Promise<false | ProjectRootResult> {\n  return recursivelyResolveProjectRoot(basePath, findAppConfigPath, 'app', iterations)\n}\n"],"names":["findAppConfigPath","findStudioConfigPath","recursivelyResolveProjectRoot","findProjectRoot","cwd","studioProjectRoot","resolveProjectRootForStudio","appProjectRoot","resolveProjectRootForApp","Error","err","message","basePath","iterations"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,8BAA6B;AAC7D,SAAQC,oBAAoB,QAAO,iCAAgC;AACnE,SAEEC,6BAA6B,QACxB,0CAAyC;AAEhD;;;;;;;;;;;CAWC,GACD,OAAO,eAAeC,gBAAgBC,GAAW;IAC/C,IAAI;QACF,6EAA6E;QAC7E,MAAMC,oBAAoB,MAAMC,4BAA4BF;QAC5D,IAAIC,mBAAmB;YACrB,OAAOA;QACT;QAEA,wEAAwE;QACxE,MAAME,iBAAiB,MAAMC,yBAAyBJ;QACtD,IAAIG,gBAAgB;YAClB,OAAOA;QACT;QAEA,qCAAqC;QACrC,MAAM,IAAIE,MAAM;IAClB,EAAE,OAAOC,KAAc;QACrB,MAAMC,UAAUD,eAAeD,QAAQC,IAAIC,OAAO,GAAG,GAAGD,KAAK;QAC7D,MAAM,IAAID,MAAM,CAAC,gDAAgD,EAAEE,SAAS;IAC9E;AACF;AAEA;;;;;;;;CAQC,GACD,eAAeL,4BACbM,QAAgB,EAChBC,aAAa,CAAC;IAEd,OAAOX,8BAA8BU,UAAUX,sBAAsB,UAAUY;AACjF;AAEA;;;;;;;CAOC,GACD,eAAeL,yBACbI,QAAgB,EAChBC,aAAa,CAAC;IAEd,OAAOX,8BAA8BU,UAAUZ,mBAAmB,OAAOa;AAC3E"}

package/dist/config/studio/getStudioConfig.d.ts

@@ -0,0 +1,14 @@
+import { type RawStudioConfig, type ResolvedStudioConfig } from './readStudioConfig.js';
+/**
+ * Get the studio config for a project, given the root path.
+ *
+ * @param rootPath - The root path for the project
+ * @returns The studio config (some properties may be missing)
+ * @internal
+ */
+export declare function getStudioConfig(rootPath: string, options: {
+    resolvePlugins: true;
+}): Promise<ResolvedStudioConfig>;
+export declare function getStudioConfig(rootPath: string, options: {
+    resolvePlugins: false;
+}): Promise<RawStudioConfig>;

package/dist/config/studio/getStudioConfig.js

@@ -0,0 +1,16 @@
+import { findStudioConfigPath } from '../util/findStudioConfigPath.js';
+import { readStudioConfig } from './readStudioConfig.js';
+export async function getStudioConfig(rootPath, options) {
+    const studioConfigPath = await findStudioConfigPath(rootPath);
+    if (!studioConfigPath) {
+        throw new Error(`Unable to find studio configuration file in ${rootPath}`);
+    }
+    // TypeScript is not being very clever with our overloads :(
+    return options.resolvePlugins ? readStudioConfig(studioConfigPath, {
+        resolvePlugins: true
+    }) : readStudioConfig(studioConfigPath, {
+        resolvePlugins: false
+    });
+}
+
+//# sourceMappingURL=getStudioConfig.js.map

package/dist/config/studio/getStudioConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/studio/getStudioConfig.ts"],"sourcesContent":["import {findStudioConfigPath} from '../util/findStudioConfigPath.js'\nimport {\n  type RawStudioConfig,\n  readStudioConfig,\n  type ReadStudioConfigOptions,\n  type ResolvedStudioConfig,\n} from './readStudioConfig.js'\n\n/**\n * Get the studio config for a project, given the root path.\n *\n * @param rootPath - The root path for the project\n * @returns The studio config (some properties may be missing)\n * @internal\n */\nexport async function getStudioConfig(\n  rootPath: string,\n  options: {resolvePlugins: true},\n): Promise<ResolvedStudioConfig>\n\nexport async function getStudioConfig(\n  rootPath: string,\n  options: {resolvePlugins: false},\n): Promise<RawStudioConfig>\n\nexport async function getStudioConfig(\n  rootPath: string,\n  options: ReadStudioConfigOptions,\n): Promise<RawStudioConfig | ResolvedStudioConfig> {\n  const studioConfigPath = await findStudioConfigPath(rootPath)\n  if (!studioConfigPath) {\n    throw new Error(`Unable to find studio configuration file in ${rootPath}`)\n  }\n\n  // TypeScript is not being very clever with our overloads :(\n  return options.resolvePlugins\n    ? readStudioConfig(studioConfigPath, {resolvePlugins: true})\n    : readStudioConfig(studioConfigPath, {resolvePlugins: false})\n}\n"],"names":["findStudioConfigPath","readStudioConfig","getStudioConfig","rootPath","options","studioConfigPath","Error","resolvePlugins"],"mappings":"AAAA,SAAQA,oBAAoB,QAAO,kCAAiC;AACpE,SAEEC,gBAAgB,QAGX,wBAAuB;AAmB9B,OAAO,eAAeC,gBACpBC,QAAgB,EAChBC,OAAgC;IAEhC,MAAMC,mBAAmB,MAAML,qBAAqBG;IACpD,IAAI,CAACE,kBAAkB;QACrB,MAAM,IAAIC,MAAM,CAAC,4CAA4C,EAAEH,UAAU;IAC3E;IAEA,4DAA4D;IAC5D,OAAOC,QAAQG,cAAc,GACzBN,iBAAiBI,kBAAkB;QAACE,gBAAgB;IAAI,KACxDN,iBAAiBI,kBAAkB;QAACE,gBAAgB;IAAK;AAC/D"}