rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/runtime/lib/router.js

@@ -0,0 +1,210 @@
+import React from "react";
+import { isValidElementType } from "react-is";
+export function matchPath(routePath, requestPath) {
+    // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
+    if (routePath.includes(":")) {
+        const segments = routePath.split("/");
+        for (const segment of segments) {
+            if ((segment.match(/:/g) || []).length > 1) {
+                throw new Error(`Invalid route pattern: segment "${segment}" in "${routePath}" contains multiple colons.`);
+            }
+        }
+    }
+    // Check for invalid pattern: double wildcard (e.g., /**/)
+    if (routePath.indexOf("**") !== -1) {
+        throw new Error(`Invalid route pattern: "${routePath}" contains "**". Use "*" for a single wildcard segment.`);
+    }
+    const pattern = routePath
+        .replace(/:[a-zA-Z0-9]+/g, "([^/]+)") // Convert :param to capture group
+        .replace(/\*/g, "(.*)"); // Convert * to wildcard capture group
+    const regex = new RegExp(`^${pattern}$`);
+    const matches = requestPath.match(regex);
+    if (!matches) {
+        return null;
+    }
+    // Revised parameter extraction:
+    const params = {};
+    let currentMatchIndex = 1; // Regex matches are 1-indexed
+    // This regex finds either a named parameter token (e.g., ":id") or a wildcard star token ("*").
+    const tokenRegex = /:([a-zA-Z0-9_]+)|\*/g;
+    let matchToken;
+    let wildcardCounter = 0;
+    // Ensure regex starts from the beginning of the routePath for each call if it's stateful (it is with /g)
+    tokenRegex.lastIndex = 0;
+    while ((matchToken = tokenRegex.exec(routePath)) !== null) {
+        // Ensure we have a corresponding match from the regex execution
+        if (matches[currentMatchIndex] === undefined) {
+            // This case should ideally not be hit if routePath and pattern generation are correct
+            // and all parts of the regex matched.
+            // Consider logging a warning or throwing an error if critical.
+            break;
+        }
+        if (matchToken[1]) {
+            // This token is a named parameter (e.g., matchToken[1] is "id" for ":id")
+            params[matchToken[1]] = matches[currentMatchIndex];
+        }
+        else {
+            // This token is a wildcard "*"
+            params[`$${wildcardCounter}`] = matches[currentMatchIndex];
+            wildcardCounter++;
+        }
+        currentMatchIndex++;
+    }
+    return params;
+}
+function flattenRoutes(routes) {
+    return routes.reduce((acc, route) => {
+        if (Array.isArray(route)) {
+            return [...acc, ...flattenRoutes(route)];
+        }
+        return [...acc, route];
+    }, []);
+}
+export function defineRoutes(routes) {
+    const flattenedRoutes = flattenRoutes(routes);
+    return {
+        routes: flattenedRoutes,
+        async handle({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, }) {
+            const url = new URL(request.url);
+            let path = url.pathname;
+            // Must end with a trailing slash.
+            if (path !== "/" && !path.endsWith("/")) {
+                path = path + "/";
+            }
+            // Find matching route
+            let match = null;
+            for (const route of flattenedRoutes) {
+                if (typeof route === "function") {
+                    const r = await route(getRequestInfo());
+                    if (r instanceof Response) {
+                        return r;
+                    }
+                    continue;
+                }
+                const params = matchPath(route.path, path);
+                if (params) {
+                    match = { params, handler: route.handler, layouts: route.layouts };
+                    break;
+                }
+            }
+            if (!match) {
+                // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
+                return new Response("Not Found", { status: 404 });
+            }
+            let { params, handler, layouts } = match;
+            return runWithRequestInfoOverrides({ params }, async () => {
+                const handlers = Array.isArray(handler) ? handler : [handler];
+                for (const h of handlers) {
+                    if (isRouteComponent(h)) {
+                        const requestInfo = getRequestInfo();
+                        const WrappedComponent = wrapWithLayouts(h, layouts || [], requestInfo);
+                        return await renderPage(requestInfo, WrappedComponent, onError);
+                    }
+                    else {
+                        const r = await h(getRequestInfo());
+                        if (r instanceof Response) {
+                            return r;
+                        }
+                    }
+                }
+                // Add fallback return
+                return new Response("Response not returned from route handler", {
+                    status: 500,
+                });
+            });
+        },
+    };
+}
+export function route(path, handler) {
+    if (!path.endsWith("/")) {
+        path = path + "/";
+    }
+    return {
+        path,
+        handler,
+    };
+}
+export function index(handler) {
+    return route("/", handler);
+}
+export function prefix(prefixPath, routes) {
+    return routes.map((r) => {
+        if (typeof r === "function") {
+            // Pass through middleware as-is
+            return r;
+        }
+        if (Array.isArray(r)) {
+            // Recursively process nested route arrays
+            return prefix(prefixPath, r);
+        }
+        // For RouteDefinition objects, update the path and preserve layouts
+        return {
+            path: prefixPath + r.path,
+            handler: r.handler,
+            ...(r.layouts && { layouts: r.layouts }),
+        };
+    });
+}
+function wrapWithLayouts(Component, layouts = [], requestInfo) {
+    if (layouts.length === 0) {
+        return Component;
+    }
+    // Check if the final route component is a client component
+    const isRouteClientComponent = Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");
+    // Create nested layout structure - layouts[0] should be outermost, so use reduceRight
+    return layouts.reduceRight((WrappedComponent, Layout) => {
+        const Wrapped = (props) => {
+            const isClientComponent = Object.prototype.hasOwnProperty.call(Layout, "$$isClientReference");
+            return React.createElement(Layout, {
+                children: React.createElement(WrappedComponent, isRouteClientComponent ? {} : props),
+                // Only pass requestInfo to server components to avoid serialization issues
+                ...(isClientComponent ? {} : { requestInfo }),
+            });
+        };
+        return Wrapped;
+    }, Component);
+}
+export function layout(LayoutComponent, routes) {
+    // Attach layouts directly to route definitions
+    return routes.map((route) => {
+        if (typeof route === "function") {
+            // Pass through middleware as-is
+            return route;
+        }
+        if (Array.isArray(route)) {
+            // Recursively process nested route arrays
+            return layout(LayoutComponent, route);
+        }
+        // For RouteDefinition objects, prepend the layout so outer layouts come first
+        return {
+            ...route,
+            layouts: [LayoutComponent, ...(route.layouts || [])],
+        };
+    });
+}
+export function render(Document, routes, 
+/**
+ * @param options - Configuration options for rendering.
+ * @param options.rscPayload - Toggle the RSC payload that's appended to the Document. Disabling this will mean that interactivity no longer works.
+ * @param options.ssr - Disable sever side rendering for all these routes. This only allow client side rendering`, which requires `rscPayload` to be enabled.
+ */
+options = {}) {
+    options = {
+        rscPayload: true,
+        ssr: true,
+        ...options,
+    };
+    const documentMiddleware = ({ rw }) => {
+        rw.Document = Document;
+        rw.rscPayload = options.rscPayload ?? true;
+        rw.ssr = options.ssr ?? true;
+    };
+    return [documentMiddleware, ...routes];
+}
+function isRouteComponent(handler) {
+    return ((isValidElementType(handler) && handler.toString().includes("jsx")) ||
+        isClientReference(handler));
+}
+export const isClientReference = (Component) => {
+    return Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");
+};

