@cedarjs/vite 0.0.4

package/dist/rsc/rscRequestHandler.js

@@ -0,0 +1,131 @@
+import { Readable } from "node:stream";
+import * as DefaultFetchAPI from "@whatwg-node/fetch";
+import { normalizeNodeRequest } from "@whatwg-node/server";
+import busboy from "busboy";
+import {
+  decodeReply,
+  decodeReplyFromBusboy
+} from "../bundled/react-server-dom-webpack.server.js";
+import { hasStatusCode } from "../lib/StatusError.js";
+import { invoke } from "../middleware/invokeMiddleware.js";
+import { renderRscToStream } from "./rscRenderer.js";
+import { sendRscFlightToStudio } from "./rscStudioHandlers.js";
+const BASE_PATH = "/rw-rsc/";
+function createRscRequestHandler(options) {
+  return async (req, res, next) => {
+    console.log("BASE_PATH", BASE_PATH);
+    console.log("req.originalUrl", req.originalUrl, "req.url", req.url);
+    console.log("req.headers.host", req.headers.host);
+    console.log("req.headers['rw-rsc']", req.headers["rw-rsc"]);
+    const mwRouter = await options.getMiddlewareRouter();
+    if (mwRouter) {
+      const webReq = normalizeNodeRequest(req, DefaultFetchAPI);
+      const matchedMw = mwRouter.find(webReq.method, webReq.url);
+      const [mwResponse] = await invoke(
+        webReq,
+        matchedMw?.handler,
+        {
+          params: matchedMw?.params,
+          viteDevServer: options.viteDevServer
+        }
+      );
+      const webRes = mwResponse.toResponse();
+      webRes.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+      });
+      if (mwResponse.isRedirect() || mwResponse.body) {
+        throw new Error(
+          "Not Implemented: What should happen if this RSC handler fails? And which part - Client side router?"
+        );
+      }
+    }
+    if (req.headers["rw-rsc"] !== "1") {
+      return next();
+    }
+    const url = new URL(req.originalUrl || "", "http://" + req.headers.host);
+    let rscId;
+    let rsaId;
+    let args = [];
+    if (url.pathname.startsWith(BASE_PATH)) {
+      rscId = url.pathname.split("/").pop();
+      rsaId = url.searchParams.get("action_id") || void 0;
+      console.log("rscId", rscId);
+      console.log("rsaId", rsaId);
+      if (rscId && rscId !== "_") {
+        res.setHeader("Content-Type", "text/x-component");
+      } else {
+        rscId = void 0;
+      }
+      args = await handleRsa(rsaId, req, args);
+    }
+    console.log("rscRequestHandler: args", args);
+    if (rscId || rsaId) {
+      const handleError = (err) => {
+        console.log("handleError() err", err);
+        if (hasStatusCode(err)) {
+          res.statusCode = err.statusCode;
+        } else {
+          console.info("Cannot render RSC", err);
+          res.statusCode = 500;
+        }
+        res.end(String(err));
+      };
+      try {
+        const readable = await renderRscToStream({ rscId, rsaId, args });
+        Readable.fromWeb(readable).pipe(res);
+        await sendRscFlightToStudio({
+          rscId,
+          rsaId,
+          args,
+          basePath: BASE_PATH,
+          req,
+          handleError
+        });
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  };
+}
+async function handleRsa(rsaId, req, args) {
+  if (!rsaId) {
+    return args;
+  }
+  if (req.headers["content-type"]?.startsWith("multipart/form-data")) {
+    console.log("RSA: multipart/form-data");
+    const bb = busboy({ headers: req.headers });
+    const reply = decodeReplyFromBusboy(bb);
+    req.pipe(bb);
+    args = await reply;
+    if (args[0] instanceof FormData) {
+      const serializedFormData = {};
+      for (const [key, value] of args[0]) {
+        if (serializedFormData[key] !== void 0) {
+          if (!Array.isArray(serializedFormData[key])) {
+            serializedFormData[key] = [serializedFormData[key]];
+          }
+          serializedFormData[key].push(value);
+        } else {
+          serializedFormData[key] = value;
+        }
+      }
+      args[0] = {
+        __formData__: true,
+        state: serializedFormData
+      };
+    }
+  } else {
+    console.log("RSA: regular body");
+    let body = "";
+    for await (const chunk of req) {
+      body += chunk;
+    }
+    if (body) {
+      args = await decodeReply(body);
+    }
+  }
+  return args;
+}
+export {
+  createRscRequestHandler
+};

