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

package/dist/util/packageManager/packageManagerChoice.js

@@ -0,0 +1,173 @@
+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'
+]);
+/**
+ * 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\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","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","join","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.d.ts

@@ -0,0 +1,17 @@
+import { type Output } from '@sanity/cli-core';
+import { type PackageManager } from './packageManagerChoice.js';
+/**
+ * @internal
+ */
+interface UpgradeOptions {
+    packageManager: PackageManager;
+    packages: [name: string, version: string][];
+}
+/**
+ * @internal
+ */
+export declare function upgradePackages(options: UpgradeOptions, context: {
+    output: Output;
+    workDir: string;
+}): Promise<void>;
+export {};

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/pluralize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 declare function pluralize(word: string, count: number): string;

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.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 declare function readModuleVersion(dir: string, moduleName: string): Promise<string | null>;

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.d.ts

@@ -0,0 +1,45 @@
+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  ℹ️🟠
+ */
+declare const packageJsonSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    exports?: Record<string, any> | undefined;
+    dependencies?: Record<string, string> | undefined;
+    devDependencies?: Record<string, string> | undefined;
+    peerDependencies?: Record<string, string> | undefined;
+}, {
+    name: string;
+    version: string;
+    exports?: Record<string, any> | undefined;
+    dependencies?: Record<string, string> | undefined;
+    devDependencies?: Record<string, string> | undefined;
+    peerDependencies?: Record<string, string> | undefined;
+}>;
+/**
+ * Minimal representation of a package.json.
+ *
+ * @internal
+ */
+export type PackageJson = z.infer<typeof packageJsonSchema>;
+/**
+ * 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 declare function readPackageJson(filePath: string, skipSchemaValidation?: boolean): Promise<PackageJson>;
+export {};

package/dist/util/readPackageJson.js

@@ -0,0 +1,42 @@
+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(),
+    peerDependencies: z.record(z.string(), 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.errors.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  peerDependencies: z.record(z.string(), 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.errors.map((err) => err.message).join('\\n')}`,\n  )\n}\n"],"names":["readFile","z","packageJsonSchema","object","name","string","version","dependencies","record","optional","devDependencies","exports","any","peerDependencies","readPackageJson","filePath","skipSchemaValidation","pkg","JSON","parse","err","Error","cause","data","error","success","safeParse","errors","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,kBAAkBZ,EAAEO,MAAM,CAACP,EAAEI,MAAM,IAAIJ,EAAEI,MAAM,IAAII,QAAQ;AAC7D;AASA;;;;;;;CAOC,GACD,OAAO,eAAeK,gBACpBC,QAAgB,EAChBC,uBAAuB,KAAK;IAE5B,IAAIC;IACJ,IAAI;QACFA,MAAMC,KAAKC,KAAK,CAAC,MAAMnB,SAASe,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,GAAGvB,kBAAkBwB,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.d.ts

@@ -0,0 +1,21 @@
+interface DependencyDeclarations {
+    dependencies: Record<string, string | undefined>;
+    devDependencies: Record<string, string | undefined>;
+}
+interface PackageManifest extends DependencyDeclarations {
+    name: string;
+    version: string;
+}
+export interface PartialPackageManifest extends Partial<DependencyDeclarations> {
+    name: string;
+    version: string;
+}
+/**
+ * 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 declare function readPackageManifest(packageJsonPath: string, defaults?: Partial<PartialPackageManifest>): Promise<PackageManifest>;
+export {};

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"}

package/dist/util/toInt.d.ts

@@ -0,0 +1 @@
+export declare function toInt(value: number | string | undefined, defaultValue: number): number;

package/dist/util/toInt.js

@@ -0,0 +1,9 @@
+export function toInt(value, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    const intVal = Number.parseInt(`${value}`, 10);
+    return Number.isFinite(intVal) ? intVal : defaultValue;
+}
+
+//# sourceMappingURL=toInt.js.map

package/dist/util/toInt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/toInt.ts"],"sourcesContent":["export function toInt(value: number | string | undefined, defaultValue: number): number {\n  if (value === undefined) {\n    return defaultValue\n  }\n\n  const intVal = Number.parseInt(`${value}`, 10)\n  return Number.isFinite(intVal) ? intVal : defaultValue\n}\n"],"names":["toInt","value","defaultValue","undefined","intVal","Number","parseInt","isFinite"],"mappings":"AAAA,OAAO,SAASA,MAAMC,KAAkC,EAAEC,YAAoB;IAC5E,IAAID,UAAUE,WAAW;QACvB,OAAOD;IACT;IAEA,MAAME,SAASC,OAAOC,QAAQ,CAAC,GAAGL,OAAO,EAAE;IAC3C,OAAOI,OAAOE,QAAQ,CAACH,UAAUA,SAASF;AAC5C"}

package/dist/util/trimHashFromVersion.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `2.27.3-cookieless-auth.34+8ba9c1504` →
+ * `2.27.3-cookieless-auth.34`
+ */
+export declare function trimHashFromVersion(version: string): string;

package/dist/util/trimHashFromVersion.js

@@ -0,0 +1,8 @@
+/**
+ * `2.27.3-cookieless-auth.34+8ba9c1504` →
+ * `2.27.3-cookieless-auth.34`
+ */ export function trimHashFromVersion(version) {
+    return version.replace(/\+[a-z0-9]{8,}$/, '');
+}
+
+//# sourceMappingURL=trimHashFromVersion.js.map

package/dist/util/trimHashFromVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/trimHashFromVersion.ts"],"sourcesContent":["/**\n * `2.27.3-cookieless-auth.34+8ba9c1504` →\n * `2.27.3-cookieless-auth.34`\n */\nexport function trimHashFromVersion(version: string) {\n  return version.replace(/\\+[a-z0-9]{8,}$/, '')\n}\n"],"names":["trimHashFromVersion","version","replace"],"mappings":"AAAA;;;CAGC,GACD,OAAO,SAASA,oBAAoBC,OAAe;IACjD,OAAOA,QAAQC,OAAO,CAAC,mBAAmB;AAC5C"}