package/dist/runtime/lib/router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/router.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { matchPath } from "./router";
+describe("matchPath", () => {
+    // Test case 1: Static paths
+    it("should match static paths", () => {
+        expect(matchPath("/about/", "/about/")).toEqual({});
+        expect(matchPath("/contact/", "/contact/")).toEqual({});
+    });
+    it("should not match different static paths", () => {
+        expect(matchPath("/about/", "/service/")).toBeNull();
+    });
+    // Test case 2: Paths with parameters
+    it("should match paths with parameters and extract them", () => {
+        expect(matchPath("/users/:id/", "/users/123/")).toEqual({ id: "123" });
+        expect(matchPath("/posts/:category/:slug/", "/posts/tech/my-first-post/")).toEqual({ category: "tech", slug: "my-first-post" });
+    });
+    it("should not match if parameter is missing", () => {
+        expect(matchPath("/users/:id/", "/users/")).toBeNull();
+    });
+    // Test case 3: Paths with wildcards
+    it("should match paths with wildcards and extract them", () => {
+        expect(matchPath("/files/*/", "/files/document.pdf/")).toEqual({
+            $0: "document.pdf",
+        });
+        expect(matchPath("/data/*\/content/", "/data/archive/content/")).toEqual({
+            $0: "archive",
+        });
+        expect(matchPath("/assets/*/*/", "/assets/images/pic.png/")).toEqual({
+            $0: "images",
+            $1: "pic.png",
+        });
+    });
+    it("should match empty wildcard", () => {
+        expect(matchPath("/files/*/", "/files//")).toEqual({ $0: "" });
+    });
+    // Test case 4: Paths with both parameters and wildcards
+    it("should match paths with both parameters and wildcards", () => {
+        expect(matchPath("/products/:productId/*/", "/products/abc/details/more/")).toEqual({ productId: "abc", $0: "details/more" });
+    });
+    // Test case 5: Paths that don't match
+    it("should return null for non-matching paths", () => {
+        expect(matchPath("/specific/path/", "/a/different/path/")).toBeNull();
+    });
+    // Test case 6: Edge cases
+    it("should handle trailing slashes correctly", () => {
+        // Current implementation in defineRoutes adds a trailing slash if missing,
+        // and route() function also enforces it. matchPath itself doesn't normalize.
+        expect(matchPath("/path/", "/path")).toBeNull(); // Path to match must end with /
+        expect(matchPath("/path/", "/path/")).toEqual({});
+    });
+    it("should handle paths with multiple parameters and wildcards interspersed", () => {
+        expect(matchPath("/type/:typeId/item/*/:itemId/*/", "/type/a/item/image/b/thumb/")).toEqual({ typeId: "a", $0: "image", itemId: "b", $1: "thumb" });
+    });
+    it("should not allow named parameters or wildcards in the same path", () => {
+        expect(() => matchPath("/type/:typeId:is:broken", "/type/a-thumb-drive")).toThrow();
+        expect(() => matchPath("/type/**", "/type/a-thumb-drive")).toThrow();
+    });
+});