package/dist/rsc/rscStudioHandlers.d.ts

@@ -0,0 +1,10 @@
+import type { Request } from 'express';
+import type { RenderInput } from './rscRenderer.js';
+interface StudioRenderInput extends Omit<RenderInput, 'serverState'> {
+    basePath: string;
+    req: Request;
+    handleError: (e: Error) => void;
+}
+export declare const sendRscFlightToStudio: (input: StudioRenderInput) => Promise<void>;
+export {};
+//# sourceMappingURL=rscStudioHandlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rscStudioHandlers.d.ts","sourceRoot":"","sources":["../../src/rsc/rscStudioHandlers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAKtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAyGnD,UAAU,iBAAkB,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IAClE,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,OAAO,CAAA;IACZ,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;CAChC;AAED,eAAO,MAAM,qBAAqB,UAAiB,iBAAiB,kBA8CnE,CAAA"}

package/dist/rsc/rscStudioHandlers.js

@@ -0,0 +1,120 @@
+import http from "node:http";
+import { getConfig, getRawConfig } from "@cedarjs/project-config";
+import { renderRscToStream } from "./rscRenderer.js";
+const isTest = () => {
+  return process.env.NODE_ENV === "test";
+};
+const isDevelopment = () => {
+  return process.env.NODE_ENV !== "production" && !isTest();
+};
+const isStudioEnabled = () => {
+  return getRawConfig()["studio"] !== void 0;
+};
+const shouldSendToStudio = () => {
+  return isStudioEnabled() && !isDevelopment();
+};
+const getStudioPort = () => {
+  return getConfig().studio.basePort;
+};
+const processRenderRscStream = async (readable) => {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const writable = new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      },
+      close() {
+        resolve(Buffer.concat(chunks).toString("utf8"));
+      }
+    });
+    readable.pipeTo(writable).catch((error) => reject(error));
+  });
+};
+const postFlightToStudio = (payload, metadata) => {
+  if (!shouldSendToStudio()) {
+    return;
+  }
+  const base64Payload = Buffer.from(payload).toString("base64");
+  const encodedMetadata = Buffer.from(JSON.stringify(metadata)).toString(
+    "base64"
+  );
+  const jsonBody = JSON.stringify({
+    flight: {
+      encodedPayload: base64Payload,
+      encoding: "base64",
+      encodedMetadata
+    }
+  });
+  const options = {
+    hostname: "localhost",
+    port: getStudioPort(),
+    path: "/.redwood/functions/rsc-flight",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(jsonBody)
+    }
+  };
+  const req = http.request(options, (res) => {
+    res.setEncoding("utf8");
+  });
+  req.on("error", (e) => {
+    console.error("An error occurred sending the Flight Payload to Studio");
+    console.error(e);
+  });
+  req.write(jsonBody);
+  req.end();
+};
+const createStudioFlightHandler = (readable, metadata) => {
+  processRenderRscStream(readable).then((payload) => {
+    console.debug("Sending RSC Rendered stream to Studio");
+    postFlightToStudio(payload, metadata);
+    console.debug("Sent RSC Rendered stream to Studio");
+    console.debug("payload to Studio:", payload);
+    console.debug("metadata to Studio:", metadata);
+  }).catch((error) => {
+    console.error("An error occurred getting RSC Rendered steam:", error);
+  });
+};
+const sendRscFlightToStudio = async (input) => {
+  if (!shouldSendToStudio()) {
+    console.debug("Studio is not enabled");
+    return;
+  }
+  const { rscId, rsaId, args, basePath, req, handleError } = input;
+  try {
+    const startedAt = Date.now();
+    const start = performance.now();
+    const readable = await renderRscToStream({ rscId, rsaId, args });
+    const endedAt = Date.now();
+    const end = performance.now();
+    const duration = end - start;
+    const metadata = {
+      rsc: {
+        rscId,
+        rsaId,
+        args
+      },
+      request: {
+        basePath,
+        originalUrl: req.originalUrl,
+        url: req.url,
+        headers: req.headers
+      },
+      performance: {
+        startedAt,
+        endedAt,
+        duration
+      }
+    };
+    createStudioFlightHandler(readable, metadata);
+  } catch (e) {
+    if (e instanceof Error) {
+      console.error("An error occurred rendering RSC and sending to Studio:", e);
+      handleError(e);
+    }
+  }
+};
+export {
+  sendRscFlightToStudio
+};

