@cedarjs/vite 0.0.4

package/dist/plugins/vite-plugin-rsc-transform-server.js

@@ -0,0 +1,364 @@
+import path from "node:path";
+import * as babel from "@babel/core";
+import * as swc from "@swc/core";
+function rscTransformUseServerPlugin(outDir, serverEntryFiles) {
+  return {
+    name: "rsc-transform-use-server-plugin",
+    transform: async function(code, id) {
+      if (!code.includes("use server")) {
+        return code;
+      }
+      let mod;
+      const isTypescript = id.endsWith(".ts") || id.endsWith(".tsx");
+      try {
+        mod = swc.parseSync(code, {
+          target: "es2022",
+          syntax: isTypescript ? "typescript" : "ecmascript",
+          tsx: id.endsWith(".tsx"),
+          jsx: id.endsWith(".jsx")
+        });
+      } catch (e) {
+        console.error("Error parsing", id, e.message);
+        return code;
+      }
+      let useClient = false;
+      let moduleScopedUseServer = false;
+      for (const node of mod.body) {
+        if (node.type !== "ExpressionStatement" || node.expression.type !== "StringLiteral") {
+          continue;
+        }
+        if (node.expression.value === "use client") {
+          useClient = true;
+        }
+        if (node.expression.value === "use server") {
+          moduleScopedUseServer = true;
+        }
+      }
+      if (useClient && moduleScopedUseServer) {
+        throw new Error(
+          'Cannot have both "use client" and "use server" directives in the same file.'
+        );
+      }
+      let builtFileName = id;
+      const serverEntryKey = Object.entries(serverEntryFiles).find(
+        ([_key, value]) => value === id
+      )?.[0];
+      if (serverEntryKey) {
+        builtFileName = path.join(outDir, "assets", serverEntryKey + ".mjs");
+        if (process.platform === "win32") {
+          builtFileName = builtFileName.replaceAll("\\", "/");
+        }
+      }
+      if (!builtFileName) {
+        throw new Error(
+          `Could not find ${id} in serverEntryFiles: ` + JSON.stringify(serverEntryFiles)
+        );
+      }
+      let transformedCode = code;
+      if (moduleScopedUseServer) {
+        transformedCode = transformServerModule(mod, builtFileName, code);
+      } else {
+        const result = babel.transformSync(code, {
+          filename: id,
+          presets: ["@babel/preset-typescript"],
+          plugins: [[babelPluginTransformServerAction, { url: builtFileName }]]
+        });
+        if (!result) {
+          console.error("Failed to transform code", id, code);
+          throw new Error("Failed to transform code");
+        }
+        if (!result.code) {
+          console.error("Failed to transform code", id, code);
+          throw new Error("Transform didn't return any code");
+        }
+        transformedCode = result.code;
+      }
+      return transformedCode;
+    }
+  };
+}
+function transformServerModule(mod, url, code) {
+  const localNames = /* @__PURE__ */ new Map();
+  const localTypes = /* @__PURE__ */ new Map();
+  for (const node of mod.body) {
+    switch (node.type) {
+      // TODO (RSC): Add code comments with examples of each type of node
+      case "ExportDeclaration":
+        if (node.declaration.type === "FunctionDeclaration") {
+          const name = node.declaration.identifier.value;
+          localNames.set(name, name);
+          localTypes.set(name, "function");
+        } else if (node.declaration.type === "VariableDeclaration") {
+          for (const declaration of node.declaration.declarations) {
+            if (declaration.id.type === "Identifier") {
+              const name = declaration.id.value;
+              localNames.set(name, name);
+            }
+          }
+        }
+        break;
+      case "ExportDefaultDeclaration":
+        if (node.decl.type === "FunctionExpression") {
+          const identifier = node.decl.identifier;
+          if (identifier) {
+            localNames.set(identifier.value, "default");
+            localTypes.set(identifier.value, "function");
+          }
+        }
+        break;
+      case "ExportNamedDeclaration":
+        for (const specifier of node.specifiers) {
+          if (specifier.type === "ExportSpecifier") {
+            const name = specifier.orig.value;
+            if (specifier.exported?.type === "Identifier") {
+              const exportedName = specifier.exported.value;
+              localNames.set(name, exportedName);
+            } else if (specifier.orig.type === "Identifier") {
+              localNames.set(name, name);
+            }
+          }
+        }
+        break;
+      case "ExportDefaultExpression":
+        if (node.expression.type === "Identifier") {
+          localNames.set(node.expression.value, "default");
+        }
+        break;
+    }
+  }
+  let newSrc = code + '\n\nimport {registerServerReference} from "react-server-dom-webpack/server";\n';
+  localNames.forEach(function(exported, local) {
+    if (localTypes.get(local) !== "function") {
+      newSrc += "if (typeof " + local + ' === "function") ';
+    }
+    const urlStr = JSON.stringify(url);
+    const exportedStr = JSON.stringify(exported);
+    newSrc += `registerServerReference(${local},${urlStr},${exportedStr});
+`;
+  });
+  return newSrc;
+}
+function babelPluginTransformServerAction({
+  types: t
+}) {
+  const localNames = /* @__PURE__ */ new Map();
+  const localTypes = /* @__PURE__ */ new Map();
+  const serverActionNodes = [];
+  const topLevelFunctions = [];
+  return {
+    name: "babel-plugin-redwood-transform-server-action",
+    visitor: {
+      Program: {
+        enter(path2) {
+          path2.node.body.forEach((statement) => {
+            if (t.isFunctionDeclaration(statement)) {
+              if (hasUseServerDirective(statement)) {
+                const name = statement.id?.name;
+                if (!name) {
+                  throw new Error("Function declaration must have a name");
+                }
+                topLevelFunctions.push(name);
+                localTypes.set(name, "function");
+              }
+            }
+            if (t.isVariableDeclaration(statement)) {
+              statement.declarations.forEach((declarator) => {
+                if (t.isFunctionExpression(declarator.init)) {
+                  if (hasUseServerDirective(declarator.init)) {
+                    const name = declarator.id.type === "Identifier" ? declarator.id.name : void 0;
+                    if (!name) {
+                      throw new Error("Function declaration must have a name");
+                    }
+                    topLevelFunctions.push(name);
+                    localTypes.set(name, "function");
+                  }
+                } else if (t.isArrowFunctionExpression(declarator.init)) {
+                  if (hasUseServerDirective(declarator.init)) {
+                    const name = declarator.id.type === "Identifier" ? declarator.id.name : void 0;
+                    if (!name) {
+                      throw new Error("Function declaration must have a name");
+                    }
+                    topLevelFunctions.push(name);
+                    localTypes.set(name, "function");
+                  }
+                }
+              });
+            }
+          });
+        },
+        exit(path2, state) {
+          if (serverActionNodes.length === 0 && localTypes.size === 0) {
+            return;
+          }
+          const body = path2.node.body;
+          body.push(
+            t.importDeclaration(
+              [
+                t.importSpecifier(
+                  t.identifier("registerServerReference"),
+                  t.identifier("registerServerReference")
+                )
+              ],
+              t.stringLiteral("react-server-dom-webpack/server")
+            )
+          );
+          serverActionNodes.forEach((functionDeclaration) => {
+            body.push(t.exportNamedDeclaration(functionDeclaration));
+            const name = functionDeclaration.id?.name || "";
+            body.push(registerServerRef(name, state.opts.url, name));
+          });
+          localNames.forEach((exportedName, localName) => {
+            if (!localTypes.get(localName)) {
+              return;
+            }
+            const localType = localTypes.get(localName);
+            if (localType === "function") {
+              body.push(
+                registerServerRef(localName, state.opts.url, exportedName)
+              );
+            } else {
+              body.push(
+                t.ifStatement(
+                  t.binaryExpression(
+                    "===",
+                    t.unaryExpression("typeof", t.identifier(localName)),
+                    t.stringLiteral("function")
+                  ),
+                  registerServerRef(localName, state.opts.url, exportedName)
+                )
+              );
+            }
+          });
+        }
+      },
+      ExportNamedDeclaration(path2) {
+        const declaration = path2.node.declaration;
+        const specifiers = path2.node.specifiers;
+        if (t.isFunctionDeclaration(declaration)) {
+          if (hasUseServerDirective(declaration)) {
+            const identifier = declaration.id?.name;
+            if (identifier) {
+              localNames.set(identifier, identifier);
+              localTypes.set(identifier, "function");
+            }
+          } else {
+            const body = declaration.body;
+            const serverActionNodeIndex = indexOfServerActionNode(body);
+            if (serverActionNodeIndex >= 0) {
+              const serverActionNode = body.body[serverActionNodeIndex];
+              if (serverActionNode && t.isFunctionDeclaration(serverActionNode)) {
+                const name = serverActionNode.id?.name;
+                if (!name) {
+                }
+                serverActionNodes.push(serverActionNode);
+              }
+            }
+          }
+        } else if (t.isVariableDeclaration(declaration)) {
+          for (const declarator of declaration.declarations) {
+            const init = declarator.init;
+            if (!t.isArrowFunctionExpression(init) || !t.isBlockStatement(init.body)) {
+              continue;
+            }
+            if (hasUseServerDirective(init)) {
+              if (declarator.id.type === "Identifier") {
+                localNames.set(declarator.id.name, declarator.id.name);
+                localTypes.set(declarator.id.name, "function");
+              }
+            } else {
+              const serverActionNodeIndex = indexOfServerActionNode(init.body);
+              if (serverActionNodeIndex >= 0) {
+                const serverActionNode = init.body.body[serverActionNodeIndex];
+                if (t.isFunctionDeclaration(serverActionNode)) {
+                  const name = serverActionNode.id?.name;
+                  if (!name) {
+                    throw new Error("Server action must have a name");
+                  }
+                  const uniqueName = `__rwjs__rsa${serverActionNodes.length}_${name}`;
+                  serverActionNode.id = t.identifier(uniqueName);
+                  serverActionNodes.push(serverActionNode);
+                  init.body.body[serverActionNodeIndex] = t.variableDeclaration(
+                    "const",
+                    [
+                      t.variableDeclarator(
+                        t.identifier(name),
+                        t.identifier(uniqueName)
+                      )
+                    ]
+                  );
+                }
+              }
+            }
+          }
+        } else if (specifiers.length) {
+          specifiers.forEach((specifier) => {
+            if (t.isExportSpecifier(specifier)) {
+              const exportedName = t.isStringLiteral(specifier.exported) ? specifier.exported.value : specifier.exported.name;
+              localNames.set(specifier.local.name, exportedName);
+            }
+          });
+        }
+      },
+      ExportDefaultDeclaration(path2) {
+        const declaration = path2.node.declaration;
+        if (t.isFunctionDeclaration(declaration)) {
+          if (hasUseServerDirective(declaration)) {
+            const identifier = declaration.id?.name;
+            if (identifier) {
+              localNames.set(identifier, "default");
+              localTypes.set(identifier, "function");
+            }
+          } else {
+            const body = declaration.body;
+            const serverActionNodeIndex = indexOfServerActionNode(body);
+            if (serverActionNodeIndex >= 0) {
+              const serverActionNode = body.body[serverActionNodeIndex];
+              if (serverActionNode && t.isFunctionDeclaration(serverActionNode)) {
+                const name = serverActionNode.id?.name;
+                if (!name) {
+                  throw new Error("Server action must have a name");
+                }
+                const uniqueName = `__rwjs__rsa${serverActionNodes.length}_${name}`;
+                serverActionNode.id = t.identifier(uniqueName);
+                serverActionNodes.push(serverActionNode);
+                body.body[serverActionNodeIndex] = t.variableDeclaration(
+                  "const",
+                  [
+                    t.variableDeclarator(
+                      t.identifier(name),
+                      t.identifier(uniqueName)
+                    )
+                  ]
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  function hasUseServerDirective(statement) {
+    return "directives" in statement.body && statement.body.directives.some(
+      (directive) => directive.value.value === "use server"
+    );
+  }
+  function indexOfServerActionNode(blockStatement) {
+    return blockStatement.body.findIndex(
+      (node) => {
+        return t.isFunctionDeclaration(node) && hasUseServerDirective(node);
+      }
+    );
+  }
+  function registerServerRef(localName, url, exportedName) {
+    return t.expressionStatement(
+      t.callExpression(t.identifier("registerServerReference"), [
+        t.identifier(localName),
+        t.stringLiteral(url),
+        t.stringLiteral(exportedName)
+      ])
+    );
+  }
+}
+export {
+  rscTransformUseServerPlugin
+};

package/dist/plugins/vite-plugin-swap-apollo-provider.d.ts

@@ -0,0 +1,12 @@
+import type { PluginOption } from 'vite';
+/**
+ *
+ * Temporary plugin, that swaps the ApolloProvider import with the Suspense enabled one,
+ * until it becomes stable.
+ *
+ * import { RedwoodApolloProvider } from "@cedarjs/web/apollo" ->
+ * import { RedwoodApolloProvider } from "@cedarjs/web/dist/apollo/suspense"
+ *
+ */
+export declare function swapApolloProvider(): PluginOption;
+//# sourceMappingURL=vite-plugin-swap-apollo-provider.d.ts.map

package/dist/plugins/vite-plugin-swap-apollo-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-swap-apollo-provider.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-swap-apollo-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAExC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAcjD"}

package/dist/plugins/vite-plugin-swap-apollo-provider.js

@@ -0,0 +1,17 @@
+function swapApolloProvider() {
+  return {
+    name: "redwood-swap-apollo-provider",
+    async transform(code, id) {
+      if (/web\/src\/App\.(ts|tsx|js|jsx)$/.test(id)) {
+        return code.replace(
+          "@cedarjs/web/apollo",
+          "@cedarjs/web/dist/apollo/suspense"
+        );
+      }
+      return code;
+    }
+  };
+}
+export {
+  swapApolloProvider
+};

package/dist/rsc/rscBuildAnalyze.d.ts

@@ -0,0 +1,16 @@
+/**
+ * RSC build. Step 1.
+ * buildFeServer -> buildRscFeServer -> rscBuildAnalyze
+ * Uses rscAnalyzePlugin to collect client and server entry points
+ * Starts building the AST in entries.ts
+ * Doesn't output any files, only collects a list of RSCs and RSAs
+ */
+export declare function rscBuildAnalyze(): Promise<{
+    clientEntryFiles: {
+        [k: string]: string;
+    };
+    serverEntryFiles: {
+        [k: string]: string;
+    };
+}>;
+//# sourceMappingURL=rscBuildAnalyze.d.ts.map

package/dist/rsc/rscBuildAnalyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildAnalyze.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildAnalyze.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAsB,eAAe;;;;;;;GAgGpC"}

package/dist/rsc/rscBuildAnalyze.js

@@ -0,0 +1,92 @@
+import { build as viteBuild } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+import { getEntries } from "../lib/entries.js";
+import { onWarn } from "../lib/onWarn.js";
+import { rscAnalyzePlugin } from "../plugins/vite-plugin-rsc-analyze.js";
+async function rscBuildAnalyze() {
+  console.log("\n");
+  console.log("1. rscBuildAnalyze");
+  console.log("==================\n");
+  const rwPaths = getPaths();
+  const clientEntryFileSet = /* @__PURE__ */ new Set();
+  const serverEntryFileSet = /* @__PURE__ */ new Set();
+  if (!rwPaths.web.viteConfig) {
+    throw new Error("Vite config not found");
+  }
+  await viteBuild({
+    configFile: rwPaths.web.viteConfig,
+    root: rwPaths.web.src,
+    // @MARK: We don't care about the build output from this step. It's just
+    // for returning the entry names. Plus, the entire RSC build is chatty
+    // enough as it is. You can enable this temporarily if you need to for
+    // debugging, but we're keeping it silent by default.
+    logLevel: "silent",
+    plugins: [
+      rscAnalyzePlugin(
+        (id) => clientEntryFileSet.add(id),
+        (id) => serverEntryFileSet.add(id)
+      )
+    ],
+    ssr: {
+      // We can ignore everything that starts with `node:` because it's not
+      // going to be RSCs
+      // As of vite 5.2 `true` here means "all except node built-ins"
+      noExternal: true,
+      // Anything we know won't have "use client" or "use server" in it can
+      // safely be external. The more we can externalize the better, because
+      // it means we can skip analyzing them, which means faster build times.
+      external: [
+        "@prisma/client",
+        "@prisma/fetch-engine",
+        "@prisma/internals",
+        "@cedarjs/auth-dbauth-api",
+        "@cedarjs/cookie-jar",
+        "@cedarjs/server-store",
+        "@simplewebauthn/server",
+        "graphql-scalars",
+        "minimatch",
+        "playwright",
+        "react"
+      ],
+      resolve: {
+        externalConditions: ["react-server"]
+      }
+    },
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      manifest: "rsc-build-manifest.json",
+      write: false,
+      // We generate the entries from the simple `getEntries` function that analyses
+      // the various pages plus the ServerEntry file. This may need revisiting when we
+      // spend time on improving dev support or expand the scope of the components
+      // that are looked up via the entries mappings.
+      ssr: true,
+      rollupOptions: {
+        onwarn: onWarn,
+        input: getEntries()
+      }
+    }
+  });
+  const clientEntryFiles = Object.fromEntries(
+    Array.from(clientEntryFileSet).map((filename, i) => {
+      const rscName = `rsc-${filename.split(/[\/\\]/).at(-1)}-${i}`;
+      return [rscName, filename];
+    })
+  );
+  const serverEntryFiles = Object.fromEntries(
+    Array.from(serverEntryFileSet).map((filename, i) => {
+      const rsaName = `rsa-${filename.split(/[\/\\]/).at(-1)}-${i}`;
+      return [rsaName, filename];
+    })
+  );
+  console.log("clientEntryFiles", clientEntryFiles);
+  console.log("serverEntryFiles", serverEntryFiles);
+  return {
+    clientEntryFiles,
+    serverEntryFiles
+  };
+}
+export {
+  rscBuildAnalyze
+};

package/dist/rsc/rscBuildClient.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RSC build. Step 2.
+ * buildFeServer -> buildRscFeServer -> rscBuildClient
+ * Generate the client bundle
+ */
+export declare function rscBuildClient(clientEntryFiles: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+//# sourceMappingURL=rscBuildClient.d.ts.map

package/dist/rsc/rscBuildClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildClient.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildClient.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,+GAqE5E"}

package/dist/rsc/rscBuildClient.js

@@ -0,0 +1,67 @@
+import { build as viteBuild } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+import { onWarn } from "../lib/onWarn.js";
+import { rscRoutesAutoLoader } from "../plugins/vite-plugin-rsc-routes-auto-loader.js";
+import { ensureProcessDirWeb } from "../utils.js";
+async function rscBuildClient(clientEntryFiles) {
+  console.log("\n");
+  console.log("2. rscBuildClient");
+  console.log("=================\n");
+  const rwPaths = getPaths();
+  ensureProcessDirWeb();
+  if (!rwPaths.web.entryClient) {
+    throw new Error("Missing web/src/entry.client");
+  }
+  const clientBuildOutput = await viteBuild({
+    envFile: false,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV)
+    },
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      outDir: rwPaths.web.distBrowser,
+      emptyOutDir: true,
+      // Needed because `outDir` is not inside `root`
+      rollupOptions: {
+        onwarn: onWarn,
+        input: {
+          // @MARK: temporary hack to find the entry client so we can get the
+          // index.css bundle but we don't actually want this on an rsc page!
+          __rwjs__client_entry: rwPaths.web.entryClient,
+          // we need this, so that the output contains rsc-specific bundles
+          // for the client-only components. They get loaded once the page is
+          // rendered
+          ...clientEntryFiles
+        },
+        preserveEntrySignatures: "exports-only",
+        output: {
+          // This is not ideal. See
+          // https://rollupjs.org/faqs/#why-do-additional-imports-turn-up-in-my-entry-chunks-when-code-splitting
+          // But we need it to prevent `import 'client-only'` from being
+          // hoisted into App.tsx
+          // TODO (RSC): Fix when https://github.com/rollup/rollup/issues/5235
+          // is resolved
+          hoistTransitiveImports: false,
+          entryFileNames: () => {
+            return "assets/[name]-[hash].mjs";
+          },
+          chunkFileNames: `assets/[name]-[hash].mjs`
+        }
+      },
+      manifest: "client-build-manifest.json"
+    },
+    esbuild: {
+      logLevel: "debug"
+    },
+    logLevel: "info",
+    plugins: [rscRoutesAutoLoader()]
+  });
+  if (!("output" in clientBuildOutput)) {
+    throw new Error("Unexpected vite client build output");
+  }
+  return clientBuildOutput.output;
+}
+export {
+  rscBuildClient
+};

package/dist/rsc/rscBuildCopyCssAssets.d.ts

@@ -0,0 +1,7 @@
+import type { rscBuildForServer } from './rscBuildForServer.js';
+/**
+ * RSC build. Step 5.
+ * Copy CSS assets from server to client
+ */
+export declare function rscBuildCopyCssAssets(serverBuildOutput: Awaited<ReturnType<typeof rscBuildForServer>>): Promise<void[]>;
+//# sourceMappingURL=rscBuildCopyCssAssets.d.ts.map

package/dist/rsc/rscBuildCopyCssAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildCopyCssAssets.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildCopyCssAssets.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE/D;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,iBAAiB,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,mBAwBjE"}

package/dist/rsc/rscBuildCopyCssAssets.js

@@ -0,0 +1,22 @@
+import fs from "fs/promises";
+import path from "path";
+import { getPaths } from "@cedarjs/project-config";
+function rscBuildCopyCssAssets(serverBuildOutput) {
+  console.log("\n");
+  console.log("5. rscBuildCopyCssAssets");
+  console.log("========================\n");
+  const rwPaths = getPaths();
+  return Promise.all(
+    serverBuildOutput.filter((item) => {
+      return item.type === "asset" && item.fileName.endsWith(".css");
+    }).map((cssAsset) => {
+      return fs.copyFile(
+        path.join(rwPaths.web.distRsc, cssAsset.fileName),
+        path.join(rwPaths.web.distBrowser, cssAsset.fileName)
+      );
+    })
+  );
+}
+export {
+  rscBuildCopyCssAssets
+};

package/dist/rsc/rscBuildEntriesFile.d.ts

@@ -0,0 +1,10 @@
+import type { rscBuildClient } from './rscBuildClient.js';
+import type { rscBuildForServer } from './rscBuildForServer.js';
+/**
+ * RSC build. Step 6.
+ * Append a mapping of server asset names to client asset names to the
+ * `web/dist/rsc/entries.js` file.
+ * Only used by the RSC worker.
+ */
+export declare function rscBuildEntriesMappings(clientBuildOutput: Awaited<ReturnType<typeof rscBuildClient>>, ssrBuildOutput: Awaited<ReturnType<typeof rscBuildClient>>, serverBuildOutput: Awaited<ReturnType<typeof rscBuildForServer>>, clientEntryFiles: Record<string, string>): Promise<void>;
+//# sourceMappingURL=rscBuildEntriesFile.d.ts.map

package/dist/rsc/rscBuildEntriesFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildEntriesFile.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildEntriesFile.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE/D;;;;;GAKG;AAIH,wBAAsB,uBAAuB,CAC3C,iBAAiB,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,EAC7D,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,EAC1D,iBAAiB,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,EAChE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,iBAiGzC"}