@shopify/cli-kit 0.0.0-nightly-20230110194301

package/dist/public/node/hooks/prerun.js

@@ -0,0 +1,66 @@
+import { startAnalytics } from '../../../private/node/analytics.js';
+import { debug } from '../../../output.js';
+// This hook is called before each command run. More info: https://oclif.io/docs/hooks
+export const hook = async (options) => {
+    const commandContent = parseCommandContent({
+        id: options.Command.id,
+        aliases: options.Command.aliases,
+        pluginAlias: options.Command.plugin?.alias,
+    });
+    const args = options.argv;
+    debug(`Running command ${commandContent.command}`);
+    await startAnalytics({ commandContent, args, commandClass: options.Command });
+};
+export function parseCommandContent(cmdInfo) {
+    let commandContent = parseCreateCommand(cmdInfo.pluginAlias);
+    if (!commandContent) {
+        commandContent = parseNormalCommand(cmdInfo.id, cmdInfo.aliases);
+    }
+    return commandContent;
+}
+function parseNormalCommand(id, aliases) {
+    return {
+        command: id.replace(/:/g, ' '),
+        topic: parseTopic(id),
+        alias: findAlias(aliases),
+    };
+}
+/**
+ * Create commands implement Init by default, so the name of the command must be extracted from
+ * the plugin/module name. Neither alias or topic are supported
+ *
+ * @param commandClass - Oclif command configuration
+ * @returns Command content with the name of the command or undefined otherwise
+ */
+function parseCreateCommand(pluginAlias) {
+    if (!pluginAlias || !pluginAlias.startsWith('@shopify/create-')) {
+        return undefined;
+    }
+    return { command: pluginAlias.substring(pluginAlias.indexOf('/') + 1) };
+}
+/**
+ * Commands use this pattern topic:subtopic1:...:subtopicN:command. This method extract the topic and subtopic
+ * information replacing the ':' separator with one space
+ *
+ * @param cmd - Complete command string to extract the topic information
+ * @returns The topic name or undefined otherwise
+ */
+function parseTopic(cmd) {
+    if (cmd.lastIndexOf(':') === -1) {
+        return;
+    }
+    return cmd.slice(0, cmd.lastIndexOf(':')).replace(/:/g, ' ');
+}
+/**
+ * Identifies if the command was launched using an alias instead of the oficial command name
+ *
+ * @param aliases - List of possible alias a command has
+ * @returns The alias used or undefined otherwise
+ */
+function findAlias(aliases) {
+    const existingAlias = aliases.find((alias) => alias.split(':').every((aliasToken) => process.argv.includes(aliasToken)));
+    if (existingAlias) {
+        return existingAlias.replace(/:/g, ' ');
+    }
+}
+//# sourceMappingURL=prerun.js.map