package/dist/runFeServer.d.ts

@@ -0,0 +1,2 @@
+export declare function runFeServer(): Promise<void>;
+//# sourceMappingURL=runFeServer.d.ts.map

package/dist/runFeServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runFeServer.d.ts","sourceRoot":"","sources":["../src/runFeServer.ts"],"names":[],"mappings":"AAkDA,wBAAsB,WAAW,kBAsJhC"}

package/dist/runFeServer.js

@@ -0,0 +1,132 @@
+import path from "node:path";
+import url from "node:url";
+import { createServerAdapter } from "@whatwg-node/server";
+import { config as loadDotEnv } from "dotenv-defaults";
+import express from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import WebSocket, { WebSocketServer } from "ws";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { getRscStylesheetLinkGenerator } from "@cedarjs/router/rscCss";
+import { createPerRequestMap, createServerStorage } from "@cedarjs/server-store";
+import { registerFwGlobalsAndShims } from "./lib/registerFwGlobalsAndShims.js";
+import { invoke } from "./middleware/invokeMiddleware.js";
+import { createMiddlewareRouter } from "./middleware/register.js";
+import { createReactStreamingHandler } from "./streaming/createReactStreamingHandler.js";
+import { convertExpressHeaders, getFullUrl } from "./utils.js";
+loadDotEnv({
+  path: path.join(getPaths().base, ".env"),
+  defaults: path.join(getPaths().base, ".env.defaults"),
+  // @ts-expect-error - Old typings. @types/dotenv-defaults depends on dotenv
+  // v8. dotenv-defaults uses dotenv v14
+  multiline: true
+});
+async function runFeServer() {
+  const app = express();
+  const rwPaths = getPaths();
+  const rwConfig = getConfig();
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  registerFwGlobalsAndShims();
+  if (rscEnabled) {
+    const { setClientEntries } = await import("./rsc/rscRenderer.js");
+    createWebSocketServer();
+    try {
+      await setClientEntries();
+    } catch (e) {
+      console.error("Failed to load client entries");
+      console.error(e);
+      process.exit(1);
+    }
+  }
+  const routeManifestUrl = url.pathToFileURL(rwPaths.web.routeManifest).href;
+  const routeManifest = (await import(routeManifestUrl, { with: { type: "json" } })).default;
+  const clientBuildManifestUrl = url.pathToFileURL(
+    path.join(rwPaths.web.distBrowser, "client-build-manifest.json")
+  ).href;
+  const clientBuildManifest = (await import(clientBuildManifestUrl, { with: { type: "json" } })).default;
+  const clientEntry = rscEnabled ? clientBuildManifest["entry.client.tsx"] || clientBuildManifest["entry.client.jsx"] : Object.values(clientBuildManifest).find(
+    (manifestItem) => manifestItem.isEntry
+  );
+  if (!clientEntry) {
+    throw new Error("Could not find client entry in build manifest");
+  }
+  const middlewareRouter = await createMiddlewareRouter();
+  const serverStorage = createServerStorage();
+  const handleWithMiddleware = () => {
+    return createServerAdapter(async (req) => {
+      const matchedMw = middlewareRouter.find(req.method, req.url);
+      const handler = matchedMw?.handler;
+      if (!matchedMw) {
+        return new Response("No middleware found", { status: 404 });
+      }
+      const [mwRes] = await invoke(req, handler, {
+        params: matchedMw?.params
+      });
+      return mwRes.toResponse();
+    });
+  };
+  app.use(
+    "/assets",
+    express.static(rwPaths.web.distBrowser + "/assets", { index: false })
+  );
+  app.use("*", (req, _res, next) => {
+    const fullUrl = getFullUrl(req, rscEnabled);
+    const headers = convertExpressHeaders(req.headersDistinct);
+    const perReqStore = createPerRequestMap({ headers, fullUrl });
+    serverStorage.run(perReqStore, next);
+  });
+  app.use(
+    rwConfig.web.apiUrl,
+    createProxyMiddleware({
+      changeOrigin: false,
+      // Using 127.0.0.1 to force ipv4. With `localhost` you don't really know
+      // if it's going to be ipv4 or ipv6
+      target: `http://127.0.0.1:${rwConfig.api.port}`
+    })
+  );
+  if (rscEnabled) {
+    const { createRscRequestHandler } = await import("./rsc/rscRequestHandler.js");
+    app.use(
+      "/rw-rsc",
+      createRscRequestHandler({
+        getMiddlewareRouter: async () => middlewareRouter
+      })
+    );
+  }
+  app.use(express.static(rwPaths.web.distBrowser, { index: false }));
+  const getStylesheetLinks = rscEnabled ? getRscStylesheetLinkGenerator(clientEntry.css) : () => clientEntry.css || [];
+  const routeHandler = await createReactStreamingHandler({
+    routes: Object.values(routeManifest),
+    clientEntryPath: clientEntry.file,
+    getStylesheetLinks,
+    getMiddlewareRouter: async () => middlewareRouter
+  });
+  app.get("*", createServerAdapter(routeHandler));
+  app.post("*", handleWithMiddleware());
+  app.listen(rwConfig.web.port);
+  console.log(
+    `Started production FE server on http://localhost:${rwConfig.web.port}`
+  );
+}
+function createWebSocketServer() {
+  const wsServer = new WebSocketServer({ port: 18998 });
+  wsServer.on("connection", (ws) => {
+    console.log("A new client connected.");
+    ws.on("message", (data) => {
+      const message = data.toString();
+      console.log("runFeServer.ts: Received message:");
+      console.log(message.slice(0, 120) + "...");
+      wsServer.clients.forEach((client) => {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(message);
+        }
+      });
+    });
+    ws.on("close", () => {
+      console.log("A client disconnected.");
+    });
+  });
+}
+runFeServer();
+export {
+  runFeServer
+};

