@cedarjs/vite 5.0.7-next.338 → 5.0.7

package/dist/cjs/plugins/vite-plugin-cedarjs-job-path-injector.js

@@ -0,0 +1,134 @@
+"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 vite_plugin_cedarjs_job_path_injector_exports = {};
+__export(vite_plugin_cedarjs_job_path_injector_exports, {
+  cedarjsJobPathInjectorPlugin: () => cedarjsJobPathInjectorPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedarjs_job_path_injector_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_napi = require("@ast-grep/napi");
+var import_project_config = require("@cedarjs/project-config");
+function cedarjsJobPathInjectorPlugin() {
+  return {
+    name: "cedarjs-job-path-injector",
+    transform(code, id) {
+      if (!code.includes("createJob")) {
+        return null;
+      }
+      const isTypescript = id.endsWith(".ts") || id.endsWith(".tsx");
+      const language = isTypescript ? import_napi.Lang.TypeScript : import_napi.Lang.JavaScript;
+      let ast;
+      try {
+        ast = (0, import_napi.parse)(language, code);
+      } catch (error) {
+        console.warn("Failed to parse file:", id);
+        console.warn(error);
+        return null;
+      }
+      const paths = (0, import_project_config.getPaths)();
+      const edits = [];
+      const root = ast.root();
+      const createJobCalls = root.findAll({
+        rule: {
+          pattern: "export const $VAR_NAME = $OBJ.createJob({ $$$PROPS })"
+        }
+      });
+      for (const callNode of createJobCalls) {
+        const varNameNode = callNode.getMatch("VAR_NAME");
+        const propsNodes = callNode.getMultipleMatches("PROPS");
+        if (!varNameNode) {
+          continue;
+        }
+        const importName = varNameNode.text();
+        const importPath = import_node_path.default.relative(paths.api.jobs, id);
+        const importPathWithoutExtension = importPath.replace(/\.[^/.]+$/, "");
+        const pathProperty = `path: ${JSON.stringify(importPathWithoutExtension)}`;
+        const nameProperty = `name: ${JSON.stringify(importName)}`;
+        let insertText = "";
+        if (propsNodes.length > 0) {
+          const objectLiteral = callNode.find({
+            rule: {
+              kind: "object",
+              inside: {
+                kind: "arguments"
+              }
+            }
+          });
+          if (objectLiteral) {
+            insertText = `, ${pathProperty}, ${nameProperty}`;
+            const objectText = objectLiteral.text();
+            const closeBraceIndex = objectText.lastIndexOf("}");
+            if (closeBraceIndex !== -1) {
+              const range = objectLiteral.range();
+              edits.push({
+                startPos: range.start.index + closeBraceIndex,
+                endPos: range.start.index + closeBraceIndex,
+                insertedText: insertText
+              });
+            }
+          }
+        } else {
+          const objectLiteral = callNode.find({
+            rule: {
+              kind: "object",
+              inside: {
+                kind: "arguments"
+              }
+            }
+          });
+          if (objectLiteral) {
+            insertText = `${pathProperty}, ${nameProperty}`;
+            const objectText = objectLiteral.text();
+            const openBraceIndex = objectText.indexOf("{");
+            if (openBraceIndex !== -1) {
+              const range = objectLiteral.range();
+              edits.push({
+                startPos: range.start.index + openBraceIndex + 1,
+                endPos: range.start.index + openBraceIndex + 1,
+                insertedText: insertText
+              });
+            }
+          }
+        }
+      }
+      if (edits.length === 0) {
+        return null;
+      }
+      const modifiedCode = root.commitEdits(edits);
+      return {
+        code: modifiedCode,
+        map: null
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarjsJobPathInjectorPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js

@@ -0,0 +1,106 @@
+"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 vite_plugin_cedarjs_resolve_cedar_style_imports_exports = {};
+__export(vite_plugin_cedarjs_resolve_cedar_style_imports_exports, {
+  cedarjsResolveCedarStyleImportsPlugin: () => cedarjsResolveCedarStyleImportsPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedarjs_resolve_cedar_style_imports_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+function resolveFromAbsolutePath(absolutePath) {
+  const ext = import_node_path.default.extname(absolutePath);
+  const pathToResolve = ext ? absolutePath.slice(0, -ext.length) : absolutePath;
+  const direct = (0, import_project_config.resolveFile)(pathToResolve);
+  if (direct) {
+    return direct;
+  }
+  const indexFile = (0, import_project_config.resolveFile)(import_node_path.default.join(pathToResolve, "index"));
+  if (indexFile) {
+    return indexFile;
+  }
+  const dirNamedFile = (0, import_project_config.resolveFile)(
+    import_node_path.default.join(pathToResolve, import_node_path.default.basename(pathToResolve))
+  );
+  if (dirNamedFile) {
+    return dirNamedFile;
+  }
+  return null;
+}
+function cedarjsResolveCedarStyleImportsPlugin() {
+  let cedarPaths;
+  try {
+    cedarPaths = (0, import_project_config.getPaths)();
+  } catch {
+  }
+  return {
+    name: "cedarjs-resolve-cedar-style-imports",
+    resolveId(id, importer) {
+      if (!importer || (0, import_vite.normalizePath)(importer).includes("/node_modules/")) {
+        return null;
+      }
+      if (cedarPaths && id.startsWith("src/")) {
+        const normalizedImporter = (0, import_vite.normalizePath)(importer);
+        const normalizedWebSrc = (0, import_vite.normalizePath)(cedarPaths.web.src);
+        const normalizedApiSrc = (0, import_vite.normalizePath)(cedarPaths.api.src);
+        let srcDir;
+        if (normalizedImporter.startsWith(normalizedWebSrc)) {
+          srcDir = cedarPaths.web.src;
+        } else if (normalizedImporter.startsWith(normalizedApiSrc)) {
+          srcDir = cedarPaths.api.src;
+        }
+        if (srcDir) {
+          const resolved = resolveFromAbsolutePath(
+            import_node_path.default.join(srcDir, id.slice("src/".length))
+          );
+          if (resolved) {
+            return (0, import_vite.normalizePath)(resolved);
+          }
+        }
+      }
+      const resolvedPath = import_node_path.default.resolve(import_node_path.default.dirname(importer), id);
+      if (import_node_fs.default.existsSync(resolvedPath)) {
+        const stats = import_node_fs.default.statSync(resolvedPath);
+        if (stats.isFile()) {
+          return null;
+        }
+      }
+      const newPath = resolveFromAbsolutePath(resolvedPath);
+      if (!newPath) {
+        return null;
+      }
+      return (0, import_vite.normalizePath)(newPath);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarjsResolveCedarStyleImportsPlugin
+});

package/dist/cjs/plugins/vite-plugin-jsx-loader.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_jsx_loader_exports = {};
+__export(vite_plugin_jsx_loader_exports, {
+  cedarTransformJsAsJsx: () => cedarTransformJsAsJsx
+});
+module.exports = __toCommonJS(vite_plugin_jsx_loader_exports);
+var import_vite = require("vite");
+function cedarTransformJsAsJsx() {
+  return {
+    name: "transform-js-files-as-jsx",
+    async transform(code, id) {
+      if (!id.match(/src\/.*\.js$/)) {
+        return null;
+      }
+      return (0, import_vite.transformWithEsbuild)(code, id, {
+        loader: "jsx",
+        jsx: "automatic"
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarTransformJsAsJsx
+});

package/dist/cjs/plugins/vite-plugin-merged-config.js

@@ -0,0 +1,39 @@
+"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 vite_plugin_merged_config_exports = {};
+__export(vite_plugin_merged_config_exports, {
+  cedarMergedConfig: () => cedarMergedConfig
+});
+module.exports = __toCommonJS(vite_plugin_merged_config_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_getMergedConfig = require("../lib/getMergedConfig.js");
+function cedarMergedConfig() {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const rwConfig = (0, import_project_config.getConfig)();
+  return {
+    name: "vite-plugin-cedar",
+    // Using the config hook here lets us modify the config but returning
+    // plugins will **not** work
+    config: (0, import_getMergedConfig.getMergedConfig)(rwConfig, rwPaths)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarMergedConfig
+});

package/dist/cjs/plugins/vite-plugin-rsc-analyze.js

@@ -0,0 +1,104 @@
+"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 vite_plugin_rsc_analyze_exports = {};
+__export(vite_plugin_rsc_analyze_exports, {
+  rscAnalyzePlugin: () => rscAnalyzePlugin
+});
+module.exports = __toCommonJS(vite_plugin_rsc_analyze_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var swc = __toESM(require("@swc/core"), 1);
+function rscAnalyzePlugin(clientEntryCallback, serverEntryCallback) {
+  return {
+    name: "redwood-rsc-analyze-plugin",
+    transform(code, id) {
+      const ext = import_node_path.default.extname(id);
+      if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+        const mod = swc.parseSync(code, {
+          syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+          tsx: ext === ".tsx"
+        });
+        let directiveFound = false;
+        for (const item of mod.body) {
+          if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral") {
+            if (item.expression.value === "use client") {
+              clientEntryCallback(id);
+              directiveFound = true;
+            } else if (item.expression.value === "use server") {
+              serverEntryCallback(id);
+              directiveFound = true;
+            }
+          }
+        }
+        if (!directiveFound && code.includes("use server") && containsServerAction(mod)) {
+          serverEntryCallback(id);
+        }
+      }
+      return code;
+    }
+  };
+}
+function isServerAction(node) {
+  return node.body?.type === "BlockStatement" && node.body.stmts.some(
+    (s) => s.type === "ExpressionStatement" && s.expression.type === "StringLiteral" && s.expression.value === "use server"
+  );
+}
+function isFunctionDeclaration(node) {
+  return node.type === "FunctionDeclaration";
+}
+function isFunctionExpression(node) {
+  return node.type === "FunctionExpression";
+}
+function isArrowFunctionExpression(node) {
+  return node.type === "ArrowFunctionExpression";
+}
+function containsServerAction(mod) {
+  function walk(node) {
+    if (isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node)) {
+      if (isServerAction(node)) {
+        return true;
+      }
+    }
+    return Object.values(node).some(
+      (value) => (Array.isArray(value) ? value : [value]).some((v) => {
+        if (typeof v?.type === "string") {
+          return walk(v);
+        }
+        if (typeof v?.expression?.type === "string") {
+          return walk(v.expression);
+        }
+        return false;
+      })
+    );
+  }
+  return walk(mod);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscAnalyzePlugin
+});

package/dist/cjs/plugins/vite-plugin-rsc-reload.js

@@ -0,0 +1,75 @@
+"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 vite_plugin_rsc_reload_exports = {};
+__export(vite_plugin_rsc_reload_exports, {
+  rscReloadPlugin: () => rscReloadPlugin
+});
+module.exports = __toCommonJS(vite_plugin_rsc_reload_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var swc = __toESM(require("@swc/core"), 1);
+function rscReloadPlugin(fn) {
+  let enabled = false;
+  const isClientEntry = (id, code) => {
+    const ext = import_node_path.default.extname(id);
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+      const mod = swc.parseSync(code, {
+        syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+        tsx: ext === ".tsx"
+      });
+      for (const item of mod.body) {
+        if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral" && item.expression.value === "use client") {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  return {
+    name: "reload-plugin",
+    configResolved(config) {
+      if (config.mode === "development") {
+        enabled = true;
+      }
+    },
+    async handleHotUpdate(ctx) {
+      if (!enabled) {
+        return [];
+      }
+      if (ctx.modules.length && !isClientEntry(ctx.file, await ctx.read())) {
+        return fn("full-reload");
+      } else {
+        return [];
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscReloadPlugin
+});

package/dist/cjs/plugins/vite-plugin-rsc-routes-auto-loader.js

@@ -0,0 +1,159 @@
+"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 vite_plugin_rsc_routes_auto_loader_exports = {};
+__export(vite_plugin_rsc_routes_auto_loader_exports, {
+  rscRoutesAutoLoader: () => rscRoutesAutoLoader
+});
+module.exports = __toCommonJS(vite_plugin_rsc_routes_auto_loader_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var t = __toESM(require("@babel/types"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+const generate = import_generator.default.default;
+const traverse = import_traverse.default.default;
+const getPathRelativeToSrc = (maybeAbsolutePath) => {
+  if (!import_node_path.default.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${import_node_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 rscRoutesAutoLoader() {
+  const routesFileId = (0, import_vite.normalizePath)((0, import_project_config.getPaths)().web.routes);
+  const 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) {
+    const pageNames = Array.from(duplicatePageImportNames).map((name) => `'${name}'`).join(", ");
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${pageNames}`
+    );
+  }
+  return {
+    name: "rsc-routes-auto-loader-dev",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        return null;
+      }
+      if (pages.length === 0) {
+        return null;
+      }
+      const ext = import_node_path.default.extname(id);
+      const plugins = [];
+      if (ext === ".jsx") {
+        plugins.push("jsx");
+      }
+      const ast = (0, import_parser.parse)(code, {
+        sourceType: "unambiguous",
+        plugins
+      });
+      const importedNames = /* @__PURE__ */ new Set();
+      const allImports = /* @__PURE__ */ new Map();
+      const wrappers = /* @__PURE__ */ new Set();
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const importPath = path2.node.source.value;
+          if (importPath === null) {
+            return;
+          }
+          const userImportRelativePath = getPathRelativeToSrc(
+            (0, import_project_config.importStatementPath)(importPath)
+          );
+          const defaultSpecifier = path2.node.specifiers.find(
+            (specifier) => t.isImportDefaultSpecifier(specifier)
+          );
+          if (userImportRelativePath && defaultSpecifier) {
+            importedNames.add(defaultSpecifier.local.name);
+          }
+          path2.node.specifiers.forEach((specifier) => {
+            allImports.set(specifier.local.name, path2.node);
+          });
+        },
+        JSXElement() {
+        },
+        CallExpression(path2) {
+          if ((t.isIdentifier(path2.node.callee, { name: "jsxs" }) || t.isIdentifier(path2.node.callee, { name: "jsx" })) && t.isIdentifier(path2.node.arguments[0]) && path2.node.arguments[0].name === "Set") {
+            const jsxArgs = path2.node.arguments;
+            if (t.isObjectExpression(jsxArgs[1])) {
+              const wrapProp = jsxArgs[1].properties.find(
+                (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: "wrap" })
+              );
+              if (t.isArrayExpression(wrapProp?.value)) {
+                wrapProp.value.elements.forEach((element) => {
+                  if (t.isIdentifier(element)) {
+                    wrappers.add(element.name);
+                  }
+                });
+              } else if (t.isIdentifier(wrapProp?.value)) {
+                wrappers.add(wrapProp.value.name);
+              }
+            }
+          }
+        }
+      });
+      const nonImportedPages = pages.filter(
+        (page) => !importedNames.has(page.importName)
+      );
+      wrappers.forEach((wrapper) => {
+        const wrapperImport = allImports.get(wrapper);
+        if (wrapperImport) {
+          wrapperImport.source.value = "@cedarjs/router/dist/dummyComponent";
+        }
+      });
+      for (const page of nonImportedPages) {
+        ast.program.body.unshift(
+          t.variableDeclaration("const", [
+            t.variableDeclarator(
+              t.identifier(page.constName),
+              t.arrowFunctionExpression([], t.nullLiteral())
+            )
+          ])
+        );
+      }
+      return generate(ast).code;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscRoutesAutoLoader
+});