package/dist/runtime/lib/streams/consumeEventStream.d.ts

@@ -0,0 +1,4 @@
+import { type EventSourceMessage } from "eventsource-parser/stream";
+export declare function consumeEventStream({ onChunk, }: {
+    onChunk: (chunk: EventSourceMessage) => void;
+}): WritableStream<Uint8Array>;

package/dist/runtime/lib/streams/consumeEventStream.js

@@ -0,0 +1,13 @@
+import { EventSourceParserStream, } from "eventsource-parser/stream";
+export function consumeEventStream({ onChunk, }) {
+    const stream = new TransformStream();
+    stream.readable
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream())
+        .pipeTo(new WritableStream({
+        write(chunk) {
+            onChunk(chunk);
+        },
+    }));
+    return stream.writable;
+}

package/dist/runtime/lib/turnstile/TurnstileScript.d.ts

@@ -0,0 +1 @@
+export declare const TurnstileScript: () => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/lib/turnstile/TurnstileScript.js

@@ -0,0 +1,2 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export const TurnstileScript = () => (_jsx("script", { src: "https://challenges.cloudflare.com/turnstile/v0/api.js", async: true, defer: true }));

package/dist/runtime/lib/turnstile/turnstile.d.ts

@@ -0,0 +1,3 @@
+export * from "./TurnstileScript";
+export * from "./useTurnstile";
+export * from "./verifyTurnstileToken";

package/dist/runtime/lib/turnstile/turnstile.js

@@ -0,0 +1,3 @@
+export * from "./TurnstileScript";
+export * from "./useTurnstile";
+export * from "./verifyTurnstileToken";

package/dist/runtime/lib/turnstile/useTurnstile.d.ts

