@sanity/cli-core 0.0.0-20260410130107

package/dist/config/findProjectRootSync.js

@@ -0,0 +1,88 @@
+import { dirname, resolve } from 'node:path';
+import { ProjectRootNotFoundError } from '../errors/ProjectRootNotFoundError.js';
+import { findAppConfigPathSync, findStudioConfigPathSync } from './util/configPathsSync.js';
+/**
+ * Generic recursive search function for project configuration files (synchronous version).
+ *
+ * @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 An object if config is found, false otherwise
+ * @internal
+ */ function recursivelyResolveProjectRootSync(basePath, findConfigFn, projectType, iterations = 0) {
+    const configPath = 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 recursivelyResolveProjectRootSync(parentDir, findConfigFn, projectType, iterations + 1);
+}
+/**
+ * Resolve project root directory and type synchronously.
+ *
+ * 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.
+ *
+ * @param cwd - Current working directory to start searching from
+ * @returns Project root result
+ * @internal
+ */ export function findProjectRootSync(cwd) {
+    try {
+        // First try to find a studio project root, looks for `sanity.config.(ts|js)`
+        const studioProjectRoot = resolveProjectRootForStudioSync(cwd);
+        if (studioProjectRoot) {
+            return studioProjectRoot;
+        }
+        // Second try to find a app project root, looks for `sanity.cli.(ts|js)`
+        const appProjectRoot = resolveProjectRootForAppSync(cwd);
+        if (appProjectRoot) {
+            return appProjectRoot;
+        }
+        // If nothing is found throw a specific error
+        throw new ProjectRootNotFoundError(`No project root found in ${cwd}`);
+    } catch (err) {
+        if (err instanceof ProjectRootNotFoundError) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : `${err}`;
+        throw new Error(`Error occurred trying to resolve project root:\n${message}`, {
+            cause: err
+        });
+    }
+}
+/**
+ * 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 An object if config is found, false otherwise
+ * @internal
+ */ function resolveProjectRootForStudioSync(basePath, iterations = 0) {
+    return recursivelyResolveProjectRootSync(basePath, findStudioConfigPathSync, '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 An object if config is found, false otherwise
+ * @internal
+ */ function resolveProjectRootForAppSync(basePath, iterations = 0) {
+    return recursivelyResolveProjectRootSync(basePath, findAppConfigPathSync, 'app', iterations);
+}
+
+//# sourceMappingURL=findProjectRootSync.js.map

package/dist/config/findProjectRootSync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/findProjectRootSync.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path'\n\nimport {ProjectRootNotFoundError} from '../errors/ProjectRootNotFoundError.js'\nimport {findAppConfigPathSync, findStudioConfigPathSync} from './util/configPathsSync.js'\nimport {ProjectRootResult} from './util/recursivelyResolveProjectRoot.js'\n\n/**\n * Generic recursive search function for project configuration files (synchronous version).\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 An object if config is found, false otherwise\n * @internal\n */\nfunction recursivelyResolveProjectRootSync(\n  basePath: string,\n  findConfigFn: (path: string) => string | undefined,\n  projectType: 'app' | 'studio',\n  iterations = 0,\n): false | ProjectRootResult {\n  const configPath = 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 recursivelyResolveProjectRootSync(parentDir, findConfigFn, projectType, iterations + 1)\n}\n\n/**\n * Resolve project root directory and type synchronously.\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 * @param cwd - Current working directory to start searching from\n * @returns Project root result\n * @internal\n */\nexport function findProjectRootSync(cwd: string): ProjectRootResult {\n  try {\n    // First try to find a studio project root, looks for `sanity.config.(ts|js)`\n    const studioProjectRoot = resolveProjectRootForStudioSync(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 = resolveProjectRootForAppSync(cwd)\n    if (appProjectRoot) {\n      return appProjectRoot\n    }\n\n    // If nothing is found throw a specific error\n    throw new ProjectRootNotFoundError(`No project root found in ${cwd}`)\n  } catch (err: unknown) {\n    if (err instanceof ProjectRootNotFoundError) {\n      throw err\n    }\n    const message = err instanceof Error ? err.message : `${err}`\n    throw new Error(`Error occurred trying to resolve project root:\\n${message}`, {cause: err})\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 An object if config is found, false otherwise\n * @internal\n */\nfunction resolveProjectRootForStudioSync(\n  basePath: string,\n  iterations = 0,\n): false | ProjectRootResult {\n  return recursivelyResolveProjectRootSync(basePath, findStudioConfigPathSync, '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 An object if config is found, false otherwise\n * @internal\n */\nfunction resolveProjectRootForAppSync(basePath: string, iterations = 0): false | ProjectRootResult {\n  return recursivelyResolveProjectRootSync(basePath, findAppConfigPathSync, 'app', iterations)\n}\n"],"names":["dirname","resolve","ProjectRootNotFoundError","findAppConfigPathSync","findStudioConfigPathSync","recursivelyResolveProjectRootSync","basePath","findConfigFn","projectType","iterations","configPath","directory","path","type","parentDir","findProjectRootSync","cwd","studioProjectRoot","resolveProjectRootForStudioSync","appProjectRoot","resolveProjectRootForAppSync","err","message","Error","cause"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAW;AAE1C,SAAQC,wBAAwB,QAAO,wCAAuC;AAC9E,SAAQC,qBAAqB,EAAEC,wBAAwB,QAAO,4BAA2B;AAGzF;;;;;;;;;CASC,GACD,SAASC,kCACPC,QAAgB,EAChBC,YAAkD,EAClDC,WAA6B,EAC7BC,aAAa,CAAC;IAEd,MAAMC,aAAaH,aAAaD;IAEhC,IAAII,YAAY;QACd,OAAO;YACLC,WAAWX,QAAQU;YACnBE,MAAMF;YACNG,MAAML;QACR;IACF;IAEA,MAAMM,YAAYb,QAAQK,UAAU;IACpC,IAAIQ,cAAcR,YAAYG,aAAa,IAAI;QAC7C,uCAAuC;QACvC,OAAO;IACT;IAEA,OAAOJ,kCAAkCS,WAAWP,cAAcC,aAAaC,aAAa;AAC9F;AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASM,oBAAoBC,GAAW;IAC7C,IAAI;QACF,6EAA6E;QAC7E,MAAMC,oBAAoBC,gCAAgCF;QAC1D,IAAIC,mBAAmB;YACrB,OAAOA;QACT;QAEA,wEAAwE;QACxE,MAAME,iBAAiBC,6BAA6BJ;QACpD,IAAIG,gBAAgB;YAClB,OAAOA;QACT;QAEA,6CAA6C;QAC7C,MAAM,IAAIjB,yBAAyB,CAAC,yBAAyB,EAAEc,KAAK;IACtE,EAAE,OAAOK,KAAc;QACrB,IAAIA,eAAenB,0BAA0B;YAC3C,MAAMmB;QACR;QACA,MAAMC,UAAUD,eAAeE,QAAQF,IAAIC,OAAO,GAAG,GAAGD,KAAK;QAC7D,MAAM,IAAIE,MAAM,CAAC,gDAAgD,EAAED,SAAS,EAAE;YAACE,OAAOH;QAAG;IAC3F;AACF;AAEA;;;;;;;;CAQC,GACD,SAASH,gCACPZ,QAAgB,EAChBG,aAAa,CAAC;IAEd,OAAOJ,kCAAkCC,UAAUF,0BAA0B,UAAUK;AACzF;AAEA;;;;;;;CAOC,GACD,SAASW,6BAA6Bd,QAAgB,EAAEG,aAAa,CAAC;IACpE,OAAOJ,kCAAkCC,UAAUH,uBAAuB,OAAOM;AACnF"}

package/dist/config/studio/getStudioConfig.js

@@ -0,0 +1,13 @@
+import { findStudioConfigPath } from '../util/findStudioConfigPath.js';
+import { readStudioConfig } from './readStudioConfig.js';
+export async function getStudioConfig(rootPath, options) {
+    const studioConfigPath = await findStudioConfigPath(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 * @public\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\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","resolvePlugins"],"mappings":"AAAA,SAAQA,oBAAoB,QAAO,kCAAiC;AACpE,SAEEC,gBAAgB,QAGX,wBAAuB;AAmB9B,OAAO,eAAeC,gBACpBC,QAAgB,EAChBC,OAAgC;IAEhC,MAAMC,mBAAmB,MAAML,qBAAqBG;IAEpD,4DAA4D;IAC5D,OAAOC,QAAQE,cAAc,GACzBL,iBAAiBI,kBAAkB;QAACC,gBAAgB;IAAI,KACxDL,iBAAiBI,kBAAkB;QAACC,gBAAgB;IAAK;AAC/D"}

package/dist/config/studio/getStudioWorkspaces.js

@@ -0,0 +1,63 @@
+import { stat } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { isMainThread } from 'node:worker_threads';
+import { firstValueFrom, of } from 'rxjs';
+import { subdebug } from '../../debug.js';
+import { doImport } from '../../util/doImport.js';
+import { getEmptyAuth } from '../../util/getEmptyAuth.js';
+import { resolveLocalPackage } from '../../util/resolveLocalPackage.js';
+import { findStudioConfigPath } from '../util/findStudioConfigPath.js';
+import { isStudioConfig } from './isStudioConfig.js';
+const debug = subdebug('worker:getStudioWorkspaces');
+/**
+ * Resolves the workspaces from the studio config.
+ *
+ * NOTE: This function should only be called from a worker thread.
+ *
+ * @param configPath - The path to the studio config
+ * @returns The workspaces
+ * @internal
+ */ export async function getStudioWorkspaces(configPath) {
+    if (isMainThread) {
+        throw new Error('getStudioWorkspaces should only be called from a worker thread');
+    }
+    const isDirectory = (await stat(configPath)).isDirectory();
+    if (isDirectory) {
+        configPath = await findStudioConfigPath(configPath);
+    }
+    debug('Finding studio config path %s', configPath);
+    let config = await doImport(configPath);
+    debug('Imported config %o', config);
+    if (!isStudioConfig(config)) {
+        if (!('default' in config) || !isStudioConfig(config.default)) {
+            debug('Invalid studio config format in "%s"', configPath);
+            throw new TypeError(`Invalid studio config format in "${configPath}"`);
+        }
+        config = config.default;
+    }
+    const workDir = dirname(configPath);
+    debug('Work dir %s', workDir);
+    const { resolveConfig } = await resolveLocalPackage('sanity', workDir);
+    if (typeof resolveConfig !== 'function') {
+        throw new TypeError('Expected `resolveConfig` from `sanity` to be a function');
+    }
+    // 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 rawWorkspaces = Array.isArray(config) ? config : [
+        {
+            ...config,
+            basePath: config.basePath || '/',
+            name: config.name || 'default'
+        }
+    ];
+    const unauthedWorkspaces = rawWorkspaces.map((workspace)=>({
+            ...workspace,
+            auth: {
+                state: of(getEmptyAuth())
+            }
+        }));
+    debug('Unauthed workspaces %o', unauthedWorkspaces);
+    return firstValueFrom(resolveConfig(unauthedWorkspaces));
+}
+
+//# sourceMappingURL=getStudioWorkspaces.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/studio/getStudioWorkspaces.ts"],"sourcesContent":["import {stat} from 'node:fs/promises'\nimport {dirname} from 'node:path'\nimport {isMainThread} from 'node:worker_threads'\n\nimport {firstValueFrom, of} from 'rxjs'\nimport {type Workspace} from 'sanity'\n\nimport {subdebug} from '../../debug.js'\nimport {doImport} from '../../util/doImport.js'\nimport {getEmptyAuth} from '../../util/getEmptyAuth.js'\nimport {resolveLocalPackage} from '../../util/resolveLocalPackage.js'\nimport {findStudioConfigPath} from '../util/findStudioConfigPath.js'\nimport {isStudioConfig} from './isStudioConfig.js'\n\nconst debug = subdebug('worker:getStudioWorkspaces')\n\n/**\n * Resolves the workspaces from the studio config.\n *\n * NOTE: This function should only be called from a worker thread.\n *\n * @param configPath - The path to the studio config\n * @returns The workspaces\n * @internal\n */\nexport async function getStudioWorkspaces(configPath: string): Promise<Workspace[]> {\n  if (isMainThread) {\n    throw new Error('getStudioWorkspaces should only be called from a worker thread')\n  }\n  const isDirectory = (await stat(configPath)).isDirectory()\n  if (isDirectory) {\n    configPath = await findStudioConfigPath(configPath)\n  }\n  debug('Finding studio config path %s', configPath)\n  let config = await doImport(configPath)\n\n  debug('Imported config %o', config)\n  if (!isStudioConfig(config)) {\n    if (!('default' in config) || !isStudioConfig(config.default)) {\n      debug('Invalid studio config format in \"%s\"', configPath)\n      throw new TypeError(`Invalid studio config format in \"${configPath}\"`)\n    }\n\n    config = config.default\n  }\n\n  const workDir = dirname(configPath)\n  debug('Work dir %s', workDir)\n  const {resolveConfig} = await resolveLocalPackage<typeof import('sanity')>('sanity', workDir)\n  if (typeof resolveConfig !== 'function') {\n    throw new TypeError('Expected `resolveConfig` from `sanity` to be a function')\n  }\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 rawWorkspaces = Array.isArray(config)\n    ? config\n    : [{...config, basePath: config.basePath || '/', name: config.name || 'default'}]\n\n  const unauthedWorkspaces = rawWorkspaces.map((workspace) => ({\n    ...workspace,\n    auth: {state: of(getEmptyAuth())},\n  }))\n\n  debug('Unauthed workspaces %o', unauthedWorkspaces)\n\n  return firstValueFrom(resolveConfig(unauthedWorkspaces))\n}\n"],"names":["stat","dirname","isMainThread","firstValueFrom","of","subdebug","doImport","getEmptyAuth","resolveLocalPackage","findStudioConfigPath","isStudioConfig","debug","getStudioWorkspaces","configPath","Error","isDirectory","config","default","TypeError","workDir","resolveConfig","rawWorkspaces","Array","isArray","basePath","name","unauthedWorkspaces","map","workspace","auth","state"],"mappings":"AAAA,SAAQA,IAAI,QAAO,mBAAkB;AACrC,SAAQC,OAAO,QAAO,YAAW;AACjC,SAAQC,YAAY,QAAO,sBAAqB;AAEhD,SAAQC,cAAc,EAAEC,EAAE,QAAO,OAAM;AAGvC,SAAQC,QAAQ,QAAO,iBAAgB;AACvC,SAAQC,QAAQ,QAAO,yBAAwB;AAC/C,SAAQC,YAAY,QAAO,6BAA4B;AACvD,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,oBAAoB,QAAO,kCAAiC;AACpE,SAAQC,cAAc,QAAO,sBAAqB;AAElD,MAAMC,QAAQN,SAAS;AAEvB;;;;;;;;CAQC,GACD,OAAO,eAAeO,oBAAoBC,UAAkB;IAC1D,IAAIX,cAAc;QAChB,MAAM,IAAIY,MAAM;IAClB;IACA,MAAMC,cAAc,AAAC,CAAA,MAAMf,KAAKa,WAAU,EAAGE,WAAW;IACxD,IAAIA,aAAa;QACfF,aAAa,MAAMJ,qBAAqBI;IAC1C;IACAF,MAAM,iCAAiCE;IACvC,IAAIG,SAAS,MAAMV,SAASO;IAE5BF,MAAM,sBAAsBK;IAC5B,IAAI,CAACN,eAAeM,SAAS;QAC3B,IAAI,CAAE,CAAA,aAAaA,MAAK,KAAM,CAACN,eAAeM,OAAOC,OAAO,GAAG;YAC7DN,MAAM,wCAAwCE;YAC9C,MAAM,IAAIK,UAAU,CAAC,iCAAiC,EAAEL,WAAW,CAAC,CAAC;QACvE;QAEAG,SAASA,OAAOC,OAAO;IACzB;IAEA,MAAME,UAAUlB,QAAQY;IACxBF,MAAM,eAAeQ;IACrB,MAAM,EAACC,aAAa,EAAC,GAAG,MAAMZ,oBAA6C,UAAUW;IACrF,IAAI,OAAOC,kBAAkB,YAAY;QACvC,MAAM,IAAIF,UAAU;IACtB;IAEA,kFAAkF;IAClF,mFAAmF;IACnF,MAAMG,gBAAgBC,MAAMC,OAAO,CAACP,UAChCA,SACA;QAAC;YAAC,GAAGA,MAAM;YAAEQ,UAAUR,OAAOQ,QAAQ,IAAI;YAAKC,MAAMT,OAAOS,IAAI,IAAI;QAAS;KAAE;IAEnF,MAAMC,qBAAqBL,cAAcM,GAAG,CAAC,CAACC,YAAe,CAAA;YAC3D,GAAGA,SAAS;YACZC,MAAM;gBAACC,OAAO1B,GAAGG;YAAe;QAClC,CAAA;IAEAI,MAAM,0BAA0Be;IAEhC,OAAOvB,eAAeiB,cAAcM;AACtC"}

package/dist/config/studio/isStudioConfig.js

@@ -0,0 +1,19 @@
+/**
+ * Checks if the given value conforms to a minimum studio config shape.
+ *
+ * @param value - The value to check
+ * @returns Whether the value is a studio config
+ * @internal
+ */ export function isStudioConfig(value) {
+    if (Array.isArray(value)) {
+        return value.every((item)=>isStudioConfig(item));
+    }
+    // Only actual properties marked as required by typescript are `projectId` and `dataset`,
+    // so this is a pretty weak check - but better than nothing.
+    if (typeof value === 'object' && value !== null) {
+        return 'projectId' in value && typeof value.projectId === 'string' && 'dataset' in value && typeof value.dataset === 'string';
+    }
+    return false;
+}
+
+//# sourceMappingURL=isStudioConfig.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/studio/isStudioConfig.ts"],"sourcesContent":["/**\n * Checks if the given value conforms to a minimum studio config shape.\n *\n * @param value - The value to check\n * @returns Whether the value is a studio config\n * @internal\n */\nexport function isStudioConfig(value: unknown): boolean {\n  if (Array.isArray(value)) {\n    return value.every((item) => isStudioConfig(item))\n  }\n\n  // Only actual properties marked as required by typescript are `projectId` and `dataset`,\n  // so this is a pretty weak check - but better than nothing.\n  if (typeof value === 'object' && value !== null) {\n    return (\n      'projectId' in value &&\n      typeof value.projectId === 'string' &&\n      'dataset' in value &&\n      typeof value.dataset === 'string'\n    )\n  }\n\n  return false\n}\n"],"names":["isStudioConfig","value","Array","isArray","every","item","projectId","dataset"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,eAAeC,KAAc;IAC3C,IAAIC,MAAMC,OAAO,CAACF,QAAQ;QACxB,OAAOA,MAAMG,KAAK,CAAC,CAACC,OAASL,eAAeK;IAC9C;IAEA,yFAAyF;IACzF,4DAA4D;IAC5D,IAAI,OAAOJ,UAAU,YAAYA,UAAU,MAAM;QAC/C,OACE,eAAeA,SACf,OAAOA,MAAMK,SAAS,KAAK,YAC3B,aAAaL,SACb,OAAOA,MAAMM,OAAO,KAAK;IAE7B;IAEA,OAAO;AACT"}

package/dist/config/studio/readStudioConfig.js

@@ -0,0 +1,82 @@
+import { dirname } from 'node:path';
+import { z } from 'zod/mini';
+import { studioWorkerTask } from '../../loaders/studio/studioWorkerTask.js';
+const schemaSchema = z.looseObject({
+    name: z.optional(z.string()),
+    types: z.array(z.looseObject({}))
+});
+const sourceSchema = z.looseObject({
+    dataset: z.string(),
+    projectId: z.string(),
+    schema: z.looseObject({
+        _original: schemaSchema
+    })
+});
+// Raw workspace schema (resolvePlugins: false) - unstable_sources not yet populated
+const rawWorkspaceSchema = z.looseObject({
+    ...sourceSchema.shape,
+    basePath: z.optional(z.string()),
+    name: z.optional(z.string()),
+    plugins: z.optional(z.array(z.unknown())),
+    schema: z.optional(schemaSchema),
+    title: z.optional(z.string()),
+    unstable_sources: z.optional(z.array(sourceSchema))
+});
+// Resolved config schema (resolvePlugins: true) - all fields required
+const resolvedWorkspaceSchema = z.looseObject({
+    ...sourceSchema.shape,
+    basePath: z.string(),
+    name: z.string(),
+    plugins: z.optional(z.array(z.unknown())),
+    title: z.string(),
+    unstable_sources: z.array(sourceSchema)
+});
+const rawConfigSchema = z.union([
+    z.array(rawWorkspaceSchema),
+    rawWorkspaceSchema
+]);
+const resolvedConfigSchema = z.array(resolvedWorkspaceSchema);
+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
+        }
+    });
+    try {
+        return options.resolvePlugins ? resolvedConfigSchema.parse(result) : rawConfigSchema.parse(result);
+    } catch (err) {
+        if (err instanceof z.core.$ZodError) {
+            throw new TypeError(`Invalid studio config at ${configPath}:\n${formatZodIssues(err.issues)}`, {
+                cause: err
+            });
+        }
+        throw err;
+    }
+}
+/**
+ * Recursively extracts leaf-level messages from Zod issues, including
+ * those nested inside union errors. Note that `prettifyError` from Zod
+ * only gives a high-level summary for union errors, so this function is
+ * needed to get the full details of all validation issues in a readable format.
+ *
+ * @internal exported for testing only
+ */ export function formatZodIssues(issues, indent = 2) {
+    const lines = [];
+    const prefix = ' '.repeat(indent);
+    for (const issue of issues){
+        if (issue.code === 'invalid_union' && 'errors' in issue && Array.isArray(issue.errors)) {
+            for (const [i, unionIssues] of issue.errors.entries()){
+                lines.push(`${prefix}Union option ${i + 1}:`, formatZodIssues(unionIssues, indent + 2));
+            }
+        } else {
+            const path = issue.path.length > 0 ? ` at "${issue.path.join('.')}"` : '';
+            lines.push(`${prefix}- ${issue.message}${path}`);
+        }
+    }
+    return lines.join('\n');
+}
+
+//# 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/mini'\n\nimport {studioWorkerTask} from '../../loaders/studio/studioWorkerTask.js'\n\nconst schemaSchema = z.looseObject({\n  name: z.optional(z.string()),\n  types: z.array(z.looseObject({})),\n})\n\nconst sourceSchema = z.looseObject({\n  dataset: z.string(),\n  projectId: z.string(),\n  schema: z.looseObject({_original: schemaSchema}),\n})\n\n// Raw workspace schema (resolvePlugins: false) - unstable_sources not yet populated\nconst rawWorkspaceSchema = z.looseObject({\n  ...sourceSchema.shape,\n  basePath: z.optional(z.string()),\n  name: z.optional(z.string()),\n  plugins: z.optional(z.array(z.unknown())),\n  schema: z.optional(schemaSchema),\n  title: z.optional(z.string()),\n  unstable_sources: z.optional(z.array(sourceSchema)),\n})\n\n// Resolved config schema (resolvePlugins: true) - all fields required\nconst resolvedWorkspaceSchema = z.looseObject({\n  ...sourceSchema.shape,\n  basePath: z.string(),\n  name: z.string(),\n  plugins: z.optional(z.array(z.unknown())),\n  title: z.string(),\n  unstable_sources: z.array(sourceSchema),\n})\n\nconst rawConfigSchema = z.union([z.array(rawWorkspaceSchema), rawWorkspaceSchema])\nconst resolvedConfigSchema = z.array(resolvedWorkspaceSchema)\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  try {\n    return options.resolvePlugins\n      ? resolvedConfigSchema.parse(result)\n      : rawConfigSchema.parse(result)\n  } catch (err) {\n    if (err instanceof z.core.$ZodError) {\n      throw new TypeError(\n        `Invalid studio config at ${configPath}:\\n${formatZodIssues(err.issues)}`,\n        {\n          cause: err,\n        },\n      )\n    }\n\n    throw err\n  }\n}\n\n/**\n * Recursively extracts leaf-level messages from Zod issues, including\n * those nested inside union errors. Note that `prettifyError` from Zod\n * only gives a high-level summary for union errors, so this function is\n * needed to get the full details of all validation issues in a readable format.\n *\n * @internal exported for testing only\n */\nexport function formatZodIssues(issues: z.core.$ZodIssue[], indent = 2): string {\n  const lines: string[] = []\n  const prefix = ' '.repeat(indent)\n\n  for (const issue of issues) {\n    if (issue.code === 'invalid_union' && 'errors' in issue && Array.isArray(issue.errors)) {\n      for (const [i, unionIssues] of issue.errors.entries()) {\n        lines.push(`${prefix}Union option ${i + 1}:`, formatZodIssues(unionIssues, indent + 2))\n      }\n    } else {\n      const path = issue.path.length > 0 ? ` at \"${issue.path.join('.')}\"` : ''\n      lines.push(`${prefix}- ${issue.message}${path}`)\n    }\n  }\n\n  return lines.join('\\n')\n}\n"],"names":["dirname","z","studioWorkerTask","schemaSchema","looseObject","name","optional","string","types","array","sourceSchema","dataset","projectId","schema","_original","rawWorkspaceSchema","shape","basePath","plugins","unknown","title","unstable_sources","resolvedWorkspaceSchema","rawConfigSchema","union","resolvedConfigSchema","readStudioConfig","configPath","options","result","URL","url","studioRootPath","workerData","resolvePlugins","parse","err","core","$ZodError","TypeError","formatZodIssues","issues","cause","indent","lines","prefix","repeat","issue","code","Array","isArray","errors","i","unionIssues","entries","push","path","length","join","message"],"mappings":"AAAA,SAAQA,OAAO,QAAO,YAAW;AAEjC,SAAQC,CAAC,QAAO,WAAU;AAE1B,SAAQC,gBAAgB,QAAO,2CAA0C;AAEzE,MAAMC,eAAeF,EAAEG,WAAW,CAAC;IACjCC,MAAMJ,EAAEK,QAAQ,CAACL,EAAEM,MAAM;IACzBC,OAAOP,EAAEQ,KAAK,CAACR,EAAEG,WAAW,CAAC,CAAC;AAChC;AAEA,MAAMM,eAAeT,EAAEG,WAAW,CAAC;IACjCO,SAASV,EAAEM,MAAM;IACjBK,WAAWX,EAAEM,MAAM;IACnBM,QAAQZ,EAAEG,WAAW,CAAC;QAACU,WAAWX;IAAY;AAChD;AAEA,oFAAoF;AACpF,MAAMY,qBAAqBd,EAAEG,WAAW,CAAC;IACvC,GAAGM,aAAaM,KAAK;IACrBC,UAAUhB,EAAEK,QAAQ,CAACL,EAAEM,MAAM;IAC7BF,MAAMJ,EAAEK,QAAQ,CAACL,EAAEM,MAAM;IACzBW,SAASjB,EAAEK,QAAQ,CAACL,EAAEQ,KAAK,CAACR,EAAEkB,OAAO;IACrCN,QAAQZ,EAAEK,QAAQ,CAACH;IACnBiB,OAAOnB,EAAEK,QAAQ,CAACL,EAAEM,MAAM;IAC1Bc,kBAAkBpB,EAAEK,QAAQ,CAACL,EAAEQ,KAAK,CAACC;AACvC;AAEA,sEAAsE;AACtE,MAAMY,0BAA0BrB,EAAEG,WAAW,CAAC;IAC5C,GAAGM,aAAaM,KAAK;IACrBC,UAAUhB,EAAEM,MAAM;IAClBF,MAAMJ,EAAEM,MAAM;IACdW,SAASjB,EAAEK,QAAQ,CAACL,EAAEQ,KAAK,CAACR,EAAEkB,OAAO;IACrCC,OAAOnB,EAAEM,MAAM;IACfc,kBAAkBpB,EAAEQ,KAAK,CAACC;AAC5B;AAEA,MAAMa,kBAAkBtB,EAAEuB,KAAK,CAAC;IAACvB,EAAEQ,KAAK,CAACM;IAAqBA;CAAmB;AACjF,MAAMU,uBAAuBxB,EAAEQ,KAAK,CAACa;AAiCrC,OAAO,eAAeI,iBACpBC,UAAkB,EAClBC,OAAgC;IAEhC,MAAMC,SAAS,MAAM3B,iBAAiB,IAAI4B,IAAI,8BAA8B,YAAYC,GAAG,GAAG;QAC5F1B,MAAM;QACN2B,gBAAgBhC,QAAQ2B;QACxBM,YAAY;YAACN;YAAYO,gBAAgBN,QAAQM,cAAc;QAAA;IACjE;IAEA,IAAI;QACF,OAAON,QAAQM,cAAc,GACzBT,qBAAqBU,KAAK,CAACN,UAC3BN,gBAAgBY,KAAK,CAACN;IAC5B,EAAE,OAAOO,KAAK;QACZ,IAAIA,eAAenC,EAAEoC,IAAI,CAACC,SAAS,EAAE;YACnC,MAAM,IAAIC,UACR,CAAC,yBAAyB,EAAEZ,WAAW,GAAG,EAAEa,gBAAgBJ,IAAIK,MAAM,GAAG,EACzE;gBACEC,OAAON;YACT;QAEJ;QAEA,MAAMA;IACR;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,gBAAgBC,MAA0B,EAAEE,SAAS,CAAC;IACpE,MAAMC,QAAkB,EAAE;IAC1B,MAAMC,SAAS,IAAIC,MAAM,CAACH;IAE1B,KAAK,MAAMI,SAASN,OAAQ;QAC1B,IAAIM,MAAMC,IAAI,KAAK,mBAAmB,YAAYD,SAASE,MAAMC,OAAO,CAACH,MAAMI,MAAM,GAAG;YACtF,KAAK,MAAM,CAACC,GAAGC,YAAY,IAAIN,MAAMI,MAAM,CAACG,OAAO,GAAI;gBACrDV,MAAMW,IAAI,CAAC,GAAGV,OAAO,aAAa,EAAEO,IAAI,EAAE,CAAC,CAAC,EAAEZ,gBAAgBa,aAAaV,SAAS;YACtF;QACF,OAAO;YACL,MAAMa,OAAOT,MAAMS,IAAI,CAACC,MAAM,GAAG,IAAI,CAAC,KAAK,EAAEV,MAAMS,IAAI,CAACE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG;YACvEd,MAAMW,IAAI,CAAC,GAAGV,OAAO,EAAE,EAAEE,MAAMY,OAAO,GAAGH,MAAM;QACjD;IACF;IAEA,OAAOZ,MAAMc,IAAI,CAAC;AACpB"}

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