package/dist/public/node/hooks/prerun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerun.js","sourceRoot":"","sources":["../../../../src/public/node/hooks/prerun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAA;AASxC,sFAAsF;AACtF,MAAM,CAAC,MAAM,IAAI,GAAgB,KAAK,EAAE,OAAO,EAAE,EAAE;IACjD,MAAM,cAAc,GAAG,mBAAmB,CAAC;QACzC,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE;QACtB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO;QAChC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK;KAC3C,CAAC,CAAA;IACF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;IACzB,KAAK,CAAC,mBAAmB,cAAc,CAAC,OAAO,EAAE,CAAC,CAAA;IAClD,MAAM,cAAc,CAAC,EAAC,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,OAAoC,EAAC,CAAC,CAAA;AAC1G,CAAC,CAAA;AAED,MAAM,UAAU,mBAAmB,CAAC,OAA8D;IAChG,IAAI,cAAc,GAAG,kBAAkB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC5D,IAAI,CAAC,cAAc,EAAE;QACnB,cAAc,GAAG,kBAAkB,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KACjE;IACD,OAAO,cAAc,CAAA;AACvB,CAAC;AAED,SAAS,kBAAkB,CAAC,EAAU,EAAE,OAAiB;IACvD,OAAO;QACL,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;QAC9B,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC;QACrB,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC;KAC1B,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAC,WAAoB;IAC9C,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE;QAC/D,OAAO,SAAS,CAAA;KACjB;IAED,OAAO,EAAC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAC,CAAA;AACvE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,GAAW;IAC7B,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;QAC/B,OAAM;KACP;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;AAC9D,CAAC;AAED;;;;;GAKG;AACH,SAAS,SAAS,CAAC,OAAiB;IAClC,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAC1E,CAAA;IACD,IAAI,aAAa,EAAE;QACjB,OAAO,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;KACxC;AACH,CAAC","sourcesContent":["import {startAnalytics} from '../../../private/node/analytics.js'\nimport {debug} from '../../../output.js'\nimport Command from '../../../public/node/base-command.js'\nimport {Hook} from '@oclif/core'\n\nexport declare interface CommandContent {\n  command: string\n  topic?: string\n  alias?: string\n}\n// This hook is called before each command run. More info: https://oclif.io/docs/hooks\nexport const hook: Hook.Prerun = async (options) => {\n  const commandContent = parseCommandContent({\n    id: options.Command.id,\n    aliases: options.Command.aliases,\n    pluginAlias: options.Command.plugin?.alias,\n  })\n  const args = options.argv\n  debug(`Running command ${commandContent.command}`)\n  await startAnalytics({commandContent, args, commandClass: options.Command as unknown as typeof Command})\n}\n\nexport function parseCommandContent(cmdInfo: {id: string; aliases: string[]; pluginAlias?: string}): CommandContent {\n  let commandContent = parseCreateCommand(cmdInfo.pluginAlias)\n  if (!commandContent) {\n    commandContent = parseNormalCommand(cmdInfo.id, cmdInfo.aliases)\n  }\n  return commandContent\n}\n\nfunction parseNormalCommand(id: string, aliases: string[]): CommandContent {\n  return {\n    command: id.replace(/:/g, ' '),\n    topic: parseTopic(id),\n    alias: findAlias(aliases),\n  }\n}\n\n/**\n * Create commands implement Init by default, so the name of the command must be extracted from\n * the plugin/module name. Neither alias or topic are supported\n *\n * @param commandClass - Oclif command configuration\n * @returns Command content with the name of the command or undefined otherwise\n */\nfunction parseCreateCommand(pluginAlias?: string): CommandContent | undefined {\n  if (!pluginAlias || !pluginAlias.startsWith('@shopify/create-')) {\n    return undefined\n  }\n\n  return {command: pluginAlias.substring(pluginAlias.indexOf('/') + 1)}\n}\n\n/**\n * Commands use this pattern topic:subtopic1:...:subtopicN:command. This method extract the topic and subtopic\n * information replacing the ':' separator with one space\n *\n * @param cmd - Complete command string to extract the topic information\n * @returns The topic name or undefined otherwise\n */\nfunction parseTopic(cmd: string) {\n  if (cmd.lastIndexOf(':') === -1) {\n    return\n  }\n  return cmd.slice(0, cmd.lastIndexOf(':')).replace(/:/g, ' ')\n}\n\n/**\n * Identifies if the command was launched using an alias instead of the oficial command name\n *\n * @param aliases - List of possible alias a command has\n * @returns The alias used or undefined otherwise\n */\nfunction findAlias(aliases: string[]) {\n  const existingAlias = aliases.find((alias) =>\n    alias.split(':').every((aliasToken) => process.argv.includes(aliasToken)),\n  )\n  if (existingAlias) {\n    return existingAlias.replace(/:/g, ' ')\n  }\n}\n"]}

package/dist/public/node/node-package-manager.d.ts