@@ -0,0 +1,4 @@
+export declare function useTurnstile(siteKey: string): {
+    ref: import("react").RefObject<HTMLDivElement | null>;
+    challenge: () => Promise<string>;
+};

package/dist/runtime/lib/turnstile/useTurnstile.js

@@ -0,0 +1,23 @@
+"use client";
+import { useRef, useCallback } from "react";
+import { IS_DEV } from "../../constants";
+export function useTurnstile(siteKey) {
+    const containerRef = useRef(null);
+    const resolverRef = useRef(Promise.withResolvers());
+    const widgetIdRef = useRef(null);
+    const challenge = useCallback(async () => {
+        if (!widgetIdRef.current &&
+            containerRef.current &&
+            window.turnstile) {
+            widgetIdRef.current = window.turnstile.render(containerRef.current, {
+                sitekey: IS_DEV ? "1x00000000000000000000AA" : siteKey,
+                callback: (token) => resolverRef.current.resolve(token),
+            });
+        }
+        return resolverRef.current.promise;
+    }, [siteKey]);
+    return {
+        ref: containerRef,
+        challenge,
+    };
+}

package/dist/runtime/lib/turnstile/verifyTurnstileToken.d.ts

@@ -0,0 +1,4 @@
+export declare const verifyTurnstileToken: ({ token, secretKey, }: {
+    token: string;
+    secretKey: string;
+}) => Promise<boolean>;

package/dist/runtime/lib/turnstile/verifyTurnstileToken.js

@@ -0,0 +1,15 @@
+export const verifyTurnstileToken = async ({ token, secretKey, }) => {
+    const response = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ secret: secretKey, response: token }),
+    });
+    try {
+        const data = (await response.json());
+        return data?.success === true;
+    }
+    catch (error) {
+        console.error("Error verifying Turnstile token", error);
+        return false;
+    }
+};

package/dist/runtime/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare const generateNonce: () => string;

package/dist/runtime/lib/utils.js

@@ -0,0 +1 @@
+export const generateNonce = () => btoa(crypto.getRandomValues(new Uint8Array(16)).join(""));

package/dist/runtime/register/client.d.ts

@@ -0,0 +1 @@
+export declare const createServerReference: (id: string, name: string) => Function;

package/dist/runtime/register/client.js

@@ -0,0 +1,5 @@
+import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.browser";
+export const createServerReference = (id, name) => {
+    id = id + "#" + name;
+    return baseCreateServerReference(id, globalThis.__rsc_callServer);
+};

package/dist/runtime/register/ssr.d.ts

@@ -0,0 +1,3 @@
+export declare const loadServerModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const getServerModuleExport: (id: string) => Promise<any>;
+export declare const createServerReference: (id: string, name: string) => any;

package/dist/runtime/register/ssr.js

@@ -0,0 +1,26 @@
+import memoize from "lodash/memoize";
+import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.edge";
+export const loadServerModule = memoize(async (id) => {
+    const { useServerLookup } = await import("virtual:use-server-lookup.js");
+    const moduleFn = useServerLookup[id];
+    if (!moduleFn) {
+        throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);
+    }
+    return await moduleFn();
+});
+export const getServerModuleExport = async (id) => {
+    const [file, name] = id.split("#");
+    const module = await loadServerModule(file);
+    return module[name];
+};
+const ssrCallServer = async (id, args) => {
+    const action = await getServerModuleExport(id);
+    if (typeof action !== "function") {
+        throw new Error(`Server function ${id} is not a function`);
+    }
+    return action(...args);
+};
+export const createServerReference = (id, name) => {
+    id = id + "#" + name;
+    return baseCreateServerReference(id, ssrCallServer);
+};

package/dist/runtime/register/worker.d.ts

@@ -0,0 +1,4 @@
+export declare function registerServerReference(action: Function, id: string, name: string): Function;
+export declare function registerClientReference<Target extends Record<string, any>>(id: string, exportName: string, value: any): any;
+export declare function __smokeTestActionHandler(timestamp?: number): Promise<unknown>;
+export declare function rscActionHandler(req: Request): Promise<unknown>;

package/dist/runtime/register/worker.js

