@cedarjs/vite 0.0.4

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_path = __toESM(require("path"), 1);
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser/index.cjs");
+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_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 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_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.filter(
+            (specifier) => t.isImportDefaultSpecifier(specifier)
+          )[0];
+          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
+});

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

@@ -0,0 +1,125 @@
+"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_imports_exports = {};
+__export(vite_plugin_rsc_routes_imports_exports, {
+  rscRoutesImports: () => rscRoutesImports
+});
+module.exports = __toCommonJS(vite_plugin_rsc_routes_imports_exports);
+var import_path = __toESM(require("path"), 1);
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser/index.cjs");
+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 { default: generate } = import_generator.default;
+const { default: traverse } = import_traverse.default;
+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 rscRoutesImports() {
+  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-imports",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        return null;
+      }
+      if (pages.length === 0) {
+        return null;
+      }
+      const ext = import_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();
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const importPath = path2.node.source.value;
+          if (importPath === null) {
+            return;
+          }
+          const userImportRelativePath = getPathRelativeToSrc(
+            (0, import_project_config.importStatementPath)(path2.node.source?.value)
+          );
+          const defaultSpecifier = path2.node.specifiers.filter(
+            (specifier) => t.isImportDefaultSpecifier(specifier)
+          )[0];
+          if (userImportRelativePath && defaultSpecifier) {
+            importedNames.add(defaultSpecifier.local.name);
+          }
+        }
+      });
+      const nonImportedPages = pages.filter((page) => {
+        return !importedNames.has(page.importName);
+      });
+      for (const page of nonImportedPages) {
+        ast.program.body.unshift(
+          t.importDeclaration(
+            [t.importDefaultSpecifier(t.identifier(page.importName))],
+            t.stringLiteral(page.importPath)
+          )
+        );
+      }
+      return generate(ast).code;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscRoutesImports
+});

package/dist/cjs/plugins/vite-plugin-rsc-ssr-router-import.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_ssr_router_import_exports = {};
+__export(vite_plugin_rsc_ssr_router_import_exports, {
+  rscSsrRouterImport: () => rscSsrRouterImport
+});
+module.exports = __toCommonJS(vite_plugin_rsc_ssr_router_import_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_parser = require("@babel/parser/index.cjs");
+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 { default: generate } = import_generator.default;
+const { default: traverse } = import_traverse.default;
+function rscSsrRouterImport() {
+  const routesFileId = (0, import_vite.normalizePath)((0, import_project_config.getPaths)().web.routes);
+  return {
+    name: "rsc-ssr-router-import",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        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
+      });
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const source = path2.node.source.value;
+          if (source === "@cedarjs/router/RscRouter") {
+            path2.node.source = t.stringLiteral("@cedarjs/router/SsrRouter");
+          }
+        }
+      });
+      return generate(ast).code;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscSsrRouterImport
+});

package/dist/cjs/plugins/vite-plugin-rsc-transform-client.js