@@ -0,0 +1,25 @@
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { z } from 'zod/mini';
+import { subdebug } from '../../debug.js';
+import { doImport } from '../../util/doImport.js';
+import { safeStructuredClone } from '../../util/safeStructuredClone.js';
+import { getStudioWorkspaces } from './getStudioWorkspaces.js';
+if (isMainThread || !parentPort) {
+    throw new Error('Should only be run in a worker!');
+}
+const debug = subdebug('readStudioConfig.worker');
+const { configPath, resolvePlugins } = z.object({
+    configPath: z.string(),
+    resolvePlugins: z.boolean()
+}).parse(workerData);
+debug('Parsing config path %s', configPath);
+let { default: config } = await doImport(configPath);
+debug('Imported config %o', config);
+if (resolvePlugins) {
+    debug('Resolving workspaces');
+    config = await getStudioWorkspaces(configPath);
+    debug('Resolved workspaces %o', config);
+}
+parentPort.postMessage(safeStructuredClone(config));
+
+//# 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 {isMainThread, parentPort, workerData} from 'node:worker_threads'\n\nimport {z} from 'zod/mini'\n\nimport {subdebug} from '../../debug.js'\nimport {doImport} from '../../util/doImport.js'\nimport {safeStructuredClone} from '../../util/safeStructuredClone.js'\nimport {getStudioWorkspaces} from './getStudioWorkspaces.js'\n\nif (isMainThread || !parentPort) {\n  throw new Error('Should only be run in a worker!')\n}\n\nconst debug = subdebug('readStudioConfig.worker')\n\nconst {configPath, resolvePlugins} = z\n  .object({configPath: z.string(), resolvePlugins: z.boolean()})\n  .parse(workerData)\n\ndebug('Parsing config path %s', configPath)\n\nlet {default: config} = await doImport(configPath)\n\ndebug('Imported config %o', config)\n\nif (resolvePlugins) {\n  debug('Resolving workspaces')\n  config = await getStudioWorkspaces(configPath)\n  debug('Resolved workspaces %o', config)\n}\n\nparentPort.postMessage(safeStructuredClone(config))\n"],"names":["isMainThread","parentPort","workerData","z","subdebug","doImport","safeStructuredClone","getStudioWorkspaces","Error","debug","configPath","resolvePlugins","object","string","boolean","parse","default","config","postMessage"],"mappings":"AAAA,SAAQA,YAAY,EAAEC,UAAU,EAAEC,UAAU,QAAO,sBAAqB;AAExE,SAAQC,CAAC,QAAO,WAAU;AAE1B,SAAQC,QAAQ,QAAO,iBAAgB;AACvC,SAAQC,QAAQ,QAAO,yBAAwB;AAC/C,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D,IAAIP,gBAAgB,CAACC,YAAY;IAC/B,MAAM,IAAIO,MAAM;AAClB;AAEA,MAAMC,QAAQL,SAAS;AAEvB,MAAM,EAACM,UAAU,EAAEC,cAAc,EAAC,GAAGR,EAClCS,MAAM,CAAC;IAACF,YAAYP,EAAEU,MAAM;IAAIF,gBAAgBR,EAAEW,OAAO;AAAE,GAC3DC,KAAK,CAACb;AAETO,MAAM,0BAA0BC;AAEhC,IAAI,EAACM,SAASC,MAAM,EAAC,GAAG,MAAMZ,SAASK;AAEvCD,MAAM,sBAAsBQ;AAE5B,IAAIN,gBAAgB;IAClBF,MAAM;IACNQ,SAAS,MAAMV,oBAAoBG;IACnCD,MAAM,0BAA0BQ;AAClC;AAEAhB,WAAWiB,WAAW,CAACZ,oBAAoBW"}