package/dist/streaming/buildForStreamingServer.d.ts

@@ -0,0 +1,4 @@
+export declare function buildForStreamingServer({ verbose, }: {
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=buildForStreamingServer.d.ts.map

package/dist/streaming/buildForStreamingServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildForStreamingServer.d.ts","sourceRoot":"","sources":["../../src/streaming/buildForStreamingServer.ts"],"names":[],"mappings":"AAKA,wBAAsB,uBAAuB,CAAC,EAC5C,OAAe,GAChB,EAAE;IACD,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,iBAkCA"}

package/dist/streaming/buildForStreamingServer.js

@@ -0,0 +1,41 @@
+import { build as viteBuild } from "vite";
+import { cjsInterop } from "vite-plugin-cjs-interop";
+import { getPaths } from "@cedarjs/project-config";
+async function buildForStreamingServer({
+  verbose = false
+}) {
+  console.log("Starting streaming server build...\n");
+  const rwPaths = getPaths();
+  if (!rwPaths.web.viteConfig) {
+    throw new Error("Vite config not found");
+  }
+  await viteBuild({
+    configFile: rwPaths.web.viteConfig,
+    plugins: [
+      cjsInterop({
+        dependencies: [
+          // Skip ESM modules: rwjs/auth, rwjs/web, rwjs/auth-*-middleware, rwjs/router
+          "@cedarjs/forms",
+          "@cedarjs/prerender/*",
+          "@cedarjs/auth-*-api",
+          "@cedarjs/auth-*-web"
+        ]
+      })
+    ],
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      outDir: rwPaths.web.distSsr,
+      ssr: true,
+      emptyOutDir: true
+    },
+    envFile: false,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV)
+    },
+    logLevel: verbose ? "info" : "warn"
+  });
+}
+export {
+  buildForStreamingServer
+};

