@redmix/babel-config 0.0.1

package/dist/plugins/babel-plugin-redwood-otel-wrapping.js

@@ -0,0 +1,329 @@
+"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 babel_plugin_redwood_otel_wrapping_exports = {};
+__export(babel_plugin_redwood_otel_wrapping_exports, {
+  default: () => babel_plugin_redwood_otel_wrapping_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_otel_wrapping_exports);
+var nodejsPath = __toESM(require("path"));
+var import_project_config = require("@redmix/project-config");
+function addOpenTelemetryImport(path, t) {
+  path.node.body.unshift(
+    t.importDeclaration(
+      [
+        t.importSpecifier(
+          t.identifier("RW_OTEL_WRAPPER_TRACE"),
+          t.identifier("trace")
+        )
+      ],
+      t.stringLiteral("@opentelemetry/api")
+    )
+  );
+}
+function getRedwoodPaths(state) {
+  if (process.env.NODE_ENV === "test") {
+    return {
+      filename: "__MOCKED_FILENAME__",
+      apiFolder: "__MOCKED_API_FOLDER__"
+    };
+  }
+  const filename = state.file.opts.filename;
+  const filenameOffset = filename ? (0, import_project_config.getBaseDirFromFile)(filename).length + 9 : 0;
+  const apiFolder = filename ? filename.substring(
+    filenameOffset,
+    filename.substring(filenameOffset).indexOf(nodejsPath.sep) + filenameOffset
+  ) : "?";
+  return {
+    filename,
+    apiFolder
+  };
+}
+function wrapExportNamedDeclaration(path, state, t) {
+  const declaration = path.node.declaration;
+  const declarationIsSupported = declaration != null && declaration.type === "VariableDeclaration" && declaration.declarations[0].init?.type === "ArrowFunctionExpression";
+  if (!declarationIsSupported) {
+    return;
+  }
+  const originalFunction = declaration.declarations[0].init;
+  if (!originalFunction) {
+    return;
+  }
+  const originalFunctionName = declaration.declarations[0].id.type === "Identifier" ? declaration.declarations[0].id.name : "?";
+  const wrappedFunctionName = `__${originalFunctionName === "?" ? "RW_OTEL_WRAPPER_UNKNOWN_FUNCTION" : originalFunctionName}`;
+  const originalFunctionArgumentsWithoutDefaults = [];
+  for (const param of originalFunction.params) {
+    if (param.type === "Identifier") {
+      originalFunctionArgumentsWithoutDefaults.push(param);
+      continue;
+    }
+    if (param.type === "ObjectPattern") {
+      const objectProperties = param.properties.filter(
+        (p) => p.type === "ObjectProperty"
+      );
+      originalFunctionArgumentsWithoutDefaults.push(
+        t.objectExpression(
+          objectProperties.map((p) => {
+            if (p.value.type === "AssignmentPattern") {
+              return t.objectProperty(p.key, p.value.left);
+            }
+            return p;
+          })
+        )
+      );
+      continue;
+    }
+    if (param.type === "AssignmentPattern") {
+      if (param.left.type === "Identifier") {
+        originalFunctionArgumentsWithoutDefaults.push(param.left);
+      } else if (param.left.type === "ObjectPattern") {
+        const objectProperties = param.left.properties.filter(
+          (p) => p.type === "ObjectProperty"
+        );
+        originalFunctionArgumentsWithoutDefaults.push(
+          t.objectExpression(
+            objectProperties.map((p) => {
+              if (p.value.type === "AssignmentPattern") {
+                return t.objectProperty(p.key, p.value.left);
+              }
+              return p;
+            })
+          )
+        );
+      } else {
+        return;
+      }
+    }
+    if (param.type === "ArrayPattern" || param.type === "RestElement") {
+      return;
+    }
+  }
+  const { filename, apiFolder } = getRedwoodPaths(state);
+  const activeSpanBlock = t.callExpression(
+    t.memberExpression(
+      t.identifier("RW_OTEL_WRAPPER_TRACER"),
+      t.identifier("startActiveSpan")
+    ),
+    [
+      t.stringLiteral(`redwoodjs:api:${apiFolder}:${originalFunctionName}`),
+      t.arrowFunctionExpression(
+        [t.identifier("span")],
+        t.blockStatement([
+          t.expressionStatement(
+            t.callExpression(
+              t.memberExpression(
+                t.identifier("span"),
+                t.identifier("setAttribute")
+              ),
+              [
+                t.stringLiteral("code.function"),
+                t.stringLiteral(originalFunctionName)
+              ]
+            )
+          ),
+          t.expressionStatement(
+            t.callExpression(
+              t.memberExpression(
+                t.identifier("span"),
+                t.identifier("setAttribute")
+              ),
+              [
+                t.stringLiteral("code.filepath"),
+                t.stringLiteral(filename || "?")
+              ]
+            )
+          ),
+          t.tryStatement(
+            t.blockStatement([
+              t.variableDeclaration("const", [
+                t.variableDeclarator(
+                  t.identifier("RW_OTEL_WRAPPER_INNER_RESULT"),
+                  originalFunction.async ? t.awaitExpression(
+                    t.callExpression(
+                      t.identifier(wrappedFunctionName),
+                      originalFunctionArgumentsWithoutDefaults
+                    )
+                  ) : t.callExpression(
+                    t.identifier(wrappedFunctionName),
+                    originalFunctionArgumentsWithoutDefaults
+                  )
+                )
+              ]),
+              t.expressionStatement(
+                t.callExpression(
+                  t.memberExpression(t.identifier("span"), t.identifier("end")),
+                  []
+                )
+              ),
+              t.returnStatement(t.identifier("RW_OTEL_WRAPPER_INNER_RESULT"))
+            ]),
+            t.catchClause(
+              t.identifier("error"),
+              t.blockStatement([
+                t.expressionStatement(
+                  t.callExpression(
+                    t.memberExpression(
+                      t.identifier("span"),
+                      t.identifier("recordException")
+                    ),
+                    [t.identifier("error")]
+                  )
+                ),
+                t.expressionStatement(
+                  t.callExpression(
+                    t.memberExpression(
+                      t.identifier("span"),
+                      t.identifier("setStatus")
+                    ),
+                    [
+                      t.objectExpression([
+                        t.objectProperty(
+                          t.identifier("code"),
+                          t.numericLiteral(2)
+                        ),
+                        t.objectProperty(
+                          t.identifier("message"),
+                          t.logicalExpression(
+                            "??",
+                            t.optionalMemberExpression(
+                              t.optionalCallExpression(
+                                t.optionalMemberExpression(
+                                  t.optionalMemberExpression(
+                                    t.identifier("error"),
+                                    t.identifier("message"),
+                                    false,
+                                    true
+                                  ),
+                                  t.identifier("split"),
+                                  false,
+                                  true
+                                ),
+                                [t.stringLiteral("\n")],
+                                false
+                              ),
+                              t.numericLiteral(0),
+                              true,
+                              false
+                            ),
+                            t.optionalMemberExpression(
+                              t.optionalCallExpression(
+                                t.optionalMemberExpression(
+                                  t.optionalCallExpression(
+                                    t.optionalMemberExpression(
+                                      t.identifier("error"),
+                                      t.identifier("toString"),
+                                      false,
+                                      true
+                                    ),
+                                    [],
+                                    false
+                                  ),
+                                  t.identifier("split"),
+                                  false,
+                                  true
+                                ),
+                                [t.stringLiteral("\n")],
+                                false
+                              ),
+                              t.numericLiteral(0),
+                              true,
+                              false
+                            )
+                          )
+                        )
+                      ])
+                    ]
+                  )
+                ),
+                t.expressionStatement(
+                  t.callExpression(
+                    t.memberExpression(
+                      t.identifier("span"),
+                      t.identifier("end")
+                    ),
+                    []
+                  )
+                ),
+                t.throwStatement(t.identifier("error"))
+              ])
+            )
+          )
+        ]),
+        originalFunction.async
+      )
+    ]
+  );
+  const wrapper = t.arrowFunctionExpression(
+    originalFunction.params,
+    t.blockStatement(
+      [
+        t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.identifier(wrappedFunctionName),
+            originalFunction
+          )
+        ]),
+        t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.identifier("RW_OTEL_WRAPPER_TRACER"),
+            t.callExpression(
+              t.memberExpression(
+                t.identifier("RW_OTEL_WRAPPER_TRACE"),
+                t.identifier("getTracer")
+              ),
+              [t.stringLiteral("redwoodjs")]
+            )
+          )
+        ]),
+        t.variableDeclaration("const", [
+          t.variableDeclarator(
+            t.identifier("RW_OTEL_WRAPPER_RESULT"),
+            originalFunction.async ? t.awaitExpression(activeSpanBlock) : activeSpanBlock
+          )
+        ]),
+        t.returnStatement(t.identifier("RW_OTEL_WRAPPER_RESULT"))
+      ],
+      originalFunction.body.type === "BlockStatement" ? originalFunction.body.directives : void 0
+    ),
+    originalFunction.async
+  );
+  declaration.declarations[0].init = wrapper;
+}
+function babel_plugin_redwood_otel_wrapping_default({ types: t }) {
+  return {
+    name: "babel-plugin-redwood-otel-wrapping",
+    visitor: {
+      Program(path) {
+        addOpenTelemetryImport(path, t);
+      },
+      ExportNamedDeclaration(path, state) {
+        wrapExportNamedDeclaration(path, state, t);
+      }
+    }
+  };
+}

