@cedarjs/babel-config 5.0.7-next.338 → 5.0.7

package/dist/index.js

@@ -1,35 +1,55 @@
-import {
-  TARGETS_NODE,
-  getApiSideBabelConfigPath,
-  getApiSideBabelPlugins,
-  getApiSideBabelPluginsForVite,
-  getApiSideBabelPresets,
-  getApiSideDefaultBabelConfig,
-  registerApiSideBabelHook,
-  transformWithBabel
-} from "./api.js";
-import {
-  getWebSideBabelConfigPath,
-  getWebSideBabelPlugins,
-  getWebSideBabelPresets,
-  getWebSideDefaultBabelConfig,
-  getWebSideOverrides,
-  registerWebSideBabelHook
-} from "./web.js";
-import {
-  getPathsFromTypeScriptConfig,
-  getRouteHookBabelPlugins,
-  parseTypeScriptConfigFiles,
-  registerBabel
-} from "./common.js";
-export {
+"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 index_exports = {};
+__export(index_exports, {
+  TARGETS_NODE: () => import_api.TARGETS_NODE,
+  getApiSideBabelConfigPath: () => import_api.getApiSideBabelConfigPath,
+  getApiSideBabelPlugins: () => import_api.getApiSideBabelPlugins,
+  getApiSideBabelPresets: () => import_api.getApiSideBabelPresets,
+  getApiSideDefaultBabelConfig: () => import_api.getApiSideDefaultBabelConfig,
+  getCommonPlugins: () => import_common.getCommonPlugins,
+  getPathsFromConfig: () => import_common.getPathsFromTypeScriptConfig,
+  getRouteHookBabelPlugins: () => import_common.getRouteHookBabelPlugins,
+  getWebSideBabelConfigPath: () => import_web.getWebSideBabelConfigPath,
+  getWebSideBabelPlugins: () => import_web.getWebSideBabelPlugins,
+  getWebSideBabelPresets: () => import_web.getWebSideBabelPresets,
+  getWebSideDefaultBabelConfig: () => import_web.getWebSideDefaultBabelConfig,
+  getWebSideOverrides: () => import_web.getWebSideOverrides,
+  parseTypeScriptConfigFiles: () => import_common.parseTypeScriptConfigFiles,
+  registerApiSideBabelHook: () => import_api.registerApiSideBabelHook,
+  registerBabel: () => import_common.registerBabel,
+  registerWebSideBabelHook: () => import_web.registerWebSideBabelHook,
+  transformWithBabel: () => import_api.transformWithBabel
+});
+module.exports = __toCommonJS(index_exports);
+var import_api = require("./api.js");
+var import_web = require("./web.js");
+var import_common = require("./common.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   TARGETS_NODE,
   getApiSideBabelConfigPath,
   getApiSideBabelPlugins,
-  getApiSideBabelPluginsForVite,
   getApiSideBabelPresets,
   getApiSideDefaultBabelConfig,
-  getPathsFromTypeScriptConfig as getPathsFromConfig,
+  getCommonPlugins,
+  getPathsFromConfig,
   getRouteHookBabelPlugins,
   getWebSideBabelConfigPath,
   getWebSideBabelPlugins,
@@ -41,4 +61,4 @@ export {
   registerBabel,
   registerWebSideBabelHook,
   transformWithBabel
-};
+});

package/dist/plugins/babel-plugin-cedar-gqlorm-inject.d.ts

@@ -0,0 +1,32 @@
+import type { PluginObj, types } from '@babel/core';
+/**
+ * Babel plugin that injects the auto-generated gqlorm backend into
+ * `api/src/functions/graphql.ts` at build time.
+ *
+ * When `experimental.gqlorm.enabled = true` and `.cedar/gqlorm/backend.ts`
+ * exists, this plugin:
+ *
+ * 1. Adds imports at the top of graphql.ts:
+ *      import * as __gqlorm_sdl__ from '../../../.cedar/gqlorm/backend'
+ *      import { db as __gqlorm_db__ } from 'src/lib/db'
+ *
+ * 2. Inserts a statement immediately before the `createGraphQLHandler` call:
+ *      sdls = {
+ *        ...sdls,
+ *        __gqlorm__: {
+ *          schema: __gqlorm_sdl__.schema,
+ *          resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+ *        },
+ *      }
+ *
+ * The `sdls` variable is already a `let` binding at this point because
+ * `babel-plugin-redwood-import-dir` transforms the glob import
+ * `import sdls from 'src/graphql/**\/*.sdl.{js,ts}'` into `let sdls = {}`.
+ *
+ * This plugin is a no-op when gqlorm is disabled or the backend file does
+ * not exist.
+ */
+export default function ({ types: t }: {
+    types: typeof types;
+}): PluginObj;
+//# sourceMappingURL=babel-plugin-cedar-gqlorm-inject.d.ts.map

