@sanity/cli 5.9.0-next.8 → 6.0.0-alpha.11

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

@@ -0,0 +1,3 @@
+export { loadEnv } from 'vite';
+
+//# sourceMappingURL=loadEnv.js.map

package/dist/util/loadEnv.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/loadEnv.ts"],"sourcesContent":["export {loadEnv} from 'vite'\n"],"names":["loadEnv"],"mappings":"AAAA,SAAQA,OAAO,QAAO,OAAM"}

package/dist/util/moduleFormatUtils.js

@@ -0,0 +1,18 @@
+import { formatSize } from './formatSize.js';
+export function formatModuleSizes(modules) {
+    const lines = [];
+    for (const mod of modules){
+        lines.push(` - ${formatModuleName(mod.name)} (${formatSize(mod.renderedLength)})`);
+    }
+    return lines.join('\n');
+}
+function formatModuleName(modName) {
+    const delimiter = '/node_modules/';
+    const nodeIndex = modName.lastIndexOf(delimiter);
+    return nodeIndex === -1 ? modName : modName.slice(nodeIndex + delimiter.length);
+}
+export function sortModulesBySize(chunks) {
+    return chunks.flatMap((chunk)=>chunk.modules).toSorted((modA, modB)=>modB.renderedLength - modA.renderedLength);
+}
+
+//# sourceMappingURL=moduleFormatUtils.js.map