@@ -0,0 +1,42 @@
+import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
+import { getServerModuleExport } from "../imports/worker.js";
+import { IS_DEV } from "../constants";
+export function registerServerReference(action, id, name) {
+    if (typeof action !== "function") {
+        return action;
+    }
+    // Note: We no longer need to register in a Map since we use virtual lookup
+    return baseRegisterServerReference(action, id, name);
+}
+export function registerClientReference(id, exportName, value) {
+    const wrappedValue = (value && typeof value === "function") || typeof value === "object"
+        ? value
+        : () => null;
+    const reference = baseRegisterClientReference({}, id, exportName);
+    return Object.defineProperties(wrappedValue, {
+        ...Object.getOwnPropertyDescriptors(reference),
+        $$async: { value: true },
+        $$isClientReference: { value: true },
+    });
+}
+export async function __smokeTestActionHandler(timestamp) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return { status: "ok", timestamp };
+}
+export async function rscActionHandler(req) {
+    const url = new URL(req.url);
+    const contentType = req.headers.get("content-type");
+    const data = contentType?.startsWith("multipart/form-data")
+        ? await req.formData()
+        : await req.text();
+    const args = (await decodeReply(data, null));
+    const actionId = url.searchParams.get("__rsc_action_id");
+    if (IS_DEV && actionId === "__rsc_hot_update") {
+        return null;
+    }
+    const action = await getServerModuleExport(actionId);
+    if (typeof action !== "function") {
+        throw new Error(`Action ${actionId} is not a function`);
+    }
+    return action(...args);
+}

package/dist/runtime/render/createClientManifest.d.ts

@@ -0,0 +1 @@
+export declare const createClientManifest: () => ClientManifest;

package/dist/runtime/render/createClientManifest.js

@@ -0,0 +1,7 @@
+export const createClientManifest = () => {
+    return new Proxy({}, {
+        get(_, key) {
+            return { id: key, name: key, chunks: [] };
+        },
+    });
+};

package/dist/runtime/render/createModuleMap.d.ts

@@ -0,0 +1 @@
+export declare const createModuleMap: () => {};

package/dist/runtime/render/createModuleMap.js

@@ -0,0 +1,13 @@
+export const createModuleMap = () => new Proxy({}, {
+    get(_, id) {
+        return new Proxy({}, {
+            get(_, name) {
+                return {
+                    id,
+                    name,
+                    chunks: [],
+                };
+            },
+        });
+    },
+});

package/dist/runtime/render/renderRscThenableToHtmlStream.d.ts

@@ -0,0 +1,9 @@
+import { type DocumentProps } from "../lib/router";
+import { type RequestInfo } from "../requestInfo/types";
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, onError, }: {
+    thenable: any;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+    shouldSSR: boolean;
+    onError: (error: unknown) => void;
+}) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { use } from "react";
+import { renderToReadableStream } from "react-dom/server.edge";
+export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, onError, }) => {
+    const Component = () => {
+        const node = use(thenable).node;
+        // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
+        // surface context. e.g:
+        // * we assign `user: requestInfo.clientCtx` here
+        // * user populates requestInfo.clientCtx on worker side
+        // * user can import a read only `import { clientCtx } from "rwsdk/client"`
+        // on client side
+        const clientContext = {
+            rw: {
+                ssr: shouldSSR,
+            },
+        };
+        return (_jsxs(Document, { ...requestInfo, children: [_jsx("script", { nonce: requestInfo.rw.nonce, dangerouslySetInnerHTML: {
+                        __html: `globalThis.__RWSDK_CONTEXT = ${JSON.stringify(clientContext)}`,
+                    } }), _jsx("div", { id: "hydrate-root", children: node })] }));
+    };
+    return await renderToReadableStream(_jsx(Component, {}), {
+        nonce: requestInfo.rw.nonce,
+        onError(error, { componentStack }) {
+            try {
+                if (!error) {
+                    error = new Error(`A falsy value was thrown during rendering: ${String(error)}.`);
+                }
+                const message = error
+                    ? (error.stack ?? error.message ?? error)
+                    : error;
+                const wrappedMessage = `${message}\n\nComponent stack:${componentStack}`;
+                if (error instanceof Error) {
+                    const wrappedError = new Error(wrappedMessage);
+                    wrappedError.stack = error.stack;
+                    error = wrappedError;
+                }
+                else {
+                    error = new Error(wrappedMessage);
+                    error.stack = componentStack;
+                }
+                onError(error);
+            }
+            catch {
+                onError(error);
+            }
+        },
+    });
+};