package/dist/streaming/collectCss.d.ts

@@ -0,0 +1,7 @@
+import type { ViteDevServer, ModuleNode } from 'vite';
+/**
+ * Collect SSR CSS for Vite
+ */
+export declare const componentsModules: (components: string[], vite: ViteDevServer) => Set<ModuleNode>;
+export declare const collectCssPaths: (mods: Set<ModuleNode>, cssLinks?: Set<string>, checkedComponents?: Set<unknown>) => Set<string>;
+//# sourceMappingURL=collectCss.d.ts.map

package/dist/streaming/collectCss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectCss.d.ts","sourceRoot":"","sources":["../../src/streaming/collectCss.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAGrD;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAChB,MAAM,EAAE,QACd,aAAa,oBAUpB,CAAA;AAED,eAAO,MAAM,eAAe,SACpB,GAAG,CAAC,UAAU,CAAC,0EAmBtB,CAAA"}

package/dist/streaming/collectCss.js

@@ -0,0 +1,27 @@
+import { normalizePath } from "vite";
+const componentsModules = (components, vite) => {
+  const matchedModules = /* @__PURE__ */ new Set();
+  components.forEach((component) => {
+    const modules = vite.moduleGraph.getModulesByFile(normalizePath(component));
+    modules?.forEach((mod) => {
+      matchedModules.add(mod);
+    });
+  });
+  return matchedModules;
+};
+const collectCssPaths = (mods, cssLinks = /* @__PURE__ */ new Set(), checkedComponents = /* @__PURE__ */ new Set()) => {
+  for (const mod of mods) {
+    if (mod.file?.endsWith(".scss") || mod.file?.endsWith(".css") || mod.file?.endsWith(".less")) {
+      cssLinks.add(mod.url);
+    }
+    if (mod.importedModules.size > 0 && !checkedComponents.has(mod.id)) {
+      checkedComponents.add(mod.id);
+      collectCssPaths(mod.importedModules, cssLinks, checkedComponents);
+    }
+  }
+  return cssLinks;
+};
+export {
+  collectCssPaths,
+  componentsModules
+};

package/dist/streaming/createReactStreamingHandler.d.ts

@@ -0,0 +1,12 @@
+import type Router from 'find-my-way';
+import type { ViteDevServer } from 'vite';
+import type { RouteSpec, RWRouteManifestItem } from '@cedarjs/internal';
+interface CreateReactStreamingHandlerOptions {
+    routes: RWRouteManifestItem[];
+    clientEntryPath: string;
+    getStylesheetLinks: (route?: RWRouteManifestItem | RouteSpec) => string[];
+    getMiddlewareRouter: () => Promise<Router.Instance<any>>;
+}
+export declare const createReactStreamingHandler: ({ routes, clientEntryPath, getStylesheetLinks, getMiddlewareRouter, }: CreateReactStreamingHandlerOptions, viteDevServer?: ViteDevServer) => Promise<(req: Request) => Promise<Response>>;
+export {};
+//# sourceMappingURL=createReactStreamingHandler.d.ts.map

