@sanity/cli-core 0.0.2-alpha.0

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

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+declare const rawConfigSchema: z.ZodUnion<[z.ZodArray<z.ZodObject<{
+    basePath: z.ZodString;
+    dataset: z.ZodString;
+    name: z.ZodString;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    projectId: z.ZodString;
+    schema: z.ZodObject<{
+        _original: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            types: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        }, {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        _original: {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    }, {
+        _original: {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    }>;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    dataset: string;
+    projectId: string;
+    basePath: string;
+    schema: {
+        _original: {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    };
+    title: string;
+    plugins?: unknown[] | undefined;
+}, {
+    name: string;
+    dataset: string;
+    projectId: string;
+    basePath: string;
+    schema: {
+        _original: {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    };
+    title: string;
+    plugins?: unknown[] | undefined;
+}>, "many">, z.ZodObject<{
+    basePath: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    projectId: z.ZodString;
+    schema: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        types: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }, {
+        types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    basePath: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    projectId: z.ZodString;
+    schema: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        types: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }, {
+        types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    basePath: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    projectId: z.ZodString;
+    schema: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        types: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }, {
+        types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+        name?: string | undefined;
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>]>;
+declare const resolvedConfigSchema: z.ZodArray<z.ZodObject<{
+    basePath: z.ZodString;
+    dataset: z.ZodString;
+    name: z.ZodString;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    projectId: z.ZodString;
+    schema: z.ZodObject<{
+        _original: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            types: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        }, {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        _original: {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    }, {
+        _original: {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    }>;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    dataset: string;
+    projectId: string;
+    basePath: string;
+    schema: {
+        _original: {
+            types: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    };
+    title: string;
+    plugins?: unknown[] | undefined;
+}, {
+    name: string;
+    dataset: string;
+    projectId: string;
+    basePath: string;
+    schema: {
+        _original: {
+            types: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            name?: string | undefined;
+        };
+    };
+    title: string;
+    plugins?: unknown[] | undefined;
+}>, "many">;
+export type RawStudioConfig = z.infer<typeof rawConfigSchema>;
+export type ResolvedStudioConfig = z.infer<typeof resolvedConfigSchema>;
+export interface ReadStudioConfigOptions {
+    /**
+     * Whether or not to resolve the plugins defined in the config.
+     *
+     * In some cases, you need this in order to have the full picture of what the studio
+     * would "see". As an example, plugins can define schema types that are not explicitly
+     * defined in the users' schema types. In order to get the full picture, you need to
+     * resolve the plugins, which is an asyncronous operation.
+     *
+     * In other cases, it might be enough to only do a shallow pass. As an example, if you
+     * only need to know about the defined workspace, or the user-defined schema types,
+     * this can be set to `false` - which should resolve faster (and potentially "safer")
+     * in terms of not triggering all kinds of browser behavior that may or may not be
+     * loaded as the plugins are resolved.
+     */
+    resolvePlugins: boolean;
+}
+export declare function readStudioConfig(configPath: string, options: {
+    resolvePlugins: true;
+}): Promise<ResolvedStudioConfig>;
+export declare function readStudioConfig(configPath: string, options: {
+    resolvePlugins: false;
+}): Promise<RawStudioConfig>;
+export {};

package/dist/config/studio/readStudioConfig.js

@@ -0,0 +1,45 @@
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { studioWorkerTask } from '../../loaders/studio/studioWorkerTask.js';
+const schemaSchema = z.object({
+    name: z.string().optional(),
+    types: z.array(z.object({}).passthrough())
+});
+const singleStudioWorkspaceSchema = z.object({
+    basePath: z.string().optional(),
+    dataset: z.string(),
+    name: z.string().optional(),
+    plugins: z.array(z.unknown()).optional(),
+    projectId: z.string(),
+    schema: schemaSchema.optional(),
+    title: z.string().optional()
+}).passthrough();
+const studioWorkspaceSchema = z.object({
+    basePath: z.string(),
+    dataset: z.string(),
+    name: z.string(),
+    plugins: z.array(z.unknown()).optional(),
+    projectId: z.string(),
+    schema: z.object({
+        _original: schemaSchema
+    }),
+    title: z.string()
+});
+const rawConfigSchema = z.union([
+    z.array(studioWorkspaceSchema),
+    singleStudioWorkspaceSchema
+]);
+const resolvedConfigSchema = z.array(studioWorkspaceSchema);
+export async function readStudioConfig(configPath, options) {
+    const result = await studioWorkerTask(new URL('readStudioConfig.worker.js', import.meta.url), {
+        name: 'studioConfig',
+        studioRootPath: dirname(configPath),
+        workerData: {
+            configPath,
+            resolvePlugins: options.resolvePlugins
+        }
+    });
+    return options.resolvePlugins ? resolvedConfigSchema.parse(result) : rawConfigSchema.parse(result);
+}
+
+//# sourceMappingURL=readStudioConfig.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/studio/readStudioConfig.ts"],"sourcesContent":["import {dirname} from 'node:path'\n\nimport {z} from 'zod'\n\nimport {studioWorkerTask} from '../../loaders/studio/studioWorkerTask.js'\n\nconst schemaSchema = z.object({\n  name: z.string().optional(),\n  types: z.array(z.object({}).passthrough()),\n})\n\nconst singleStudioWorkspaceSchema = z\n  .object({\n    basePath: z.string().optional(),\n    dataset: z.string(),\n    name: z.string().optional(),\n    plugins: z.array(z.unknown()).optional(),\n    projectId: z.string(),\n    schema: schemaSchema.optional(),\n    title: z.string().optional(),\n  })\n  .passthrough()\n\nconst studioWorkspaceSchema = z.object({\n  basePath: z.string(),\n  dataset: z.string(),\n  name: z.string(),\n  plugins: z.array(z.unknown()).optional(),\n  projectId: z.string(),\n  schema: z.object({_original: schemaSchema}),\n  title: z.string(),\n})\n\nconst rawConfigSchema = z.union([z.array(studioWorkspaceSchema), singleStudioWorkspaceSchema])\nconst resolvedConfigSchema = z.array(studioWorkspaceSchema)\n\nexport type RawStudioConfig = z.infer<typeof rawConfigSchema>\nexport type ResolvedStudioConfig = z.infer<typeof resolvedConfigSchema>\n\nexport interface ReadStudioConfigOptions {\n  /**\n   * Whether or not to resolve the plugins defined in the config.\n   *\n   * In some cases, you need this in order to have the full picture of what the studio\n   * would \"see\". As an example, plugins can define schema types that are not explicitly\n   * defined in the users' schema types. In order to get the full picture, you need to\n   * resolve the plugins, which is an asyncronous operation.\n   *\n   * In other cases, it might be enough to only do a shallow pass. As an example, if you\n   * only need to know about the defined workspace, or the user-defined schema types,\n   * this can be set to `false` - which should resolve faster (and potentially \"safer\")\n   * in terms of not triggering all kinds of browser behavior that may or may not be\n   * loaded as the plugins are resolved.\n   */\n  resolvePlugins: boolean\n}\n\nexport async function readStudioConfig(\n  configPath: string,\n  options: {resolvePlugins: true},\n): Promise<ResolvedStudioConfig>\n\nexport async function readStudioConfig(\n  configPath: string,\n  options: {resolvePlugins: false},\n): Promise<RawStudioConfig>\n\nexport async function readStudioConfig(\n  configPath: string,\n  options: ReadStudioConfigOptions,\n): Promise<RawStudioConfig | ResolvedStudioConfig> {\n  const result = await studioWorkerTask(new URL('readStudioConfig.worker.js', import.meta.url), {\n    name: 'studioConfig',\n    studioRootPath: dirname(configPath),\n    workerData: {configPath, resolvePlugins: options.resolvePlugins},\n  })\n\n  return options.resolvePlugins ? resolvedConfigSchema.parse(result) : rawConfigSchema.parse(result)\n}\n"],"names":["dirname","z","studioWorkerTask","schemaSchema","object","name","string","optional","types","array","passthrough","singleStudioWorkspaceSchema","basePath","dataset","plugins","unknown","projectId","schema","title","studioWorkspaceSchema","_original","rawConfigSchema","union","resolvedConfigSchema","readStudioConfig","configPath","options","result","URL","url","studioRootPath","workerData","resolvePlugins","parse"],"mappings":"AAAA,SAAQA,OAAO,QAAO,YAAW;AAEjC,SAAQC,CAAC,QAAO,MAAK;AAErB,SAAQC,gBAAgB,QAAO,2CAA0C;AAEzE,MAAMC,eAAeF,EAAEG,MAAM,CAAC;IAC5BC,MAAMJ,EAAEK,MAAM,GAAGC,QAAQ;IACzBC,OAAOP,EAAEQ,KAAK,CAACR,EAAEG,MAAM,CAAC,CAAC,GAAGM,WAAW;AACzC;AAEA,MAAMC,8BAA8BV,EACjCG,MAAM,CAAC;IACNQ,UAAUX,EAAEK,MAAM,GAAGC,QAAQ;IAC7BM,SAASZ,EAAEK,MAAM;IACjBD,MAAMJ,EAAEK,MAAM,GAAGC,QAAQ;IACzBO,SAASb,EAAEQ,KAAK,CAACR,EAAEc,OAAO,IAAIR,QAAQ;IACtCS,WAAWf,EAAEK,MAAM;IACnBW,QAAQd,aAAaI,QAAQ;IAC7BW,OAAOjB,EAAEK,MAAM,GAAGC,QAAQ;AAC5B,GACCG,WAAW;AAEd,MAAMS,wBAAwBlB,EAAEG,MAAM,CAAC;IACrCQ,UAAUX,EAAEK,MAAM;IAClBO,SAASZ,EAAEK,MAAM;IACjBD,MAAMJ,EAAEK,MAAM;IACdQ,SAASb,EAAEQ,KAAK,CAACR,EAAEc,OAAO,IAAIR,QAAQ;IACtCS,WAAWf,EAAEK,MAAM;IACnBW,QAAQhB,EAAEG,MAAM,CAAC;QAACgB,WAAWjB;IAAY;IACzCe,OAAOjB,EAAEK,MAAM;AACjB;AAEA,MAAMe,kBAAkBpB,EAAEqB,KAAK,CAAC;IAACrB,EAAEQ,KAAK,CAACU;IAAwBR;CAA4B;AAC7F,MAAMY,uBAAuBtB,EAAEQ,KAAK,CAACU;AAiCrC,OAAO,eAAeK,iBACpBC,UAAkB,EAClBC,OAAgC;IAEhC,MAAMC,SAAS,MAAMzB,iBAAiB,IAAI0B,IAAI,8BAA8B,YAAYC,GAAG,GAAG;QAC5FxB,MAAM;QACNyB,gBAAgB9B,QAAQyB;QACxBM,YAAY;YAACN;YAAYO,gBAAgBN,QAAQM,cAAc;QAAA;IACjE;IAEA,OAAON,QAAQM,cAAc,GAAGT,qBAAqBU,KAAK,CAACN,UAAUN,gBAAgBY,KAAK,CAACN;AAC7F"}

package/dist/config/studio/readStudioConfig.worker.d.ts

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

package/dist/config/studio/readStudioConfig.worker.js

@@ -0,0 +1,64 @@
+import { pathToFileURL } from 'node:url';
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { createClient } from '@sanity/client';
+import { moduleResolve } from 'import-meta-resolve';
+import { z } from 'zod';
+import { safeStructuredClone } from '../../util/safeStructuredClone.js';
+if (isMainThread || !parentPort) {
+    throw new Error('Should only be run in a worker!');
+}
+const EMPTY_AUTH_STATE = {
+    authenticated: false,
+    client: getDummyClient(),
+    currentUser: null
+};
+const { configPath, resolvePlugins } = z.object({
+    configPath: z.string(),
+    resolvePlugins: z.boolean()
+}).parse(workerData);
+let { default: config } = await import(configPath);
+if (resolvePlugins) {
+    // If we need to resolve plugins, we need to import and use the `resolveConfig`
+    // function from the `sanity` package. This package should be installed in the users'
+    // studio project, not as part of the CLI - so we need to resolve the full path of the
+    // Sanity package relative to the studio.
+    const configUrl = pathToFileURL(configPath);
+    const sanityUrl = await moduleResolve('sanity', configUrl);
+    const { resolveConfig } = await import(sanityUrl.href);
+    if (typeof resolveConfig !== 'function') {
+        throw new TypeError('Expected `resolveConfig` from `sanity` to be a function');
+    }
+    // We'll want to use some observable tooling, but we'd prefer to use something
+    // compatible with what the studio uses internally, thus try to load RxJS from the
+    // sanity module path instead of installing it as a dependency locally.
+    const rxjsPath = (await moduleResolve('rxjs', sanityUrl)).href;
+    const { firstValueFrom, of } = await import(rxjsPath);
+    // We will also want to stub out some configuration - we don't need to resolve the
+    // users' logged in state, for instance - so let's disable the auth implementation.
+    const workspaces = Array.isArray(config) ? config : [
+        config
+    ];
+    workspaces.map((workspace)=>{
+        workspace.auth = {
+            state: of(EMPTY_AUTH_STATE)
+        };
+    });
+    config = await firstValueFrom(resolveConfig(config));
+}
+parentPort.postMessage(safeStructuredClone(config));
+// Explicitly exit the process to avoid any dangling references from keeping
+// the process alive after resolving it's main task
+setImmediate(()=>{
+    process.exit(1);
+});
+function getDummyClient() {
+    return createClient({
+        apiHost: 'http://localhost',
+        apiVersion: '2025-02-01',
+        projectId: 'unused',
+        requestTagPrefix: 'sanity.cli',
+        useCdn: false
+    });
+}
+
+//# sourceMappingURL=readStudioConfig.worker.js.map

package/dist/config/studio/readStudioConfig.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/studio/readStudioConfig.worker.ts"],"sourcesContent":["import {pathToFileURL} from 'node:url'\nimport {isMainThread, parentPort, workerData} from 'node:worker_threads'\n\nimport {createClient} from '@sanity/client'\nimport {moduleResolve} from 'import-meta-resolve'\nimport {z} from 'zod'\n\nimport {safeStructuredClone} from '../../util/safeStructuredClone.js'\n\nif (isMainThread || !parentPort) {\n  throw new Error('Should only be run in a worker!')\n}\n\nconst EMPTY_AUTH_STATE = {\n  authenticated: false,\n  client: getDummyClient(),\n  currentUser: null,\n}\n\nconst {configPath, resolvePlugins} = z\n  .object({configPath: z.string(), resolvePlugins: z.boolean()})\n  .parse(workerData)\n\nlet {default: config} = await import(configPath)\n\nif (resolvePlugins) {\n  // If we need to resolve plugins, we need to import and use the `resolveConfig`\n  // function from the `sanity` package. This package should be installed in the users'\n  // studio project, not as part of the CLI - so we need to resolve the full path of the\n  // Sanity package relative to the studio.\n  const configUrl = pathToFileURL(configPath)\n\n  const sanityUrl = await moduleResolve('sanity', configUrl)\n  const {resolveConfig} = await import(sanityUrl.href)\n  if (typeof resolveConfig !== 'function') {\n    throw new TypeError('Expected `resolveConfig` from `sanity` to be a function')\n  }\n\n  // We'll want to use some observable tooling, but we'd prefer to use something\n  // compatible with what the studio uses internally, thus try to load RxJS from the\n  // sanity module path instead of installing it as a dependency locally.\n  const rxjsPath = (await moduleResolve('rxjs', sanityUrl)).href\n  const {firstValueFrom, of} = await import(rxjsPath)\n\n  // We will also want to stub out some configuration - we don't need to resolve the\n  // users' logged in state, for instance - so let's disable the auth implementation.\n  const workspaces = Array.isArray(config) ? config : [config]\n  workspaces.map((workspace) => {\n    workspace.auth = {state: of(EMPTY_AUTH_STATE)}\n  })\n\n  config = await firstValueFrom(resolveConfig(config))\n}\n\nparentPort.postMessage(safeStructuredClone(config))\n\n// Explicitly exit the process to avoid any dangling references from keeping\n// the process alive after resolving it's main task\nsetImmediate(() => {\n  process.exit(1)\n})\n\nfunction getDummyClient() {\n  return createClient({\n    apiHost: 'http://localhost',\n    apiVersion: '2025-02-01',\n    projectId: 'unused',\n    requestTagPrefix: 'sanity.cli',\n    useCdn: false,\n  })\n}\n"],"names":["pathToFileURL","isMainThread","parentPort","workerData","createClient","moduleResolve","z","safeStructuredClone","Error","EMPTY_AUTH_STATE","authenticated","client","getDummyClient","currentUser","configPath","resolvePlugins","object","string","boolean","parse","default","config","configUrl","sanityUrl","resolveConfig","href","TypeError","rxjsPath","firstValueFrom","of","workspaces","Array","isArray","map","workspace","auth","state","postMessage","setImmediate","process","exit","apiHost","apiVersion","projectId","requestTagPrefix","useCdn"],"mappings":"AAAA,SAAQA,aAAa,QAAO,WAAU;AACtC,SAAQC,YAAY,EAAEC,UAAU,EAAEC,UAAU,QAAO,sBAAqB;AAExE,SAAQC,YAAY,QAAO,iBAAgB;AAC3C,SAAQC,aAAa,QAAO,sBAAqB;AACjD,SAAQC,CAAC,QAAO,MAAK;AAErB,SAAQC,mBAAmB,QAAO,oCAAmC;AAErE,IAAIN,gBAAgB,CAACC,YAAY;IAC/B,MAAM,IAAIM,MAAM;AAClB;AAEA,MAAMC,mBAAmB;IACvBC,eAAe;IACfC,QAAQC;IACRC,aAAa;AACf;AAEA,MAAM,EAACC,UAAU,EAAEC,cAAc,EAAC,GAAGT,EAClCU,MAAM,CAAC;IAACF,YAAYR,EAAEW,MAAM;IAAIF,gBAAgBT,EAAEY,OAAO;AAAE,GAC3DC,KAAK,CAAChB;AAET,IAAI,EAACiB,SAASC,MAAM,EAAC,GAAG,MAAM,MAAM,CAACP;AAErC,IAAIC,gBAAgB;IAClB,+EAA+E;IAC/E,qFAAqF;IACrF,sFAAsF;IACtF,yCAAyC;IACzC,MAAMO,YAAYtB,cAAcc;IAEhC,MAAMS,YAAY,MAAMlB,cAAc,UAAUiB;IAChD,MAAM,EAACE,aAAa,EAAC,GAAG,MAAM,MAAM,CAACD,UAAUE,IAAI;IACnD,IAAI,OAAOD,kBAAkB,YAAY;QACvC,MAAM,IAAIE,UAAU;IACtB;IAEA,8EAA8E;IAC9E,kFAAkF;IAClF,uEAAuE;IACvE,MAAMC,WAAW,AAAC,CAAA,MAAMtB,cAAc,QAAQkB,UAAS,EAAGE,IAAI;IAC9D,MAAM,EAACG,cAAc,EAAEC,EAAE,EAAC,GAAG,MAAM,MAAM,CAACF;IAE1C,kFAAkF;IAClF,mFAAmF;IACnF,MAAMG,aAAaC,MAAMC,OAAO,CAACX,UAAUA,SAAS;QAACA;KAAO;IAC5DS,WAAWG,GAAG,CAAC,CAACC;QACdA,UAAUC,IAAI,GAAG;YAACC,OAAOP,GAAGpB;QAAiB;IAC/C;IAEAY,SAAS,MAAMO,eAAeJ,cAAcH;AAC9C;AAEAnB,WAAWmC,WAAW,CAAC9B,oBAAoBc;AAE3C,4EAA4E;AAC5E,mDAAmD;AACnDiB,aAAa;IACXC,QAAQC,IAAI,CAAC;AACf;AAEA,SAAS5B;IACP,OAAOR,aAAa;QAClBqC,SAAS;QACTC,YAAY;QACZC,WAAW;QACXC,kBAAkB;QAClBC,QAAQ;IACV;AACF"}

package/dist/config/util/findAppConfigPath.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves to a string containing the found config path, or `undefined` if not found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found
+ * @internal
+ */
+export declare function findAppConfigPath(basePath: string): Promise<string | undefined>;

package/dist/config/util/findAppConfigPath.js

@@ -0,0 +1,22 @@
+import { findPathForFiles } from './findConfigsPaths.js';
+/**
+ * Resolves to a string containing the found config path, or `undefined` if not found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found
+ * @internal
+ */ export async function findAppConfigPath(basePath) {
+    const paths = await findPathForFiles(basePath, [
+        'sanity.cli.ts',
+        'sanity.cli.js'
+    ]);
+    const configPaths = paths.filter((path)=>path.exists);
+    if (configPaths.length > 1) {
+        throw new Error(`Multiple app config files found (${configPaths.map((path)=>path.path).join(', ')})`);
+    }
+    if (configPaths.length === 1) {
+        return configPaths[0].path;
+    }
+}
+
+//# sourceMappingURL=findAppConfigPath.js.map

package/dist/config/util/findAppConfigPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/findAppConfigPath.ts"],"sourcesContent":["import {findPathForFiles} from './findConfigsPaths.js'\n\n/**\n * Resolves to a string containing the found config path, or `undefined` if not found.\n *\n * @param basePath - The base path to start searching from\n * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found\n * @internal\n */\nexport async function findAppConfigPath(basePath: string): Promise<string | undefined> {\n  const paths = await findPathForFiles(basePath, ['sanity.cli.ts', 'sanity.cli.js'])\n  const configPaths = paths.filter((path) => path.exists)\n  if (configPaths.length > 1) {\n    throw new Error(\n      `Multiple app config files found (${configPaths.map((path) => path.path).join(', ')})`,\n    )\n  }\n\n  if (configPaths.length === 1) {\n    return configPaths[0].path\n  }\n}\n"],"names":["findPathForFiles","findAppConfigPath","basePath","paths","configPaths","filter","path","exists","length","Error","map","join"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAuB;AAEtD;;;;;;CAMC,GACD,OAAO,eAAeC,kBAAkBC,QAAgB;IACtD,MAAMC,QAAQ,MAAMH,iBAAiBE,UAAU;QAAC;QAAiB;KAAgB;IACjF,MAAME,cAAcD,MAAME,MAAM,CAAC,CAACC,OAASA,KAAKC,MAAM;IACtD,IAAIH,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,IAAIP,YAAYI,MAAM,KAAK,GAAG;QAC5B,OAAOJ,WAAW,CAAC,EAAE,CAACE,IAAI;IAC5B;AACF"}

package/dist/config/util/findConfigsPaths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @internal
+ */
+interface PathResult {
+    exists: boolean;
+    path: string;
+}
+/**
+ * Finds the path for a given set of files.
+ *
+ * @param basePath - The base path to search for files.
+ * @param files - The files to search for.
+ * @internal
+ */
+export declare function findPathForFiles(basePath: string, files: string[]): Promise<PathResult[]>;
+export {};

package/dist/config/util/findConfigsPaths.js

@@ -0,0 +1,21 @@
+import { join } from 'node:path';
+import { fileExists } from '../../util/fileExists.js';
+/**
+ * Finds the path for a given set of files.
+ *
+ * @param basePath - The base path to search for files.
+ * @param files - The files to search for.
+ * @internal
+ */ export async function findPathForFiles(basePath, files) {
+    const paths = await Promise.all(files.map(async (file)=>{
+        const path = join(basePath, file);
+        const exists = await fileExists(path);
+        return {
+            exists,
+            path
+        };
+    }));
+    return paths;
+}
+
+//# sourceMappingURL=findConfigsPaths.js.map

package/dist/config/util/findConfigsPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/findConfigsPaths.ts"],"sourcesContent":["import {join} from 'node:path'\n\nimport {fileExists} from '../../util/fileExists.js'\n\n/**\n * @internal\n */\ninterface PathResult {\n  exists: boolean\n  path: string\n}\n\n/**\n * Finds the path for a given set of files.\n *\n * @param basePath - The base path to search for files.\n * @param files - The files to search for.\n * @internal\n */\nexport async function findPathForFiles(basePath: string, files: string[]): Promise<PathResult[]> {\n  const paths = await Promise.all(\n    files.map(async (file) => {\n      const path = join(basePath, file)\n      const exists = await fileExists(path)\n      return {exists, path}\n    }),\n  )\n\n  return paths\n}\n"],"names":["join","fileExists","findPathForFiles","basePath","files","paths","Promise","all","map","file","path","exists"],"mappings":"AAAA,SAAQA,IAAI,QAAO,YAAW;AAE9B,SAAQC,UAAU,QAAO,2BAA0B;AAUnD;;;;;;CAMC,GACD,OAAO,eAAeC,iBAAiBC,QAAgB,EAAEC,KAAe;IACtE,MAAMC,QAAQ,MAAMC,QAAQC,GAAG,CAC7BH,MAAMI,GAAG,CAAC,OAAOC;QACf,MAAMC,OAAOV,KAAKG,UAAUM;QAC5B,MAAME,SAAS,MAAMV,WAAWS;QAChC,OAAO;YAACC;YAAQD;QAAI;IACtB;IAGF,OAAOL;AACT"}

package/dist/config/util/findStudioConfigPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves to a string containing the found config path, or `false` if not found.
+ * Throws if Sanity v2 studio root is found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found
+ * @internal
+ */
+export declare function findStudioConfigPath(basePath: string): Promise<string | undefined>;

package/dist/config/util/findStudioConfigPath.js

@@ -0,0 +1,31 @@
+import { basename } from 'node:path';
+import { findPathForFiles } from './findConfigsPaths.js';
+import { isSanityV2StudioRoot } from './isSanityV2StudioRoot.js';
+/**
+ * Resolves to a string containing the found config path, or `false` if not found.
+ * Throws if Sanity v2 studio root is found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found
+ * @internal
+ */ export async function findStudioConfigPath(basePath) {
+    if (await isSanityV2StudioRoot(basePath)) {
+        throw new Error(`Found 'sanity.json' at ${basePath} - Sanity Studio < v3 is no longer supported`);
+    }
+    const paths = await findPathForFiles(basePath, [
+        'sanity.config.ts',
+        'sanity.config.tsx',
+        'sanity.config.js',
+        'sanity.config.jsx'
+    ]);
+    const configPaths = paths.filter((path)=>path.exists);
+    if (configPaths.length > 1) {
+        const baseNames = configPaths.map((config)=>config.path).map((path)=>basename(path));
+        throw new Error(`Multiple studio config files found (${baseNames.join(', ')})`);
+    }
+    if (configPaths.length === 1) {
+        return configPaths[0].path;
+    }
+}
+
+//# sourceMappingURL=findStudioConfigPath.js.map

package/dist/config/util/findStudioConfigPath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/findStudioConfigPath.ts"],"sourcesContent":["import {basename} from 'node:path'\n\nimport {findPathForFiles} from './findConfigsPaths.js'\nimport {isSanityV2StudioRoot} from './isSanityV2StudioRoot.js'\n\n/**\n * Resolves to a string containing the found config path, or `false` if not found.\n * Throws if Sanity v2 studio root is found.\n *\n * @param basePath - The base path to start searching from\n * @returns A promise that resolves to a string containing the found config path, or `undefined` if not found\n * @internal\n */\nexport async function findStudioConfigPath(basePath: string): Promise<string | undefined> {\n  if (await isSanityV2StudioRoot(basePath)) {\n    throw new Error(\n      `Found 'sanity.json' at ${basePath} - Sanity Studio < v3 is no longer supported`,\n    )\n  }\n\n  const paths = await findPathForFiles(basePath, [\n    'sanity.config.ts',\n    'sanity.config.tsx',\n    'sanity.config.js',\n    'sanity.config.jsx',\n  ])\n\n  const configPaths = paths.filter((path) => path.exists)\n  if (configPaths.length > 1) {\n    const baseNames = configPaths.map((config) => config.path).map((path) => basename(path))\n    throw new Error(`Multiple studio config files found (${baseNames.join(', ')})`)\n  }\n\n  if (configPaths.length === 1) {\n    return configPaths[0].path\n  }\n}\n"],"names":["basename","findPathForFiles","isSanityV2StudioRoot","findStudioConfigPath","basePath","Error","paths","configPaths","filter","path","exists","length","baseNames","map","config","join"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,YAAW;AAElC,SAAQC,gBAAgB,QAAO,wBAAuB;AACtD,SAAQC,oBAAoB,QAAO,4BAA2B;AAE9D;;;;;;;CAOC,GACD,OAAO,eAAeC,qBAAqBC,QAAgB;IACzD,IAAI,MAAMF,qBAAqBE,WAAW;QACxC,MAAM,IAAIC,MACR,CAAC,uBAAuB,EAAED,SAAS,4CAA4C,CAAC;IAEpF;IAEA,MAAME,QAAQ,MAAML,iBAAiBG,UAAU;QAC7C;QACA;QACA;QACA;KACD;IAED,MAAMG,cAAcD,MAAME,MAAM,CAAC,CAACC,OAASA,KAAKC,MAAM;IACtD,IAAIH,YAAYI,MAAM,GAAG,GAAG;QAC1B,MAAMC,YAAYL,YAAYM,GAAG,CAAC,CAACC,SAAWA,OAAOL,IAAI,EAAEI,GAAG,CAAC,CAACJ,OAAST,SAASS;QAClF,MAAM,IAAIJ,MAAM,CAAC,oCAAoC,EAAEO,UAAUG,IAAI,CAAC,MAAM,CAAC,CAAC;IAChF;IAEA,IAAIR,YAAYI,MAAM,KAAK,GAAG;QAC5B,OAAOJ,WAAW,CAAC,EAAE,CAACE,IAAI;IAC5B;AACF"}

package/dist/config/util/isSanityV2StudioRoot.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks for a `sanity.json` file with `"root": true` in the given directory.
+ *
+ * @param basePath - The base path to look for a `sanity.json` in
+ * @returns Resolves to true if a `sanity.json` with `"root": true` is found, false otherwise
+ * @internal
+ */
+export declare function isSanityV2StudioRoot(basePath: string): Promise<boolean>;

package/dist/config/util/isSanityV2StudioRoot.js

@@ -0,0 +1,19 @@
+import { join } from 'node:path';
+import { readJsonFile } from '../../util/readJsonFile.js';
+/**
+ * Checks for a `sanity.json` file with `"root": true` in the given directory.
+ *
+ * @param basePath - The base path to look for a `sanity.json` in
+ * @returns Resolves to true if a `sanity.json` with `"root": true` is found, false otherwise
+ * @internal
+ */ export async function isSanityV2StudioRoot(basePath) {
+    try {
+        const sanityJson = await readJsonFile(join(basePath, 'sanity.json'));
+        const isRoot = Boolean(sanityJson?.root);
+        return isRoot;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=isSanityV2StudioRoot.js.map

package/dist/config/util/isSanityV2StudioRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/isSanityV2StudioRoot.ts"],"sourcesContent":["import {join} from 'node:path'\n\nimport {readJsonFile} from '../../util/readJsonFile.js'\n\n/**\n * Checks for a `sanity.json` file with `\"root\": true` in the given directory.\n *\n * @param basePath - The base path to look for a `sanity.json` in\n * @returns Resolves to true if a `sanity.json` with `\"root\": true` is found, false otherwise\n * @internal\n */\nexport async function isSanityV2StudioRoot(basePath: string): Promise<boolean> {\n  try {\n    const sanityJson = await readJsonFile(join(basePath, 'sanity.json'))\n    const isRoot = Boolean(sanityJson?.root)\n    return isRoot\n  } catch {\n    return false\n  }\n}\n"],"names":["join","readJsonFile","isSanityV2StudioRoot","basePath","sanityJson","isRoot","Boolean","root"],"mappings":"AAAA,SAAQA,IAAI,QAAO,YAAW;AAE9B,SAAQC,YAAY,QAAO,6BAA4B;AAEvD;;;;;;CAMC,GACD,OAAO,eAAeC,qBAAqBC,QAAgB;IACzD,IAAI;QACF,MAAMC,aAAa,MAAMH,aAAaD,KAAKG,UAAU;QACrD,MAAME,SAASC,QAAQF,YAAYG;QACnC,OAAOF;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/dist/config/util/recursivelyResolveProjectRoot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Result of finding a project configuration
+ *
+ * @internal
+ */
+export interface ProjectRootResult {
+    directory: string;
+    /**
+     * Path to the project configuration file, if found.
+     */
+    path: string;
+    /**
+     * Type of project root.
+     */
+    type: 'app' | 'studio';
+}
+/**
+ * Generic recursive search function for project configuration files.
+ *
+ * @param basePath - The base path to start searching from
+ * @param findConfigFn - Function that looks for config files in a given directory
+ * @param projectType - The type of project ('app' | 'studio')
+ * @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
+ */
+export declare function recursivelyResolveProjectRoot(basePath: string, findConfigFn: (path: string) => Promise<string | undefined>, projectType: 'app' | 'studio', iterations?: number): Promise<false | ProjectRootResult>;

package/dist/config/util/recursivelyResolveProjectRoot.js

@@ -0,0 +1,28 @@
+import { dirname, resolve } from 'node:path';
+/**
+ * Generic recursive search function for project configuration files.
+ *
+ * @param basePath - The base path to start searching from
+ * @param findConfigFn - Function that looks for config files in a given directory
+ * @param projectType - The type of project ('app' | 'studio')
+ * @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
+ */ export async function recursivelyResolveProjectRoot(basePath, findConfigFn, projectType, iterations = 0) {
+    const configPath = await findConfigFn(basePath);
+    if (configPath) {
+        return {
+            directory: dirname(configPath),
+            path: configPath,
+            type: projectType
+        };
+    }
+    const parentDir = resolve(basePath, '..');
+    if (parentDir === basePath || iterations > 50) {
+        // Reached root (or max depth), give up
+        return false;
+    }
+    return recursivelyResolveProjectRoot(parentDir, findConfigFn, projectType, iterations + 1);
+}
+
+//# sourceMappingURL=recursivelyResolveProjectRoot.js.map

package/dist/config/util/recursivelyResolveProjectRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/recursivelyResolveProjectRoot.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path'\n\n/**\n * Result of finding a project configuration\n *\n * @internal\n */\nexport interface ProjectRootResult {\n  directory: string\n  /**\n   * Path to the project configuration file, if found.\n   */\n  path: string\n  /**\n   * Type of project root.\n   */\n  type: 'app' | 'studio'\n}\n\n/**\n * Generic recursive search function for project configuration files.\n *\n * @param basePath - The base path to start searching from\n * @param findConfigFn - Function that looks for config files in a given directory\n * @param projectType - The type of project ('app' | 'studio')\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 */\nexport async function recursivelyResolveProjectRoot(\n  basePath: string,\n  findConfigFn: (path: string) => Promise<string | undefined>,\n  projectType: 'app' | 'studio',\n  iterations = 0,\n): Promise<false | ProjectRootResult> {\n  const configPath = await findConfigFn(basePath)\n\n  if (configPath) {\n    return {\n      directory: dirname(configPath),\n      path: configPath,\n      type: projectType,\n    }\n  }\n\n  const parentDir = resolve(basePath, '..')\n  if (parentDir === basePath || iterations > 50) {\n    // Reached root (or max depth), give up\n    return false\n  }\n\n  return recursivelyResolveProjectRoot(parentDir, findConfigFn, projectType, iterations + 1)\n}\n"],"names":["dirname","resolve","recursivelyResolveProjectRoot","basePath","findConfigFn","projectType","iterations","configPath","directory","path","type","parentDir"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAW;AAmB1C;;;;;;;;;CASC,GACD,OAAO,eAAeC,8BACpBC,QAAgB,EAChBC,YAA2D,EAC3DC,WAA6B,EAC7BC,aAAa,CAAC;IAEd,MAAMC,aAAa,MAAMH,aAAaD;IAEtC,IAAII,YAAY;QACd,OAAO;YACLC,WAAWR,QAAQO;YACnBE,MAAMF;YACNG,MAAML;QACR;IACF;IAEA,MAAMM,YAAYV,QAAQE,UAAU;IACpC,IAAIQ,cAAcR,YAAYG,aAAa,IAAI;QAC7C,uCAAuC;QACvC,OAAO;IACT;IAEA,OAAOJ,8BAA8BS,WAAWP,cAAcC,aAAaC,aAAa;AAC1F"}

package/dist/debug.d.ts

@@ -0,0 +1,15 @@
+import debugIt from 'debug';
+/**
+ * `debug` instance for the CLI
+ *
+ * @internal
+ */
+export declare const debug: debugIt.Debugger;
+/**
+ * Get a `debug` instance which extends the CLI debug instance with the given namespace,
+ * eg namespace would be `sanity:cli:<providedNamespace>`
+ *
+ * @param namespace - The namespace to extend the CLI debug instance with
+ * @returns The extended `debug` instance
+ */
+export declare const subdebug: (namespace: string) => debugIt.Debugger;

package/dist/debug.js

@@ -0,0 +1,15 @@
+import debugIt from 'debug';
+/**
+ * `debug` instance for the CLI
+ *
+ * @internal
+ */ export const debug = debugIt('sanity:cli');
+/**
+ * Get a `debug` instance which extends the CLI debug instance with the given namespace,
+ * eg namespace would be `sanity:cli:<providedNamespace>`
+ *
+ * @param namespace - The namespace to extend the CLI debug instance with
+ * @returns The extended `debug` instance
+ */ export const subdebug = (namespace)=>debug.extend(namespace);
+
+//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/debug.ts"],"sourcesContent":["import debugIt from 'debug'\n\n/**\n * `debug` instance for the CLI\n *\n * @internal\n */\nexport const debug = debugIt('sanity:cli')\n\n/**\n * Get a `debug` instance which extends the CLI debug instance with the given namespace,\n * eg namespace would be `sanity:cli:<providedNamespace>`\n *\n * @param namespace - The namespace to extend the CLI debug instance with\n * @returns The extended `debug` instance\n */\nexport const subdebug = (namespace: string) => debug.extend(namespace)\n"],"names":["debugIt","debug","subdebug","namespace","extend"],"mappings":"AAAA,OAAOA,aAAa,QAAO;AAE3B;;;;CAIC,GACD,OAAO,MAAMC,QAAQD,QAAQ,cAAa;AAE1C;;;;;;CAMC,GACD,OAAO,MAAME,WAAW,CAACC,YAAsBF,MAAMG,MAAM,CAACD,WAAU"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export * from './config/cli/getCliConfig.js';
+export { type CliConfig, type ReactCompilerConfig, type UserViteConfig } from './config/cli/types.js';
+export * from './config/findProjectRoot.js';
+export * from './config/studio/getStudioConfig.js';
+export * from './config/util/findConfigsPaths.js';
+export * from './config/util/findStudioConfigPath.js';
+export { type ProjectRootResult } from './config/util/recursivelyResolveProjectRoot.js';
+export * from './debug.js';
+export * from './loaders/tsx/tsxWorkerTask.js';
+export * from './SanityCommand.js';
+export * from './services/apiClient.js';
+export * from './services/cliUserConfig.js';
+export * from './services/getCliToken.js';
+export { type Output } from './types.js';
+export * from './util/createExpiringConfig.js';
+export * from './util/getSanityEnvVar.js';
+export * from './util/getSanityUrl.js';
+export * from './util/getUserConfig.js';
+export * from './util/isCi.js';
+export * from './util/isHttpError.js';
+export * from './util/isInteractive.js';
+export * from './util/isTrueish.js';
+export * from './ux/colorizeJson.js';
+export * from './ux/formatObject.js';
+export * from './ux/logSymbols.js';
+export * from './ux/printKeyValue.js';
+export * from './ux/spinner.js';
+export * from './ux/timer.js';