package/dist/runtime/render/renderToRscStream.d.ts

@@ -0,0 +1,5 @@
+export declare const renderToRscStream: (app: {
+    node: React.ReactElement;
+    actionResult: any;
+    onError?: (error: unknown) => void;
+}) => ReadableStream;

package/dist/runtime/render/renderToRscStream.js

@@ -0,0 +1,46 @@
+import { renderToReadableStream as baseRenderToRscStream } from "react-server-dom-webpack/server.edge";
+import { createClientManifest } from "./createClientManifest.js";
+// context(justinvdm, 24 Mar 2025): React flight limits chunks to 28 bytes, so we need to rechunk
+// the stream to avoid losing data
+function rechunkStream(stream, maxChunkSize = 28) {
+    const reader = stream.getReader();
+    return new ReadableStream({
+        async pull(controller) {
+            let buffer = new Uint8Array(0);
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done && buffer.length === 0) {
+                        controller.close();
+                        return;
+                    }
+                    if (value) {
+                        buffer = new Uint8Array([...buffer, ...value]);
+                    }
+                    while (buffer.length >= maxChunkSize || (done && buffer.length > 0)) {
+                        const chunk = buffer.slice(0, maxChunkSize);
+                        buffer = buffer.slice(maxChunkSize);
+                        controller.enqueue(chunk);
+                    }
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+export const renderToRscStream = (app) => {
+    const { node, onError } = app;
+    let { actionResult } = app;
+    if (actionResult instanceof ReadableStream) {
+        actionResult = rechunkStream(actionResult);
+    }
+    return baseRenderToRscStream({ node, actionResult }, createClientManifest(), {
+        onError,
+    });
+};

package/dist/runtime/render/renderToStream.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement, FC } from "react";
+import { DocumentProps } from "../lib/router";
+export interface RenderToStreamOptions {
+    Document?: FC<DocumentProps>;
+    injectRSCPayload?: boolean;
+    onError?: (error: unknown) => void;
+}
+export declare const IdentityDocument: FC<DocumentProps>;
+export declare const renderToStream: (element: ReactElement, { Document, injectRSCPayload: shouldInjectRSCPayload, onError, }?: RenderToStreamOptions) => Promise<ReadableStream>;

package/dist/runtime/render/renderToStream.js

@@ -0,0 +1,27 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { renderToRscStream } from "./renderToRscStream";
+import { transformRscToHtmlStream } from "./transformRscToHtmlStream";
+import { requestInfo } from "../requestInfo/worker";
+import { injectRSCPayload } from "rsc-html-stream/server";
+export const IdentityDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
+export const renderToStream = async (element, { Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = false, onError = () => { }, } = {}) => {
+    let rscStream = renderToRscStream({
+        node: element,
+        actionResult: null,
+        onError,
+    });
+    if (shouldInjectRSCPayload) {
+        const [rscPayloadStream1, rscPayloadStream2] = rscStream.tee();
+        rscStream = rscPayloadStream1;
+        rscStream = rscStream.pipeThrough(injectRSCPayload(rscPayloadStream2, {
+            nonce: requestInfo.rw.nonce,
+        }));
+    }
+    const htmlStream = await transformRscToHtmlStream({
+        stream: rscStream,
+        Document,
+        requestInfo,
+        onError,
+    });
+    return htmlStream;
+};

package/dist/runtime/render/renderToString.d.ts

@@ -0,0 +1,7 @@
+import { FC, ReactElement } from "react";
+import { DocumentProps } from "../lib/router";
+export interface RenderToStringOptions {
+    Document?: FC<DocumentProps>;
+    injectRSCPayload?: boolean;
+}
+export declare const renderToString: (element: ReactElement, options?: RenderToStringOptions) => Promise<string>;