package/dist/streaming/createReactStreamingHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createReactStreamingHandler.d.ts","sourceRoot":"","sources":["../../src/streaming/createReactStreamingHandler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAGrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAIzC,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAcvE,UAAU,kCAAkC;IAC1C,MAAM,EAAE,mBAAmB,EAAE,CAAA;IAC7B,eAAe,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,CAAC,KAAK,CAAC,EAAE,mBAAmB,GAAG,SAAS,KAAK,MAAM,EAAE,CAAA;IACzE,mBAAmB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;CACzD;AAOD,eAAO,MAAM,2BAA2B,0EAMnC,kCAAkC,kBACrB,aAAa,mBA6BV,OAAO,uBA8I3B,CAAA"}

package/dist/streaming/createReactStreamingHandler.js

@@ -0,0 +1,139 @@
+import path from "path";
+import { Response } from "@whatwg-node/fetch";
+import { createIsbotFromList, list as isbotList } from "isbot";
+import { middlewareDefaultAuthProviderState } from "@cedarjs/auth/dist/AuthProvider/AuthProviderState.js";
+import { getAppRouteHook, getConfig, getPaths } from "@cedarjs/project-config";
+import { matchPath } from "@cedarjs/router/util";
+import { MiddlewareResponse } from "@cedarjs/web/middleware";
+import { invoke } from "../middleware/invokeMiddleware.js";
+import { makeFilePath, ssrLoadEntryServer } from "../utils.js";
+import { reactRenderToStreamResponse } from "./streamHelpers.js";
+import { loadAndRunRouteHooks } from "./triggerRouteHooks.js";
+const isbot = createIsbotFromList(
+  isbotList.filter((record) => !record.includes("chrome-lighthouse"))
+);
+const createReactStreamingHandler = async ({
+  routes,
+  clientEntryPath,
+  getStylesheetLinks,
+  getMiddlewareRouter
+}, viteDevServer) => {
+  const rwPaths = getPaths();
+  const rwConfig = getConfig();
+  const isProd = !viteDevServer;
+  const middlewareRouter = await getMiddlewareRouter();
+  let entryServerImport;
+  let fallbackDocumentImport;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  if (isProd) {
+    if (rscEnabled) {
+      entryServerImport = await import(makeFilePath(rwPaths.web.distSsrEntryServer));
+    } else {
+      entryServerImport = await import(makeFilePath(rwPaths.web.distSsrEntryServer));
+    }
+    fallbackDocumentImport = await import(makeFilePath(rwPaths.web.distSsrDocument));
+  }
+  return async (req) => {
+    let mwResponse = MiddlewareResponse.next();
+    let decodedAuthState = {
+      ...middlewareDefaultAuthProviderState,
+      cookieHeader: req.headers.get("cookie"),
+      roles: []
+    };
+    let currentRoute;
+    let parsedParams = {};
+    const currentUrl = new URL(req.url);
+    for (const route of routes) {
+      const { match, ...rest } = matchPath(
+        route.pathDefinition,
+        currentUrl.pathname
+      );
+      if (match) {
+        currentRoute = route;
+        parsedParams = rest;
+        break;
+      }
+    }
+    const cssLinks = getStylesheetLinks(currentRoute);
+    if (middlewareRouter) {
+      const matchedMw = middlewareRouter.find(req.method, req.url);
+      [mwResponse, decodedAuthState] = await invoke(
+        req,
+        matchedMw?.handler,
+        {
+          route: currentRoute,
+          cssPaths: cssLinks,
+          params: matchedMw?.params,
+          viteDevServer
+        }
+      );
+      if (mwResponse.isRedirect() || mwResponse.body) {
+        return mwResponse.toResponse();
+      }
+    }
+    if (!currentRoute) {
+      throw new Error("404 handling not implemented");
+    }
+    if (currentRoute.redirect) {
+      return new Response(null, {
+        status: 302,
+        headers: {
+          Location: currentRoute.redirect.to
+        }
+      });
+    }
+    if (!isProd) {
+      entryServerImport = await ssrLoadEntryServer(viteDevServer);
+      fallbackDocumentImport = await viteDevServer.ssrLoadModule(
+        rwPaths.web.document
+      );
+    }
+    const ServerEntry = entryServerImport.ServerEntry || entryServerImport.default;
+    const FallbackDocument = fallbackDocumentImport.Document || fallbackDocumentImport.default;
+    let metaTags = [];
+    let routeHookPath = currentRoute.routeHooks;
+    if (isProd) {
+      routeHookPath = currentRoute.routeHooks ? path.join(rwPaths.web.distRouteHooks, currentRoute.routeHooks) : null;
+    }
+    const routeHookOutput = await loadAndRunRouteHooks({
+      paths: [getAppRouteHook(isProd), routeHookPath],
+      reqMeta: {
+        req,
+        parsedParams
+      },
+      viteDevServer
+    });
+    metaTags = routeHookOutput.meta;
+    const jsBundles = [viteDevServer ? clientEntryPath : "/" + clientEntryPath];
+    if (currentRoute.bundle) {
+      jsBundles.push("/" + currentRoute.bundle);
+    }
+    const isSeoCrawler = isbot(req.headers.get("user-agent") || "");
+    const reactResponse = await reactRenderToStreamResponse(
+      mwResponse,
+      {
+        ServerEntry,
+        FallbackDocument,
+        currentUrl,
+        metaTags,
+        cssLinks,
+        isProd,
+        jsBundles,
+        authState: decodedAuthState
+      },
+      {
+        waitForAllReady: isSeoCrawler,
+        onError: (err) => {
+          if (!isProd && viteDevServer) {
+            viteDevServer.ssrFixStacktrace(err);
+          }
+          console.error(err);
+        }
+      }
+    );
+    return reactResponse;
+  };
+};
+export {
+  createReactStreamingHandler
+};