package/dist/plugins/babel-plugin-cedar-gqlorm-inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-cedar-gqlorm-inject.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-cedar-gqlorm-inject.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAY,SAAS,EAAc,KAAK,EAAE,MAAM,aAAa,CAAA;AAIzE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,GAAG,SAAS,CA8KzE"}

package/dist/plugins/babel-plugin-cedar-gqlorm-inject.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 babel_plugin_cedar_gqlorm_inject_exports = {};
+__export(babel_plugin_cedar_gqlorm_inject_exports, {
+  default: () => babel_plugin_cedar_gqlorm_inject_default
+});
+module.exports = __toCommonJS(babel_plugin_cedar_gqlorm_inject_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_project_config = require("@cedarjs/project-config");
+function babel_plugin_cedar_gqlorm_inject_default({ types: t }) {
+  return {
+    name: "babel-plugin-cedar-gqlorm-inject",
+    visitor: {
+      Program(programPath, state) {
+        let config;
+        try {
+          config = (0, import_project_config.getConfig)();
+        } catch {
+          return;
+        }
+        if (!config.experimental?.gqlorm?.enabled) {
+          return;
+        }
+        let paths;
+        try {
+          paths = (0, import_project_config.getPaths)();
+        } catch {
+          return;
+        }
+        const backendPathWithoutExt = import_node_path.default.join(
+          paths.generated.base,
+          "gqlorm",
+          "backend"
+        );
+        const backendExists = import_node_fs.default.existsSync(backendPathWithoutExt + ".ts") || import_node_fs.default.existsSync(backendPathWithoutExt + ".js");
+        if (!backendExists) {
+          return;
+        }
+        const importNames = /* @__PURE__ */ new Set();
+        programPath.traverse({
+          ImportDeclaration(p) {
+            if (t.isStringLiteral(p.node.source, {
+              value: "@cedarjs/graphql-server"
+            })) {
+              for (const specifier of p.node.specifiers) {
+                if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && specifier.imported.name === "createGraphQLHandler") {
+                  importNames.add(specifier.local.name);
+                }
+              }
+            }
+          }
+        });
+        if (importNames.size === 0) {
+          return;
+        }
+        const callExpressionPaths = [];
+        programPath.traverse({
+          CallExpression(p) {
+            if (t.isIdentifier(p.node.callee) && importNames.has(p.node.callee.name)) {
+              callExpressionPaths.push(p);
+            }
+          }
+        });
+        if (callExpressionPaths.length === 0) {
+          return;
+        }
+        const callExpressionPath = callExpressionPaths[0];
+        const statementParent = callExpressionPath.getStatementParent();
+        if (!statementParent) {
+          return;
+        }
+        const filename = state.file.opts.filename;
+        if (!filename) {
+          return;
+        }
+        const relPath = import_node_path.default.relative(import_node_path.default.dirname(filename), backendPathWithoutExt).replace(/\\/g, "/") + ".ts";
+        const importSdl = t.importDeclaration(
+          [t.importNamespaceSpecifier(t.identifier("__gqlorm_sdl__"))],
+          t.stringLiteral(relPath)
+        );
+        const importDb = t.importDeclaration(
+          [
+            t.importSpecifier(
+              t.identifier("__gqlorm_db__"),
+              t.identifier("db")
+            )
+          ],
+          t.stringLiteral("src/lib/db")
+        );
+        programPath.unshiftContainer("body", [importDb, importSdl]);
+        const sdlsMutation = t.expressionStatement(
+          t.callExpression(
+            t.memberExpression(t.identifier("Object"), t.identifier("assign")),
+            [
+              t.identifier("sdls"),
+              t.objectExpression([
+                t.objectProperty(
+                  t.identifier("__gqlorm__"),
+                  t.objectExpression([
+                    t.objectProperty(
+                      t.identifier("schema"),
+                      t.memberExpression(
+                        t.identifier("__gqlorm_sdl__"),
+                        t.identifier("schema")
+                      )
+                    ),
+                    t.objectProperty(
+                      t.identifier("resolvers"),
+                      t.callExpression(
+                        t.memberExpression(
+                          t.identifier("__gqlorm_sdl__"),
+                          t.identifier("createGqlormResolvers")
+                        ),
+                        [t.identifier("__gqlorm_db__")]
+                      )
+                    )
+                  ])
+                )
+              ])
+            ]
+          )
+        );
+        statementParent.insertBefore(sdlsMutation);
+      }
+    }
+  };
+}