@@ -0,0 +1,229 @@
+"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_transform_client_exports = {};
+__export(vite_plugin_rsc_transform_client_exports, {
+  rscTransformUseClientPlugin: () => rscTransformUseClientPlugin
+});
+module.exports = __toCommonJS(vite_plugin_rsc_transform_client_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var acorn = __toESM(require("acorn-loose"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+function rscTransformUseClientPlugin(clientEntryFiles) {
+  return {
+    name: "rsc-transform-use-client-plugin",
+    transform: async function(code, id) {
+      if (!code.includes("use client")) {
+        return code;
+      }
+      if (code.includes("$$id")) {
+        return code;
+      }
+      let body;
+      try {
+        body = acorn.parse(code, {
+          ecmaVersion: 2024,
+          sourceType: "module"
+        }).body;
+      } catch (x) {
+        console.error("Error parsing %s %s", id, x.message);
+        return code;
+      }
+      let useClient = false;
+      let useServer = false;
+      for (const node of body) {
+        if (node.type !== "ExpressionStatement" || !node.directive) {
+          break;
+        }
+        if (node.directive === "use client") {
+          useClient = true;
+        }
+        if (node.directive === "use server") {
+          useServer = true;
+        }
+      }
+      if (!useClient) {
+        return code;
+      }
+      if (useClient && useServer) {
+        throw new Error(
+          'Cannot have both "use client" and "use server" directives in the same file.'
+        );
+      }
+      const transformedCode = await transformClientModule(
+        code,
+        body,
+        id,
+        clientEntryFiles
+      );
+      return transformedCode;
+    }
+  };
+}
+function addExportNames(names, node) {
+  switch (node.type) {
+    case "Identifier":
+      names.push(node.name);
+      return;
+    case "ObjectPattern":
+      for (const property of node.properties) {
+        addExportNames(names, property);
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of node.elements) {
+        if (element) {
+          addExportNames(names, element);
+        }
+      }
+      return;
+    case "Property":
+      addExportNames(names, node.value);
+      return;
+    case "AssignmentPattern":
+      addExportNames(names, node.left);
+      return;
+    case "RestElement":
+      addExportNames(names, node.argument);
+      return;
+    case "ParenthesizedExpression":
+      addExportNames(names, node.expression);
+      return;
+  }
+}
+async function parseExportNamesIntoNames(code, body, names) {
+  for (const node of body) {
+    switch (node.type) {
+      case "ExportAllDeclaration":
+        if (node.exported) {
+          addExportNames(names, node.exported);
+          continue;
+        } else {
+          let childBody;
+          try {
+            childBody = acorn.parse(code, {
+              ecmaVersion: 2024,
+              sourceType: "module"
+            }).body;
+          } catch (x) {
+            console.error("Error parsing %s %s", "", x.message);
+            continue;
+          }
+          await parseExportNamesIntoNames(code, childBody, names);
+          continue;
+        }
+      case "ExportDefaultDeclaration":
+        names.push("default");
+        continue;
+      case "ExportNamedDeclaration":
+        if (node.declaration) {
+          if (node.declaration.type === "VariableDeclaration") {
+            const declarations = node.declaration.declarations;
+            for (const declaration of declarations) {
+              addExportNames(names, declaration.id);
+            }
+          } else {
+            addExportNames(names, node.declaration.id);
+          }
+        }
+        if (node.specifiers) {
+          const specifiers = node.specifiers;
+          for (const specifier of specifiers) {
+            addExportNames(names, specifier.exported);
+          }
+        }
+        continue;
+      // For CJS support
+      case "ExpressionStatement": {
+        let assignmentExpression = null;
+        if (node.expression.type === "AssignmentExpression") {
+          assignmentExpression = node.expression;
+        } else if (node.expression.type === "LogicalExpression" && node.expression.right.type === "AssignmentExpression") {
+          assignmentExpression = node.expression.right;
+        }
+        if (!assignmentExpression) {
+          continue;
+        }
+        if (assignmentExpression.left.type !== "MemberExpression") {
+          continue;
+        }
+        if (assignmentExpression.left.object.type !== "Identifier") {
+          continue;
+        }
+        if (assignmentExpression.left.object.name === "exports" && assignmentExpression.left.property.type === "Identifier") {
+          if (!names.includes(assignmentExpression.left.property.name)) {
+            names.push(assignmentExpression.left.property.name);
+          }
+        } else if (assignmentExpression.left.object.name === "module" && assignmentExpression.left.property.type === "Identifier" && assignmentExpression.left.property.name === "exports" && assignmentExpression.right.type === "ObjectExpression") {
+          assignmentExpression.right.properties.forEach((property) => {
+            if (property.type === "Property" && property.key.type === "Identifier") {
+              if (!names.includes(property.key.name)) {
+                names.push(property.key.name);
+              }
+            }
+          });
+        }
+        continue;
+      }
+    }
+  }
+}
+async function transformClientModule(code, body, url, clientEntryFiles) {
+  const names = [];
+  await parseExportNamesIntoNames(code, body, names);
+  console.log("transformClientModule names", names);
+  const entryRecord = Object.entries(clientEntryFiles).find(
+    ([_key, value]) => value === url
+  );
+  const loadId = (0, import_vite.normalizePath)(
+    entryRecord ? import_node_path.default.join((0, import_project_config.getPaths)().web.distRsc, "assets", `${entryRecord[0]}.mjs`) : url
+  );
+  let newSrc = 'import {registerClientReference} from "react-server-dom-webpack/server";\n';
+  for (const name of names) {
+    if (name === "default") {
+      newSrc += "export default registerClientReference(function() {";
+      newSrc += "throw new Error(" + JSON.stringify(
+        "Attempted to call the default export of " + url + " from the server but it's on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component."
+      ) + ");";
+    } else {
+      newSrc += "export const " + name + " = ";
+      newSrc += "registerClientReference(function() {";
+      newSrc += "throw new Error(" + JSON.stringify(
+        "Attempted to call " + name + "() from the server but " + name + " is on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component."
+      ) + ");";
+    }
+    newSrc += `},${JSON.stringify(loadId)},${JSON.stringify(name)})
+;`;
+  }
+  return newSrc;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscTransformUseClientPlugin
+});