@sanity/cli 5.1.1-next.5 → 6.0.0-alpha.3

package/dist/util/formatSize.js

@@ -0,0 +1,10 @@
+import { chalk } from '@sanity/cli-core/ux';
+/**
+ * Formats bytes to kB
+ *
+ * @internal
+ */ export function formatSize(bytes) {
+    return chalk.cyan(`${(bytes / 1024).toFixed(0)} kB`);
+}
+
+//# sourceMappingURL=formatSize.js.map

package/dist/util/formatSize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/formatSize.ts"],"sourcesContent":["import {chalk} from '@sanity/cli-core/ux'\n\n/**\n * Formats bytes to kB\n *\n * @internal\n */\nexport function formatSize(bytes: number): string {\n  return chalk.cyan(`${(bytes / 1024).toFixed(0)} kB`)\n}\n"],"names":["chalk","formatSize","bytes","cyan","toFixed"],"mappings":"AAAA,SAAQA,KAAK,QAAO,sBAAqB;AAEzC;;;;CAIC,GACD,OAAO,SAASC,WAAWC,KAAa;IACtC,OAAOF,MAAMG,IAAI,CAAC,GAAG,AAACD,CAAAA,QAAQ,IAAG,EAAGE,OAAO,CAAC,GAAG,GAAG,CAAC;AACrD"}

package/dist/util/getCliVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the version of the `@sanity/cli` package.
+ *
+ * @internal
+ * @returns The version of the `@sanity/cli` package.
+ */
+export declare function getCliVersion(): Promise<string>;

package/dist/util/getCliVersion.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { packageDirectory } from 'pkg-dir';
+import { readPackageJson } from './readPackageJson.js';
+/**
+ * Get the version of the `@sanity/cli` package.
+ *
+ * @internal
+ * @returns The version of the `@sanity/cli` package.
+ */ export async function getCliVersion() {
+    // using the meta.url will resolve to the code running from the cli
+    // this will find the package.json in cli package.
+    const cliPath = await packageDirectory({
+        cwd: fileURLToPath(import.meta.url)
+    });
+    if (!cliPath) {
+        throw new Error('Unable to resolve root of @sanity/cli module');
+    }
+    let pkg;
+    try {
+        pkg = await readPackageJson(path.join(cliPath, 'package.json'));
+    } catch (err) {
+        throw new Error(`Unable to read @sanity/cli/package.json: ${err.message}`);
+    }
+    return pkg.version;
+}
+
+//# sourceMappingURL=getCliVersion.js.map