package/dist/plugins/babel-plugin-cedar-graphql-options-extract.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-cedar-graphql-options-extract.d.ts.map

package/dist/plugins/babel-plugin-cedar-graphql-options-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-cedar-graphql-options-extract.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-cedar-graphql-options-extract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,SAAS,EAAc,KAAK,EAAE,MAAM,aAAa,CAAA;AAkCzE,MAAM,CAAC,OAAO,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,GAAG,SAAS,CAyEzE"}

package/dist/plugins/babel-plugin-cedar-graphql-options-extract.js

@@ -0,0 +1,88 @@
+"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_cedar_graphql_options_extract_exports = {};
+__export(babel_plugin_cedar_graphql_options_extract_exports, {
+  default: () => babel_plugin_cedar_graphql_options_extract_default
+});
+module.exports = __toCommonJS(babel_plugin_cedar_graphql_options_extract_exports);
+const exportVariableName = "__cedar_graphqlOptions";
+function optionsConstNode(t, value, state) {
+  if (t.isIdentifier(value) || t.isObjectExpression(value) || t.isCallExpression(value) || t.isConditionalExpression(value)) {
+    return t.exportNamedDeclaration(
+      t.variableDeclaration("const", [
+        t.variableDeclarator(t.identifier(exportVariableName), value)
+      ])
+    );
+  } else {
+    throw new Error(
+      `Unable to parse graphql function options in '${state.file.opts.filename}'`
+    );
+  }
+}
+function babel_plugin_cedar_graphql_options_extract_default({ types: t }) {
+  return {
+    name: "babel-plugin-cedar-graphql-options-extract",
+    visitor: {
+      Program(path, state) {
+        const importNames = /* @__PURE__ */ new Set();
+        path.traverse({
+          ImportDeclaration(p) {
+            if (t.isStringLiteral(p.node.source, {
+              value: "@cedarjs/graphql-server"
+            })) {
+              for (const specifier of p.node.specifiers) {
+                if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && specifier.imported.name === "createGraphQLHandler") {
+                  importNames.add(specifier.local.name);
+                }
+              }
+            }
+          }
+        });
+        const callExpressionPaths = [];
+        path.traverse({
+          CallExpression(p) {
+            if (t.isIdentifier(p.node.callee) && importNames.has(p.node.callee.name)) {
+              callExpressionPaths.push(p);
+            }
+          }
+        });
+        if (callExpressionPaths.length > 1) {
+          console.log(
+            `There are ${callExpressionPaths.length} calls to 'createGraphQLHandler' in '${state.file.opts.filename}'. The automatic extraction of graphql options will fallback to the first usage.`
+          );
+          return;
+        }
+        const callExpressionPath = callExpressionPaths[0];
+        if (!callExpressionPath) {
+          return;
+        }
+        const options = callExpressionPath.node.arguments[0];
+        const optionsConst = optionsConstNode(t, options, state);
+        const statementParent = callExpressionPath.getStatementParent();
+        if (!statementParent) {
+          throw new Error(
+            `Unable to find statement parent for graphql function in '${state.file.opts.filename}'`
+          );
+        }
+        statementParent.insertBefore(optionsConst);
+        callExpressionPath.node.arguments[0] = t.identifier(exportVariableName);
+      }
+    }
+  };
+}

package/dist/plugins/{babel-plugin-handler-als-wrapping.d.ts → babel-plugin-redwood-context-wrapping.d.ts}

@@ -4,4 +4,4 @@ export default function ({ types: t }: {
 }, { projectIsEsm }?: {
     projectIsEsm?: boolean;
 }): PluginObj;