@@ -0,0 +1,243 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { AbortError, BugError } from './error.js';
+import { AbortSignal } from './abort.js';
+import type { Writable } from 'stream';
+/** The name of the Yarn lock file */
+export declare const yarnLockfile = "yarn.lock";
+/** The name of the npm lock file */
+export declare const npmLockfile = "package-lock.json";
+/** The name of the pnpm lock file */
+export declare const pnpmLockfile = "pnpm-lock.yaml";
+/** The name of the pnpm workspace file */
+export declare const pnpmWorkspaceFile = "pnpm-workspace.yaml";
+/** An array containing the lockfiles from all the package managers */
+export declare const lockfiles: Lockfile[];
+export declare type Lockfile = 'yarn.lock' | 'package-lock.json' | 'pnpm-lock.yaml';
+/**
+ * A union type that represents the type of dependencies in the package.json
+ * - dev: devDependencies
+ * - prod: dependencies
+ * - peer: peerDependencies
+ */
+export declare type DependencyType = 'dev' | 'prod' | 'peer';
+/**
+ * A union that represents the package managers available.
+ */
+export declare const packageManager: readonly ["yarn", "npm", "pnpm"];
+export declare type PackageManager = typeof packageManager[number];
+/**
+ * Returns an abort error that's thrown when a directory that's expected to have
+ * a package.json doesn't have it.
+ * @param directory - The path to the directory that should contain a package.json
+ * @returns An abort error.
+ */
+export declare const PackageJsonNotFoundError: (directory: string) => AbortError;
+/**
+ * Returns a bug error that's thrown when the lookup of the package.json traversing the directory
+ * hierarchy up can't find a package.json
+ * @param directory - The directory from which the traverse has been done
+ * @returns An abort error.
+ */
+export declare const FindUpAndReadPackageJsonNotFoundError: (directory: string) => BugError;
+/**
+ * Returns the dependency manager used to run the create workflow.
+ * @param env - The environment variables of the process in which the CLI runs.
+ * @returns The dependency manager
+ */
+export declare function packageManagerUsedForCreating(env?: NodeJS.ProcessEnv): PackageManager | 'unknown';
+/**
+ * Returns the dependency manager used by an existing project.
+ * @param directory - The root directory of the project.
+ * @returns The dependency manager
+ */
+export declare function getPackageManager(directory: string): Promise<PackageManager>;
+interface InstallNPMDependenciesRecursivelyOptions {
+    /**
+     * The dependency manager to use to install the dependencies.
+     */
+    packageManager: PackageManager;
+    /**
+     * The directory from where we'll find package.json's recursively
+     */
+    directory: string;
+    /**
+     * Specifies the maximum depth of the glob search.
+     */
+    deep?: number;
+}
+/**
+ * This function traverses down a directory tree to find directories containing a package.json
+ * and installs the dependencies if needed. To know if it's needed, it uses the "check" command
+ * provided by dependency managers.
+ * @param options - Options to install dependencies recursively.
+ */
+export declare function installNPMDependenciesRecursively(options: InstallNPMDependenciesRecursivelyOptions): Promise<void>;
+interface InstallNodeModulesOptions {
+    directory: string;
+    args: string[];
+    packageManager: PackageManager;
+    stdout?: Writable;
+    stderr?: Writable;
+    signal?: AbortSignal;
+}
+export declare function installNodeModules(options: InstallNodeModulesOptions): Promise<void>;
+/**
+ * Returns the name of the package configured in its package.json
+ * @param packageJsonPath - Path to the package.json file
+ * @returns A promise that resolves with the name.
+ */
+export declare function getPackageName(packageJsonPath: string): Promise<string | undefined>;
+/**
+ * Returns the list of production and dev dependencies of a package.json
+ * @param packageJsonPath - Path to the package.json file
+ * @returns A promise that resolves with the list of dependencies.
+ */
+export declare function getDependencies(packageJsonPath: string): Promise<{
+    [key: string]: string;
+}>;
+/**
+ * Returns true if the app uses workspaces, false otherwise.
+ * @param packageJsonPath - Path to the package.json file
+ * @param pnpmWorkspacePath - Path to the pnpm-workspace.yaml file
+ * @returns A promise that resolves with true if the app uses workspaces, false otherwise.
+ */
+export declare function usesWorkspaces(appDirectory: string): Promise<boolean>;
+/**
+ * Given an NPM dependency, it checks if there's a more recent version, and if there is, it returns its value.
+ * @param dependency - The dependency name (e.g. react)
+ * @param currentVersion - The current version.
+ * @returns A promise that resolves with a more recent version or undefined if there's no more recent version.
+ */
+export declare function checkForNewVersion(dependency: string, currentVersion: string): Promise<string | undefined>;
+/**
+ * An interface that represents a package.json
+ */
+export interface PackageJson {
+    /**
+     * The name attribute of the package.json
+     */
+    name?: string;
+    /**
+     * The version attribute of the package.json
+     */
+    version?: string;
+    /**
+     * The dependencies attribute of the package.json
+     */
+    dependencies?: {
+        [key: string]: string;
+    };
+    /**
+     * The devDependencies attribute of the package.json
+     */
+    devDependencies?: {
+        [key: string]: string;
+    };
+    /**
+     * The optional oclif settings attribute of the package.json
+     */
+    oclif?: {
+        plugins?: string[];
+    };
+    /**
+     * The workspaces attribute of the package.json
+     */
+    workspaces?: string[];
+    /**
+     * The resolutions attribute of the package.json. Only useful when using yarn as package manager
+     */
+    resolutions?: {
+        [key: string]: string;
+    };
+    /**
+     * The overrides attribute of the package.json. Only useful when using npm o npmn as package managers
+     */
+    overrides?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Reads and parses a package.json
+ * @param packageJsonPath - Path to the package.json
+ * @returns An promise that resolves with an in-memory representation
+ *    of the package.json or rejects with an error if the file is not found or the content is
+ *    not decodable.
+ */
+export declare function readAndParsePackageJson(packageJsonPath: string): Promise<PackageJson>;
+interface AddNPMDependenciesIfNeededOptions {
+    /** How dependencies should be added */
+    type: DependencyType;
+    /** The dependency manager to use to add dependencies */
+    packageManager: PackageManager;
+    /** The directory that contains the package.json where dependencies will be added */
+    directory: string;
+    /** Standard output coming from the underlying installation process */
+    stdout?: Writable;
+    /** Standard error coming from the underlying installation process */
+    stderr?: Writable;
+    /** Abort signal to stop the process */
+    signal?: AbortSignal;
+}
+/**
+ * An interface that represents a dependency name with its version
+ */
+export interface DependencyVersion {
+    /**
+     * The name of the NPM dependency as it's reflected in the package.json:
+     *
+     * @example
+     * In the example below name would be "react"
+     * ```
+     * {
+     *   "react": "1.2.3"
+     * }
+     * ```
+     */
+    name: string;
+    /**
+     * The version of the NPM dependency as it's reflected in the package.json:
+     *
+     * @example
+     * In the example below version would be "1.2.3"
+     * ```
+     * {
+     *   "react": "1.2.3"
+     * }
+     * ```
+     */
+    version: string | undefined;
+}
+/**
+ * Adds dependencies to a Node project (i.e. a project that has a package.json)
+ * @param dependencies - List of dependencies to be added.
+ * @param options - Options for adding dependencies.
+ */
+export declare function addNPMDependenciesIfNeeded(dependencies: DependencyVersion[], options: AddNPMDependenciesIfNeededOptions): Promise<void>;
+export declare function addNPMDependencies(dependencies: DependencyVersion[], options: AddNPMDependenciesIfNeededOptions): Promise<void>;
+export declare function addNPMDependenciesWithoutVersionIfNeeded(dependencies: string[], options: AddNPMDependenciesIfNeededOptions): Promise<void>;
+/**
+ * Given a directory it traverses the directory up looking for a package.json and if found, it reads it
+ * decodes the JSON, and returns its content as a Javascript object.
+ * @param options - The directory from which traverse up.
+ * @returns If found, the promise resolves with the path to the
+ *  package.json and its content. If not found, it throws a FindUpAndReadPackageJsonNotFoundError error.
+ */
+export declare function findUpAndReadPackageJson(fromDirectory: string): Promise<{
+    path: string;
+    content: unknown;
+}>;
+export declare function addResolutionOrOverride(directory: string, dependencies: {
+    [key: string]: string;
+}): Promise<void>;
+interface FindPackageVersionUpOptions {
+    fromModuleURL: import('url').URL | string;
+}
+/**
+ * Given a module URL, it traverses the directory hierarchy up until it finds a package.json
+ * and then it returns the version in it.
+ * @param options - Options
+ * @returns The version if it can find the package.json and it exists. An error otherwise.
+ */
+export declare function findPackageVersionUp(options: FindPackageVersionUpOptions): Promise<string>;
+export {};

package/dist/public/node/node-package-manager.js

@@ -0,0 +1,369 @@
+import { AbortError, BugError } from './error.js';
+import { Version } from './semver.js';
+import { AbortController } from './abort.js';
+import { exec } from '../../system.js';
+import { exists as fileExists, read as readFile, write as writeFile } from '../../file.js';
+import { glob, dirname, join as pathJoin, findUp, moduleDirectory } from '../../path.js';
+import { token, content, debug } from '../../output.js';
+import { Bug } from '../../error.js';
+import latestVersion from 'latest-version';
+/** The name of the Yarn lock file */
+export const yarnLockfile = 'yarn.lock';
+/** The name of the npm lock file */
+export const npmLockfile = 'package-lock.json';
+/** The name of the pnpm lock file */
+export const pnpmLockfile = 'pnpm-lock.yaml';
+/** The name of the pnpm workspace file */
+export const pnpmWorkspaceFile = 'pnpm-workspace.yaml';
+/** An array containing the lockfiles from all the package managers */
+export const lockfiles = [yarnLockfile, pnpmLockfile, npmLockfile];
+/**
+ * A union that represents the package managers available.
+ */
+export const packageManager = ['yarn', 'npm', 'pnpm'];
+/**
+ * Returns an abort error that's thrown when a directory that's expected to have
+ * a package.json doesn't have it.
+ * @param directory - The path to the directory that should contain a package.json
+ * @returns An abort error.
+ */
+export const PackageJsonNotFoundError = (directory) => {
+    return new AbortError(`The directory ${directory} doesn't have a package.json.`);
+};
+/**
+ * Returns a bug error that's thrown when the lookup of the package.json traversing the directory
+ * hierarchy up can't find a package.json
+ * @param directory - The directory from which the traverse has been done
+ * @returns An abort error.
+ */
+export const FindUpAndReadPackageJsonNotFoundError = (directory) => {
+    return new BugError(content `Couldn't find a a package.json traversing directories from ${token.path(directory)}`);
+};
+/**
+ * Returns the dependency manager used to run the create workflow.
+ * @param env - The environment variables of the process in which the CLI runs.
+ * @returns The dependency manager
+ */
+export function packageManagerUsedForCreating(env = process.env) {
+    if (env.npm_config_user_agent?.includes('yarn')) {
+        return 'yarn';
+    }
+    else if (env.npm_config_user_agent?.includes('pnpm')) {
+        return 'pnpm';
+    }
+    else if (env.npm_config_user_agent?.includes('npm')) {
+        return 'npm';
+    }
+    return 'unknown';
+}
+/**
+ * Returns the dependency manager used by an existing project.
+ * @param directory - The root directory of the project.
+ * @returns The dependency manager
+ */
+export async function getPackageManager(directory) {
+    debug(content `Obtaining the dependency manager in directory ${token.path(directory)}...`);
+    const yarnLockPath = pathJoin(directory, yarnLockfile);
+    const pnpmLockPath = pathJoin(directory, pnpmLockfile);
+    if (await fileExists(yarnLockPath)) {
+        return 'yarn';
+    }
+    else if (await fileExists(pnpmLockPath)) {
+        return 'pnpm';
+    }
+    else {
+        return 'npm';
+    }
+}
+/**
+ * This function traverses down a directory tree to find directories containing a package.json
+ * and installs the dependencies if needed. To know if it's needed, it uses the "check" command
+ * provided by dependency managers.
+ * @param options - Options to install dependencies recursively.
+ */
+export async function installNPMDependenciesRecursively(options) {
+    const packageJsons = await glob(pathJoin(options.directory, '**/package.json'), {
+        ignore: [pathJoin(options.directory, 'node_modules/**/package.json')],
+        cwd: options.directory,
+        onlyFiles: true,
+        deep: options.deep,
+    });
+    const abortController = new AbortController();
+    try {
+        await Promise.all(packageJsons.map(async (packageJsonPath) => {
+            const directory = dirname(packageJsonPath);
+            await installNodeModules({
+                directory,
+                packageManager: options.packageManager,
+                stdout: undefined,
+                stderr: undefined,
+                signal: abortController.signal,
+                args: [],
+            });
+        }));
+    }
+    catch (error) {
+        abortController.abort();
+        throw error;
+    }
+}
+export async function installNodeModules(options) {
+    const execOptions = {
+        cwd: options.directory,
+        stdin: undefined,
+        stdout: options.stdout,
+        stderr: options.stderr,
+        signal: options.signal,
+    };
+    let args = ['install'];
+    if (options.args) {
+        args = args.concat(options.args);
+    }
+    await exec(options.packageManager, args, execOptions);
+}
+/**
+ * Returns the name of the package configured in its package.json
+ * @param packageJsonPath - Path to the package.json file
+ * @returns A promise that resolves with the name.
+ */
+export async function getPackageName(packageJsonPath) {
+    const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+    return packageJsonContent.name;
+}
+/**
+ * Returns the list of production and dev dependencies of a package.json
+ * @param packageJsonPath - Path to the package.json file
+ * @returns A promise that resolves with the list of dependencies.
+ */
+export async function getDependencies(packageJsonPath) {
+    const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+    const dependencies = packageJsonContent.dependencies ?? {};
+    const devDependencies = packageJsonContent.devDependencies ?? {};
+    return { ...dependencies, ...devDependencies };
+}
+/**
+ * Returns true if the app uses workspaces, false otherwise.
+ * @param packageJsonPath - Path to the package.json file
+ * @param pnpmWorkspacePath - Path to the pnpm-workspace.yaml file
+ * @returns A promise that resolves with true if the app uses workspaces, false otherwise.
+ */
+export async function usesWorkspaces(appDirectory) {
+    const packageJsonPath = pathJoin(appDirectory, 'package.json');
+    const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+    const pnpmWorkspacePath = pathJoin(appDirectory, pnpmWorkspaceFile);
+    return Boolean(packageJsonContent.workspaces) || fileExists(pnpmWorkspacePath);
+}
+/**
+ * Given an NPM dependency, it checks if there's a more recent version, and if there is, it returns its value.
+ * @param dependency - The dependency name (e.g. react)
+ * @param currentVersion - The current version.
+ * @returns A promise that resolves with a more recent version or undefined if there's no more recent version.
+ */
+export async function checkForNewVersion(dependency, currentVersion) {
+    debug(content `Checking if there's a version of ${dependency} newer than ${currentVersion}`);
+    try {
+        const lastVersion = await getLatestNPMPackageVersion(dependency);
+        if (lastVersion && new Version(currentVersion).compare(lastVersion) < 0) {
+            return lastVersion;
+        }
+        else {
+            return undefined;
+        }
+        // eslint-disable-next-line no-catch-all/no-catch-all
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+/**
+ * Reads and parses a package.json
+ * @param packageJsonPath - Path to the package.json
+ * @returns An promise that resolves with an in-memory representation
+ *    of the package.json or rejects with an error if the file is not found or the content is
+ *    not decodable.
+ */
+export async function readAndParsePackageJson(packageJsonPath) {
+    if (!(await fileExists(packageJsonPath))) {
+        throw PackageJsonNotFoundError(dirname(packageJsonPath));
+    }
+    return JSON.parse(await readFile(packageJsonPath));
+}
+/**
+ * Adds dependencies to a Node project (i.e. a project that has a package.json)
+ * @param dependencies - List of dependencies to be added.
+ * @param options - Options for adding dependencies.
+ */
+export async function addNPMDependenciesIfNeeded(dependencies, options) {
+    debug(content `Adding the following dependencies if needed:
+${token.json(dependencies)}
+With options:
+${token.json(options)}
+  `);
+    const packageJsonPath = pathJoin(options.directory, 'package.json');
+    if (!(await fileExists(packageJsonPath))) {
+        throw PackageJsonNotFoundError(options.directory);
+    }
+    const existingDependencies = Object.keys(await getDependencies(packageJsonPath));
+    let dependenciesToAdd = dependencies;
+    dependenciesToAdd = dependencies.filter((dep) => {
+        return !existingDependencies.includes(dep.name);
+    });
+    if (dependenciesToAdd.length === 0) {
+        return;
+    }
+    await addNPMDependencies(dependenciesToAdd, options);
+}
+export async function addNPMDependencies(dependencies, options) {
+    let args;
+    const depedenciesWithVersion = dependencies.map((dep) => {
+        return dep.version ? `${dep.name}@${dep.version}` : dep.name;
+    });
+    switch (options.packageManager) {
+        case 'npm':
+            args = argumentsToAddDependenciesWithNPM(depedenciesWithVersion, options.type);
+            break;
+        case 'yarn':
+            args = argumentsToAddDependenciesWithYarn(depedenciesWithVersion, options.type);
+            break;
+        case 'pnpm':
+            args = argumentsToAddDependenciesWithPNPM(depedenciesWithVersion, options.type);
+            break;
+    }
+    options.stdout?.write(`Executing... ${[options.packageManager, ...args].join(' ')}`);
+    await exec(options.packageManager, args, {
+        cwd: options.directory,
+        stdout: options.stdout,
+        stderr: options.stderr,
+        signal: options.signal,
+    });
+}
+export async function addNPMDependenciesWithoutVersionIfNeeded(dependencies, options) {
+    await addNPMDependenciesIfNeeded(dependencies.map((dependency) => {
+        return { name: dependency, version: undefined };
+    }), options);
+}
+/**
+ * Returns the arguments to add dependencies using NPM.
+ * @param dependencies - The list of dependencies to add
+ * @param type - The dependency type.
+ * @returns An array with the arguments.
+ */
+function argumentsToAddDependenciesWithNPM(dependencies, type) {
+    let command = ['install'];
+    command = command.concat(dependencies);
+    switch (type) {
+        case 'dev':
+            command.push('--save-dev');
+            break;
+        case 'peer':
+            command.push('--save-peer');
+            break;
+        case 'prod':
+            command.push('--save-prod');
+            break;
+    }
+    return command;
+}
+/**
+ * Returns the arguments to add dependencies using Yarn.
+ * @param dependencies - The list of dependencies to add
+ * @param type - The dependency type.
+ * @returns An array with the arguments.
+ */
+function argumentsToAddDependenciesWithYarn(dependencies, type) {
+    let command = ['add'];
+    command = command.concat(dependencies);
+    switch (type) {
+        case 'dev':
+            command.push('--dev');
+            break;
+        case 'peer':
+            command.push('--peer');
+            break;
+        case 'prod':
+            command.push('--prod');
+            break;
+    }
+    return command;
+}
+/**
+ * Returns the arguments to add dependencies using PNPM.
+ * @param dependencies - The list of dependencies to add
+ * @param type - The dependency type.
+ * @returns An array with the arguments.
+ */
+function argumentsToAddDependenciesWithPNPM(dependencies, type) {
+    let command = ['add'];
+    command = command.concat(dependencies);
+    switch (type) {
+        case 'dev':
+            command.push('--save-dev');
+            break;
+        case 'peer':
+            command.push('--save-peer');
+            break;
+        case 'prod':
+            command.push('--save-prod');
+            break;
+    }
+    return command;
+}
+/**
+ * Given a directory it traverses the directory up looking for a package.json and if found, it reads it
+ * decodes the JSON, and returns its content as a Javascript object.
+ * @param options - The directory from which traverse up.
+ * @returns If found, the promise resolves with the path to the
+ *  package.json and its content. If not found, it throws a FindUpAndReadPackageJsonNotFoundError error.
+ */
+export async function findUpAndReadPackageJson(fromDirectory) {
+    const packageJsonPath = await findUp('package.json', { cwd: fromDirectory, type: 'file' });
+    if (packageJsonPath) {
+        const packageJson = JSON.parse(await readFile(packageJsonPath));
+        return { path: packageJsonPath, content: packageJson };
+    }
+    else {
+        throw FindUpAndReadPackageJsonNotFoundError(fromDirectory);
+    }
+}
+export async function addResolutionOrOverride(directory, dependencies) {
+    const packageManager = await getPackageManager(directory);
+    const packageJsonPath = pathJoin(directory, 'package.json');
+    const packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+    if (packageManager === 'yarn') {
+        packageJsonContent.resolutions = packageJsonContent.resolutions
+            ? { ...packageJsonContent.resolutions, ...dependencies }
+            : dependencies;
+    }
+    if (packageManager === 'npm' || packageManager === 'pnpm') {
+        packageJsonContent.overrides = packageJsonContent.overrides
+            ? { ...packageJsonContent.overrides, ...dependencies }
+            : dependencies;
+    }
+    await writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
+}
+/**
+ * Returns the latest available version of an NPM package.
+ * @param name - The name of the NPM package.
+ * @returns A promise to get the latest available version of a package.
+ */
+async function getLatestNPMPackageVersion(name) {
+    debug(content `Getting the latest version of NPM package: ${token.raw(name)}`);
+    return latestVersion(name);
+}
+/**
+ * Given a module URL, it traverses the directory hierarchy up until it finds a package.json
+ * and then it returns the version in it.
+ * @param options - Options
+ * @returns The version if it can find the package.json and it exists. An error otherwise.
+ */
+export async function findPackageVersionUp(options) {
+    const fromDirectory = moduleDirectory(options.fromModuleURL);
+    const packageJson = await findUpAndReadPackageJson(fromDirectory);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const version = packageJson.content.version;
+    if (!version) {
+        throw new Bug(content `The package.json at path ${token.path(packageJson.path)} doesn't contain a version`);
+    }
+    return version;
+}
+//# sourceMappingURL=node-package-manager.js.map