package/dist/plugins/babel-plugin-redwood-remove-dev-fatal-error-page.d.ts

@@ -0,0 +1,5 @@
+import type { PluginObj, types } from '@babel/core';
+export default function ({ types: t }: {
+    types: typeof types;
+}): PluginObj;
+//# sourceMappingURL=babel-plugin-redwood-remove-dev-fatal-error-page.d.ts.map

package/dist/plugins/babel-plugin-redwood-remove-dev-fatal-error-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-remove-dev-fatal-error-page.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-redwood-remove-dev-fatal-error-page.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAOnD,MAAM,CAAC,OAAO,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,GAAG,SAAS,CAuBzE"}

package/dist/plugins/babel-plugin-redwood-remove-dev-fatal-error-page.js

@@ -0,0 +1,41 @@
+"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 babel_plugin_redwood_remove_dev_fatal_error_page_exports = {};
+__export(babel_plugin_redwood_remove_dev_fatal_error_page_exports, {
+  default: () => babel_plugin_redwood_remove_dev_fatal_error_page_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_remove_dev_fatal_error_page_exports);
+function babel_plugin_redwood_remove_dev_fatal_error_page_default({ types: t }) {
+  return {
+    name: "babel-plugin-redwood-remove-dev-fatal-error-page",
+    visitor: {
+      ImportDeclaration(path) {
+        if (path.node.source.value === "@redmix/web/dist/components/DevFatalErrorPage") {
+          const variableDeclaration = t.variableDeclaration("const", [
+            t.variableDeclarator(
+              t.identifier("DevFatalErrorPage"),
+              t.identifier("undefined")
+            )
+          ]);
+          path.replaceWith(variableDeclaration);
+        }
+      }
+    }
+  };
+}

package/dist/plugins/babel-plugin-redwood-routes-auto-loader.d.ts

@@ -0,0 +1,23 @@
+import type { PluginObj, types } from '@babel/core';
+import type { PagesDependency } from '@redmix/project-config';
+export interface PluginOptions {
+    forPrerender?: boolean;
+}
+/**
+ * When running from the CLI: Babel-plugin-module-resolver will convert
+ * For dev/build/prerender (forJest == false): 'src/pages/ExamplePage' -> './pages/ExamplePage'
+ * For test (forJest == true): 'src/pages/ExamplePage' -> '/Users/blah/pathToProject/web/src/pages/ExamplePage'
+ */
+export declare const getPathRelativeToSrc: (maybeAbsolutePath: string) => string;
+export declare const withRelativeImports: (page: PagesDependency) => {
+    relativeImport: string;
+    importName: string;
+    constName: string;
+    importPath: string;
+    path: string;
+    importStatement: string;
+};
+export default function ({ types: t }: {
+    types: typeof types;
+}, { forPrerender }: PluginOptions): PluginObj;
+//# sourceMappingURL=babel-plugin-redwood-routes-auto-loader.d.ts.map

package/dist/plugins/babel-plugin-redwood-routes-auto-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-routes-auto-loader.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-redwood-routes-auto-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAQ7D,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,sBAAuB,MAAM,WAO7D,CAAA;AAED,eAAO,MAAM,mBAAmB,SAAU,eAAe;;;;;;;CAKxD,CAAA;AAED,MAAM,CAAC,OAAO,WACZ,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,EACrC,EAAE,YAAoB,EAAE,EAAE,aAAa,GACtC,SAAS,CA0KX"}

package/dist/plugins/babel-plugin-redwood-routes-auto-loader.js

@@ -0,0 +1,182 @@
+"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 babel_plugin_redwood_routes_auto_loader_exports = {};
+__export(babel_plugin_redwood_routes_auto_loader_exports, {
+  default: () => babel_plugin_redwood_routes_auto_loader_default,
+  getPathRelativeToSrc: () => getPathRelativeToSrc,
+  withRelativeImports: () => withRelativeImports
+});
+module.exports = __toCommonJS(babel_plugin_redwood_routes_auto_loader_exports);
+var import_path = __toESM(require("path"));
+var import_project_config = require("@redmix/project-config");
+const getPathRelativeToSrc = (maybeAbsolutePath) => {
+  if (!import_path.default.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${import_path.default.relative((0, import_project_config.getPaths)().web.src, maybeAbsolutePath)}`;
+};
+const withRelativeImports = (page) => {
+  return {
+    ...page,
+    relativeImport: (0, import_project_config.ensurePosixPath)(getPathRelativeToSrc(page.importPath))
+  };
+};
+function babel_plugin_redwood_routes_auto_loader_default({ types: t }, { forPrerender = false }) {
+  let pages = (0, import_project_config.processPagesDir)().map(withRelativeImports);
+  const duplicatePageImportNames = /* @__PURE__ */ new Set();
+  const sortedPageImportNames = pages.map((page) => page.importName).sort();
+  for (let i = 0; i < sortedPageImportNames.length - 1; i++) {
+    if (sortedPageImportNames[i + 1] === sortedPageImportNames[i]) {
+      duplicatePageImportNames.add(sortedPageImportNames[i]);
+    }
+  }
+  if (duplicatePageImportNames.size > 0) {
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${Array.from(
+        duplicatePageImportNames
+      ).map((name) => `'${name}'`).join(", ")}`
+    );
+  }
+  return {
+    name: "babel-plugin-redwood-routes-auto-loader",
+    visitor: {
+      // Remove any pages that have been explicitly imported in the Routes file,
+      // because when one is present, the user is requesting that the module be
+      // included in the main bundle.
+      ImportDeclaration(p) {
+        if (pages.length === 0) {
+          return;
+        }
+        const userImportRelativePath = getPathRelativeToSrc(
+          (0, import_project_config.importStatementPath)(p.node.source?.value)
+        );
+        const defaultSpecifier = p.node.specifiers.find(
+          (specifiers) => t.isImportDefaultSpecifier(specifiers)
+        );
+        if (!defaultSpecifier) {
+          return;
+        }
+        if (forPrerender) {
+          const pageThatUserImported = pages.find((page) => {
+            return page.relativeImport === (0, import_project_config.ensurePosixPath)(userImportRelativePath);
+          });
+          if (pageThatUserImported) {
+            pageThatUserImported.importName = defaultSpecifier.local.name;
+            p.node.specifiers = p.node.specifiers.filter(
+              (specifier) => !t.isImportDefaultSpecifier(specifier)
+            );
+          }
+          return;
+        }
+        if (userImportRelativePath && defaultSpecifier) {
+          pages = pages.filter(
+            (page) => !(page.relativeImport === (0, import_project_config.ensurePosixPath)(userImportRelativePath))
+          );
+        }
+      },
+      Program: {
+        enter() {
+          pages = (0, import_project_config.processPagesDir)().map(withRelativeImports);
+        },
+        exit(p) {
+          if (pages.length === 0) {
+            return;
+          }
+          const nodes = [];
+          nodes.unshift(
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier("lazy"), t.identifier("lazy"))],
+              t.stringLiteral("react")
+            )
+          );
+          for (const { importName, relativeImport } of pages) {
+            const importArgument = t.stringLiteral(relativeImport);
+            nodes.push(
+              t.variableDeclaration("const", [
+                t.variableDeclarator(
+                  t.identifier(importName),
+                  t.objectExpression([
+                    t.objectProperty(
+                      t.identifier("name"),
+                      t.stringLiteral(importName)
+                    ),
+                    // prerenderLoader for ssr/prerender and first load of
+                    // prerendered pages in browser (csr)
+                    // prerenderLoader: (name) => { prerenderLoaderImpl }
+                    t.objectProperty(
+                      t.identifier("prerenderLoader"),
+                      t.arrowFunctionExpression(
+                        [t.identifier("name")],
+                        prerenderLoaderImpl(forPrerender, relativeImport, t)
+                      )
+                    ),
+                    t.objectProperty(
+                      t.identifier("LazyComponent"),
+                      t.callExpression(t.identifier("lazy"), [
+                        t.arrowFunctionExpression(
+                          [],
+                          t.callExpression(t.identifier("import"), [
+                            importArgument
+                          ])
+                        )
+                      ])
+                    )
+                  ])
+                )
+              ])
+            );
+          }
+          p.node.body.unshift(...nodes);
+        }
+      }
+    }
+  };
+}
+function prerenderLoaderImpl(forPrerender, relativeImport, t) {
+  if (forPrerender) {
+    return t.callExpression(t.identifier("require"), [
+      t.stringLiteral(relativeImport)
+    ]);
+  }
+  return t.objectExpression([
+    t.objectProperty(
+      t.identifier("default"),
+      t.memberExpression(
+        t.identifier("globalThis.__REDWOOD__PRERENDER_PAGES"),
+        t.identifier("name"),
+        true
+      )
+    )
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathRelativeToSrc,
+  withRelativeImports
+});

package/dist/plugins/babel-plugin-redwood-src-alias.d.ts

@@ -0,0 +1,8 @@
+import type { PluginObj, types } from '@babel/core';
+export default function ({ types: t }: {
+    types: typeof types;
+}, options: {
+    /** absolute path to the `src` directory */
+    srcAbsPath: string;
+}): PluginObj;
+//# sourceMappingURL=babel-plugin-redwood-src-alias.d.ts.map

package/dist/plugins/babel-plugin-redwood-src-alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-src-alias.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-redwood-src-alias.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,CAAC,OAAO,WACZ,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,EACrC,OAAO,EAAE;IACP,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAA;CACnB,GACA,SAAS,CA6DX"}

package/dist/plugins/babel-plugin-redwood-src-alias.js

@@ -0,0 +1,72 @@
+"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 babel_plugin_redwood_src_alias_exports = {};
+__export(babel_plugin_redwood_src_alias_exports, {
+  default: () => babel_plugin_redwood_src_alias_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_src_alias_exports);
+var import_path = __toESM(require("path"));
+function babel_plugin_redwood_src_alias_default({ types: t }, options) {
+  return {
+    name: "babel-plugin-redwood-src-alias",
+    visitor: {
+      ImportDeclaration(p, state) {
+        const { value } = p.node.source;
+        const { filename } = state.file.opts;
+        if (!filename || filename?.includes("/node_modules/") || !value.startsWith("src/")) {
+          return;
+        }
+        const absPath = import_path.default.join(options.srcAbsPath, value.substr(4));
+        let newImport = import_path.default.relative(import_path.default.dirname(filename), absPath);
+        if (process.platform === "win32") {
+          newImport = newImport.replaceAll("\\", "/");
+        }
+        if (!newImport.startsWith(".")) {
+          newImport = "./" + newImport;
+        }
+        const newSource = t.stringLiteral(newImport);
+        p.node.source = newSource;
+      },
+      ExportDeclaration(p, state) {
+        if (!p?.node?.source) {
+          return;
+        }
+        const { value } = p.node.source;
+        const { filename } = state.file.opts;
+        if (!filename || filename?.includes("/node_modules/") || !value.startsWith("src/")) {
+          return;
+        }
+        const absPath = import_path.default.join(options.srcAbsPath, value.substr(4));
+        const newImport = import_path.default.relative(import_path.default.dirname(filename), absPath);
+        const newSource = t.stringLiteral(newImport);
+        p.node.source = newSource;
+      }
+    }
+  };
+}