@cedarjs/cli-helpers 5.0.4-next.167 → 5.0.4

package/dist/cjs/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/lib/paths.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,QAAQ,4CAUvB"}

package/dist/cjs/lib/paths.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paths_exports = {};
+__export(paths_exports, {
+  getPaths: () => getPaths
+});
+module.exports = __toCommonJS(paths_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_colors = require("./colors.js");
+function isErrorWithMessage(e) {
+  return !!e.message;
+}
+function getPaths() {
+  try {
+    return (0, import_project_config.getPaths)();
+  } catch (e) {
+    if (isErrorWithMessage(e)) {
+      console.error(import_colors.colors.error(e.message));
+    }
+    process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPaths
+});

package/dist/cjs/lib/project.d.ts

@@ -0,0 +1,44 @@
+import type { Config } from '@cedarjs/project-config';
+export declare const getGraphqlPath: () => string | null;
+export declare const graphFunctionDoesExist: () => boolean | "" | null;
+export declare const isTypeScriptProject: () => boolean;
+export declare const getInstalledRedwoodVersion: () => any;
+/**
+ * Updates the project's cedar.toml file to include the specified packages
+ * plugin
+ *
+ * Uses toml parsing to determine if the plugin is already included in the file
+ * and only adds it if it is not.
+ *
+ * Writes the updated config to the file system by appending strings, not
+ * stringify-ing the toml.
+ */
+export declare const updateTomlConfig: (packageName: string) => void;
+export declare const updateTomlConfigTask: (packageName: string) => {
+    title: string;
+    task: () => void;
+};
+export declare const addEnvVarTask: (name: string, value: string, comment: string) => {
+    title: string;
+    task: () => void;
+};
+export declare const addEnvVar: (name: string, value: string, comment: string) => string | void;
+/**
+ * This sets the `CEDAR_CWD` env var to the redwood project directory. This is typically required for internal
+ * redwood packages to work correctly. For example, `@cedarjs/project-config` uses this when reading config
+ * or paths.
+ *
+ * @param cwd Explicitly set the redwood cwd. If not set, we'll try to determine it automatically. You likely
+ * only want to set this based on some specific input, like a CLI flag.
+ */
+export declare function setRedwoodCWD(cwd?: string): void;
+/**
+ * Create or update the given setting, in the given section, with the given value.
+ *
+ * If the section already exists it adds the new setting last
+ * If the section, and the setting, already exists, the setting is updated
+ * If the section does not exist it is created at the end of the file and the setting is added
+ * If the setting exists in the section, but is commented out, it will be uncommented and updated
+ */
+export declare function setTomlSetting(section: keyof Config, setting: string, value: string | boolean | number): void;
+//# sourceMappingURL=project.d.ts.map

package/dist/cjs/lib/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/lib/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAWrD,eAAO,MAAM,cAAc,qBAE1B,CAAA;AAED,eAAO,MAAM,sBAAsB,2BAGlC,CAAA;AAED,eAAO,MAAM,mBAAmB,eAM/B,CAAA;AAED,eAAO,MAAM,0BAA0B,WAQtC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,SAkDnD,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,aAAa,MAAM;;;CAOvD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,SAAS,MAAM;;;CAOzE,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,SAAS,MAAM,kBAqCrE,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,QAmCzC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,QA0HjC"}

package/dist/cjs/lib/project.js

@@ -0,0 +1,268 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_exports = {};
+__export(project_exports, {
+  addEnvVar: () => addEnvVar,
+  addEnvVarTask: () => addEnvVarTask,
+  getGraphqlPath: () => getGraphqlPath,
+  getInstalledRedwoodVersion: () => getInstalledRedwoodVersion,
+  graphFunctionDoesExist: () => graphFunctionDoesExist,
+  isTypeScriptProject: () => isTypeScriptProject,
+  setRedwoodCWD: () => setRedwoodCWD,
+  setTomlSetting: () => setTomlSetting,
+  updateTomlConfig: () => updateTomlConfig,
+  updateTomlConfigTask: () => updateTomlConfigTask
+});
+module.exports = __toCommonJS(project_exports);
+var fs = __toESM(require("node:fs"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_dotenv = __toESM(require("dotenv"), 1);
+var toml = __toESM(require("smol-toml"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_colors = require("./colors.js");
+var import_paths = require("./paths.js");
+const getGraphqlPath = () => {
+  return (0, import_project_config.resolveFile)(path.join((0, import_paths.getPaths)().api.functions, "graphql"));
+};
+const graphFunctionDoesExist = () => {
+  const graphqlPath = getGraphqlPath();
+  return graphqlPath && fs.existsSync(graphqlPath);
+};
+const isTypeScriptProject = () => {
+  const paths = (0, import_paths.getPaths)();
+  return fs.existsSync(path.join(paths.web.base, "tsconfig.json")) || fs.existsSync(path.join(paths.api.base, "tsconfig.json"));
+};
+const getInstalledRedwoodVersion = () => {
+  try {
+    const packageJson = require("../../package.json");
+    return packageJson.version;
+  } catch {
+    console.error(import_colors.colors.error("Could not find installed Cedar version"));
+    process.exit(1);
+  }
+};
+const updateTomlConfig = (packageName) => {
+  const configTomlPath = (0, import_project_config.getConfigPath)();
+  const originalTomlContent = fs.readFileSync(configTomlPath, "utf-8");
+  let tomlToAppend = {};
+  const config = (0, import_project_config.getConfig)();
+  const cliSection = config.experimental?.cli;
+  if (!cliSection) {
+    tomlToAppend = {
+      experimental: {
+        cli: {
+          autoInstall: true,
+          plugins: [{ package: packageName, enabled: true }]
+        }
+      }
+    };
+  } else if (cliSection.plugins) {
+    const packageExists = cliSection.plugins.some(
+      (plugin) => plugin.package === packageName
+    );
+    if (!packageExists) {
+      tomlToAppend = {
+        experimental: {
+          cli: {
+            plugins: [{ package: packageName, enabled: true }]
+          }
+        }
+      };
+    }
+  } else {
+    tomlToAppend = {
+      experimental: {
+        cli: {
+          plugins: [{ package: packageName, enabled: true }]
+        }
+      }
+    };
+  }
+  const newConfig = originalTomlContent + "\n" + (Object.keys(tomlToAppend).length > 0 ? toml.stringify(tomlToAppend) + "\n" : "");
+  return fs.writeFileSync(configTomlPath, newConfig, "utf-8");
+};
+const updateTomlConfigTask = (packageName) => {
+  return {
+    title: `Updating config file to configure ${packageName} ...`,
+    task: () => {
+      updateTomlConfig(packageName);
+    }
+  };
+};
+const addEnvVarTask = (name, value, comment) => {
+  return {
+    title: `Adding ${name} var to .env...`,
+    task: () => {
+      addEnvVar(name, value, comment);
+    }
+  };
+};
+const addEnvVar = (name, value, comment) => {
+  const envPath = path.join((0, import_paths.getPaths)().base, ".env");
+  let envFile = "";
+  const newEnvironmentVariable = [
+    comment && `# ${comment}`,
+    `${name}=${value}`,
+    ""
+  ].flat().join("\n");
+  if (fs.existsSync(envPath)) {
+    envFile = fs.readFileSync(envPath).toString();
+    const existingEnvVars = import_dotenv.default.parse(envFile);
+    if (existingEnvVars[name] && existingEnvVars[name] === value) {
+      return envFile;
+    }
+    if (existingEnvVars[name]) {
+      const p = [
+        `# Note: The existing environment variable ${name} was not overwritten. Uncomment to use its new value.`,
+        comment && `# ${comment}`,
+        `# ${name}=${value}`,
+        ""
+      ].flat().join("\n");
+      envFile += "\n" + p;
+    } else {
+      envFile += "\n" + newEnvironmentVariable;
+    }
+  } else {
+    envFile = newEnvironmentVariable;
+  }
+  return fs.writeFileSync(envPath, envFile);
+};
+function setRedwoodCWD(cwd) {
+  const configFiles = ["cedar.toml", "redwood.toml"];
+  cwd ??= process.env.CEDAR_CWD;
+  cwd ??= process.env.RWJS_CWD;
+  if (cwd) {
+    const absCwd = path.resolve(process.cwd(), cwd);
+    const found = configFiles.some((f) => fs.existsSync(path.join(absCwd, f)));
+    if (!found) {
+      const tomls = configFiles.join('" or "');
+      throw new Error(`Couldn't find a "${tomls}" file in ${absCwd}`);
+    }
+  } else {
+    const configTomlPath = (0, import_project_config.findUp)("cedar.toml", process.cwd()) || (0, import_project_config.findUp)("redwood.toml", process.cwd());
+    if (!configTomlPath) {
+      throw new Error(
+        `Couldn't find up a "cedar.toml" or "redwood.toml" file from ${process.cwd()}`
+      );
+    }
+    cwd = path.dirname(configTomlPath);
+  }
+  process.env.CEDAR_CWD = cwd;
+}
+function setTomlSetting(section, setting, value) {
+  const cedarTomlPath = (0, import_project_config.getConfigPath)();
+  const originalTomlContent = fs.readFileSync(cedarTomlPath, "utf-8");
+  const cedarTomlObject = toml.parse(originalTomlContent);
+  const sectionValue = cedarTomlObject[section];
+  const existingValue = (
+    // I don't like this type cast, but I couldn't come up with a much better
+    // solution
+    sectionValue?.[setting]
+  );
+  if (existingValue === value) {
+    return;
+  }
+  let newTomlContent = originalTomlContent.replace(/\n$/, "") + `
+
+[${section}]
+  ${setting} = ${value}`;
+  const hasExistingSettingSection = !!cedarTomlObject?.[section];
+  if (hasExistingSettingSection) {
+    const existingSectionSettings = Object.keys(cedarTomlObject[section]);
+    let inSection = false;
+    let indentation = "";
+    let insertionIndex = 1;
+    let updateExistingValue = false;
+    let updateExistingCommentedValue = false;
+    const tomlLines = originalTomlContent.split("\n");
+    tomlLines.forEach((line, index) => {
+      if (line.startsWith(`[${section}]`)) {
+        inSection = true;
+        insertionIndex = index + 1;
+      } else {
+        if (/^\s*\[/.test(line)) {
+          inSection = false;
+        }
+        if (inSection && !updateExistingValue) {
+          for (const existingSectionSetting of existingSectionSettings) {
+            const matches = line.match(
+              new RegExp(`^(\\s*)${existingSectionSetting}\\s*=`, "i")
+            );
+            if (!updateExistingValue && matches) {
+              if (!updateExistingCommentedValue) {
+                indentation = matches[1];
+              }
+              if (existingSectionSetting === setting) {
+                updateExistingValue = true;
+                insertionIndex = index;
+                indentation = matches[1];
+              }
+            }
+            if (!updateExistingValue && !updateExistingCommentedValue && /^\s*\w+\s*=/.test(line)) {
+              insertionIndex = index + 1;
+            }
+          }
+          if (!updateExistingValue) {
+            const matchesComment = line.match(
+              new RegExp(`^(\\s*)#(\\s*)${setting}\\s*=`, "i")
+            );
+            if (matchesComment) {
+              const commentIndentation = matchesComment[1].length > matchesComment[2].length ? matchesComment[1] : matchesComment[2];
+              if (commentIndentation.length - 1 > indentation.length) {
+                indentation = commentIndentation;
+              }
+              updateExistingCommentedValue = true;
+              insertionIndex = index;
+            }
+          }
+        }
+      }
+    });
+    tomlLines.splice(
+      insertionIndex,
+      updateExistingValue || updateExistingCommentedValue ? 1 : 0,
+      `${indentation}${setting} = ${value}`
+    );
+    newTomlContent = tomlLines.join("\n");
+  }
+  fs.writeFileSync(cedarTomlPath, newTomlContent);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addEnvVar,
+  addEnvVarTask,
+  getGraphqlPath,
+  getInstalledRedwoodVersion,
+  graphFunctionDoesExist,
+  isTypeScriptProject,
+  setRedwoodCWD,
+  setTomlSetting,
+  updateTomlConfig,
+  updateTomlConfigTask
+});

package/dist/cjs/lib/version.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Check if the package at the given version is compatible with the current version of the user's RedwoodJS project. This is
+ * determined by checking if the package's engines.redwoodjs field intersects with the user's RedwoodJS version.
+ *
+ * If the preferred version is not compatible, the latest compatible version will be returned if one exists.
+ */
+export declare function getCompatibilityData(packageName: string, preferredVersionOrTag: string): Promise<{
+    preferred: {
+        tag: string | undefined;
+        version: string;
+    };
+    compatible: {
+        tag: string | undefined;
+        version: string;
+    };
+}>;
+//# sourceMappingURL=version.d.ts.map

package/dist/cjs/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/lib/version.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM;;;;;;;;;GA2F9B"}

package/dist/cjs/lib/version.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  getCompatibilityData: () => getCompatibilityData
+});
+module.exports = __toCommonJS(version_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_semver = __toESM(require("semver"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function getCorrespondingTag(version, distTags) {
+  return Object.entries(distTags).find(([_, v]) => v === version)?.[0];
+}
+async function getCompatibilityData(packageName, preferredVersionOrTag) {
+  const projectPackageJson = JSON.parse(
+    import_node_fs.default.readFileSync(import_path.default.join((0, import_project_config.getPaths)().base, "package.json"), {
+      encoding: "utf8"
+    })
+  );
+  const projectRedwoodVersion = projectPackageJson.devDependencies["@cedarjs/core"];
+  const semverVersion = import_semver.default.parse(preferredVersionOrTag);
+  const isUsingTag = semverVersion === null;
+  const res = await fetch(`https://registry.npmjs.org/${packageName}`);
+  const packument = await res.json();
+  if (packument.error !== void 0) {
+    throw new Error(packument.error);
+  }
+  if (isUsingTag) {
+    if (packument["dist-tags"][preferredVersionOrTag] === void 0) {
+      throw new Error(
+        `The package '${packageName}' does not have a tag '${preferredVersionOrTag}'`
+      );
+    }
+  } else {
+    if (packument.versions[preferredVersionOrTag] === void 0) {
+      throw new Error(
+        `The package '${packageName}' does not have a version '${preferredVersionOrTag}'`
+      );
+    }
+  }
+  const preferredVersion = isUsingTag ? packument["dist-tags"][preferredVersionOrTag] : preferredVersionOrTag;
+  const packageRedwoodSpecification = packument.versions[preferredVersion].engines?.redwoodjs;
+  if (packageRedwoodSpecification !== void 0 && import_semver.default.intersects(projectRedwoodVersion, packageRedwoodSpecification)) {
+    const tag = getCorrespondingTag(preferredVersion, packument["dist-tags"]);
+    return {
+      preferred: {
+        tag,
+        version: preferredVersion
+      },
+      compatible: {
+        tag,
+        version: preferredVersion
+      }
+    };
+  }
+  const versions = import_semver.default.sort(Object.keys(packument.versions));
+  for (let i = versions.length - 1; i >= 0; i--) {
+    const redwoodVersionRequired = packument.versions[versions[i]].engines?.redwoodjs;
+    if (redwoodVersionRequired === void 0) {
+      continue;
+    }
+    if (import_semver.default.intersects(projectRedwoodVersion, redwoodVersionRequired)) {
+      return {
+        preferred: {
+          tag: getCorrespondingTag(preferredVersion, packument["dist-tags"]),
+          version: preferredVersion
+        },
+        compatible: {
+          tag: getCorrespondingTag(versions[i], packument["dist-tags"]),
+          version: versions[i]
+        }
+      };
+    }
+  }
+  throw new Error(`No compatible version of '${packageName}' was found`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCompatibilityData
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/packageManager/display.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Returns the formatted install command for the detected package manager.
+ *
+ * yarn → `yarn install`
+ * npm  → `npm install`
+ * pnpm → `pnpm install`
+ */
+export declare function formatInstallCommand(): string;
+/**
+ * Returns a formatted string for running a Cedar CLI command via the detected
+ * package manager.
+ *
+ * npm  → `npx cedar <args>`
+ * yarn → `yarn cedar <args>`
+ * pnpm → `pnpm cedar <args>`
+ */
+export declare function formatCedarCommand(args: string[]): string;
+/**
+ * Returns a formatted string for running a package.json script via the
+ * detected package manager.
+ *
+ * npm  → `npm run <script>[ -- args]`
+ * yarn → `yarn <script> [args]`
+ * pnpm → `pnpm <script> [args]`
+ */
+export declare function formatRunScriptCommand(script: string, args?: string[]): string;
+/**
+ * Returns a formatted string for running a package.json script in a workspace
+ * via the detected package manager.
+ *
+ * yarn → `yarn workspace <workspace> <script> [args]`
+ * npm  → `npm run <script> -w <workspace>[ -- args]`
+ * pnpm → `pnpm <script> --filter <workspace>[-- args]`
+ */
+export declare function formatRunWorkspaceScriptCommand(workspace: string, script: string, args?: string[]): string;
+/**
+ * Returns a formatted string for running a local binary (from
+ * node_modules/.bin) via the detected package manager.
+ *
+ * yarn → `yarn <bin> [args]`  (PnP-safe)
+ * npm  → `npx <bin> [args]`
+ * pnpm → `pnpm exec <bin> [args]`
+ */
+export declare function formatRunBinCommand(bin: string, args?: string[]): string;
+/**
+ * Returns a formatted string for running a local binary in a workspace context
+ * via the detected package manager.
+ *
+ * yarn → `yarn workspace <workspace> <bin> [args]`
+ * npm  → `npm exec -w <workspace> -- <bin> [args]`
+ * pnpm → `pnpm exec --filter <workspace> <bin> [args]`
+ */
+export declare function formatRunWorkspaceBinCommand(workspace: string, bin: string, args?: string[]): string;
+/**
+ * Returns a formatted string for a one-off package execution via the detected
+ * package manager.
+ *
+ * yarn → `yarn dlx <command> [args]`
+ * npm  → `npx <command> [args]`
+ * pnpm → `pnpm dlx <command> [args]`
+ */
+export declare function formatDlxCommand(command: string, args?: string[]): string;
+/**
+ * Returns a formatted string for adding packages to the project root via the
+ * detected package manager.
+ *
+ * yarn → `yarn add [-D] <packages>`
+ * npm  → `npm install [-D] <packages>`
+ * pnpm → `pnpm add [-D] <packages>`
+ */
+export declare function formatAddRootPackagesCommand(packages: string[], dev?: boolean): string;
+/**
+ * Returns a formatted string for adding packages to a workspace via the
+ * detected package manager.
+ *
+ * yarn → `yarn workspace <workspace> add [-D] <packages>`
+ * npm  → `npm install [-D] <packages> -w <workspace>`
+ * pnpm → `pnpm add [-D] <packages> --filter <workspace>`
+ */
+export declare function formatAddWorkspacePackagesCommand(workspace: string, packages: string[], dev?: boolean): string;
+/**
+ * Returns a formatted string for removing packages from a workspace via the
+ * detected package manager.
+ *
+ * yarn → `yarn workspace <workspace> remove <packages>`
+ * npm  → `npm uninstall <packages> -w <workspace>`
+ * pnpm → `pnpm remove <packages> --filter <workspace>`
+ */
+export declare function formatRemoveWorkspacePackagesCommand(workspace: string, packages: string[]): string;
+//# sourceMappingURL=display.d.ts.map

package/dist/cjs/packageManager/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../src/packageManager/display.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CASzD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAAM,EAAO,GAClB,MAAM,CAUR;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAAM,EAAO,GAClB,MAAM,CAgBR;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,GAAG,MAAM,CAa5E;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,MAAM,EAAO,GAClB,MAAM,CAcR;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,GAAG,MAAM,CAS7E;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAAE,EAClB,GAAG,UAAQ,GACV,MAAM,CAOR;AAED;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAAE,EAClB,GAAG,UAAQ,GACV,MAAM,CAeR;AAED;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,CAClD,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAAE,GACjB,MAAM,CAcR"}