-//# sourceMappingURL=babel-plugin-handler-als-wrapping.d.ts.map
+//# sourceMappingURL=babel-plugin-redwood-context-wrapping.d.ts.map

package/dist/plugins/babel-plugin-redwood-context-wrapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-context-wrapping.d.ts","sourceRoot":"","sources":["../../src/plugins/babel-plugin-redwood-context-wrapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAkEnD,MAAM,CAAC,OAAO,WACZ,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,EACrC,EAAE,YAAoB,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACxD,SAAS,CA+DX"}

package/dist/plugins/{babel-plugin-handler-als-wrapping.js → babel-plugin-redwood-context-wrapping.js}

@@ -1,10 +1,33 @@
+"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_context_wrapping_exports = {};
+__export(babel_plugin_redwood_context_wrapping_exports, {
+  default: () => babel_plugin_redwood_context_wrapping_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_context_wrapping_exports);
 function generateWrappedHandler(t, isAsync) {
   const contextStoreVariableDeclaration = t.variableDeclaration("const", [
     t.variableDeclarator(
-      t.identifier("__cedar_contextStore"),
+      t.identifier("__rw_contextStore"),
       t.callExpression(
         t.memberExpression(
-          t.callExpression(t.identifier("__cedar_getAsyncStoreInstance"), []),
+          t.callExpression(t.identifier("__rw_getAsyncStoreInstance"), []),
           t.identifier("getStore")
         ),
         []
@@ -18,13 +41,13 @@ function generateWrappedHandler(t, isAsync) {
     true
   );
   return t.arrowFunctionExpression(
-    [t.identifier("__cedar_event"), t.identifier("__cedar_context")],
+    [t.identifier("__rw_event"), t.identifier("__rw__context")],
     t.blockStatement([
       contextStoreVariableDeclaration,
       t.ifStatement(
         t.binaryExpression(
           "===",
-          t.identifier("__cedar_contextStore"),
+          t.identifier("__rw_contextStore"),
           t.identifier("undefined")
         ),
         t.blockStatement([
@@ -32,34 +55,34 @@ function generateWrappedHandler(t, isAsync) {
             t.callExpression(
               t.memberExpression(
                 t.callExpression(
-                  t.identifier("__cedar_getAsyncStoreInstance"),
+                  t.identifier("__rw_getAsyncStoreInstance"),
                   []
                 ),
                 t.identifier("run")
               ),
               [
                 t.newExpression(t.identifier("Map"), []),
-                t.identifier("__cedar_handler"),
-                t.identifier("__cedar_event"),
-                t.identifier("__cedar_context")
+                t.identifier("__rw_handler"),
+                t.identifier("__rw_event"),
+                t.identifier("__rw__context")
               ]
             )
           )
         ])
       ),
       t.returnStatement(
-        t.callExpression(t.identifier("__cedar_handler"), [
-          t.identifier("__cedar_event"),
-          t.identifier("__cedar_context")
+        t.callExpression(t.identifier("__rw_handler"), [
+          t.identifier("__rw_event"),
+          t.identifier("__rw__context")
         ])
       )
     ]),
     isAsync
   );
 }
-function babel_plugin_handler_als_wrapping_default({ types: t }, { projectIsEsm = false } = {}) {
+function babel_plugin_redwood_context_wrapping_default({ types: t }, { projectIsEsm = false } = {}) {
   return {
-    name: "babel-plugin-handler-als-wrapping",
+    name: "babel-plugin-redwood-context-wrapping",
     visitor: {
       ExportNamedDeclaration(path, _state) {
         const declaration = path.node.declaration;
@@ -78,11 +101,11 @@ function babel_plugin_handler_als_wrapping_default({ types: t }, { projectIsEsm
           return;
         }
         path.insertBefore(
-          // import { getAsyncStoreInstance as __cedar_getAsyncStoreInstance } from '@cedarjs/context/dist/store'
+          // import { getAsyncStoreInstance as __rw_getAsyncStoreInstance } from '@cedarjs/context/dist/store'
           t.importDeclaration(
             [
               t.importSpecifier(
-                t.identifier("__cedar_getAsyncStoreInstance"),
+                t.identifier("__rw_getAsyncStoreInstance"),
                 t.identifier("getAsyncStoreInstance")
               )
             ],
@@ -94,7 +117,7 @@ function babel_plugin_handler_als_wrapping_default({ types: t }, { projectIsEsm
         path.insertBefore(
           t.variableDeclaration("const", [
             t.variableDeclarator(
-              t.identifier("__cedar_handler"),
+              t.identifier("__rw_handler"),
               declaration.declarations[0].init
             )
           ])
@@ -109,6 +132,3 @@ function babel_plugin_handler_als_wrapping_default({ types: t }, { projectIsEsm
     }
   };
 }
-export {
-  babel_plugin_handler_als_wrapping_default as default
-};

package/dist/plugins/babel-plugin-redwood-directory-named-import.js

@@ -1,14 +1,47 @@
-import path from "path";
-import { resolveFile } from "@cedarjs/project-config";
+"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_directory_named_import_exports = {};
+__export(babel_plugin_redwood_directory_named_import_exports, {
+  default: () => babel_plugin_redwood_directory_named_import_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_directory_named_import_exports);
+var import_path = __toESM(require("path"));
+var import_project_config = require("@cedarjs/project-config");
 const getNewPath = (value, filename) => {
-  const dirname = path.dirname(value);
-  const basename = path.basename(value);
+  const dirname = import_path.default.dirname(value);
+  const basename = import_path.default.basename(value);
   const indexImportPath = [dirname, basename, "index"].join("/");
-  if (resolveFile(path.resolve(path.dirname(filename), indexImportPath))) {
+  if ((0, import_project_config.resolveFile)(import_path.default.resolve(import_path.default.dirname(filename), indexImportPath))) {
     return indexImportPath;
   } else {
     const dirnameImportPath = [dirname, basename, basename].join("/");
-    if (resolveFile(path.resolve(path.dirname(filename), dirnameImportPath))) {
+    if ((0, import_project_config.resolveFile)(import_path.default.resolve(import_path.default.dirname(filename), dirnameImportPath))) {
       return dirnameImportPath;
     }
   }
@@ -59,6 +92,3 @@ function babel_plugin_redwood_directory_named_import_default({ types: t }) {
     }
   };
 }
-export {
-  babel_plugin_redwood_directory_named_import_default as default
-};

package/dist/plugins/babel-plugin-redwood-import-dir.js

@@ -1,6 +1,39 @@
-import path from "path";
-import fg from "fast-glob";
-import { importStatementPath } from "@cedarjs/project-config";
+"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_import_dir_exports = {};
+__export(babel_plugin_redwood_import_dir_exports, {
+  default: () => babel_plugin_redwood_import_dir_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_import_dir_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_project_config = require("@cedarjs/project-config");
 function babel_plugin_redwood_import_dir_default({ types: t }) {
   return {
     name: "babel-plugin-redwood-import-dir",
@@ -19,15 +52,15 @@ function babel_plugin_redwood_import_dir_default({ types: t }) {
             )
           ])
         );
-        const importGlob = importStatementPath(p.node.source.value);
-        const cwd = path.dirname(state.file.opts.filename);
-        const dirFiles = fg.sync(importGlob, { cwd }).filter((n) => !n.includes(".test.")).filter((n) => !n.includes(".scenarios.")).filter((n) => !n.includes(".d.ts"));
+        const importGlob = (0, import_project_config.importStatementPath)(p.node.source.value);
+        const cwd = import_path.default.dirname(state.file.opts.filename);
+        const dirFiles = import_fast_glob.default.sync(importGlob, { cwd }).filter((n) => !n.includes(".test.")).filter((n) => !n.includes(".scenarios.")).filter((n) => !n.includes(".d.ts"));
         const staticGlob = importGlob.split("*")[0];
         const filePathToVarName = (filePath) => {
           return filePath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
         };
         for (const filePath of dirFiles) {
-          const { dir: fileDir, name: fileName } = path.parse(filePath);
+          const { dir: fileDir, name: fileName } = import_path.default.parse(filePath);
           const filePathWithoutExtension = fileDir + "/" + fileName;
           const fpVarName = filePathToVarName(filePath);
           nodes.push(
@@ -61,6 +94,3 @@ function babel_plugin_redwood_import_dir_default({ types: t }) {
     }
   };
 }
-export {
-  babel_plugin_redwood_import_dir_default as default
-};