@cedarjs/cli-helpers 0.0.4

package/dist/cjs/lib/project.js

@@ -0,0 +1,265 @@
+"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 redwoodTomlPath = (0, import_project_config.getConfigPath)();
+  const originalTomlContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+  let tomlToAppend = {};
+  const config = (0, import_project_config.getConfig)(redwoodTomlPath);
+  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(redwoodTomlPath, newConfig, "utf-8");
+};
+const updateTomlConfigTask = (packageName) => {
+  return {
+    title: `Updating redwood.toml 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);
+};
+const setRedwoodCWD = (cwd) => {
+  cwd ??= process.env.RWJS_CWD;
+  if (cwd) {
+    if (!fs.existsSync(path.join(cwd, "redwood.toml"))) {
+      throw new Error(`Couldn't find a "redwood.toml" file in ${cwd}`);
+    }
+  } else {
+    const redwoodTOMLPath = (0, import_project_config.findUp)("redwood.toml", process.cwd());
+    if (!redwoodTOMLPath) {
+      throw new Error(
+        `Couldn't find up a "redwood.toml" file from ${process.cwd()}`
+      );
+    }
+    if (redwoodTOMLPath) {
+      cwd = path.dirname(redwoodTOMLPath);
+    }
+  }
+  process.env.RWJS_CWD = cwd;
+};
+function setTomlSetting(section, setting, value) {
+  const redwoodTomlPath = (0, import_project_config.getConfigPath)();
+  const originalTomlContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+  const redwoodTomlObject = toml.parse(originalTomlContent);
+  const sectionValue = redwoodTomlObject[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 = !!redwoodTomlObject?.[section];
+  if (hasExistingSettingSection) {
+    const existingSectionSettings = Object.keys(redwoodTomlObject[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(redwoodTomlPath, 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_fs = __toESM(require("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_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/telemetry/index.d.ts

@@ -0,0 +1,20 @@
+import type { AttributeValue, Span } from '@opentelemetry/api';
+type TelemetryAttributes = {
+    [key: string]: AttributeValue;
+};
+/**
+ * Safely records attributes to the opentelemetry span
+ *
+ * @param attributes An object of key-value pairs to be individually recorded as attributes
+ * @param span An optional span to record the attributes to. If not provided, the current active span will be used
+ */
+export declare function recordTelemetryAttributes(attributes: TelemetryAttributes, span?: Span): void;
+/**
+ * Safely records an error to the opentelemetry span
+ *
+ * @param error An error to record to the span
+ * @param span An optional span to record the error to. If not provided, the current active span will be used
+ */
+export declare function recordTelemetryError(error: any, span?: Span): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/telemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/telemetry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAG9D,KAAK,mBAAmB,GAAG;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;CAC9B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,mBAAmB,EAC/B,IAAI,CAAC,EAAE,IAAI,QASZ;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,IAAI,QAe3D"}

package/dist/cjs/telemetry/index.js

@@ -0,0 +1,62 @@
+"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 telemetry_exports = {};
+__export(telemetry_exports, {
+  recordTelemetryAttributes: () => recordTelemetryAttributes,
+  recordTelemetryError: () => recordTelemetryError
+});
+module.exports = __toCommonJS(telemetry_exports);
+var import_api = __toESM(require("@opentelemetry/api"), 1);
+function recordTelemetryAttributes(attributes, span) {
+  const spanToRecord = span ?? import_api.default.trace.getActiveSpan();
+  if (spanToRecord === void 0) {
+    return;
+  }
+  for (const [key, value] of Object.entries(attributes)) {
+    spanToRecord.setAttribute(key, value);
+  }
+}
+function recordTelemetryError(error, span) {
+  const spanToRecord = span ?? import_api.default.trace.getActiveSpan();
+  if (spanToRecord === void 0) {
+    return;
+  }
+  const message = error?.message ?? error?.toString() ?? "Unknown error";
+  const firstLineOfError = message.split("\n")[0];
+  spanToRecord.setStatus({
+    code: import_api.SpanStatusCode.ERROR,
+    message: firstLineOfError
+  });
+  spanToRecord.recordException(error ?? new Error(firstLineOfError));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  recordTelemetryAttributes,
+  recordTelemetryError
+});

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './lib/index.js';
+export * from './lib/colors.js';
+export { loadEnvFiles } from './lib/loadEnvFiles.js';
+export { loadDefaultEnvFiles, loadNodeEnvDerivedEnvFile, loadUserSpecifiedEnvFiles, } from './lib/loadEnvFiles.js';
+export * from './lib/paths.js';
+export * from './lib/project.js';
+export * from './lib/version.js';
+export * from './auth/setupHelpers.js';
+export type { AuthHandlerArgs } from './auth/setupHelpers.js';
+export * from './lib/installHelpers.js';
+export * from './telemetry/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,cAAc,yBAAyB,CAAA;AAEvC,cAAc,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,20 @@
+export * from "./lib/index.js";
+export * from "./lib/colors.js";
+import { loadEnvFiles } from "./lib/loadEnvFiles.js";
+import {
+  loadDefaultEnvFiles,
+  loadNodeEnvDerivedEnvFile,
+  loadUserSpecifiedEnvFiles
+} from "./lib/loadEnvFiles.js";
+export * from "./lib/paths.js";
+export * from "./lib/project.js";
+export * from "./lib/version.js";
+export * from "./auth/setupHelpers.js";
+export * from "./lib/installHelpers.js";
+export * from "./telemetry/index.js";
+export {
+  loadDefaultEnvFiles,
+  loadEnvFiles,
+  loadNodeEnvDerivedEnvFile,
+  loadUserSpecifiedEnvFiles
+};

package/dist/lib/colors.d.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+/**
+ * To keep a consistent color/style palette between cli packages, such as
+ * @redwood/cli and @redwood/create-cedar-app, please only use the colors
+ * defined here. If you *really* can't find a color that fits your needs,
+ * it's better to add it here than to introduce a new one-off color in whatever
+ * package you're going to use it in.
+ */
+export declare const colors: {
+    error: chalk.Chalk;
+    warning: chalk.Chalk;
+    highlight: chalk.Chalk;
+    success: chalk.Chalk;
+    info: chalk.Chalk;
+    bold: chalk.Chalk;
+    underline: chalk.Chalk;
+    note: chalk.Chalk;
+    tip: chalk.Chalk;
+    important: chalk.Chalk;
+    caution: chalk.Chalk;
+    link: chalk.Chalk;
+};
+//# sourceMappingURL=colors.d.ts.map

package/dist/lib/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/lib/colors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;CAalB,CAAA"}

package/dist/lib/colors.js

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+const colors = {
+  error: chalk.bold.red,
+  warning: chalk.hex("#ffa500"),
+  highlight: chalk.hex("#ffa500"),
+  success: chalk.green,
+  info: chalk.grey,
+  bold: chalk.bold,
+  underline: chalk.underline,
+  note: chalk.blue,
+  tip: chalk.green,
+  important: chalk.magenta,
+  caution: chalk.red,
+  link: chalk.underline
+};
+export {
+  colors
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,21 @@
+import type { ListrTaskWrapper, ListrRenderer } from 'listr2';
+import { Listr } from 'listr2';
+export declare const transformTSToJS: (filename: string, content: string) => string | Promise<string>;
+/**
+ * This returns the config present in `prettier.config.js` of a Redwood project.
+ */
+export declare const getPrettierOptions: () => Promise<any>;
+export declare const prettify: (templateFilename: string, renderedTemplate: string) => Promise<string>;
+export type ExistingFiles = 'OVERWRITE' | 'SKIP' | 'FAIL';
+export declare const writeFile: <Renderer extends typeof ListrRenderer>(target: string, contents: string, { existingFiles }?: {
+    existingFiles?: ExistingFiles;
+}, task?: ListrTaskWrapper<never, Renderer, Renderer>) => void;
+/**
+ * Creates a list of tasks that write files to the disk.
+ *
+ * @param files - {[filepath]: contents}
+ */
+export declare const writeFilesTask: <Renderer extends typeof ListrRenderer>(files: Record<string, string>, options: {
+    existingFiles: ExistingFiles;
+}) => Listr<never, Renderer, "simple">;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EAEd,MAAM,QAAQ,CAAA;AACf,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAU9B,eAAO,MAAM,eAAe,aAAc,MAAM,WAAW,MAAM,6BA8BhE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,oBAkB9B,CAAA;AAED,eAAO,MAAM,QAAQ,qBACD,MAAM,oBACN,MAAM,KACvB,OAAO,CAAC,MAAM,CAqBhB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAA;AAEzD,eAAO,MAAM,SAAS,GAAI,QAAQ,SAAS,OAAO,aAAa,UACrD,MAAM,YACJ,MAAM,sBACY;IAAE,aAAa,CAAC,EAAE,aAAa,CAAA;CAAE,SAGvD,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC,SAwBlD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,SAAS,OAAO,aAAa,SAC3D,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WACpB;IAAE,aAAa,EAAE,aAAa,CAAA;CAAE,qCAuB1C,CAAA"}