package/dist/util/getCliVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getCliVersion.ts"],"sourcesContent":["import path from 'node:path'\nimport {fileURLToPath} from 'node:url'\n\nimport {packageDirectory} from 'pkg-dir'\n\nimport {type PackageJson, readPackageJson} from './readPackageJson.js'\n\n/**\n * Get the version of the `@sanity/cli` package.\n *\n * @internal\n * @returns The version of the `@sanity/cli` package.\n */\nexport async function getCliVersion(): Promise<string> {\n  // using the meta.url will resolve to the code running from the cli\n  // this will find the package.json in cli package.\n  const cliPath = await packageDirectory({cwd: fileURLToPath(import.meta.url)})\n  if (!cliPath) {\n    throw new Error('Unable to resolve root of @sanity/cli module')\n  }\n\n  let pkg: PackageJson | undefined\n  try {\n    pkg = await readPackageJson(path.join(cliPath, 'package.json'))\n  } catch (err) {\n    throw new Error(`Unable to read @sanity/cli/package.json: ${(err as Error).message}`)\n  }\n\n  return pkg.version\n}\n"],"names":["path","fileURLToPath","packageDirectory","readPackageJson","getCliVersion","cliPath","cwd","url","Error","pkg","join","err","message","version"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAC5B,SAAQC,aAAa,QAAO,WAAU;AAEtC,SAAQC,gBAAgB,QAAO,UAAS;AAExC,SAA0BC,eAAe,QAAO,uBAAsB;AAEtE;;;;;CAKC,GACD,OAAO,eAAeC;IACpB,mEAAmE;IACnE,kDAAkD;IAClD,MAAMC,UAAU,MAAMH,iBAAiB;QAACI,KAAKL,cAAc,YAAYM,GAAG;IAAC;IAC3E,IAAI,CAACF,SAAS;QACZ,MAAM,IAAIG,MAAM;IAClB;IAEA,IAAIC;IACJ,IAAI;QACFA,MAAM,MAAMN,gBAAgBH,KAAKU,IAAI,CAACL,SAAS;IACjD,EAAE,OAAOM,KAAK;QACZ,MAAM,IAAIH,MAAM,CAAC,yCAAyC,EAAE,AAACG,IAAcC,OAAO,EAAE;IACtF;IAEA,OAAOH,IAAII,OAAO;AACpB"}

package/dist/util/getErrorMessage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get the error message from an error object
+ *
+ * @param err - The error object
+ * @returns The error message
+ * @internal
+ */
+export declare function getErrorMessage(err: unknown): string;

package/dist/util/getErrorMessage.js

@@ -0,0 +1,19 @@
+import { isHttpError } from '@sanity/client';
+/**
+ * Get the error message from an error object
+ *
+ * @param err - The error object
+ * @returns The error message
+ * @internal
+ */ export function getErrorMessage(err) {
+    if (isHttpError(err)) {
+        const body = err.response.body;
+        if (typeof body === 'object' && body !== null && 'message' in body && typeof body.message === 'string') {
+            return body.message;
+        }
+        return err.message || 'HTTP error';
+    }
+    return err instanceof Error ? err.message : 'Unknown error';
+}
+
+//# sourceMappingURL=getErrorMessage.js.map

package/dist/util/getErrorMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getErrorMessage.ts"],"sourcesContent":["import {isHttpError} from '@sanity/client'\n\n/**\n * Get the error message from an error object\n *\n * @param err - The error object\n * @returns The error message\n * @internal\n */\nexport function getErrorMessage(err: unknown): string {\n  if (isHttpError(err)) {\n    const body = err.response.body\n    if (\n      typeof body === 'object' &&\n      body !== null &&\n      'message' in body &&\n      typeof body.message === 'string'\n    ) {\n      return body.message\n    }\n    return err.message || 'HTTP error'\n  }\n  return err instanceof Error ? err.message : 'Unknown error'\n}\n"],"names":["isHttpError","getErrorMessage","err","body","response","message","Error"],"mappings":"AAAA,SAAQA,WAAW,QAAO,iBAAgB;AAE1C;;;;;;CAMC,GACD,OAAO,SAASC,gBAAgBC,GAAY;IAC1C,IAAIF,YAAYE,MAAM;QACpB,MAAMC,OAAOD,IAAIE,QAAQ,CAACD,IAAI;QAC9B,IACE,OAAOA,SAAS,YAChBA,SAAS,QACT,aAAaA,QACb,OAAOA,KAAKE,OAAO,KAAK,UACxB;YACA,OAAOF,KAAKE,OAAO;QACrB;QACA,OAAOH,IAAIG,OAAO,IAAI;IACxB;IACA,OAAOH,eAAeI,QAAQJ,IAAIG,OAAO,GAAG;AAC9C"}

package/dist/util/getLocalPackageVersion.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get the version of a package installed locally.
+ *
+ * @param moduleId - The name of the package in npm.
+ * @param workDir - The working directory to resolve the module from.
+ * @returns The version of the package installed locally.
+ * @internal
+ */
+export declare function getLocalPackageVersion(moduleId: string, workDir: string): Promise<string | undefined>;

package/dist/util/getLocalPackageVersion.js

@@ -0,0 +1,32 @@
+import { join, normalize as normalizePath } from 'node:path';
+import resolveFrom from 'resolve-from';
+import { readPackageJson } from './readPackageJson.js';
+/**
+ * Get the version of a package installed locally.
+ *
+ * @param moduleId - The name of the package in npm.
+ * @param workDir - The working directory to resolve the module from.
+ * @returns The version of the package installed locally.
+ * @internal
+ */ export async function getLocalPackageVersion(moduleId, workDir) {
+    const fromPath = workDir || process.cwd();
+    const modulePath = resolveFrom.silent(fromPath, join(moduleId, 'package.json'));
+    if (modulePath) {
+        const pkg = await readPackageJson(modulePath);
+        return pkg.version;
+    }
+    // In the case of packages with an `exports` key, we may not be able to resolve `package.json`.
+    // If this happens, try to resolve the module itself and look for the last occurence of the
+    // package name, then append `package.json` to that path
+    const pathSegment = normalizePath(moduleId);
+    const parentPath = resolveFrom.silent(fromPath, moduleId);
+    if (!parentPath) {
+        return undefined;
+    }
+    const moduleRoot = parentPath.slice(0, parentPath.lastIndexOf(pathSegment) + pathSegment.length);
+    const manifestPath = join(moduleRoot, 'package.json');
+    const pkg = await readPackageJson(manifestPath);
+    return pkg.version;
+}
+
+//# sourceMappingURL=getLocalPackageVersion.js.map

package/dist/util/getLocalPackageVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getLocalPackageVersion.ts"],"sourcesContent":["import {join, normalize as normalizePath} from 'node:path'\n\nimport resolveFrom from 'resolve-from'\n\nimport {readPackageJson} from './readPackageJson.js'\n\n/**\n * Get the version of a package installed locally.\n *\n * @param moduleId - The name of the package in npm.\n * @param workDir - The working directory to resolve the module from.\n * @returns The version of the package installed locally.\n * @internal\n */\nexport async function getLocalPackageVersion(\n  moduleId: string,\n  workDir: string,\n): Promise<string | undefined> {\n  const fromPath = workDir || process.cwd()\n  const modulePath = resolveFrom.silent(fromPath, join(moduleId, 'package.json'))\n  if (modulePath) {\n    const pkg = await readPackageJson(modulePath)\n    return pkg.version\n  }\n\n  // In the case of packages with an `exports` key, we may not be able to resolve `package.json`.\n  // If this happens, try to resolve the module itself and look for the last occurence of the\n  // package name, then append `package.json` to that path\n  const pathSegment = normalizePath(moduleId)\n  const parentPath = resolveFrom.silent(fromPath, moduleId)\n  if (!parentPath) {\n    return undefined\n  }\n\n  const moduleRoot = parentPath.slice(0, parentPath.lastIndexOf(pathSegment) + pathSegment.length)\n  const manifestPath = join(moduleRoot, 'package.json')\n  const pkg = await readPackageJson(manifestPath)\n  return pkg.version\n}\n"],"names":["join","normalize","normalizePath","resolveFrom","readPackageJson","getLocalPackageVersion","moduleId","workDir","fromPath","process","cwd","modulePath","silent","pkg","version","pathSegment","parentPath","undefined","moduleRoot","slice","lastIndexOf","length","manifestPath"],"mappings":"AAAA,SAAQA,IAAI,EAAEC,aAAaC,aAAa,QAAO,YAAW;AAE1D,OAAOC,iBAAiB,eAAc;AAEtC,SAAQC,eAAe,QAAO,uBAAsB;AAEpD;;;;;;;CAOC,GACD,OAAO,eAAeC,uBACpBC,QAAgB,EAChBC,OAAe;IAEf,MAAMC,WAAWD,WAAWE,QAAQC,GAAG;IACvC,MAAMC,aAAaR,YAAYS,MAAM,CAACJ,UAAUR,KAAKM,UAAU;IAC/D,IAAIK,YAAY;QACd,MAAME,MAAM,MAAMT,gBAAgBO;QAClC,OAAOE,IAAIC,OAAO;IACpB;IAEA,+FAA+F;IAC/F,2FAA2F;IAC3F,wDAAwD;IACxD,MAAMC,cAAcb,cAAcI;IAClC,MAAMU,aAAab,YAAYS,MAAM,CAACJ,UAAUF;IAChD,IAAI,CAACU,YAAY;QACf,OAAOC;IACT;IAEA,MAAMC,aAAaF,WAAWG,KAAK,CAAC,GAAGH,WAAWI,WAAW,CAACL,eAAeA,YAAYM,MAAM;IAC/F,MAAMC,eAAetB,KAAKkB,YAAY;IACtC,MAAML,MAAM,MAAMT,gBAAgBkB;IAClC,OAAOT,IAAIC,OAAO;AACpB"}

package/dist/util/getSharedServerConfig.d.ts

@@ -0,0 +1,30 @@
+import { type CliConfig } from '@sanity/cli-core';
+interface GetSharedServerConfigOptions {
+    flags: {
+        host?: string;
+        port?: number | string;
+    };
+    workDir: string;
+    cliConfig?: CliConfig;
+}
+export interface GetSharedServerConfigResult {
+    basePath: string;
+    cwd: string;
+    httpHost: string;
+    httpPort: number;
+    vite: CliConfig['vite'];
+    entry?: string;
+    isApp?: boolean;
+}
+/**
+ * @internal
+ *
+ * Resolves the shared configuration for the dev/preview server using:
+ *
+ * - CLI flags
+ * - Environment variables
+ * - User build config
+ * - Default configuration
+ */
+export declare function getSharedServerConfig({ cliConfig, flags, workDir, }: GetSharedServerConfigOptions): GetSharedServerConfigResult;
+export {};

package/dist/util/getSharedServerConfig.js

@@ -0,0 +1,31 @@
+import { getSanityEnvVar } from '@sanity/cli-core';
+import { ensureTrailingSlash } from './ensureTrailingSlash.js';
+import { toInt } from './toInt.js';
+/**
+ * @internal
+ *
+ * Resolves the shared configuration for the dev/preview server using:
+ *
+ * - CLI flags
+ * - Environment variables
+ * - User build config
+ * - Default configuration
+ */ export function getSharedServerConfig({ cliConfig, flags, workDir }) {
+    // Order of preference: CLI flags, environment variables, user build config, default config
+    const isApp = cliConfig && 'app' in cliConfig;
+    const httpHost = flags.host || getSanityEnvVar('SERVER_HOSTNAME', isApp ?? false) || cliConfig?.server?.hostname || 'localhost';
+    const httpPort = toInt(flags.port || getSanityEnvVar('SERVER_PORT', isApp ?? false) || cliConfig?.server?.port, 3333);
+    const basePath = ensureTrailingSlash(getSanityEnvVar('BASEPATH', isApp ?? false) ?? (cliConfig?.project?.basePath || '/'));
+    const entry = cliConfig?.app?.entry;
+    return {
+        basePath,
+        cwd: workDir,
+        entry,
+        httpHost,
+        httpPort,
+        isApp,
+        vite: cliConfig?.vite
+    };
+}
+
+//# sourceMappingURL=getSharedServerConfig.js.map

package/dist/util/getSharedServerConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getSharedServerConfig.ts"],"sourcesContent":["import {type CliConfig, getSanityEnvVar} from '@sanity/cli-core'\n\nimport {ensureTrailingSlash} from './ensureTrailingSlash.js'\nimport {toInt} from './toInt.js'\n\ninterface GetSharedServerConfigOptions {\n  flags: {host?: string; port?: number | string}\n  workDir: string\n\n  cliConfig?: CliConfig\n}\n\nexport interface GetSharedServerConfigResult {\n  basePath: string\n  cwd: string\n  httpHost: string\n  httpPort: number\n  vite: CliConfig['vite']\n\n  entry?: string\n  isApp?: boolean\n}\n\n/**\n * @internal\n *\n * Resolves the shared configuration for the dev/preview server using:\n *\n * - CLI flags\n * - Environment variables\n * - User build config\n * - Default configuration\n */\nexport function getSharedServerConfig({\n  cliConfig,\n  flags,\n  workDir,\n}: GetSharedServerConfigOptions): GetSharedServerConfigResult {\n  // Order of preference: CLI flags, environment variables, user build config, default config\n  const isApp = cliConfig && 'app' in cliConfig\n\n  const httpHost =\n    flags.host ||\n    getSanityEnvVar('SERVER_HOSTNAME', isApp ?? false) ||\n    cliConfig?.server?.hostname ||\n    'localhost'\n\n  const httpPort = toInt(\n    flags.port || getSanityEnvVar('SERVER_PORT', isApp ?? false) || cliConfig?.server?.port,\n    3333,\n  )\n\n  const basePath = ensureTrailingSlash(\n    getSanityEnvVar('BASEPATH', isApp ?? false) ?? (cliConfig?.project?.basePath || '/'),\n  )\n\n  const entry = cliConfig?.app?.entry\n\n  return {\n    basePath,\n    cwd: workDir,\n    entry,\n    httpHost,\n    httpPort,\n    isApp,\n    vite: cliConfig?.vite,\n  }\n}\n"],"names":["getSanityEnvVar","ensureTrailingSlash","toInt","getSharedServerConfig","cliConfig","flags","workDir","isApp","httpHost","host","server","hostname","httpPort","port","basePath","project","entry","app","cwd","vite"],"mappings":"AAAA,SAAwBA,eAAe,QAAO,mBAAkB;AAEhE,SAAQC,mBAAmB,QAAO,2BAA0B;AAC5D,SAAQC,KAAK,QAAO,aAAY;AAoBhC;;;;;;;;;CASC,GACD,OAAO,SAASC,sBAAsB,EACpCC,SAAS,EACTC,KAAK,EACLC,OAAO,EACsB;IAC7B,2FAA2F;IAC3F,MAAMC,QAAQH,aAAa,SAASA;IAEpC,MAAMI,WACJH,MAAMI,IAAI,IACVT,gBAAgB,mBAAmBO,SAAS,UAC5CH,WAAWM,QAAQC,YACnB;IAEF,MAAMC,WAAWV,MACfG,MAAMQ,IAAI,IAAIb,gBAAgB,eAAeO,SAAS,UAAUH,WAAWM,QAAQG,MACnF;IAGF,MAAMC,WAAWb,oBACfD,gBAAgB,YAAYO,SAAS,UAAWH,CAAAA,WAAWW,SAASD,YAAY,GAAE;IAGpF,MAAME,QAAQZ,WAAWa,KAAKD;IAE9B,OAAO;QACLF;QACAI,KAAKZ;QACLU;QACAR;QACAI;QACAL;QACAY,MAAMf,WAAWe;IACnB;AACF"}

package/dist/util/getWorkspace.d.ts

@@ -0,0 +1,3 @@
+export declare function getWorkspace<T extends {
+    name: string;
+}>(workspaces: T[], workspaceName?: string): T;

package/dist/util/getWorkspace.js

@@ -0,0 +1,18 @@
+export function getWorkspace(workspaces, workspaceName) {
+    if (workspaces.length === 0) {
+        throw new Error('No workspaces found');
+    }
+    if (workspaces.length === 1) {
+        return workspaces[0];
+    }
+    if (!workspaceName) {
+        throw new Error(`Multiple workspaces found. Please specify which workspace to use with "--workspace". Available workspaces: ${workspaces.map((w)=>w.name).join(', ')}`);
+    }
+    const workspace = workspaces.find((w)=>w.name === workspaceName);
+    if (!workspace) {
+        throw new Error(`Could not find "${workspaceName}" workspace. Available workspaces: ${workspaces.map((w)=>w.name).join(', ')}`);
+    }
+    return workspace;
+}
+
+//# sourceMappingURL=getWorkspace.js.map

package/dist/util/getWorkspace.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getWorkspace.ts"],"sourcesContent":["export function getWorkspace<T extends {name: string}>(workspaces: T[], workspaceName?: string) {\n  if (workspaces.length === 0) {\n    throw new Error('No workspaces found')\n  }\n\n  if (workspaces.length === 1) {\n    return workspaces[0]\n  }\n\n  if (!workspaceName) {\n    throw new Error(\n      `Multiple workspaces found. Please specify which workspace to use with \"--workspace\". Available workspaces: ${workspaces.map((w) => w.name).join(', ')}`,\n    )\n  }\n\n  const workspace = workspaces.find((w) => w.name === workspaceName)\n\n  if (!workspace) {\n    throw new Error(\n      `Could not find \"${workspaceName}\" workspace. Available workspaces: ${workspaces.map((w) => w.name).join(', ')}`,\n    )\n  }\n\n  return workspace\n}\n"],"names":["getWorkspace","workspaces","workspaceName","length","Error","map","w","name","join","workspace","find"],"mappings":"AAAA,OAAO,SAASA,aAAuCC,UAAe,EAAEC,aAAsB;IAC5F,IAAID,WAAWE,MAAM,KAAK,GAAG;QAC3B,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIH,WAAWE,MAAM,KAAK,GAAG;QAC3B,OAAOF,UAAU,CAAC,EAAE;IACtB;IAEA,IAAI,CAACC,eAAe;QAClB,MAAM,IAAIE,MACR,CAAC,2GAA2G,EAAEH,WAAWI,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,EAAEC,IAAI,CAAC,OAAO;IAE5J;IAEA,MAAMC,YAAYR,WAAWS,IAAI,CAAC,CAACJ,IAAMA,EAAEC,IAAI,KAAKL;IAEpD,IAAI,CAACO,WAAW;QACd,MAAM,IAAIL,MACR,CAAC,gBAAgB,EAAEF,cAAc,mCAAmC,EAAED,WAAWI,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI,EAAEC,IAAI,CAAC,OAAO;IAEpH;IAEA,OAAOC;AACT"}

package/dist/util/humanFileSize.d.ts

@@ -0,0 +1 @@
+export declare function humanFileSize(size: number): string;

package/dist/util/humanFileSize.js

@@ -0,0 +1,12 @@
+export function humanFileSize(size) {
+    const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return `${(size / Math.pow(1024, i)).toFixed(2)} ${[
+        'B',
+        'kB',
+        'MB',
+        'GB',
+        'TB'
+    ][i]}`;
+}
+
+//# sourceMappingURL=humanFileSize.js.map

package/dist/util/humanFileSize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/humanFileSize.ts"],"sourcesContent":["export function humanFileSize(size: number): string {\n  const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024))\n  return `${(size / Math.pow(1024, i)).toFixed(2)} ${['B', 'kB', 'MB', 'GB', 'TB'][i]}`\n}\n"],"names":["humanFileSize","size","i","Math","floor","log","pow","toFixed"],"mappings":"AAAA,OAAO,SAASA,cAAcC,IAAY;IACxC,MAAMC,IAAID,QAAQ,IAAI,IAAIE,KAAKC,KAAK,CAACD,KAAKE,GAAG,CAACJ,QAAQE,KAAKE,GAAG,CAAC;IAC/D,OAAO,GAAG,AAACJ,CAAAA,OAAOE,KAAKG,GAAG,CAAC,MAAMJ,EAAC,EAAGK,OAAO,CAAC,GAAG,CAAC,EAAE;QAAC;QAAK;QAAM;QAAM;QAAM;KAAK,CAACL,EAAE,EAAE;AACvF"}

package/dist/util/importStudioConfig.d.ts

@@ -0,0 +1 @@
+export declare function importStudioConfig(rootPath: string): Promise<import("sanity").Workspace[]>;

package/dist/util/importStudioConfig.js

@@ -0,0 +1,43 @@
+import { findStudioConfigPath, getEmptyAuth, mockBrowserEnvironment, tryGetDefaultExport } from '@sanity/cli-core';
+import { getTsconfig } from 'get-tsconfig';
+import { firstValueFrom, of } from 'rxjs';
+import { resolveConfig } from 'sanity';
+import { tsImport } from 'tsx/esm/api';
+export async function importStudioConfig(rootPath) {
+    const mockBrowserCleanup = await mockBrowserEnvironment(rootPath);
+    try {
+        const tsconfig = getTsconfig(rootPath);
+        const configPath = await findStudioConfigPath(rootPath);
+        if (!configPath) {
+            throw new Error(`Failed to find config in "${rootPath}"`);
+        }
+        let config = await tsImport(configPath, {
+            parentURL: import.meta.url,
+            tsconfig: tsconfig?.path ?? undefined
+        });
+        config = tryGetDefaultExport(config);
+        if (!config) {
+            throw new Error('Invalid CLI config structure');
+        }
+        let workspaces = Array.isArray(config) ? config : [
+            {
+                ...config,
+                basePath: config.basePath || '/',
+                name: config.name || 'default'
+            }
+        ];
+        workspaces = workspaces.map((workspace)=>({
+                ...workspace,
+                auth: {
+                    state: of(getEmptyAuth())
+                }
+            }));
+        return await firstValueFrom(resolveConfig(workspaces));
+    } catch (err) {
+        throw new Error(`Failed to import config: ${err.message}`);
+    } finally{
+        mockBrowserCleanup();
+    }
+}
+
+//# sourceMappingURL=importStudioConfig.js.map

package/dist/util/importStudioConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/importStudioConfig.ts"],"sourcesContent":["import {\n  findStudioConfigPath,\n  getEmptyAuth,\n  mockBrowserEnvironment,\n  tryGetDefaultExport,\n} from '@sanity/cli-core'\nimport {getTsconfig} from 'get-tsconfig'\nimport {firstValueFrom, of} from 'rxjs'\nimport {resolveConfig} from 'sanity'\nimport {tsImport} from 'tsx/esm/api'\n\nexport async function importStudioConfig(rootPath: string) {\n  const mockBrowserCleanup = await mockBrowserEnvironment(rootPath)\n\n  try {\n    const tsconfig = getTsconfig(rootPath)\n    const configPath = await findStudioConfigPath(rootPath)\n\n    if (!configPath) {\n      throw new Error(`Failed to find config in \"${rootPath}\"`)\n    }\n\n    let config = await tsImport(configPath, {\n      parentURL: import.meta.url,\n      tsconfig: tsconfig?.path ?? undefined,\n    })\n\n    config = tryGetDefaultExport(config)\n\n    if (!config) {\n      throw new Error('Invalid CLI config structure')\n    }\n\n    let workspaces = Array.isArray(config)\n      ? config\n      : [{...config, basePath: config.basePath || '/', name: config.name || 'default'}]\n\n    workspaces = workspaces.map((workspace) => ({\n      ...workspace,\n      auth: {state: of(getEmptyAuth())},\n    }))\n\n    return await firstValueFrom(resolveConfig(workspaces))\n  } catch (err) {\n    throw new Error(`Failed to import config: ${err.message}`)\n  } finally {\n    mockBrowserCleanup()\n  }\n}\n"],"names":["findStudioConfigPath","getEmptyAuth","mockBrowserEnvironment","tryGetDefaultExport","getTsconfig","firstValueFrom","of","resolveConfig","tsImport","importStudioConfig","rootPath","mockBrowserCleanup","tsconfig","configPath","Error","config","parentURL","url","path","undefined","workspaces","Array","isArray","basePath","name","map","workspace","auth","state","err","message"],"mappings":"AAAA,SACEA,oBAAoB,EACpBC,YAAY,EACZC,sBAAsB,EACtBC,mBAAmB,QACd,mBAAkB;AACzB,SAAQC,WAAW,QAAO,eAAc;AACxC,SAAQC,cAAc,EAAEC,EAAE,QAAO,OAAM;AACvC,SAAQC,aAAa,QAAO,SAAQ;AACpC,SAAQC,QAAQ,QAAO,cAAa;AAEpC,OAAO,eAAeC,mBAAmBC,QAAgB;IACvD,MAAMC,qBAAqB,MAAMT,uBAAuBQ;IAExD,IAAI;QACF,MAAME,WAAWR,YAAYM;QAC7B,MAAMG,aAAa,MAAMb,qBAAqBU;QAE9C,IAAI,CAACG,YAAY;YACf,MAAM,IAAIC,MAAM,CAAC,0BAA0B,EAAEJ,SAAS,CAAC,CAAC;QAC1D;QAEA,IAAIK,SAAS,MAAMP,SAASK,YAAY;YACtCG,WAAW,YAAYC,GAAG;YAC1BL,UAAUA,UAAUM,QAAQC;QAC9B;QAEAJ,SAASZ,oBAAoBY;QAE7B,IAAI,CAACA,QAAQ;YACX,MAAM,IAAID,MAAM;QAClB;QAEA,IAAIM,aAAaC,MAAMC,OAAO,CAACP,UAC3BA,SACA;YAAC;gBAAC,GAAGA,MAAM;gBAAEQ,UAAUR,OAAOQ,QAAQ,IAAI;gBAAKC,MAAMT,OAAOS,IAAI,IAAI;YAAS;SAAE;QAEnFJ,aAAaA,WAAWK,GAAG,CAAC,CAACC,YAAe,CAAA;gBAC1C,GAAGA,SAAS;gBACZC,MAAM;oBAACC,OAAOtB,GAAGL;gBAAe;YAClC,CAAA;QAEA,OAAO,MAAMI,eAAeE,cAAca;IAC5C,EAAE,OAAOS,KAAK;QACZ,MAAM,IAAIf,MAAM,CAAC,yBAAyB,EAAEe,IAAIC,OAAO,EAAE;IAC3D,SAAU;QACRnB;IACF;AACF"}

package/dist/util/isPathDirName.d.ts

@@ -0,0 +1 @@
+export declare function isPathDirName(filepath: string): boolean;

package/dist/util/isPathDirName.js

@@ -0,0 +1,6 @@
+export function isPathDirName(filepath) {
+    // Check if the path has an extension, commonly indicating a file
+    return !/\.\w+$/.test(filepath);
+}
+
+//# sourceMappingURL=isPathDirName.js.map

package/dist/util/isPathDirName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isPathDirName.ts"],"sourcesContent":["export function isPathDirName(filepath: string): boolean {\n  // Check if the path has an extension, commonly indicating a file\n  return !/\\.\\w+$/.test(filepath)\n}\n"],"names":["isPathDirName","filepath","test"],"mappings":"AAAA,OAAO,SAASA,cAAcC,QAAgB;IAC5C,iEAAiE;IACjE,OAAO,CAAC,SAASC,IAAI,CAACD;AACxB"}

package/dist/util/isSanityDocumentish.d.ts

@@ -0,0 +1,19 @@
+import { type IdentifiedSanityDocumentStub } from '@sanity/client';
+/**
+ * Checks if a document is a Sanity document
+ * @param doc - The document to check
+ * @returns True if the document is a Sanity document, false otherwise
+ *
+ * @internal
+ */
+export declare function isSanityDocumentish(doc: unknown): doc is {
+    _type: string;
+};
+/**
+ * Checks if a document is a Sanity document with an _id
+ * @param doc - The document to check
+ * @returns True if the document is a Sanity document with an _id, false otherwise
+ *
+ * @internal
+ */
+export declare function isIdentifiedSanityDocument(doc: unknown): doc is IdentifiedSanityDocumentStub;

package/dist/util/isSanityDocumentish.js

@@ -0,0 +1,20 @@
+/**
+ * Checks if a document is a Sanity document
+ * @param doc - The document to check
+ * @returns True if the document is a Sanity document, false otherwise
+ *
+ * @internal
+ */ export function isSanityDocumentish(doc) {
+    return doc !== null && typeof doc === 'object' && '_type' in doc && typeof doc._type === 'string';
+}
+/**
+ * Checks if a document is a Sanity document with an _id
+ * @param doc - The document to check
+ * @returns True if the document is a Sanity document with an _id, false otherwise
+ *
+ * @internal
+ */ export function isIdentifiedSanityDocument(doc) {
+    return isSanityDocumentish(doc) && '_id' in doc;
+}
+
+//# sourceMappingURL=isSanityDocumentish.js.map

package/dist/util/isSanityDocumentish.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isSanityDocumentish.ts"],"sourcesContent":["import {type IdentifiedSanityDocumentStub} from '@sanity/client'\n\n/**\n * Checks if a document is a Sanity document\n * @param doc - The document to check\n * @returns True if the document is a Sanity document, false otherwise\n *\n * @internal\n */\nexport function isSanityDocumentish(doc: unknown): doc is {_type: string} {\n  return (\n    doc !== null &&\n    typeof doc === 'object' &&\n    '_type' in doc &&\n    typeof (doc as Record<string, unknown>)._type === 'string'\n  )\n}\n\n/**\n * Checks if a document is a Sanity document with an _id\n * @param doc - The document to check\n * @returns True if the document is a Sanity document with an _id, false otherwise\n *\n * @internal\n */\nexport function isIdentifiedSanityDocument(doc: unknown): doc is IdentifiedSanityDocumentStub {\n  return isSanityDocumentish(doc) && '_id' in doc\n}\n"],"names":["isSanityDocumentish","doc","_type","isIdentifiedSanityDocument"],"mappings":"AAEA;;;;;;CAMC,GACD,OAAO,SAASA,oBAAoBC,GAAY;IAC9C,OACEA,QAAQ,QACR,OAAOA,QAAQ,YACf,WAAWA,OACX,OAAO,AAACA,IAAgCC,KAAK,KAAK;AAEtD;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,2BAA2BF,GAAY;IACrD,OAAOD,oBAAoBC,QAAQ,SAASA;AAC9C"}

package/dist/util/loadEnv.d.ts

@@ -0,0 +1 @@
+export declare function loadEnv(mode: string, envDir: string, _prefixes?: string[]): Record<string, string>;

package/dist/util/loadEnv.js

@@ -0,0 +1,8 @@
+// @todo implement
+export function loadEnv(mode, envDir, _prefixes = [
+    'VITE_'
+]) {
+    return {};
+}
+
+//# sourceMappingURL=loadEnv.js.map

package/dist/util/loadEnv.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/loadEnv.ts"],"sourcesContent":["// @todo implement\nexport function loadEnv(\n  mode: string,\n  envDir: string,\n  _prefixes: string[] = ['VITE_'],\n): Record<string, string> {\n  return {}\n}\n"],"names":["loadEnv","mode","envDir","_prefixes"],"mappings":"AAAA,kBAAkB;AAClB,OAAO,SAASA,QACdC,IAAY,EACZC,MAAc,EACdC,YAAsB;IAAC;CAAQ;IAE/B,OAAO,CAAC;AACV"}

package/dist/util/migration/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MIGRATIONS_DIRECTORY = "migrations";
+export declare const MIGRATION_SCRIPT_EXTENSIONS: string[];
+export declare const DEFAULT_API_VERSION = "v2024-01-29";

package/dist/util/migration/constants.js

@@ -0,0 +1,10 @@
+export const MIGRATIONS_DIRECTORY = 'migrations';
+export const MIGRATION_SCRIPT_EXTENSIONS = [
+    'mjs',
+    'js',
+    'ts',
+    'cjs'
+];
+export const DEFAULT_API_VERSION = 'v2024-01-29';
+
+//# sourceMappingURL=constants.js.map

package/dist/util/migration/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/migration/constants.ts"],"sourcesContent":["export const MIGRATIONS_DIRECTORY = 'migrations'\nexport const MIGRATION_SCRIPT_EXTENSIONS = ['mjs', 'js', 'ts', 'cjs']\nexport const DEFAULT_API_VERSION = 'v2024-01-29'\n"],"names":["MIGRATIONS_DIRECTORY","MIGRATION_SCRIPT_EXTENSIONS","DEFAULT_API_VERSION"],"mappings":"AAAA,OAAO,MAAMA,uBAAuB,aAAY;AAChD,OAAO,MAAMC,8BAA8B;IAAC;IAAO;IAAM;IAAM;CAAM,CAAA;AACrE,OAAO,MAAMC,sBAAsB,cAAa"}

package/dist/util/migration/ensureApiVersionFormat.d.ts

@@ -0,0 +1,9 @@
+import { type APIConfig } from '@sanity/migrate';
+type ApiVersion = APIConfig['apiVersion'];
+/**
+ * Ensures that the provided API version string is in the correct format.
+ * If the version does not start with 'v', it will be prefixed with 'v'.
+ * If the version does not match the expected pattern, an error will be thrown.
+ */
+export declare function ensureApiVersionFormat(version: string): ApiVersion;
+export {};

package/dist/util/migration/ensureApiVersionFormat.js

@@ -0,0 +1,16 @@
+const VERSION_PATTERN = /^v\d+-\d+-\d+$|^vX$/ // Matches version strings like vYYYY-MM-DD or vX
+;
+/**
+ * Ensures that the provided API version string is in the correct format.
+ * If the version does not start with 'v', it will be prefixed with 'v'.
+ * If the version does not match the expected pattern, an error will be thrown.
+ */ export function ensureApiVersionFormat(version) {
+    const normalizedVersion = version.startsWith('v') ? version : `v${version}`;
+    // Check if the version matches the expected pattern
+    if (!VERSION_PATTERN.test(normalizedVersion)) {
+        throw new Error(`Invalid API version format: ${normalizedVersion}. Expected format: vYYYY-MM-DD or vX`);
+    }
+    return normalizedVersion;
+}
+
+//# sourceMappingURL=ensureApiVersionFormat.js.map

package/dist/util/migration/ensureApiVersionFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/migration/ensureApiVersionFormat.ts"],"sourcesContent":["import {type APIConfig} from '@sanity/migrate'\n\ntype ApiVersion = APIConfig['apiVersion']\n\nconst VERSION_PATTERN = /^v\\d+-\\d+-\\d+$|^vX$/ // Matches version strings like vYYYY-MM-DD or vX\n\n/**\n * Ensures that the provided API version string is in the correct format.\n * If the version does not start with 'v', it will be prefixed with 'v'.\n * If the version does not match the expected pattern, an error will be thrown.\n */\nexport function ensureApiVersionFormat(version: string): ApiVersion {\n  const normalizedVersion = version.startsWith('v') ? version : `v${version}`\n\n  // Check if the version matches the expected pattern\n  if (!VERSION_PATTERN.test(normalizedVersion)) {\n    throw new Error(\n      `Invalid API version format: ${normalizedVersion}. Expected format: vYYYY-MM-DD or vX`,\n    )\n  }\n\n  return normalizedVersion as ApiVersion\n}\n"],"names":["VERSION_PATTERN","ensureApiVersionFormat","version","normalizedVersion","startsWith","test","Error"],"mappings":"AAIA,MAAMA,kBAAkB,sBAAsB,iDAAiD;;AAE/F;;;;CAIC,GACD,OAAO,SAASC,uBAAuBC,OAAe;IACpD,MAAMC,oBAAoBD,QAAQE,UAAU,CAAC,OAAOF,UAAU,CAAC,CAAC,EAAEA,SAAS;IAE3E,oDAAoD;IACpD,IAAI,CAACF,gBAAgBK,IAAI,CAACF,oBAAoB;QAC5C,MAAM,IAAIG,MACR,CAAC,4BAA4B,EAAEH,kBAAkB,oCAAoC,CAAC;IAE1F;IAEA,OAAOA;AACT"}

package/dist/util/migration/prettyMutationFormatter.d.ts

@@ -0,0 +1,8 @@
+import { type Migration, type Mutation, type Transaction } from '@sanity/migrate';
+interface FormatterOptions<Subject> {
+    migration: Migration;
+    subject: Subject;
+    indentSize?: number;
+}
+export declare function prettyFormat({ indentSize, migration, subject, }: FormatterOptions<(Mutation | Transaction)[] | Mutation | Transaction>): string;
+export {};

package/dist/util/migration/prettyMutationFormatter.js

@@ -0,0 +1,141 @@
+import { isatty } from 'node:tty';
+import { convertToTree, formatTree, maxKeyLength } from '@sanity/cli-core/tree';
+import { chalk } from '@sanity/cli-core/ux';
+const isTty = isatty(1);
+export function prettyFormat({ indentSize = 0, migration, subject }) {
+    return (Array.isArray(subject) ? subject : [
+        subject
+    ]).map((subjectEntry)=>{
+        if (subjectEntry.type === 'transaction') {
+            return [
+                [
+                    badge('transaction', 'info'),
+                    subjectEntry.id === undefined ? null : chalk.underline(subjectEntry.id)
+                ].filter(Boolean).join(' '),
+                indent(prettyFormat({
+                    indentSize: indentSize,
+                    migration,
+                    subject: subjectEntry.mutations
+                }))
+            ].join('\n\n');
+        }
+        return prettyFormatMutation({
+            indentSize,
+            migration,
+            subject: subjectEntry
+        });
+    }).join('\n\n');
+}
+function encodeItemRef(ref) {
+    return typeof ref === 'number' ? ref : ref._key;
+}
+function badgeStyle(variant) {
+    const styles = {
+        destructive: chalk.bgRed.black.bold,
+        incremental: chalk.bgGreen.black.bold,
+        info: chalk.bgWhite.black,
+        maybeDestructive: chalk.bgYellow.black.bold
+    };
+    return styles[variant];
+}
+function badge(label, variant) {
+    if (!isTty) {
+        return `[${label}]`;
+    }
+    return badgeStyle(variant)(` ${label} `);
+}
+const mutationImpact = {
+    create: 'incremental',
+    createIfNotExists: 'incremental',
+    createOrReplace: 'maybeDestructive',
+    delete: 'destructive',
+    patch: 'maybeDestructive'
+};
+function documentId(mutation) {
+    if ('id' in mutation) {
+        return mutation.id;
+    }
+    if ('document' in mutation) {
+        return mutation.document._id;
+    }
+    return undefined;
+}
+const listFormatter = new Intl.ListFormat('en-US', {
+    type: 'disjunction'
+});
+function mutationHeader(mutation, migration) {
+    const mutationType = badge(mutation.type, mutationImpact[mutation.type]);
+    const documentType = 'document' in mutation || migration.documentTypes ? badge('document' in mutation ? mutation.document._type : listFormatter.format(migration.documentTypes ?? []), 'info') : null;
+    // TODO: Should we list documentType when a mutation can be yielded for any document type?
+    return [
+        mutationType,
+        documentType,
+        chalk.underline(documentId(mutation))
+    ].filter(Boolean).join(' ');
+}
+function prettyFormatMutation({ indentSize = 0, migration, subject }) {
+    const lock = 'options' in subject ? chalk.cyan(`(if revision==${subject.options?.ifRevision})`) : '';
+    const header = [
+        mutationHeader(subject, migration),
+        lock
+    ].join(' ');
+    const padding = ' '.repeat(indentSize);
+    if (subject.type === 'create' || subject.type === 'createIfNotExists' || subject.type === 'createOrReplace') {
+        return [
+            header,
+            '\n',
+            indent(JSON.stringify(subject.document, null, 2), indentSize)
+        ].join('');
+    }
+    if (subject.type === 'patch') {
+        const tree = convertToTree(subject.patches.flat());
+        const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30);
+        return [
+            header,
+            '\n',
+            formatTree({
+                getMessage: (patch)=>formatPatchMutation(patch),
+                indent: padding,
+                node: tree.children,
+                paddingLength
+            })
+        ].join('');
+    }
+    return header;
+}
+function formatPatchMutation(patch) {
+    const { op } = patch;
+    const formattedType = chalk.bold(op.type);
+    if (op.type === 'unset') {
+        return `${chalk.red(formattedType)}()`;
+    }
+    if (op.type === 'diffMatchPatch') {
+        return `${chalk.yellow(formattedType)}(${op.value})`;
+    }
+    if (op.type === 'inc' || op.type === 'dec') {
+        return `${chalk.yellow(formattedType)}(${op.amount})`;
+    }
+    if (op.type === 'set') {
+        return `${chalk.yellow(formattedType)}(${JSON.stringify(op.value)})`;
+    }
+    if (op.type === 'setIfMissing') {
+        return `${chalk.green(formattedType)}(${JSON.stringify(op.value)})`;
+    }
+    if (op.type === 'insert') {
+        return `${chalk.green(formattedType)}(${op.position}, ${encodeItemRef(op.referenceItem)}, ${JSON.stringify(op.items)})`;
+    }
+    if (op.type === 'replace') {
+        return `${chalk.yellow(formattedType)}(${encodeItemRef(op.referenceItem)}, ${JSON.stringify(op.items)})`;
+    }
+    if (op.type === 'truncate') {
+        return `${chalk.red(formattedType)}(${op.startIndex}, ${op.endIndex})`;
+    }
+    // @ts-expect-error all cases are covered
+    throw new Error(`Invalid operation type: ${op.type}`);
+}
+function indent(subject, size = 2) {
+    const padding = ' '.repeat(size);
+    return subject.split('\n').map((line)=>padding + line).join('\n');
+}
+
+//# sourceMappingURL=prettyMutationFormatter.js.map