package/dist/util/moduleFormatUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/moduleFormatUtils.ts"],"sourcesContent":["import {type ChunkModule, type ChunkStats} from '../actions/build/buildStaticFiles.js'\nimport {formatSize} from './formatSize.js'\n\nexport function formatModuleSizes(modules: ChunkModule[]): string {\n  const lines: string[] = []\n  for (const mod of modules) {\n    lines.push(` - ${formatModuleName(mod.name)} (${formatSize(mod.renderedLength)})`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction formatModuleName(modName: string): string {\n  const delimiter = '/node_modules/'\n  const nodeIndex = modName.lastIndexOf(delimiter)\n  return nodeIndex === -1 ? modName : modName.slice(nodeIndex + delimiter.length)\n}\n\nexport function sortModulesBySize(chunks: ChunkStats[]): ChunkModule[] {\n  return chunks\n    .flatMap((chunk) => chunk.modules)\n    .toSorted((modA, modB) => modB.renderedLength - modA.renderedLength)\n}\n"],"names":["formatSize","formatModuleSizes","modules","lines","mod","push","formatModuleName","name","renderedLength","join","modName","delimiter","nodeIndex","lastIndexOf","slice","length","sortModulesBySize","chunks","flatMap","chunk","toSorted","modA","modB"],"mappings":"AACA,SAAQA,UAAU,QAAO,kBAAiB;AAE1C,OAAO,SAASC,kBAAkBC,OAAsB;IACtD,MAAMC,QAAkB,EAAE;IAC1B,KAAK,MAAMC,OAAOF,QAAS;QACzBC,MAAME,IAAI,CAAC,CAAC,GAAG,EAAEC,iBAAiBF,IAAIG,IAAI,EAAE,EAAE,EAAEP,WAAWI,IAAII,cAAc,EAAE,CAAC,CAAC;IACnF;IAEA,OAAOL,MAAMM,IAAI,CAAC;AACpB;AAEA,SAASH,iBAAiBI,OAAe;IACvC,MAAMC,YAAY;IAClB,MAAMC,YAAYF,QAAQG,WAAW,CAACF;IACtC,OAAOC,cAAc,CAAC,IAAIF,UAAUA,QAAQI,KAAK,CAACF,YAAYD,UAAUI,MAAM;AAChF;AAEA,OAAO,SAASC,kBAAkBC,MAAoB;IACpD,OAAOA,OACJC,OAAO,CAAC,CAACC,QAAUA,MAAMjB,OAAO,EAChCkB,QAAQ,CAAC,CAACC,MAAMC,OAASA,KAAKd,cAAc,GAAGa,KAAKb,cAAc;AACvE"}

package/dist/util/packageManager/installPackages.js

@@ -0,0 +1,87 @@
+import { spinner } from '@sanity/cli-core/ux';
+import { execa } from 'execa';
+import { getPartialEnvWithNpmPath } from './packageManagerChoice.js';
+const PACKAGE_MANAGER_COMMANDS = {
+    add: {
+        bun: (packages)=>[
+                'add',
+                ...packages
+            ],
+        npm: (packages)=>[
+                'install',
+                '--save',
+                ...packages
+            ],
+        pnpm: (packages)=>[
+                'add',
+                '--save-prod',
+                ...packages
+            ],
+        yarn: (packages)=>[
+                'add',
+                ...packages
+            ]
+    },
+    install: {
+        bun: [
+            'install'
+        ],
+        npm: [
+            'install'
+        ],
+        pnpm: [
+            'install'
+        ],
+        yarn: [
+            'install'
+        ]
+    }
+};
+async function executePackageManagerCommand(packageManager, args, execOptions, output, errorMessage) {
+    const progress = spinner(`Running ${packageManager} ${args.join(' ')}\n`).start();
+    const result = await execa(packageManager, args, execOptions);
+    if (result?.exitCode || result?.failed) {
+        progress.fail();
+        output.log(String(result.stdout));
+        output.error(errorMessage, {
+            exit: 1
+        });
+    } else {
+        progress.succeed();
+    }
+}
+export async function installDeclaredPackages(cwd, packageManager, context) {
+    const { output } = context;
+    const execOptions = {
+        cwd,
+        encoding: 'utf8',
+        env: getPartialEnvWithNpmPath(cwd),
+        stdio: 'pipe'
+    };
+    if (packageManager === 'manual') {
+        const npmCommand = PACKAGE_MANAGER_COMMANDS.install.npm;
+        output.log(`Manual installation selected — run 'npm ${npmCommand.join(' ')}' or equivalent`);
+    } else {
+        const args = PACKAGE_MANAGER_COMMANDS.install[packageManager];
+        await executePackageManagerCommand(packageManager, args, execOptions, output, 'Dependency installation failed');
+    }
+}
+export async function installNewPackages(options, context) {
+    const { packageManager, packages } = options;
+    const { output, workDir } = context;
+    const execOptions = {
+        cwd: workDir,
+        encoding: 'utf8',
+        env: getPartialEnvWithNpmPath(workDir),
+        stdio: 'pipe'
+    };
+    if (packageManager === 'manual') {
+        const npmCommand = PACKAGE_MANAGER_COMMANDS.add.npm(packages);
+        output.log(`Manual installation selected - run 'npm ${npmCommand.join(' ')}' or equivalent`);
+    } else {
+        const args = PACKAGE_MANAGER_COMMANDS.add[packageManager](packages);
+        await executePackageManagerCommand(packageManager, args, execOptions, output, 'Package installation failed');
+    }
+}
+
+//# sourceMappingURL=installPackages.js.map

package/dist/util/packageManager/installPackages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/packageManager/installPackages.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport {execa, type Options} from 'execa'\n\nimport {getPartialEnvWithNpmPath, type PackageManager} from './packageManagerChoice.js'\n\ntype PackageManagerLibs = Exclude<PackageManager, 'manual'>\n\n/**\n * @internal\n */\ninterface InstallOptions {\n  packageManager: PackageManager\n  packages: string[]\n}\n\ninterface PackageManagerCommands {\n  add: {[key in PackageManagerLibs]: (packages: string[]) => string[]}\n  install: {[key in PackageManagerLibs]: string[]}\n}\n\nconst PACKAGE_MANAGER_COMMANDS: PackageManagerCommands = {\n  add: {\n    bun: (packages) => ['add', ...packages],\n    npm: (packages) => ['install', '--save', ...packages],\n    pnpm: (packages) => ['add', '--save-prod', ...packages],\n    yarn: (packages) => ['add', ...packages],\n  },\n  install: {\n    bun: ['install'],\n    npm: ['install'],\n    pnpm: ['install'],\n    yarn: ['install'],\n  },\n}\n\nasync function executePackageManagerCommand(\n  packageManager: PackageManagerLibs,\n  args: string[],\n  execOptions: Options,\n  output: Output,\n  errorMessage: string,\n): Promise<void> {\n  const progress = spinner(`Running ${packageManager} ${args.join(' ')}\\n`).start()\n\n  const result = await execa(packageManager, args, execOptions)\n\n  if (result?.exitCode || result?.failed) {\n    progress.fail()\n    output.log(String(result.stdout))\n    output.error(errorMessage, {exit: 1})\n  } else {\n    progress.succeed()\n  }\n}\n\nexport async function installDeclaredPackages(\n  cwd: string,\n  packageManager: PackageManager,\n  context: {output: Output; workDir: string},\n): Promise<void> {\n  const {output} = context\n  const execOptions: Options = {\n    cwd,\n    encoding: 'utf8',\n    env: getPartialEnvWithNpmPath(cwd),\n    stdio: 'pipe',\n  }\n\n  if (packageManager === 'manual') {\n    const npmCommand = PACKAGE_MANAGER_COMMANDS.install.npm\n    output.log(`Manual installation selected — run 'npm ${npmCommand.join(' ')}' or equivalent`)\n  } else {\n    const args = PACKAGE_MANAGER_COMMANDS.install[packageManager]\n    await executePackageManagerCommand(\n      packageManager,\n      args,\n      execOptions,\n      output,\n      'Dependency installation failed',\n    )\n  }\n}\n\nexport async function installNewPackages(\n  options: InstallOptions,\n  context: {output: Output; workDir: string},\n): Promise<void> {\n  const {packageManager, packages} = options\n  const {output, workDir} = context\n  const execOptions: Options = {\n    cwd: workDir,\n    encoding: 'utf8',\n    env: getPartialEnvWithNpmPath(workDir),\n    stdio: 'pipe',\n  }\n\n  if (packageManager === 'manual') {\n    const npmCommand = PACKAGE_MANAGER_COMMANDS.add.npm(packages)\n    output.log(`Manual installation selected - run 'npm ${npmCommand.join(' ')}' or equivalent`)\n  } else {\n    const args = PACKAGE_MANAGER_COMMANDS.add[packageManager](packages)\n    await executePackageManagerCommand(\n      packageManager,\n      args,\n      execOptions,\n      output,\n      'Package installation failed',\n    )\n  }\n}\n"],"names":["spinner","execa","getPartialEnvWithNpmPath","PACKAGE_MANAGER_COMMANDS","add","bun","packages","npm","pnpm","yarn","install","executePackageManagerCommand","packageManager","args","execOptions","output","errorMessage","progress","join","start","result","exitCode","failed","fail","log","String","stdout","error","exit","succeed","installDeclaredPackages","cwd","context","encoding","env","stdio","npmCommand","installNewPackages","options","workDir"],"mappings":"AACA,SAAQA,OAAO,QAAO,sBAAqB;AAC3C,SAAQC,KAAK,QAAqB,QAAO;AAEzC,SAAQC,wBAAwB,QAA4B,4BAA2B;AAiBvF,MAAMC,2BAAmD;IACvDC,KAAK;QACHC,KAAK,CAACC,WAAa;gBAAC;mBAAUA;aAAS;QACvCC,KAAK,CAACD,WAAa;gBAAC;gBAAW;mBAAaA;aAAS;QACrDE,MAAM,CAACF,WAAa;gBAAC;gBAAO;mBAAkBA;aAAS;QACvDG,MAAM,CAACH,WAAa;gBAAC;mBAAUA;aAAS;IAC1C;IACAI,SAAS;QACPL,KAAK;YAAC;SAAU;QAChBE,KAAK;YAAC;SAAU;QAChBC,MAAM;YAAC;SAAU;QACjBC,MAAM;YAAC;SAAU;IACnB;AACF;AAEA,eAAeE,6BACbC,cAAkC,EAClCC,IAAc,EACdC,WAAoB,EACpBC,MAAc,EACdC,YAAoB;IAEpB,MAAMC,WAAWjB,QAAQ,CAAC,QAAQ,EAAEY,eAAe,CAAC,EAAEC,KAAKK,IAAI,CAAC,KAAK,EAAE,CAAC,EAAEC,KAAK;IAE/E,MAAMC,SAAS,MAAMnB,MAAMW,gBAAgBC,MAAMC;IAEjD,IAAIM,QAAQC,YAAYD,QAAQE,QAAQ;QACtCL,SAASM,IAAI;QACbR,OAAOS,GAAG,CAACC,OAAOL,OAAOM,MAAM;QAC/BX,OAAOY,KAAK,CAACX,cAAc;YAACY,MAAM;QAAC;IACrC,OAAO;QACLX,SAASY,OAAO;IAClB;AACF;AAEA,OAAO,eAAeC,wBACpBC,GAAW,EACXnB,cAA8B,EAC9BoB,OAA0C;IAE1C,MAAM,EAACjB,MAAM,EAAC,GAAGiB;IACjB,MAAMlB,cAAuB;QAC3BiB;QACAE,UAAU;QACVC,KAAKhC,yBAAyB6B;QAC9BI,OAAO;IACT;IAEA,IAAIvB,mBAAmB,UAAU;QAC/B,MAAMwB,aAAajC,yBAAyBO,OAAO,CAACH,GAAG;QACvDQ,OAAOS,GAAG,CAAC,CAAC,wCAAwC,EAAEY,WAAWlB,IAAI,CAAC,KAAK,eAAe,CAAC;IAC7F,OAAO;QACL,MAAML,OAAOV,yBAAyBO,OAAO,CAACE,eAAe;QAC7D,MAAMD,6BACJC,gBACAC,MACAC,aACAC,QACA;IAEJ;AACF;AAEA,OAAO,eAAesB,mBACpBC,OAAuB,EACvBN,OAA0C;IAE1C,MAAM,EAACpB,cAAc,EAAEN,QAAQ,EAAC,GAAGgC;IACnC,MAAM,EAACvB,MAAM,EAAEwB,OAAO,EAAC,GAAGP;IAC1B,MAAMlB,cAAuB;QAC3BiB,KAAKQ;QACLN,UAAU;QACVC,KAAKhC,yBAAyBqC;QAC9BJ,OAAO;IACT;IAEA,IAAIvB,mBAAmB,UAAU;QAC/B,MAAMwB,aAAajC,yBAAyBC,GAAG,CAACG,GAAG,CAACD;QACpDS,OAAOS,GAAG,CAAC,CAAC,wCAAwC,EAAEY,WAAWlB,IAAI,CAAC,KAAK,eAAe,CAAC;IAC7F,OAAO;QACL,MAAML,OAAOV,yBAAyBC,GAAG,CAACQ,eAAe,CAACN;QAC1D,MAAMK,6BACJC,gBACAC,MACAC,aACAC,QACA;IAEJ;AACF"}

package/dist/util/packageManager/packageManagerChoice.js

@@ -0,0 +1,181 @@
+import path from 'node:path';
+import { isInteractive } from '@sanity/cli-core';
+import { select } from '@sanity/cli-core/ux';
+// eslint-disable-next-line unicorn/no-named-default
+import { default as preferredPM } from 'preferred-pm';
+import which from 'which';
+const EXPERIMENTAL = new Set([
+    'bun'
+]);
+export const ALLOWED_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn',
+    'pnpm',
+    'bun',
+    'manual'
+];
+export const allowedPackageManagersString = ALLOWED_PACKAGE_MANAGERS.join(' | ');
+/**
+ * Attempts to resolve the most optimal package manager to use to install/upgrade
+ * packages/dependencies at a given path. It does so by looking for package manager
+ * specific lockfiles. If it finds a lockfile belonging to a certain package manager,
+ * it prioritizes this one. However, if that package manager is not installed, it will
+ * prompt the user for which one they want to use and hint at the most optimal one
+ * not being installed.
+ *
+ * Note that this function also takes local npm binary paths into account - for instance,
+ * `yarn` can be installed as a dependency of the project instead of globally, and it
+ * will use that is available.
+ *
+ * The user can also select 'manual' to skip the process and run their preferred package
+ * manager manually. Commands using this function must take this `manual` choice into
+ * account and act accordingly if chosen.
+ *
+ * @param workDir - The working directory where a lockfile is most likely to be present
+ * @param options - Pass `interactive: false` to fall back to npm if most optimal is
+ *                  not available, instead of prompting
+ * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice
+ */ export async function getPackageManagerChoice(workDir, options) {
+    const rootDir = workDir || process.cwd();
+    const preferred = (await preferredPM(rootDir))?.name;
+    if (preferred && await hasCommand(preferred, rootDir)) {
+        // There is an optimal/preferred package manager, and the user has it installed!
+        return {
+            chosen: preferred,
+            mostOptimal: preferred
+        };
+    }
+    const mostLikelyPM = await getMostLikelyInstalledPackageManager(rootDir);
+    const interactive = typeof options.interactive === 'boolean' ? options.interactive : isInteractive();
+    if (!interactive) {
+        // We can't ask the user for their preference, so fall back to either the one that is being run
+        // or whatever is installed on the system (npm being the preferred choice).
+        // Note that the most optimal choice is already picked above if available.
+        return {
+            chosen: mostLikelyPM || await getFallback(rootDir),
+            mostOptimal: preferred
+        };
+    }
+    // We can ask the user for their preference, hurray!
+    const messageSuffix = preferred ? ` (preferred is ${preferred}, but is not installed)` : '';
+    const installed = await getAvailablePackageManagers(rootDir);
+    const chosen = await select({
+        choices: installed.map((pm)=>({
+                name: EXPERIMENTAL.has(pm) ? `${pm} (experimental)` : pm,
+                value: pm
+            })),
+        default: preferred || mostLikelyPM,
+        message: `Package manager to use for installing dependencies?${messageSuffix}`
+    });
+    return {
+        chosen,
+        mostOptimal: preferred
+    };
+}
+async function getFallback(cwd) {
+    if (await hasNpmInstalled(cwd)) {
+        return 'npm';
+    }
+    if (await hasYarnInstalled(cwd)) {
+        return 'yarn';
+    }
+    if (await hasPnpmInstalled(cwd)) {
+        return 'pnpm';
+    }
+    if (await hasBunInstalled(cwd)) {
+        return 'bun';
+    }
+    return 'manual';
+}
+async function getAvailablePackageManagers(cwd) {
+    const [npm, yarn, pnpm, bun] = await Promise.all([
+        hasNpmInstalled(cwd),
+        hasYarnInstalled(cwd),
+        hasPnpmInstalled(cwd),
+        hasBunInstalled(cwd)
+    ]);
+    const choices = [
+        npm && 'npm',
+        yarn && 'yarn',
+        pnpm && 'pnpm',
+        bun && 'bun',
+        'manual'
+    ];
+    return choices.filter((pm)=>pm !== false);
+}
+function hasNpmInstalled(cwd) {
+    return hasCommand('npm', cwd);
+}
+function hasYarnInstalled(cwd) {
+    return hasCommand('yarn', cwd);
+}
+function hasPnpmInstalled(cwd) {
+    return hasCommand('pnpm', cwd);
+}
+function hasBunInstalled(cwd) {
+    return hasCommand('bun', cwd);
+}
+function getNpmRunPath(cwd) {
+    let previous;
+    let cwdPath = path.resolve(cwd);
+    const result = [];
+    while(previous !== cwdPath){
+        result.push(path.join(cwdPath, 'node_modules', '.bin'));
+        previous = cwdPath;
+        cwdPath = path.resolve(cwdPath, '..');
+    }
+    result.push(path.resolve(cwd, process.execPath, '..'));
+    const pathEnv = process.env[getPathEnvVarKey()];
+    return [
+        ...result,
+        pathEnv
+    ].join(path.delimiter);
+}
+export function getPartialEnvWithNpmPath(cwd) {
+    const key = getPathEnvVarKey();
+    return {
+        [key]: getNpmRunPath(cwd)
+    };
+}
+function getPathEnvVarKey() {
+    if (process.platform !== 'win32') {
+        return 'PATH';
+    }
+    return Object.keys(process.env).toReversed().find((key)=>key.toUpperCase() === 'PATH') || 'Path';
+}
+function getCommandPath(cmd, cwd) {
+    const options = cwd ? {
+        path: getNpmRunPath(cwd)
+    } : undefined;
+    return which(cmd, options).catch(()=>null);
+}
+function hasCommand(cmd, cwd) {
+    return getCommandPath(cmd, cwd).then((cmdPath)=>cmdPath !== null);
+}
+async function getMostLikelyInstalledPackageManager(rootDir) {
+    const installed = await getAvailablePackageManagers(rootDir);
+    const running = getRunningPackageManager();
+    return running && installed.includes(running) ? running : undefined;
+}
+function getRunningPackageManager() {
+    // Yes, the env var is lowercase - it is set by the package managers themselves
+    const agent = process.env.npm_config_user_agent || '';
+    if (agent.includes('yarn')) {
+        return 'yarn';
+    }
+    if (agent.includes('pnpm')) {
+        return 'pnpm';
+    }
+    if (agent.includes('bun')) {
+        return 'bun';
+    }
+    // Both yarn and pnpm does a `npm/?` thing, thus the slightly different match here
+    // Theoretically not needed since we check for yarn/pnpm above, but in case other
+    // package managers do the same thing, we'll (hopefully) catch them here.
+    if (/^npm\/\d/.test(agent)) {
+        return 'npm';
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=packageManagerChoice.js.map

package/dist/util/packageManager/packageManagerChoice.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/packageManager/packageManagerChoice.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {isInteractive} from '@sanity/cli-core'\nimport {select} from '@sanity/cli-core/ux'\n// eslint-disable-next-line unicorn/no-named-default\nimport {default as preferredPM} from 'preferred-pm'\nimport which from 'which'\n\nexport type PackageManager = 'bun' | 'manual' | 'npm' | 'pnpm' | 'yarn'\n\nconst EXPERIMENTAL = new Set(['bun'])\n\nexport const ALLOWED_PACKAGE_MANAGERS: readonly PackageManager[] = [\n  'npm',\n  'yarn',\n  'pnpm',\n  'bun',\n  'manual',\n] as const\n\nexport const allowedPackageManagersString = ALLOWED_PACKAGE_MANAGERS.join(' | ')\n\n/**\n * Attempts to resolve the most optimal package manager to use to install/upgrade\n * packages/dependencies at a given path. It does so by looking for package manager\n * specific lockfiles. If it finds a lockfile belonging to a certain package manager,\n * it prioritizes this one. However, if that package manager is not installed, it will\n * prompt the user for which one they want to use and hint at the most optimal one\n * not being installed.\n *\n * Note that this function also takes local npm binary paths into account - for instance,\n * `yarn` can be installed as a dependency of the project instead of globally, and it\n * will use that is available.\n *\n * The user can also select 'manual' to skip the process and run their preferred package\n * manager manually. Commands using this function must take this `manual` choice into\n * account and act accordingly if chosen.\n *\n * @param workDir - The working directory where a lockfile is most likely to be present\n * @param options - Pass `interactive: false` to fall back to npm if most optimal is\n *                  not available, instead of prompting\n * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice\n */\nexport async function getPackageManagerChoice(\n  workDir: string,\n  options: {interactive: boolean},\n): Promise<{chosen: PackageManager; mostOptimal?: PackageManager}> {\n  const rootDir = workDir || process.cwd()\n  const preferred = (await preferredPM(rootDir))?.name\n\n  if (preferred && (await hasCommand(preferred, rootDir))) {\n    // There is an optimal/preferred package manager, and the user has it installed!\n    return {chosen: preferred, mostOptimal: preferred}\n  }\n\n  const mostLikelyPM = await getMostLikelyInstalledPackageManager(rootDir)\n  const interactive =\n    typeof options.interactive === 'boolean' ? options.interactive : isInteractive()\n  if (!interactive) {\n    // We can't ask the user for their preference, so fall back to either the one that is being run\n    // or whatever is installed on the system (npm being the preferred choice).\n    // Note that the most optimal choice is already picked above if available.\n    return {chosen: mostLikelyPM || (await getFallback(rootDir)), mostOptimal: preferred}\n  }\n\n  // We can ask the user for their preference, hurray!\n  const messageSuffix = preferred ? ` (preferred is ${preferred}, but is not installed)` : ''\n  const installed = await getAvailablePackageManagers(rootDir)\n  const chosen = await select<PackageManager>({\n    choices: installed.map((pm) => ({\n      name: EXPERIMENTAL.has(pm) ? `${pm} (experimental)` : pm,\n      value: pm,\n    })),\n    default: preferred || mostLikelyPM,\n    message: `Package manager to use for installing dependencies?${messageSuffix}`,\n  })\n\n  return {chosen, mostOptimal: preferred}\n}\n\nasync function getFallback(cwd: string): Promise<PackageManager> {\n  if (await hasNpmInstalled(cwd)) {\n    return 'npm'\n  }\n\n  if (await hasYarnInstalled(cwd)) {\n    return 'yarn'\n  }\n\n  if (await hasPnpmInstalled(cwd)) {\n    return 'pnpm'\n  }\n\n  if (await hasBunInstalled(cwd)) {\n    return 'bun'\n  }\n\n  return 'manual'\n}\n\nasync function getAvailablePackageManagers(cwd: string): Promise<PackageManager[]> {\n  const [npm, yarn, pnpm, bun] = await Promise.all([\n    hasNpmInstalled(cwd),\n    hasYarnInstalled(cwd),\n    hasPnpmInstalled(cwd),\n    hasBunInstalled(cwd),\n  ])\n\n  const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm', bun && 'bun', 'manual']\n  return choices.filter((pm): pm is PackageManager => pm !== false)\n}\n\nfunction hasNpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('npm', cwd)\n}\n\nfunction hasYarnInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('yarn', cwd)\n}\n\nfunction hasPnpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('pnpm', cwd)\n}\n\nfunction hasBunInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('bun', cwd)\n}\n\nfunction getNpmRunPath(cwd: string): string {\n  let previous\n  let cwdPath = path.resolve(cwd)\n  const result: string[] = []\n\n  while (previous !== cwdPath) {\n    result.push(path.join(cwdPath, 'node_modules', '.bin'))\n    previous = cwdPath\n    cwdPath = path.resolve(cwdPath, '..')\n  }\n\n  result.push(path.resolve(cwd, process.execPath, '..'))\n\n  const pathEnv = process.env[getPathEnvVarKey()]\n  return [...result, pathEnv].join(path.delimiter)\n}\n\nexport function getPartialEnvWithNpmPath(cwd: string): NodeJS.ProcessEnv {\n  const key = getPathEnvVarKey()\n  return {[key]: getNpmRunPath(cwd)}\n}\n\nfunction getPathEnvVarKey(): string {\n  if (process.platform !== 'win32') {\n    return 'PATH'\n  }\n\n  return (\n    Object.keys(process.env)\n      .toReversed()\n      .find((key) => key.toUpperCase() === 'PATH') || 'Path'\n  )\n}\n\nfunction getCommandPath(cmd: string, cwd?: string): Promise<string | null> {\n  const options = cwd ? {path: getNpmRunPath(cwd)} : undefined\n  return which(cmd, options).catch(() => null)\n}\n\nfunction hasCommand(cmd: string, cwd?: string): Promise<boolean> {\n  return getCommandPath(cmd, cwd).then((cmdPath) => cmdPath !== null)\n}\n\nasync function getMostLikelyInstalledPackageManager(\n  rootDir: string,\n): Promise<PackageManager | undefined> {\n  const installed = await getAvailablePackageManagers(rootDir)\n  const running = getRunningPackageManager()\n  return running && installed.includes(running) ? running : undefined\n}\n\nfunction getRunningPackageManager(): PackageManager | undefined {\n  // Yes, the env var is lowercase - it is set by the package managers themselves\n  const agent = process.env.npm_config_user_agent || ''\n\n  if (agent.includes('yarn')) {\n    return 'yarn'\n  }\n\n  if (agent.includes('pnpm')) {\n    return 'pnpm'\n  }\n\n  if (agent.includes('bun')) {\n    return 'bun'\n  }\n\n  // Both yarn and pnpm does a `npm/?` thing, thus the slightly different match here\n  // Theoretically not needed since we check for yarn/pnpm above, but in case other\n  // package managers do the same thing, we'll (hopefully) catch them here.\n  if (/^npm\\/\\d/.test(agent)) {\n    return 'npm'\n  }\n\n  return undefined\n}\n"],"names":["path","isInteractive","select","default","preferredPM","which","EXPERIMENTAL","Set","ALLOWED_PACKAGE_MANAGERS","allowedPackageManagersString","join","getPackageManagerChoice","workDir","options","rootDir","process","cwd","preferred","name","hasCommand","chosen","mostOptimal","mostLikelyPM","getMostLikelyInstalledPackageManager","interactive","getFallback","messageSuffix","installed","getAvailablePackageManagers","choices","map","pm","has","value","message","hasNpmInstalled","hasYarnInstalled","hasPnpmInstalled","hasBunInstalled","npm","yarn","pnpm","bun","Promise","all","filter","getNpmRunPath","previous","cwdPath","resolve","result","push","execPath","pathEnv","env","getPathEnvVarKey","delimiter","getPartialEnvWithNpmPath","key","platform","Object","keys","toReversed","find","toUpperCase","getCommandPath","cmd","undefined","catch","then","cmdPath","running","getRunningPackageManager","includes","agent","npm_config_user_agent","test"],"mappings":"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"}

package/dist/util/packageManager/upgradePackages.js

@@ -0,0 +1,69 @@
+import { execa } from 'execa';
+import { getPartialEnvWithNpmPath } from './packageManagerChoice.js';
+/**
+ * @internal
+ */ export async function upgradePackages(options, context) {
+    const { packageManager, packages } = options;
+    const { output, workDir } = context;
+    const execOptions = {
+        cwd: workDir,
+        encoding: 'utf8',
+        env: getPartialEnvWithNpmPath(workDir),
+        stdio: 'inherit'
+    };
+    const upgradePackageArgs = packages.map((pkg)=>pkg.join('@'));
+    let result;
+    switch(packageManager){
+        case 'bun':
+            {
+                const bunArgs = [
+                    'update',
+                    ...upgradePackageArgs
+                ];
+                output.log(`Running 'bun ${bunArgs.join(' ')}'`);
+                result = await execa('bun', bunArgs, execOptions);
+                break;
+            }
+        case 'manual':
+            {
+                output.log(`Manual installation selected - run 'npm upgrade ${upgradePackageArgs.join(' ')}' or equivalent`);
+                break;
+            }
+        case 'npm':
+            {
+                const npmArgs = [
+                    'install',
+                    '--legacy-peer-deps',
+                    ...upgradePackageArgs
+                ];
+                output.log(`Running 'npm ${npmArgs.join(' ')}'`);
+                result = await execa('npm', npmArgs, execOptions);
+                break;
+            }
+        case 'pnpm':
+            {
+                const pnpmArgs = [
+                    'upgrade',
+                    ...upgradePackageArgs
+                ];
+                output.log(`Running 'pnpm ${pnpmArgs.join(' ')}'`);
+                result = await execa('pnpm', pnpmArgs, execOptions);
+                break;
+            }
+        case 'yarn':
+            {
+                const yarnArgs = [
+                    'upgrade ',
+                    ...upgradePackageArgs
+                ];
+                output.log(`Running 'yarn ${yarnArgs.join(' ')}'`);
+                result = await execa('yarn', yarnArgs, execOptions);
+                break;
+            }
+    }
+    if (result?.exitCode || result?.failed) {
+        throw new Error('Package upgrade failed');
+    }
+}
+
+//# sourceMappingURL=upgradePackages.js.map

package/dist/util/packageManager/upgradePackages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/packageManager/upgradePackages.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {execa, type Options, type Result} from 'execa'\n\nimport {getPartialEnvWithNpmPath, type PackageManager} from './packageManagerChoice.js'\n\n/**\n * @internal\n */\ninterface UpgradeOptions {\n  packageManager: PackageManager\n  packages: [name: string, version: string][]\n}\n\n/**\n * @internal\n */\nexport async function upgradePackages(\n  options: UpgradeOptions,\n  context: {output: Output; workDir: string},\n): Promise<void> {\n  const {packageManager, packages} = options\n  const {output, workDir} = context\n  const execOptions: Options = {\n    cwd: workDir,\n    encoding: 'utf8',\n    env: getPartialEnvWithNpmPath(workDir),\n    stdio: 'inherit',\n  }\n  const upgradePackageArgs = packages.map((pkg) => pkg.join('@'))\n  let result: Result | undefined\n  switch (packageManager) {\n    case 'bun': {\n      const bunArgs = ['update', ...upgradePackageArgs]\n      output.log(`Running 'bun ${bunArgs.join(' ')}'`)\n      result = await execa('bun', bunArgs, execOptions)\n\n      break\n    }\n    case 'manual': {\n      output.log(\n        `Manual installation selected - run 'npm upgrade ${upgradePackageArgs.join(' ')}' or equivalent`,\n      )\n\n      break\n    }\n    case 'npm': {\n      const npmArgs = ['install', '--legacy-peer-deps', ...upgradePackageArgs]\n      output.log(`Running 'npm ${npmArgs.join(' ')}'`)\n      result = await execa('npm', npmArgs, execOptions)\n\n      break\n    }\n    case 'pnpm': {\n      const pnpmArgs = ['upgrade', ...upgradePackageArgs]\n      output.log(`Running 'pnpm ${pnpmArgs.join(' ')}'`)\n      result = await execa('pnpm', pnpmArgs, execOptions)\n\n      break\n    }\n    case 'yarn': {\n      const yarnArgs = ['upgrade ', ...upgradePackageArgs]\n      output.log(`Running 'yarn ${yarnArgs.join(' ')}'`)\n      result = await execa('yarn', yarnArgs, execOptions)\n\n      break\n    }\n    // No default\n  }\n\n  if (result?.exitCode || result?.failed) {\n    throw new Error('Package upgrade failed')\n  }\n}\n"],"names":["execa","getPartialEnvWithNpmPath","upgradePackages","options","context","packageManager","packages","output","workDir","execOptions","cwd","encoding","env","stdio","upgradePackageArgs","map","pkg","join","result","bunArgs","log","npmArgs","pnpmArgs","yarnArgs","exitCode","failed","Error"],"mappings":"AACA,SAAQA,KAAK,QAAkC,QAAO;AAEtD,SAAQC,wBAAwB,QAA4B,4BAA2B;AAUvF;;CAEC,GACD,OAAO,eAAeC,gBACpBC,OAAuB,EACvBC,OAA0C;IAE1C,MAAM,EAACC,cAAc,EAAEC,QAAQ,EAAC,GAAGH;IACnC,MAAM,EAACI,MAAM,EAAEC,OAAO,EAAC,GAAGJ;IAC1B,MAAMK,cAAuB;QAC3BC,KAAKF;QACLG,UAAU;QACVC,KAAKX,yBAAyBO;QAC9BK,OAAO;IACT;IACA,MAAMC,qBAAqBR,SAASS,GAAG,CAAC,CAACC,MAAQA,IAAIC,IAAI,CAAC;IAC1D,IAAIC;IACJ,OAAQb;QACN,KAAK;YAAO;gBACV,MAAMc,UAAU;oBAAC;uBAAaL;iBAAmB;gBACjDP,OAAOa,GAAG,CAAC,CAAC,aAAa,EAAED,QAAQF,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC/CC,SAAS,MAAMlB,MAAM,OAAOmB,SAASV;gBAErC;YACF;QACA,KAAK;YAAU;gBACbF,OAAOa,GAAG,CACR,CAAC,gDAAgD,EAAEN,mBAAmBG,IAAI,CAAC,KAAK,eAAe,CAAC;gBAGlG;YACF;QACA,KAAK;YAAO;gBACV,MAAMI,UAAU;oBAAC;oBAAW;uBAAyBP;iBAAmB;gBACxEP,OAAOa,GAAG,CAAC,CAAC,aAAa,EAAEC,QAAQJ,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC/CC,SAAS,MAAMlB,MAAM,OAAOqB,SAASZ;gBAErC;YACF;QACA,KAAK;YAAQ;gBACX,MAAMa,WAAW;oBAAC;uBAAcR;iBAAmB;gBACnDP,OAAOa,GAAG,CAAC,CAAC,cAAc,EAAEE,SAASL,IAAI,CAAC,KAAK,CAAC,CAAC;gBACjDC,SAAS,MAAMlB,MAAM,QAAQsB,UAAUb;gBAEvC;YACF;QACA,KAAK;YAAQ;gBACX,MAAMc,WAAW;oBAAC;uBAAeT;iBAAmB;gBACpDP,OAAOa,GAAG,CAAC,CAAC,cAAc,EAAEG,SAASN,IAAI,CAAC,KAAK,CAAC,CAAC;gBACjDC,SAAS,MAAMlB,MAAM,QAAQuB,UAAUd;gBAEvC;YACF;IAEF;IAEA,IAAIS,QAAQM,YAAYN,QAAQO,QAAQ;QACtC,MAAM,IAAIC,MAAM;IAClB;AACF"}

package/dist/util/parseArguments.js

@@ -0,0 +1,42 @@
+import minimist from 'minimist';
+/**
+ * Parse the arguments from the command line
+ *
+ * @param argv - The arguments from the command line
+ * @returns The parsed arguments
+ */ export function parseArguments(argv = process.argv) {
+    const args = argv.slice(2);
+    const { '--': extraArguments, _, version, ...extOptions } = minimist(args, {
+        '--': true,
+        boolean: [
+            'version'
+        ],
+        string: [
+            '_'
+        ]
+    });
+    const [groupOrCommand, ...argsWithoutOptions] = _;
+    const finalExtraArguments = [
+        ...extraArguments || [],
+        ...argv.filter((arg)=>arg.startsWith('-'))
+    ];
+    // oclif allows to run `sanity help` or `sanity help <command>`
+    // It does not fire the hooks on `--help` so this is okay to track
+    const hasHelp = args.includes('help');
+    // We only have global debug via env var
+    const hasDebug = !!process.env.DEBUG;
+    return {
+        groupOrCommand,
+        argsWithoutOptions,
+        argv,
+        extOptions,
+        extraArguments: finalExtraArguments,
+        coreOptions: {
+            debug: hasDebug,
+            help: hasHelp,
+            version
+        }
+    };
+}
+
+//# sourceMappingURL=parseArguments.js.map

package/dist/util/parseArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/parseArguments.ts"],"sourcesContent":["import minimist from 'minimist'\n\ninterface ParsedArguments<F = Record<string, string>> {\n  /**\n   * Command arguments, eg any arguments after `sanity <command>` (no flags)\n   */\n  argsWithoutOptions: string[]\n\n  // Raw, forwarded arguments, for commands that want to be more explicit about parsing\n  argv: string[]\n\n  /**\n   * Options mostly relevant for the core CLI runner\n   */\n  coreOptions: {\n    debug: boolean\n\n    help: boolean\n\n    version: boolean\n  }\n\n  /**\n   * Command flags, without the core options (help, debug, version etc)\n   */\n  extOptions: F\n\n  /**\n   * Arguments after the ended argument list (--)\n   */\n  extraArguments: string[]\n\n  /**\n   * Group or command name, eg `dataset` (`sanity dataset`) or `import` (`sanity dataset import`)\n   */\n  groupOrCommand: string\n}\n\n/**\n * Parse the arguments from the command line\n *\n * @param argv - The arguments from the command line\n * @returns The parsed arguments\n */\nexport function parseArguments(argv = process.argv): ParsedArguments {\n  const args = argv.slice(2)\n\n  const {\n    '--': extraArguments,\n    _,\n    version,\n    ...extOptions\n  } = minimist(args, {\n    '--': true,\n    boolean: ['version'],\n    string: ['_'],\n  })\n\n  const [groupOrCommand, ...argsWithoutOptions] = _\n\n  const finalExtraArguments = [\n    ...(extraArguments || []),\n    ...argv.filter((arg) => arg.startsWith('-')),\n  ]\n\n  // oclif allows to run `sanity help` or `sanity help <command>`\n  // It does not fire the hooks on `--help` so this is okay to track\n  const hasHelp = args.includes('help')\n\n  // We only have global debug via env var\n  const hasDebug = !!process.env.DEBUG\n\n  return {\n    groupOrCommand,\n\n    argsWithoutOptions,\n    argv,\n    extOptions,\n    extraArguments: finalExtraArguments,\n\n    coreOptions: {\n      debug: hasDebug,\n      help: hasHelp,\n      version,\n    },\n  }\n}\n"],"names":["minimist","parseArguments","argv","process","args","slice","extraArguments","_","version","extOptions","boolean","string","groupOrCommand","argsWithoutOptions","finalExtraArguments","filter","arg","startsWith","hasHelp","includes","hasDebug","env","DEBUG","coreOptions","debug","help"],"mappings":"AAAA,OAAOA,cAAc,WAAU;AAsC/B;;;;;CAKC,GACD,OAAO,SAASC,eAAeC,OAAOC,QAAQD,IAAI;IAChD,MAAME,OAAOF,KAAKG,KAAK,CAAC;IAExB,MAAM,EACJ,MAAMC,cAAc,EACpBC,CAAC,EACDC,OAAO,EACP,GAAGC,YACJ,GAAGT,SAASI,MAAM;QACjB,MAAM;QACNM,SAAS;YAAC;SAAU;QACpBC,QAAQ;YAAC;SAAI;IACf;IAEA,MAAM,CAACC,gBAAgB,GAAGC,mBAAmB,GAAGN;IAEhD,MAAMO,sBAAsB;WACtBR,kBAAkB,EAAE;WACrBJ,KAAKa,MAAM,CAAC,CAACC,MAAQA,IAAIC,UAAU,CAAC;KACxC;IAED,+DAA+D;IAC/D,kEAAkE;IAClE,MAAMC,UAAUd,KAAKe,QAAQ,CAAC;IAE9B,wCAAwC;IACxC,MAAMC,WAAW,CAAC,CAACjB,QAAQkB,GAAG,CAACC,KAAK;IAEpC,OAAO;QACLV;QAEAC;QACAX;QACAO;QACAH,gBAAgBQ;QAEhBS,aAAa;YACXC,OAAOJ;YACPK,MAAMP;YACNV;QACF;IACF;AACF"}

package/dist/util/pluralize.js

@@ -0,0 +1,11 @@
+/**
+ * Pluralizes a word based on a count
+ * @param word - The word to pluralize
+ * @param count - The count to determine singular or plural
+ * @returns The word in singular or plural form
+ * @internal
+ */ export function pluralize(word, count) {
+    return count === 1 ? word : `${word}s`;
+}
+
+//# sourceMappingURL=pluralize.js.map

package/dist/util/pluralize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/pluralize.ts"],"sourcesContent":["/**\n * Pluralizes a word based on a count\n * @param word - The word to pluralize\n * @param count - The count to determine singular or plural\n * @returns The word in singular or plural form\n * @internal\n */\nexport function pluralize(word: string, count: number): string {\n  return count === 1 ? word : `${word}s`\n}\n"],"names":["pluralize","word","count"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,UAAUC,IAAY,EAAEC,KAAa;IACnD,OAAOA,UAAU,IAAID,OAAO,GAAGA,KAAK,CAAC,CAAC;AACxC"}

package/dist/util/readModuleVersion.js

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import resolveFrom from 'resolve-from';
+import { readPackageJson } from './readPackageJson.js';
+/**
+ * Reads the version number of the _installed_ module, or returns `null` if not found
+ *
+ * @param dir - Path of the directory to read the module from
+ * @param moduleName - Name of module to get installed version for
+ * @returns Version number, of null
+ */ export async function readModuleVersion(dir, moduleName) {
+    const manifestPath = resolveFrom.silent(dir, path.join(moduleName, 'package.json'));
+    return manifestPath ? (await readPackageJson(manifestPath)).version : null;
+}
+
+//# sourceMappingURL=readModuleVersion.js.map

package/dist/util/readModuleVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/readModuleVersion.ts"],"sourcesContent":["import path from 'node:path'\n\nimport resolveFrom from 'resolve-from'\n\nimport {readPackageJson} from './readPackageJson.js'\n\n/**\n * Reads the version number of the _installed_ module, or returns `null` if not found\n *\n * @param dir - Path of the directory to read the module from\n * @param moduleName - Name of module to get installed version for\n * @returns Version number, of null\n */\nexport async function readModuleVersion(dir: string, moduleName: string): Promise<string | null> {\n  const manifestPath = resolveFrom.silent(dir, path.join(moduleName, 'package.json'))\n  return manifestPath ? (await readPackageJson(manifestPath)).version : null\n}\n"],"names":["path","resolveFrom","readPackageJson","readModuleVersion","dir","moduleName","manifestPath","silent","join","version"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAE5B,OAAOC,iBAAiB,eAAc;AAEtC,SAAQC,eAAe,QAAO,uBAAsB;AAEpD;;;;;;CAMC,GACD,OAAO,eAAeC,kBAAkBC,GAAW,EAAEC,UAAkB;IACrE,MAAMC,eAAeL,YAAYM,MAAM,CAACH,KAAKJ,KAAKQ,IAAI,CAACH,YAAY;IACnE,OAAOC,eAAe,AAAC,CAAA,MAAMJ,gBAAgBI,aAAY,EAAGG,OAAO,GAAG;AACxE"}

package/dist/util/readPackageJson.js

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+/**
+ * Feel free to add properties to this,
+ * 🟠ℹ️   BUT ENSURE OPTIONAL STUFF IS ACTUALLY OPTIONAL  ℹ️🟠
+ * 🟠ℹ️ SINCE THIS IS USED IN A NUMBER OF LOCATIONS WHERE ℹ️🟠
+ * 🟠ℹ️ WE CANNOT ENFORCE/GUARANTEE ANY PARTICULAR PROPS  ℹ️🟠
+ */ const packageJsonSchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()).optional(),
+    exports: z.record(z.string(), z.any()).optional(),
+    main: z.string().optional(),
+    peerDependencies: z.record(z.string(), z.string()).optional(),
+    types: z.string().optional()
+});
+/**
+ * Read the `package.json` file at the given path
+ *
+ * @param filePath - Path to package.json to read
+ * @param skipSchemaValidation - Skip schema validation if true
+ * @returns The parsed package.json
+ * @internal
+ */ export async function readPackageJson(filePath, skipSchemaValidation = false) {
+    let pkg;
+    try {
+        pkg = JSON.parse(await readFile(filePath, 'utf8'));
+    } catch (err) {
+        throw new Error(`Failed to read "${filePath}"`, {
+            cause: err
+        });
+    }
+    if (skipSchemaValidation) {
+        return pkg;
+    }
+    const { data, error, success } = packageJsonSchema.safeParse(pkg);
+    if (success) {
+        return data;
+    }
+    throw new Error(`Invalid package.json at "${filePath}": ${error.issues.map((err)=>err.message).join('\n')}`);
+}
+
+//# sourceMappingURL=readPackageJson.js.map

package/dist/util/readPackageJson.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/readPackageJson.ts"],"sourcesContent":["import {readFile} from 'node:fs/promises'\n\nimport {z} from 'zod'\n\n/**\n * Feel free to add properties to this,\n * 🟠ℹ️   BUT ENSURE OPTIONAL STUFF IS ACTUALLY OPTIONAL  ℹ️🟠\n * 🟠ℹ️ SINCE THIS IS USED IN A NUMBER OF LOCATIONS WHERE ℹ️🟠\n * 🟠ℹ️ WE CANNOT ENFORCE/GUARANTEE ANY PARTICULAR PROPS  ℹ️🟠\n */\nconst packageJsonSchema = z.object({\n  name: z.string(),\n  version: z.string(),\n\n  dependencies: z.record(z.string(), z.string()).optional(),\n  devDependencies: z.record(z.string(), z.string()).optional(),\n  exports: z.record(z.string(), z.any()).optional(),\n  main: z.string().optional(),\n  peerDependencies: z.record(z.string(), z.string()).optional(),\n  types: z.string().optional(),\n})\n\n/**\n * Minimal representation of a package.json.\n *\n * @internal\n */\nexport type PackageJson = z.infer<typeof packageJsonSchema>\n\n/**\n * Read the `package.json` file at the given path\n *\n * @param filePath - Path to package.json to read\n * @param skipSchemaValidation - Skip schema validation if true\n * @returns The parsed package.json\n * @internal\n */\nexport async function readPackageJson(\n  filePath: string,\n  skipSchemaValidation = false,\n): Promise<PackageJson> {\n  let pkg: unknown\n  try {\n    pkg = JSON.parse(await readFile(filePath, 'utf8'))\n  } catch (err: unknown) {\n    throw new Error(`Failed to read \"${filePath}\"`, {cause: err})\n  }\n\n  if (skipSchemaValidation) {\n    return pkg as PackageJson\n  }\n\n  const {data, error, success} = packageJsonSchema.safeParse(pkg)\n  if (success) {\n    return data\n  }\n\n  throw new Error(\n    `Invalid package.json at \"${filePath}\": ${error.issues.map((err) => err.message).join('\\n')}`,\n  )\n}\n"],"names":["readFile","z","packageJsonSchema","object","name","string","version","dependencies","record","optional","devDependencies","exports","any","main","peerDependencies","types","readPackageJson","filePath","skipSchemaValidation","pkg","JSON","parse","err","Error","cause","data","error","success","safeParse","issues","map","message","join"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,SAAQC,CAAC,QAAO,MAAK;AAErB;;;;;CAKC,GACD,MAAMC,oBAAoBD,EAAEE,MAAM,CAAC;IACjCC,MAAMH,EAAEI,MAAM;IACdC,SAASL,EAAEI,MAAM;IAEjBE,cAAcN,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEI,MAAM,IAAII,QAAQ;IACvDC,iBAAiBT,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEI,MAAM,IAAII,QAAQ;IAC1DE,SAASV,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEW,GAAG,IAAIH,QAAQ;IAC/CI,MAAMZ,EAAEI,MAAM,GAAGI,QAAQ;IACzBK,kBAAkBb,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEI,MAAM,IAAII,QAAQ;IAC3DM,OAAOd,EAAEI,MAAM,GAAGI,QAAQ;AAC5B;AASA;;;;;;;CAOC,GACD,OAAO,eAAeO,gBACpBC,QAAgB,EAChBC,uBAAuB,KAAK;IAE5B,IAAIC;IACJ,IAAI;QACFA,MAAMC,KAAKC,KAAK,CAAC,MAAMrB,SAASiB,UAAU;IAC5C,EAAE,OAAOK,KAAc;QACrB,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEN,SAAS,CAAC,CAAC,EAAE;YAACO,OAAOF;QAAG;IAC7D;IAEA,IAAIJ,sBAAsB;QACxB,OAAOC;IACT;IAEA,MAAM,EAACM,IAAI,EAAEC,KAAK,EAAEC,OAAO,EAAC,GAAGzB,kBAAkB0B,SAAS,CAACT;IAC3D,IAAIQ,SAAS;QACX,OAAOF;IACT;IAEA,MAAM,IAAIF,MACR,CAAC,yBAAyB,EAAEN,SAAS,GAAG,EAAES,MAAMG,MAAM,CAACC,GAAG,CAAC,CAACR,MAAQA,IAAIS,OAAO,EAAEC,IAAI,CAAC,OAAO;AAEjG"}

package/dist/util/readPackageManifest.js

@@ -0,0 +1,46 @@
+// TODO: Consolidate with readPackageJson.ts
+import { readFile } from 'node:fs/promises';
+function isPackageManifest(item) {
+    return typeof item === 'object' && item !== null && 'name' in item && 'version' in item;
+}
+/**
+ * Read the `package.json` file at the given path
+ *
+ * @param filePath - Path to package.json to read
+ * @returns The parsed package.json
+ */ async function readPackageJson(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    } catch (err) {
+        throw new Error(`Failed to read "${filePath}": ${err.message}`);
+    }
+}
+/**
+ * Read the `package.json` file at the given path and return an object that guarantees
+ * the presence of name, version, dependencies, dev dependencies and peer dependencies
+ *
+ * @param packageJsonPath - Path to package.json to read
+ * @returns Reduced package.json with guarantees for name, version and dependency fields
+ */ export async function readPackageManifest(packageJsonPath, defaults = {}) {
+    let manifest;
+    try {
+        manifest = {
+            ...defaults,
+            ...await readPackageJson(packageJsonPath)
+        };
+    } catch (err) {
+        throw new Error(`Failed to read "${packageJsonPath}": ${err.message}`);
+    }
+    if (!isPackageManifest(manifest)) {
+        throw new Error(`Failed to read "${packageJsonPath}": Invalid package manifest`);
+    }
+    const { dependencies = {}, devDependencies = {}, name, version } = manifest;
+    return {
+        dependencies,
+        devDependencies,
+        name,
+        version
+    };
+}
+
+//# sourceMappingURL=readPackageManifest.js.map

