@taujs/react 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -44,7 +44,7 @@ type HydrateAppOptions<T> = {
 declare function hydrateApp<T>({ appComponent, rootElementId, enableDebug, logger, dataKey, onHydrationError, onStart, onSuccess, }: HydrateAppOptions<T>): void;
 
 type RenderCallbacks<T> = {
-    onHead?: (head: string) => boolean | void;
+    onHead?: (head: string) => void;
     onShellReady?: () => void;
     onAllReady?: (data: T) => void;
     onFinish?: (data: T) => void;
@@ -53,34 +53,36 @@ type RenderCallbacks<T> = {
 type StreamOptions = {
     /** Timeout in ms for shell to be ready (default: 10000) */
     shellTimeoutMs?: number;
-    /** Whether to use cork/uncork for batched writes (default: true) */
-    useCork?: boolean;
 };
-type HeadContext<T extends Record<string, unknown> = Record<string, unknown>> = {
+type HeadContext<T extends Record<string, unknown> = Record<string, unknown>, R = unknown> = {
     data: T;
     meta: Record<string, unknown>;
+    routeContext?: R;
 };
 type SSRResult = {
     headContent: string;
     appHtml: string;
     aborted: boolean;
 };
-type StreamCallOptions = StreamOptions & {
+type StreamCallOptions<R> = StreamOptions & {
     logger?: LoggerLike;
+    routeContext?: R;
 };
-declare function createRenderer<T extends Record<string, unknown>>({ appComponent, headContent, streamOptions, logger, enableDebug, }: {
+declare function createRenderer<T extends Record<string, unknown> = Record<string, unknown>, R = unknown>({ appComponent, headContent, streamOptions, logger, enableDebug, }: {
     appComponent: (props: {
         location: string;
+        routeContext?: R;
     }) => React.ReactElement;
-    headContent: (ctx: HeadContext<T>) => string;
+    headContent: (ctx: HeadContext<T, R>) => string;
     enableDebug?: boolean;
     logger?: LoggerLike;
     streamOptions?: StreamOptions;
 }): {
     renderSSR: (initialData: T, location: string, meta?: Record<string, unknown>, signal?: AbortSignal, opts?: {
         logger?: LoggerLike;
+        routeContext?: R;
     }) => Promise<SSRResult>;
-    renderStream: (writable: Writable, callbacks: RenderCallbacks<T> | undefined, initialData: T | Promise<T> | (() => Promise<T>), location: string, bootstrapModules?: string, meta?: Record<string, unknown>, cspNonce?: string, signal?: AbortSignal, opts?: StreamCallOptions) => {
+    renderStream: (writable: Writable, callbacks: RenderCallbacks<T> | undefined, initialData: T | Promise<T> | (() => Promise<T>), location: string, bootstrapModules?: string, meta?: Record<string, unknown>, cspNonce?: string, signal?: AbortSignal, opts?: StreamCallOptions<R>) => {
         abort: () => void;
         done: Promise<void>;
     };

package/dist/index.js

@@ -364,7 +364,7 @@ function createRenderer({
   logger,
   enableDebug = false
 }) {
-  const { shellTimeoutMs = 1e4, useCork = true } = streamOptions;
+  const { shellTimeoutMs = 1e4 } = streamOptions;
   const renderSSR = async (initialData, location, meta = {}, signal, opts) => {
     const { log, warn } = createUILogger(opts?.logger ?? logger, {
       debugCategory: "ssr",
@@ -378,11 +378,12 @@ function createRenderer({
     let aborted = false;
     const onAbort = () => aborted = true;
     signal?.addEventListener("abort", onAbort, { once: true });
+    const routeContext = opts?.routeContext;
     try {
       log("Starting SSR:", location);
-      const dynamicHead = headContent({ data: initialData, meta });
+      const dynamicHead = headContent({ data: initialData, meta, routeContext });
       const store = createSSRStore(initialData);
-      const html = renderToString(/* @__PURE__ */ jsx3(SSRStoreProvider, { store, children: appComponent({ location }) }));
+      const html = renderToString(/* @__PURE__ */ jsx3(SSRStoreProvider, { store, children: appComponent({ location, routeContext }) }));
       if (aborted) {
         warn("SSR completed after client abort", { location });
         return { headContent: "", appHtml: "", aborted: true };
@@ -409,8 +410,8 @@ function createRenderer({
       context: { scope: "react-streaming" },
       enableDebug
     });
+    const routeContext = opts?.routeContext;
     const effectiveShellTimeout = opts?.shellTimeoutMs ?? shellTimeoutMs;
-    const effectiveUseCork = opts?.useCork ?? useCork;
     const controller = createStreamController(writable, { log, warn, error });
     if (signal) {
       const handleAbortSignal = () => controller.benignAbort(`AbortSignal triggered; aborting stream for location: ${location}`);
@@ -445,9 +446,10 @@ function createRenderer({
     });
     controller.setStopShellTimer(stopShellTimer);
     log("Starting stream:", location);
+    let piped = false;
     try {
       const store = createSSRStore(initialData);
-      const appElement = /* @__PURE__ */ jsx3(SSRStoreProvider, { store, children: appComponent({ location }) });
+      const appElement = /* @__PURE__ */ jsx3(SSRStoreProvider, { store, children: appComponent({ location, routeContext }) });
       const stream = renderToPipeableStream(appElement, {
         nonce: cspNonce,
         bootstrapModules: bootstrapModules ? [bootstrapModules] : void 0,
@@ -468,39 +470,16 @@ function createRenderer({
                 });
               }
             }
-            const head = headContent({ data: headData ?? {}, meta });
-            const canCork = effectiveUseCork && typeof writable.cork === "function" && typeof writable.uncork === "function";
-            if (canCork)
-              try {
-                writable.cork();
-              } catch {
-              }
-            let wroteOk = true;
-            try {
-              const res = typeof writable.write === "function" ? writable.write(head) : true;
-              wroteOk = res !== false;
-            } finally {
-              if (canCork) {
-                try {
-                  writable.uncork();
-                } catch {
-                }
-              }
-            }
-            let forceWait = false;
+            const head = headContent({ data: headData ?? {}, meta, routeContext });
             try {
-              forceWait = cb.onHead(head) === false;
+              cb.onHead(head);
             } catch (cbErr) {
               warn("onHead callback threw:", cbErr);
             }
-            const startPipe = () => stream.pipe(writable);
-            if (forceWait || !wroteOk) {
-              if (typeof writable.once === "function") {
-                writable.once("drain", startPipe);
-              } else {
-                startPipe();
-              }
-            } else startPipe();
+            if (!piped) {
+              piped = true;
+              stream.pipe(writable);
+            }
             try {
               cb.onShellReady();
             } catch (cbErr) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taujs/react",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "taujs | τjs",
   "author": "Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
   "license": "MIT",