package/dist/streaming/streamHelpers.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+import type { ServerAuthState } from '@cedarjs/auth/dist/AuthProvider/ServerAuthProvider.js';
+import type { TagDescriptor } from '@cedarjs/web';
+import type { MiddlewareResponse } from '@cedarjs/web/middleware';
+import type { ServerEntryType } from '../types.js';
+interface RenderToStreamArgs {
+    ServerEntry: ServerEntryType;
+    FallbackDocument: React.FunctionComponent;
+    currentUrl: URL;
+    metaTags: TagDescriptor[];
+    cssLinks: string[];
+    isProd: boolean;
+    jsBundles?: string[];
+    authState: ServerAuthState;
+}
+interface StreamOptions {
+    waitForAllReady?: boolean;
+    onError?: (err: Error) => void;
+}
+export declare function reactRenderToStreamResponse(mwRes: MiddlewareResponse, renderOptions: RenderToStreamArgs, streamOptions: StreamOptions): Promise<Response>;
+export declare function importModule(mod: 'rd-server' | '__rwjs__react' | '__rwjs__location' | '__rwjs__server_auth_provider' | '__rwjs__server_inject'): Promise<any>;
+export {};
+//# sourceMappingURL=streamHelpers.d.ts.map

package/dist/streaming/streamHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamHelpers.d.ts","sourceRoot":"","sources":["../../src/streaming/streamHelpers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uDAAuD,CAAA;AAI5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAYlD,UAAU,kBAAkB;IAC1B,WAAW,EAAE,eAAe,CAAA;IAC5B,gBAAgB,EAAE,KAAK,CAAC,iBAAiB,CAAA;IACzC,UAAU,EAAE,GAAG,CAAA;IACf,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,eAAe,CAAA;CAC3B;AAED,UAAU,aAAa;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;CAC/B;AA2BD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,kBAAkB,EACzB,aAAa,EAAE,kBAAkB,EACjC,aAAa,EAAE,aAAa,qBAgM7B;AA2BD,wBAAsB,YAAY,CAChC,GAAG,EACC,WAAW,GACX,eAAe,GACf,kBAAkB,GAClB,8BAA8B,GAC9B,uBAAuB,gBA2B5B"}