package/dist/util/readPackageManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/readPackageManifest.ts"],"sourcesContent":["// TODO: Consolidate with readPackageJson.ts\nimport {readFile} from 'node:fs/promises'\n\nimport {type PackageJson} from '../types.js'\n\ninterface DependencyDeclarations {\n  dependencies: Record<string, string | undefined>\n  devDependencies: Record<string, string | undefined>\n}\n\ninterface PackageManifest extends DependencyDeclarations {\n  name: string\n  version: string\n}\n\nexport interface PartialPackageManifest extends Partial<DependencyDeclarations> {\n  name: string\n  version: string\n}\n\nfunction isPackageManifest(item: unknown): item is PartialPackageManifest {\n  return typeof item === 'object' && item !== null && 'name' in item && 'version' in item\n}\n\n/**\n * Read the `package.json` file at the given path\n *\n * @param filePath - Path to package.json to read\n * @returns The parsed package.json\n */\nasync function readPackageJson(filePath: string): Promise<PackageJson> {\n  try {\n    return JSON.parse(await readFile(filePath, 'utf8'))\n  } catch (err) {\n    throw new Error(`Failed to read \"${filePath}\": ${err.message}`)\n  }\n}\n/**\n * Read the `package.json` file at the given path and return an object that guarantees\n * the presence of name, version, dependencies, dev dependencies and peer dependencies\n *\n * @param packageJsonPath - Path to package.json to read\n * @returns Reduced package.json with guarantees for name, version and dependency fields\n */\nexport async function readPackageManifest(\n  packageJsonPath: string,\n  defaults: Partial<PartialPackageManifest> = {},\n): Promise<PackageManifest> {\n  let manifest: unknown\n  try {\n    manifest = {...defaults, ...(await readPackageJson(packageJsonPath))}\n  } catch (err) {\n    throw new Error(`Failed to read \"${packageJsonPath}\": ${err.message}`)\n  }\n\n  if (!isPackageManifest(manifest)) {\n    throw new Error(`Failed to read \"${packageJsonPath}\": Invalid package manifest`)\n  }\n\n  const {dependencies = {}, devDependencies = {}, name, version} = manifest\n  return {dependencies, devDependencies, name, version}\n}\n"],"names":["readFile","isPackageManifest","item","readPackageJson","filePath","JSON","parse","err","Error","message","readPackageManifest","packageJsonPath","defaults","manifest","dependencies","devDependencies","name","version"],"mappings":"AAAA,4CAA4C;AAC5C,SAAQA,QAAQ,QAAO,mBAAkB;AAmBzC,SAASC,kBAAkBC,IAAa;IACtC,OAAO,OAAOA,SAAS,YAAYA,SAAS,QAAQ,UAAUA,QAAQ,aAAaA;AACrF;AAEA;;;;;CAKC,GACD,eAAeC,gBAAgBC,QAAgB;IAC7C,IAAI;QACF,OAAOC,KAAKC,KAAK,CAAC,MAAMN,SAASI,UAAU;IAC7C,EAAE,OAAOG,KAAK;QACZ,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEJ,SAAS,GAAG,EAAEG,IAAIE,OAAO,EAAE;IAChE;AACF;AACA;;;;;;CAMC,GACD,OAAO,eAAeC,oBACpBC,eAAuB,EACvBC,WAA4C,CAAC,CAAC;IAE9C,IAAIC;IACJ,IAAI;QACFA,WAAW;YAAC,GAAGD,QAAQ;YAAE,GAAI,MAAMT,gBAAgBQ,gBAAgB;QAAC;IACtE,EAAE,OAAOJ,KAAK;QACZ,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEG,gBAAgB,GAAG,EAAEJ,IAAIE,OAAO,EAAE;IACvE;IAEA,IAAI,CAACR,kBAAkBY,WAAW;QAChC,MAAM,IAAIL,MAAM,CAAC,gBAAgB,EAAEG,gBAAgB,2BAA2B,CAAC;IACjF;IAEA,MAAM,EAACG,eAAe,CAAC,CAAC,EAAEC,kBAAkB,CAAC,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAC,GAAGJ;IACjE,OAAO;QAACC;QAAcC;QAAiBC;QAAMC;IAAO;AACtD"}