@cedarjs/codemods 0.0.4

package/dist/codemods/v6.x.x/convertJsToJsx/convertJsToJsx.js

@@ -0,0 +1,45 @@
+"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 convertJsToJsx_exports = {};
+__export(convertJsToJsx_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(convertJsToJsx_exports);
+var import_fs = __toESM(require("fs"));
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  const containsJSX = ast.find(j.JSXElement).length !== 0 || ast.find(j.JSXFragment).length !== 0 || ast.find(j.JSXText).length !== 0;
+  if (containsJSX) {
+    import_fs.default.renameSync(
+      file.path,
+      file.path.substring(0, file.path.lastIndexOf(".")) + ".jsx"
+    );
+  }
+}

package/dist/codemods/v6.x.x/convertJsToJsx/convertJsToJsx.yargs.js

@@ -0,0 +1,59 @@
+"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 convertJsToJsx_yargs_exports = {};
+__export(convertJsToJsx_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(convertJsToJsx_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "convert-js-to-jsx";
+const description = "(v5.x.x->v6.x.x) Converts web components from .js to .jsx";
+const handler = () => {
+  (0, import_tasuku.default)("Convert Js To Jsx", async ({ setOutput }) => {
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "convertJsToJsx.js"),
+      // All files in web/src that are .js
+      targetPaths: import_fast_glob.default.sync("web/src/**/*.js")
+    });
+    setOutput(
+      "All done! Your file contents have not been changed just the extension."
+    );
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v6.x.x/entryClientNullCheck/entryClientNullCheck.js

@@ -0,0 +1,51 @@
+"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 entryClientNullCheck_exports = {};
+__export(entryClientNullCheck_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(entryClientNullCheck_exports);
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const ast = j(file.source);
+  const node = ast.find(j.VariableDeclaration, {
+    declarations: [{ id: { name: "redwoodAppElement" } }]
+  });
+  if (node.length === 0) {
+    console.warn(
+      "\nCould not find 'redwoodAppElement' variable declaration. Please make the necessary changes to your 'web/src/index.js' file manually.\n"
+    );
+    return file.source;
+  }
+  node.insertAfter(
+    j.ifStatement(
+      j.unaryExpression("!", j.identifier("redwoodAppElement")),
+      j.blockStatement([
+        j.throwStatement(
+          j.newExpression(j.identifier("Error"), [
+            j.literal(
+              "Could not find an element with ID 'redwood-app'. Please ensure it exists in your 'web/src/index.html' file."
+            )
+          ])
+        )
+      ])
+    )
+  );
+  return ast.toSource();
+}

package/dist/codemods/v6.x.x/entryClientNullCheck/entryClientNullCheck.yargs.js

@@ -0,0 +1,60 @@
+"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 entryClientNullCheck_yargs_exports = {};
+__export(entryClientNullCheck_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(entryClientNullCheck_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "entry-client-null-check";
+const description = "(v6.x.x->v6.x.x) Converts world to bazinga";
+const handler = () => {
+  (0, import_tasuku.default)("Entry Client Null Check", async ({ setOutput }) => {
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "entryClientNullCheck.js"),
+      targetPaths: import_fast_glob.default.sync("entry.client.{jsx,tsx}", {
+        cwd: (0, import_project_config.getPaths)().web.src,
+        absolute: true
+      })
+    });
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v6.x.x/processEnvDotNotation/processEnvDotNotation.js

@@ -0,0 +1,44 @@
+"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 processEnvDotNotation_exports = {};
+__export(processEnvDotNotation_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(processEnvDotNotation_exports);
+function transform(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  root.find(j.MemberExpression, {
+    object: {
+      type: "MemberExpression",
+      object: { name: "process" },
+      property: { name: "env" }
+    }
+  }).forEach((path) => {
+    const envVarName = path.value.property;
+    if (j.StringLiteral.check(envVarName)) {
+      const dotNotation = j.memberExpression(
+        j.memberExpression(j.identifier("process"), j.identifier("env")),
+        j.identifier(envVarName.value)
+      );
+      j(path).replaceWith(dotNotation);
+    }
+  });
+  return root.toSource();
+}

package/dist/codemods/v6.x.x/processEnvDotNotation/processEnvDotNotation.yargs.js

@@ -0,0 +1,60 @@
+"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 processEnvDotNotation_yargs_exports = {};
+__export(processEnvDotNotation_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(processEnvDotNotation_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "process-env-dot-notation";
+const description = "(v6.x.x->v6.x.x) Converts world to bazinga";
+const handler = () => {
+  (0, import_tasuku.default)("Process Env Dot Notation", async ({ setOutput }) => {
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "processEnvDotNotation.js"),
+      targetPaths: import_fast_glob.default.sync("**/*.{js,jsx,tsx}", {
+        cwd: (0, import_project_config.getPaths)().web.src,
+        absolute: true
+      })
+    });
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v6.x.x/replaceComponentSvgs/replaceComponentSvgs.js

@@ -0,0 +1,154 @@
+"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 replaceComponentSvgs_exports = {};
+__export(replaceComponentSvgs_exports, {
+  default: () => transform
+});
+module.exports = __toCommonJS(replaceComponentSvgs_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_core = require("@svgr/core");
+var import_pascalcase = __toESM(require("pascalcase"));
+var import_project_config = require("@cedarjs/project-config");
+async function convertSvgToReactComponent(svgFilePath, outputPath, componentName, typescript) {
+  const svgContents = await import_promises.default.readFile(svgFilePath, "utf-8");
+  const jsCode = await (0, import_core.transform)(
+    svgContents,
+    {
+      jsxRuntime: "automatic",
+      plugins: ["@svgr/plugin-jsx"],
+      typescript
+    },
+    {
+      componentName
+    }
+  );
+  await import_promises.default.writeFile(outputPath, jsCode);
+  console.log();
+  console.log(`SVG converted to React component: ${outputPath}`);
+}
+async function transform(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const isTS = file.path.endsWith(".tsx");
+  const svgImports = root.find(j.ImportDeclaration).filter((path2) => {
+    const importPath = path2.node.source.value;
+    return importPath.endsWith(".svg");
+  });
+  const svgNamedExports = root.find(j.ExportNamedDeclaration).filter((path2) => {
+    const source = path2.value.source;
+    return Boolean(
+      source && typeof source.value === "string" && source.value.endsWith(".svg")
+    );
+  });
+  const svgsToConvert = [];
+  const importOrExportStatementsWithSvg = [
+    ...svgImports.paths(),
+    ...svgNamedExports.paths()
+  ];
+  importOrExportStatementsWithSvg.forEach((declaration) => {
+    const specifiers = declaration.node.specifiers;
+    specifiers?.forEach((specifier) => {
+      let svgName = "";
+      if (specifier.type === "ExportSpecifier") {
+        svgName = specifier.exported.name;
+      } else if (specifier.type === "ImportDefaultSpecifier") {
+        if (!specifier.local) {
+          return;
+        }
+        svgName = specifier.local.name;
+      }
+      const sourcePath = declaration.node.source?.value;
+      if (!sourcePath) {
+        return;
+      }
+      const currentFolder = import_path.default.dirname(file.path);
+      let pathToSvgFile = import_path.default.resolve(currentFolder, sourcePath);
+      if (sourcePath.startsWith("src/")) {
+        pathToSvgFile = sourcePath.replace("src/", (0, import_project_config.getPaths)().web.src + "/");
+      }
+      const svgsUsedAsComponent = root.findJSXElements(svgName);
+      const svgsUsedAsRenderProp = root.find(j.JSXExpressionContainer, {
+        expression: {
+          type: "Identifier",
+          name: svgName
+        }
+      });
+      const svgsReexported = root.find(j.ExportSpecifier).filter((path2) => {
+        return path2.value.local?.name === svgName || path2.value.exported.name === svgName;
+      });
+      const selectedSvgs = [
+        ...svgsUsedAsComponent.paths(),
+        ...svgsUsedAsRenderProp.paths(),
+        ...svgsReexported.paths()
+      ];
+      selectedSvgs.forEach(() => {
+        svgsToConvert.push({
+          filePath: pathToSvgFile,
+          importSourcePath: declaration.node.source
+          // imports are all strings in this case
+        });
+      });
+    });
+  });
+  if (svgsToConvert.length > 0) {
+    await Promise.all(
+      svgsToConvert.map(async (svg) => {
+        const svgFileNameWithoutExtension = import_path.default.basename(
+          svg.filePath,
+          import_path.default.extname(svg.filePath)
+        );
+        const componentName = (0, import_pascalcase.default)(svgFileNameWithoutExtension);
+        const newFileName = `${componentName}SVG`;
+        const outputPath = import_path.default.join(
+          import_path.default.dirname(svg.filePath),
+          `${newFileName}.${isTS ? "tsx" : "jsx"}`
+        );
+        try {
+          await convertSvgToReactComponent(
+            svg.filePath,
+            outputPath,
+            componentName,
+            isTS
+          );
+        } catch (error) {
+          console.error(
+            `Error converting ${svg.filePath} to React component: ${error.message}`
+          );
+          return;
+        }
+        svg.importSourcePath.value = svg.importSourcePath.value.replace(
+          `${svgFileNameWithoutExtension}${import_path.default.extname(svg.filePath)}`,
+          newFileName
+        );
+      })
+    );
+  }
+  return root.toSource();
+}

package/dist/codemods/v6.x.x/replaceComponentSvgs/replaceComponentSvgs.yargs.js

@@ -0,0 +1,61 @@
+"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 replaceComponentSvgs_yargs_exports = {};
+__export(replaceComponentSvgs_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(replaceComponentSvgs_yargs_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_tasuku = __toESM(require("tasuku"));
+var import_project_config = require("@cedarjs/project-config");
+var import_runTransform = __toESM(require("../../../lib/runTransform"));
+const command = "replace-component-svgs";
+const description = "(v5.x.x->v6.x.x) Converts imported SVGs used as components to React components";
+const handler = () => {
+  (0, import_tasuku.default)("Replace Component Svgs", async ({ setOutput }) => {
+    const targetPaths = import_fast_glob.default.sync("**/*.{js,jsx,tsx}", {
+      cwd: (0, import_project_config.getPaths)().web.src,
+      absolute: true
+    });
+    await (0, import_runTransform.default)({
+      transformPath: import_path.default.join(__dirname, "replaceComponentSvgs.js"),
+      targetPaths
+    });
+    setOutput("All done! Run `yarn rw lint --fix` to prettify your code");
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});

package/dist/codemods/v6.x.x/updateDevFatalErrorPage/updateDevFatalErrorPage.js

@@ -0,0 +1,58 @@
+"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 updateDevFatalErrorPage_exports = {};
+__export(updateDevFatalErrorPage_exports, {
+  updateDevFatalErrorPage: () => updateDevFatalErrorPage
+});
+module.exports = __toCommonJS(updateDevFatalErrorPage_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_fetch = require("@whatwg-node/fetch");
+var import_project_config = require("@cedarjs/project-config");
+const updateDevFatalErrorPage = async () => {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const webFatalErrorPagesDir = import_path.default.join(rwPaths.web.pages, "FatalErrorPage");
+  const filename = import_path.default.join(webFatalErrorPagesDir, "FatalErrorPage");
+  const url = "https://raw.githubusercontent.com/cedarjs/cedar/0acd00946f9ad235320ea9b0b9a380d366e8936f/packages/create-cedar-app/templates/ts/web/src/pages/FatalErrorPage/FatalErrorPage.tsx";
+  const isTsxPage = import_fs.default.existsSync(
+    import_path.default.join(webFatalErrorPagesDir, "FatalErrorPage.tsx")
+  );
+  const isJsxPage = import_fs.default.existsSync(
+    import_path.default.join(webFatalErrorPagesDir, "FatalErrorPage.jsx")
+  );
+  const ext = isTsxPage ? "tsx" : isJsxPage ? "jsx" : "js";
+  const res = await (0, import_fetch.fetch)(url);
+  const text = await res.text();
+  const newFatalErrorPage = `${filename}.${ext}`;
+  import_fs.default.writeFileSync(newFatalErrorPage, text);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  updateDevFatalErrorPage
+});

package/dist/codemods/v6.x.x/updateDevFatalErrorPage/updateDevFatalErrorPage.yargs.js

@@ -0,0 +1,50 @@
+"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 updateDevFatalErrorPage_yargs_exports = {};
+__export(updateDevFatalErrorPage_yargs_exports, {
+  command: () => command,
+  description: () => description,
+  handler: () => handler
+});
+module.exports = __toCommonJS(updateDevFatalErrorPage_yargs_exports);
+var import_tasuku = __toESM(require("tasuku"));
+var import_updateDevFatalErrorPage = require("./updateDevFatalErrorPage");
+const command = "update-dev-fatal-error-page";
+const description = "(v5.x.x->v6.x.x) Update Fatal Error Page with development version from the create-cedar-app template";
+const handler = () => {
+  (0, import_tasuku.default)("Update Fatal Error Page with regular import", async () => {
+    await (0, import_updateDevFatalErrorPage.updateDevFatalErrorPage)();
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  command,
+  description,
+  handler
+});