package/dist/config/util/configPathsSync.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+/**
+ * Checks for a `sanity.json` file with `"root": true` in the given directory synchronously.
+ *
+ * @param basePath - The base path to look for a `sanity.json` in
+ * @returns true if a `sanity.json` with `"root": true` is found, false otherwise
+ * @internal
+ */ function isSanityV2StudioRootSync(basePath) {
+    try {
+        const content = readFileSync(join(basePath, 'sanity.json'), 'utf8');
+        const sanityJson = JSON.parse(content);
+        if (!sanityJson || typeof sanityJson !== 'object' || Array.isArray(sanityJson)) {
+            throw new Error('Invalid sanity.json, expected an object');
+        }
+        const isRoot = Boolean(sanityJson?.root);
+        return isRoot;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Finds the path for a given set of files synchronously.
+ *
+ * @param basePath - The base path to search for files.
+ * @param files - The files to search for.
+ * @returns Array of path results
+ * @internal
+ */ function findPathForFilesSync(basePath, files) {
+    return files.map((file)=>{
+        const path = join(basePath, file);
+        const exists = existsSync(path);
+        return {
+            exists,
+            path
+        };
+    });
+}
+/**
+ * Resolves to a string containing the found config path, or `undefined` if not found.
+ * Throws if Sanity v2 studio root is found.
+ *
+ * @param basePath - The base path to start searching from
+ * @returns A string containing the found config path, or `undefined` if not found
+ * @internal
+ */ export function findStudioConfigPathSync(basePath) {
+    if (isSanityV2StudioRootSync(basePath)) {
+        throw new Error(`Found 'sanity.json' at ${basePath} - Sanity Studio < v3 is no longer supported`);
+    }
+    const paths = findPathForFilesSync(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;
+    }
+}
+/**
+ * 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 string containing the found config path, or `undefined` if not found
+ * @internal
+ */ export function findAppConfigPathSync(basePath) {
+    const paths = findPathForFilesSync(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=configPathsSync.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/configPathsSync.ts"],"sourcesContent":["import {existsSync, readFileSync} from 'node:fs'\nimport {basename, join} from 'node:path'\n\n/**\n * @internal\n */\ninterface PathResult {\n  exists: boolean\n  path: string\n}\n\n/**\n * Checks for a `sanity.json` file with `\"root\": true` in the given directory synchronously.\n *\n * @param basePath - The base path to look for a `sanity.json` in\n * @returns true if a `sanity.json` with `\"root\": true` is found, false otherwise\n * @internal\n */\nfunction isSanityV2StudioRootSync(basePath: string): boolean {\n  try {\n    const content = readFileSync(join(basePath, 'sanity.json'), 'utf8')\n    const sanityJson = JSON.parse(content)\n    if (!sanityJson || typeof sanityJson !== 'object' || Array.isArray(sanityJson)) {\n      throw new Error('Invalid sanity.json, expected an object')\n    }\n    const isRoot = Boolean(sanityJson?.root)\n    return isRoot\n  } catch {\n    return false\n  }\n}\n\n/**\n * Finds the path for a given set of files synchronously.\n *\n * @param basePath - The base path to search for files.\n * @param files - The files to search for.\n * @returns Array of path results\n * @internal\n */\nfunction findPathForFilesSync(basePath: string, files: string[]): PathResult[] {\n  return files.map((file) => {\n    const path = join(basePath, file)\n    const exists = existsSync(path)\n    return {exists, path}\n  })\n}\n\n/**\n * Resolves to a string containing the found config path, or `undefined` 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 string containing the found config path, or `undefined` if not found\n * @internal\n */\nexport function findStudioConfigPathSync(basePath: string): string | undefined {\n  if (isSanityV2StudioRootSync(basePath)) {\n    throw new Error(\n      `Found 'sanity.json' at ${basePath} - Sanity Studio < v3 is no longer supported`,\n    )\n  }\n\n  const paths = findPathForFilesSync(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\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 string containing the found config path, or `undefined` if not found\n * @internal\n */\nexport function findAppConfigPathSync(basePath: string): string | undefined {\n  const paths = findPathForFilesSync(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":["existsSync","readFileSync","basename","join","isSanityV2StudioRootSync","basePath","content","sanityJson","JSON","parse","Array","isArray","Error","isRoot","Boolean","root","findPathForFilesSync","files","map","file","path","exists","findStudioConfigPathSync","paths","configPaths","filter","length","baseNames","config","findAppConfigPathSync"],"mappings":"AAAA,SAAQA,UAAU,EAAEC,YAAY,QAAO,UAAS;AAChD,SAAQC,QAAQ,EAAEC,IAAI,QAAO,YAAW;AAUxC;;;;;;CAMC,GACD,SAASC,yBAAyBC,QAAgB;IAChD,IAAI;QACF,MAAMC,UAAUL,aAAaE,KAAKE,UAAU,gBAAgB;QAC5D,MAAME,aAAaC,KAAKC,KAAK,CAACH;QAC9B,IAAI,CAACC,cAAc,OAAOA,eAAe,YAAYG,MAAMC,OAAO,CAACJ,aAAa;YAC9E,MAAM,IAAIK,MAAM;QAClB;QACA,MAAMC,SAASC,QAAQP,YAAYQ;QACnC,OAAOF;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA;;;;;;;CAOC,GACD,SAASG,qBAAqBX,QAAgB,EAAEY,KAAe;IAC7D,OAAOA,MAAMC,GAAG,CAAC,CAACC;QAChB,MAAMC,OAAOjB,KAAKE,UAAUc;QAC5B,MAAME,SAASrB,WAAWoB;QAC1B,OAAO;YAACC;YAAQD;QAAI;IACtB;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASE,yBAAyBjB,QAAgB;IACvD,IAAID,yBAAyBC,WAAW;QACtC,MAAM,IAAIO,MACR,CAAC,uBAAuB,EAAEP,SAAS,4CAA4C,CAAC;IAEpF;IAEA,MAAMkB,QAAQP,qBAAqBX,UAAU;QAC3C;QACA;QACA;QACA;KACD;IAED,MAAMmB,cAAcD,MAAME,MAAM,CAAC,CAACL,OAASA,KAAKC,MAAM;IACtD,IAAIG,YAAYE,MAAM,GAAG,GAAG;QAC1B,MAAMC,YAAYH,YAAYN,GAAG,CAAC,CAACU,SAAWA,OAAOR,IAAI,EAAEF,GAAG,CAAC,CAACE,OAASlB,SAASkB;QAClF,MAAM,IAAIR,MAAM,CAAC,oCAAoC,EAAEe,UAAUxB,IAAI,CAAC,MAAM,CAAC,CAAC;IAChF;IAEA,IAAIqB,YAAYE,MAAM,KAAK,GAAG;QAC5B,OAAOF,WAAW,CAAC,EAAE,CAACJ,IAAI;IAC5B;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASS,sBAAsBxB,QAAgB;IACpD,MAAMkB,QAAQP,qBAAqBX,UAAU;QAAC;QAAiB;KAAgB;IAC/E,MAAMmB,cAAcD,MAAME,MAAM,CAAC,CAACL,OAASA,KAAKC,MAAM;IACtD,IAAIG,YAAYE,MAAM,GAAG,GAAG;QAC1B,MAAM,IAAId,MACR,CAAC,iCAAiC,EAAEY,YAAYN,GAAG,CAAC,CAACE,OAASA,KAAKA,IAAI,EAAEjB,IAAI,CAAC,MAAM,CAAC,CAAC;IAE1F;IAEA,IAAIqB,YAAYE,MAAM,KAAK,GAAG;QAC5B,OAAOF,WAAW,CAAC,EAAE,CAACJ,IAAI;IAC5B;AACF"}

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.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.js

@@ -0,0 +1,52 @@
+import { basename } from 'node:path';
+import { findPathForFiles } from './findConfigsPaths.js';
+import { isSanityV2StudioRoot } from './isSanityV2StudioRoot.js';
+/**
+ * Resolves to a string containing the found config path, otherwise throws an error.
+ * Also 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
+ * @throws On multiple config files found, if v2 studio root found, or no config 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;
+    }
+    throw new ConfigNotFoundError(`No studio config file found at ${basePath}`);
+}
+/**
+ * Tries to find the studio config path, returning `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
+ * @throws On errors other than config not found
+ * @internal
+ */ export async function tryFindStudioConfigPath(basePath) {
+    try {
+        return await findStudioConfigPath(basePath);
+    } catch (err) {
+        if (err instanceof ConfigNotFoundError) {
+            return undefined;
+        }
+        throw err;
+    }
+}
+class ConfigNotFoundError extends Error {
+}
+
+//# 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, otherwise throws an error.\n * Also 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\n * @throws On multiple config files found, if v2 studio root found, or no config found\n * @internal\n */\nexport async function findStudioConfigPath(basePath: string): Promise<string> {\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  throw new ConfigNotFoundError(`No studio config file found at ${basePath}`)\n}\n\n/**\n * Tries to find the studio config path, returning `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 * @throws On errors other than config not found\n * @internal\n */\nexport async function tryFindStudioConfigPath(basePath: string): Promise<string | undefined> {\n  try {\n    return await findStudioConfigPath(basePath)\n  } catch (err) {\n    if (err instanceof ConfigNotFoundError) {\n      return undefined\n    }\n    throw err\n  }\n}\n\nclass ConfigNotFoundError extends Error {}\n"],"names":["basename","findPathForFiles","isSanityV2StudioRoot","findStudioConfigPath","basePath","Error","paths","configPaths","filter","path","exists","length","baseNames","map","config","join","ConfigNotFoundError","tryFindStudioConfigPath","err","undefined"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,YAAW;AAElC,SAAQC,gBAAgB,QAAO,wBAAuB;AACtD,SAAQC,oBAAoB,QAAO,4BAA2B;AAE9D;;;;;;;;CAQC,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;IAEA,MAAM,IAAIO,oBAAoB,CAAC,+BAA+B,EAAEZ,UAAU;AAC5E;AAEA;;;;;;;CAOC,GACD,OAAO,eAAea,wBAAwBb,QAAgB;IAC5D,IAAI;QACF,OAAO,MAAMD,qBAAqBC;IACpC,EAAE,OAAOc,KAAK;QACZ,IAAIA,eAAeF,qBAAqB;YACtC,OAAOG;QACT;QACA,MAAMD;IACR;AACF;AAEA,MAAMF,4BAA4BX;AAAO"}

package/dist/config/util/isSanityV2StudioRoot.js

@@ -0,0 +1,22 @@
+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'));
+        if (!sanityJson || typeof sanityJson !== 'object' || Array.isArray(sanityJson)) {
+            throw new Error('Invalid sanity.json, expected an object');
+        }
+        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    if (!sanityJson || typeof sanityJson !== 'object' || Array.isArray(sanityJson)) {\n      throw new Error('Invalid sanity.json, expected an object')\n    }\n    const isRoot = Boolean(sanityJson?.root)\n    return isRoot\n  } catch {\n    return false\n  }\n}\n"],"names":["join","readJsonFile","isSanityV2StudioRoot","basePath","sanityJson","Array","isArray","Error","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,IAAI,CAACC,cAAc,OAAOA,eAAe,YAAYC,MAAMC,OAAO,CAACF,aAAa;YAC9E,MAAM,IAAIG,MAAM;QAClB;QACA,MAAMC,SAASC,QAAQL,YAAYM;QACnC,OAAOF;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

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