vike 0.4.267 → 0.4.268-commit-ca58695

package/dist/server/runtime/renderPageServer/html/serializeContext.d.ts

@@ -9,6 +9,7 @@ import type { GlobalContextServerInternal } from '../../globalContext.js';
 import type { PageContextCreatedServer } from '../createPageContextServer.js';
 import type { PageContextBegin } from '../../renderPageServer.js';
 import type { PageContextCspNonce } from '../csp.js';
+import { type StreamedValue } from '../streamedValues/registry.js';
 import '../../../assertEnvServer.js';
 type PageContextSerialization = PageContextCreatedServer & {
     pageId: string;
@@ -20,7 +21,10 @@ type PageContextSerialization = PageContextCreatedServer & {
     _globalContext: GlobalContextServerInternal;
     _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
 } & PageContextCspNonce;
-declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): {
+    pageContextSerialized: string;
+    streamedValues: StreamedValue[];
+};
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 type PassToClient = string[];
 type PassToClientPublic = (string | {

package/dist/server/runtime/renderPageServer/html/serializeContext.js

@@ -7,12 +7,12 @@ import { getPropAccessNotation } from '../../../../utils/getPropAccessNotation.j
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
 import { hasProp } from '../../../../utils/hasProp.js';
 import { isErrorPage } from '../../../../shared-server-client/error-page.js';
-import { addIs404ToPageProps } from '../../../../shared-server-client/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { NOT_SERIALIZABLE } from '../../../../shared-server-client/NOT_SERIALIZABLE.js';
 import { pageContextInitIsPassedToClient } from '../../../../shared-server-client/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../../../shared-server-client/misc/isServerSideError.js';
 import { getPropKeys, getPropVal, setPropVal } from './propKeys.js';
+import { getReplacer } from '../streamedValues/registry.js';
 import { assertRouteParams } from '../../../../shared-server-client/route/resolveRouteFunction.js';
 import '../../../assertEnvServer.js';
 const passToClientBuiltInPageContext = [
@@ -30,6 +30,8 @@ const passToClientBuiltInPageContext = [
     'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
+// Streamed pageContext values (see shared-server-client/streamedValues.ts) are serialized as placeholders and returned:
+// the caller sends them after the serialized pageContext.
 function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
     const res = applyPassToClient(passToClientPageContext, pageContext);
@@ -38,8 +40,9 @@ function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
-    return pageContextClientSerialized;
+    const { replacer, streamedValues } = getReplacer(pageContext);
+    const pageContextSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript, replacer);
+    return { pageContextSerialized, streamedValues };
 }
 function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClient = pageContext._passToClient;
@@ -49,10 +52,10 @@ function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript, replacer) {
     let serialized;
     try {
-        serialized = serializeValue(obj, isHtmlJsonScript);
+        serialized = serializeValue(obj, isHtmlJsonScript, undefined, replacer);
     }
     catch (err) {
         const h = (s) => pc.cyan(s);
@@ -65,7 +68,7 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
             const { value } = res;
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serializeValue(value, isHtmlJsonScript, varName);
+                serializeValue(value, isHtmlJsonScript, varName, replacer);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -103,7 +106,7 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
             obj[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
-            serialized = serializeValue(obj, isHtmlJsonScript);
+            serialized = serializeValue(obj, isHtmlJsonScript, undefined, replacer);
         }
         catch (err) {
             assert(false);
@@ -111,10 +114,11 @@ function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     }
     return serialized;
 }
-function serializeValue(value, isHtmlJsonScript, varName) {
+function serializeValue(value, isHtmlJsonScript, varName, replacer) {
     return stringify(value, {
         forbidReactElements: true,
         valueName: varName,
+        replacer,
         htmlScriptSafe: {
             // Could be set to `isHtmlJsonScript` but we always use `htmlScriptSafe.escapeScripts` to be extra safe
             escapeScripts: true,
@@ -127,7 +131,6 @@ function getPassToClientPageContext(pageContext) {
     let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
     if (isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
-        addIs404ToPageProps(pageContext);
         passToClient.push(...pageToClientBuiltInPageContextError);
     }
     passToClient = unique(passToClient);

package/dist/server/runtime/renderPageServer/html/stream.d.ts

@@ -16,6 +16,8 @@ export { isStreamReadableNode };
 export { getStreamName };
 export { inferStreamName };
 export { streamReadableWebToString };
+export { streamReadableWebToBytes };
+export { awaitFirstChunk };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
@@ -46,17 +48,22 @@ declare function isStreamWritableWeb(thing: unknown): thing is StreamWritableWeb
 declare function isStreamReadableNode(thing: unknown): thing is StreamReadableNode;
 declare function isStreamWritableNode(thing: unknown): thing is StreamWritableNode;
 declare function streamReadableWebToString(readableWeb: ReadableStream): Promise<string>;
+declare function streamReadableWebToBytes(readableWeb: ReadableStream): Promise<Uint8Array>;
+declare function awaitFirstChunk(stream: StreamReadableWeb, onErrorWhileStreaming: (err: unknown) => void): Promise<StreamReadableWeb>;
 declare function streamPipeNodeToString(streamPipeNode: StreamPipeNode): Promise<string>;
-declare function getStreamReadableNode(htmlRender: HtmlRender): Promise<null | StreamReadableNode>;
-declare function getStreamReadableWeb(htmlRender: HtmlRender): null | StreamReadableWeb;
-declare function pipeToStreamWritableWeb(htmlRender: HtmlRender, writable: StreamWritableWeb): boolean;
-declare function pipeToStreamWritableNode(htmlRender: HtmlRender, writable: StreamWritableNode): boolean;
-declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }: {
+declare function getStreamReadableNode(htmlRender: HtmlRender | Uint8Array): Promise<null | StreamReadableNode>;
+declare function getStreamReadableWeb(htmlRender: HtmlRender | Uint8Array): StreamReadableWeb;
+declare function pipeToStreamWritableWeb(htmlRender: HtmlRender | Uint8Array, writable: StreamWritableWeb): boolean;
+declare function pipeToStreamWritableNode(htmlRender: HtmlRender | Uint8Array, writable: StreamWritableNode): boolean;
+declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, onCancel, }: {
     injectStringAtBegin?: () => Promise<string>;
     injectStringAfterFirstChunk?: () => string | null;
-    injectStringAtEnd?: () => Promise<string>;
+    /** `writeHtml()` writes HTML before the returned string (e.g. streamed pageContext values) */
+    injectStringAtEnd?: (writeHtml: (html: string) => void) => Promise<string>;
     onErrorWhileStreaming: (err: unknown) => void;
     enableEagerStreaming?: boolean;
+    /** The stream was cancelled (e.g. the user closed the tab) or failed */
+    onCancel: () => void;
 }): Promise<StreamProviderNormalized>;
 declare function isStream(something: unknown): something is StreamProviderAny;
 declare const __streamPipeWeb = "__streamPipeWeb";

package/dist/server/runtime/renderPageServer/html/stream.js

@@ -16,6 +16,8 @@ export { isStreamReadableNode };
 export { getStreamName };
 export { inferStreamName };
 export { streamReadableWebToString };
+export { streamReadableWebToBytes };
+export { awaitFirstChunk };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
@@ -74,9 +76,60 @@ async function streamReadableWebToString(readableWeb) {
     str += getClosingChunk();
     return str;
 }
+async function streamReadableWebToBytes(readableWeb) {
+    const reader = readableWeb.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        assertUsage(value instanceof Uint8Array, `The stream emitted a chunk that isn't a Uint8Array: ${String(value)}`);
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(chunks.reduce((len, chunk) => len + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return bytes;
+}
+// Resolves after the first chunk (rejects if the stream errors before), then reads on demand
+async function awaitFirstChunk(stream, onErrorWhileStreaming) {
+    const reader = stream.getReader();
+    const firstChunk = await reader.read();
+    const streamStarted = new ReadableStream({
+        start(controller) {
+            if (firstChunk.done)
+                controller.close();
+            else
+                controller.enqueue(firstChunk.value);
+        },
+        async pull(controller) {
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch (err) {
+                onErrorWhileStreaming(err);
+                controller.error(err);
+                return;
+            }
+            if (chunk.done)
+                controller.close();
+            else
+                controller.enqueue(chunk.value);
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+    return streamStarted;
+}
 async function stringToStreamReadableNode(str) {
     const { Readable } = await loadStreamNodeModule();
-    return Readable.from(str);
+    // Readable.from() iterates a Uint8Array byte by byte
+    return Readable.from(typeof str === 'string' ? str : [str]);
 }
 async function streamReadableWebToStreamReadableNode(stream) {
     const { Readable } = await loadStreamNodeModule();
@@ -156,16 +209,19 @@ function streamPipeWebToString(streamPipeWeb) {
     return promise;
 }
 async function getStreamReadableNode(htmlRender) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         return stringToStreamReadableNode(htmlRender);
     }
     if (isStreamReadableNode(htmlRender)) {
         return htmlRender;
     }
+    if (isStreamReadableWeb(htmlRender)) {
+        return streamReadableWebToStreamReadableNode(htmlRender);
+    }
     return null;
 }
 function getStreamReadableWeb(htmlRender) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         return stringToStreamReadableWeb(htmlRender);
     }
     if (isStreamReadableWeb(htmlRender)) {
@@ -178,16 +234,30 @@ function getStreamReadableWeb(htmlRender) {
         streamPipeWeb(writable);
         return readable;
     }
-    return null;
+    if (isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender)) {
+        // A Node.js stream implies that Node.js's `stream` module is available
+        const { readable, writable } = new TransformStream();
+        loadStreamNodeModule().then(({ Readable, PassThrough }) => {
+            const passThrough = new PassThrough();
+            pipeToStreamWritableNode(htmlRender, passThrough);
+            Readable.toWeb(passThrough)
+                .pipeTo(writable)
+                .catch(() => { });
+        });
+        return readable;
+    }
+    checkType(htmlRender);
+    assert(false);
 }
 function pipeToStreamWritableWeb(htmlRender, writable) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         const streamPipeWeb = stringToStreamPipeWeb(htmlRender);
         streamPipeWeb(writable);
         return true;
     }
     if (isStreamReadableWeb(htmlRender)) {
-        htmlRender.pipeTo(writable);
+        // pipeTo() propagates a failure of either side to the other side
+        htmlRender.pipeTo(writable).catch(() => { });
         return true;
     }
     if (isStreamPipeWeb(htmlRender)) {
@@ -203,23 +273,30 @@ function pipeToStreamWritableWeb(htmlRender, writable) {
     assert(false);
 }
 function pipeToStreamWritableNode(htmlRender, writable) {
-    if (typeof htmlRender === 'string') {
+    if (typeof htmlRender === 'string' || htmlRender instanceof Uint8Array) {
         const streamPipeNode = stringToStreamPipeNode(htmlRender);
         streamPipeNode(writable);
         return true;
     }
-    if (isStreamReadableNode(htmlRender)) {
-        htmlRender.pipe(writable);
-        return true;
-    }
     if (isStreamPipeNode(htmlRender)) {
         const streamPipeNode = getStreamPipeNode(htmlRender);
         assert(streamPipeNode);
         streamPipeNode(writable);
         return true;
     }
-    if (isStreamReadableWeb(htmlRender)) {
-        streamReadableWebToStreamReadableNode(htmlRender).then((s) => s.pipe(writable));
+    if (isStreamReadableNode(htmlRender) || isStreamReadableWeb(htmlRender)) {
+        getStreamReadableNode(htmlRender).then(async (readable) => {
+            assert(readable);
+            const { pipeline } = await loadStreamNodeModule();
+            // pipeline() throws if the writable is already destroyed (e.g. the client left before the first chunk)
+            if (writable.destroyed)
+                return readable.destroy();
+            // Unlike pipe(), pipeline() destroys the readable if the writable closes early, and the writable if the readable errors or closes before its end
+            pipeline(readable, writable, () => { });
+            // E.g. compression() holds the writes until flush()
+            const w = writable;
+            readable.on('data', () => w.flush?.());
+        });
         return true;
     }
     if (isStreamPipeWeb(htmlRender)) {
@@ -228,7 +305,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     checkType(htmlRender);
     assert(false);
 }
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, onCancel, }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -275,6 +352,8 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             resolveReadyToWrite();
         },
         onError(err) {
+            // The HTML won't end: its streamed pageContext values won't be sent
+            onCancel();
             if (!promiseHasResolved) {
                 reject(err);
             }
@@ -303,7 +382,10 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                     streamOriginalEnded = true;
                 });
                 if (injectStringAtEnd && !isCancel) {
-                    const injectedChunk = await injectStringAtEnd();
+                    const injectedChunk = await injectStringAtEnd((html) => {
+                        writeStream(html);
+                        flushStream();
+                    });
                     writeStream(injectedChunk);
                 }
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
@@ -326,6 +408,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         onFlush() {
             flushStream();
         },
+        onCancel,
     });
     wrapperCreated = true;
     flushBuffer(); // In case onReadyToWrite() was already called (the flushBuffer() of onReadyToWrite() wasn't called because `wrapperCreated === false`)
@@ -388,7 +471,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         return !enableEagerStreaming && !streamOriginalHasStartedEmitting;
     }
 }
-async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, }) {
+async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, onCancel, }) {
     if (isStreamFromReactStreamingPackage(streamOriginal)) {
         debug(`onRenderHtml() hook returned ${pc.cyan('react-streaming')} result`);
         const stream = getStreamOfReactStreamingPackage(streamOriginal);
@@ -400,6 +483,16 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const pipeProxy = (writable_) => {
             writableOriginal = writable_;
             debug('original Node.js Writable received');
+            // Let the source know when the response closes early (no-op once it has ended)
+            const onClose = () => {
+                if (!hasEnded)
+                    onCancel();
+                writableProxy.destroy();
+            };
+            if (writableOriginal.destroyed)
+                onClose();
+            else
+                writableOriginal.on('close', onClose);
             onReadyToWrite();
             if (hasEnded) {
                 // onReadyToWrite() already wrote everything; we can close the stream right away
@@ -463,6 +556,11 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const pipeProxy = (writableOriginal) => {
             writerOriginal = writableOriginal.getWriter();
             debug('original Web Writable received');
+            // Let the source know when the response closes early
+            writerOriginal.closed.catch((err) => {
+                onCancel();
+                readerProxy?.cancel(err);
+            });
             (async () => {
                 // CloudFlare Workers does not implement `ready` property
                 //  - https://github.com/vuejs/vue-next/issues/4287
@@ -480,7 +578,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         stampPipe(pipeProxy, 'web-stream');
         const writeChunk = (chunk) => {
             assert(writerOriginal);
-            writerOriginal.write(encodeForWebStream(chunk));
+            writerOriginal.write(encodeForWebStream(chunk)).catch(() => { });
             debugWithChunk('data written (Web Writable)', chunk);
         };
         // Web Streams have compression built-in
@@ -491,10 +589,11 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const endStream = () => {
             hasEnded = true;
             if (writerOriginal) {
-                writerOriginal.close();
+                writerOriginal.close().catch(() => { });
             }
         };
         let writableProxy;
+        let readerProxy;
         if (typeof ReadableStream !== 'function') {
             writableProxy = new WritableStream({
                 write(chunk) {
@@ -513,7 +612,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         else {
             const { readable, writable } = new TransformStream();
             writableProxy = writable;
-            handleReadableWeb(readable, {
+            readerProxy = readable.getReader();
+            handleReadableWeb(readerProxy, {
                 onData,
                 onError(err) {
                     onError(err);
@@ -531,7 +631,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     }
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
-        const readableOriginal = streamOriginal;
+        const readerOriginal = streamOriginal.getReader();
         let isClosed = false;
         let isCancel = false;
         const closeStream = async () => {
@@ -548,7 +648,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             start(controller) {
                 controllerProxy = controller;
                 onReadyToWrite();
-                handleReadableWeb(readableOriginal, {
+                handleReadableWeb(readerOriginal, {
                     onData,
                     onError(err) {
                         onError(err);
@@ -559,18 +659,16 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                     },
                 });
             },
-            async cancel(...args) {
+            async cancel(reason) {
                 debug('stream cancelled');
                 isCancel = true;
-                await readableOriginal.cancel(...args);
-                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
-                await closeStream();
+                onCancel();
+                // Ends handleReadableWeb() which then calls closeStream()
+                await readerOriginal.cancel(reason);
             },
         });
         const writeChunk = (chunk) => {
-            if (!isCancel &&
-                // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
-                !isClosed) {
+            if (!isCancel && !isClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
                 debugWithChunk('data written (Web Readable)', chunk);
             }
@@ -603,6 +701,12 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             readableProxy.push(null);
         };
         const readableProxy = new Readable({ read() { } });
+        // Destroy the source when the consumer closes early
+        readableProxy.once('close', () => {
+            if (!readableProxy.readableEnded)
+                onCancel();
+            readableOriginal.destroy();
+        });
         onReadyToWrite();
         readableOriginal.on('data', (chunk) => {
             onData(chunk);
@@ -622,8 +726,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     }
     assert(false);
 }
-async function handleReadableWeb(readable, { onData, onError, onEnd, }) {
-    const reader = readable.getReader();
+async function handleReadableWeb(reader, { onData, onError, onEnd, }) {
     while (true) {
         let result;
         try {
@@ -776,8 +879,8 @@ function encodeForWebStream(thing) {
 // Because of Cloudflare Workers, we cannot statically import the `stream` module, instead we dynamically import it.
 async function loadStreamNodeModule() {
     const streamModule = (await import_('stream')).default;
-    const { Readable, Writable } = streamModule;
-    return { Readable, Writable };
+    const { Readable, Writable, PassThrough, pipeline } = streamModule;
+    return { Readable, Writable, PassThrough, pipeline };
 }
 function getStreamName(kind, type) {
     let typeName = capitalizeFirstLetter(type);

package/dist/server/runtime/renderPageServer/html/streamedValuesHtml.d.ts

@@ -0,0 +1,30 @@
+export { serializePageContextHtml };
+export { getStreamedValuesHtml };
+export { writeStreamedValuesHtmlAtStreamEnd };
+export { cancelStreamedValuesHtml };
+export { getStreamedValuesLinesPrerendered };
+export type { PageContextStreamedValuesHtml };
+import { type PageContextSerialization } from './serializeContext.js';
+import type { PageContextCreatedServer } from '../createPageContextServer.js';
+import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
+import { type PageContextCspNonce } from '../csp.js';
+import '../../../assertEnvServer.js';
+type StreamedValuesHtml = {
+    done: Promise<void>;
+    cancel: () => void;
+    /** The `<script>` tags not sent yet */
+    pending: string[];
+    /** Set once the HTML stream is ending */
+    writeHtml: null | ((html: string) => void);
+    /** Pre-rendering: all lines */
+    lines: null | string[];
+};
+type PageContextStreamedValuesHtml = PageContextCreatedServer & PageContextCspNonce & {
+    _requestId: number;
+    _streamedValuesHtml?: StreamedValuesHtml;
+};
+declare function serializePageContextHtml(pageContext: PageContextStreamedValuesHtml & PageContextSerialization, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage): string;
+declare function getStreamedValuesHtml(pageContext: PageContextStreamedValuesHtml): Promise<null | string>;
+declare function writeStreamedValuesHtmlAtStreamEnd(pageContext: PageContextStreamedValuesHtml, htmlEnd: string, writeHtml: (html: string) => void): Promise<string>;
+declare function cancelStreamedValuesHtml(pageContext: PageContextStreamedValuesHtml): void;
+declare function getStreamedValuesLinesPrerendered(pageContext: PageContextStreamedValuesHtml): Promise<null | string[]>;

package/dist/server/runtime/renderPageServer/html/streamedValuesHtml.js

@@ -0,0 +1,92 @@
+// The streamed pageContext values (see shared-server-client/streamedValues.ts) of the HTML's
+// `<script id="vike_pageContext">`: each line is sent as a `<script>` that pushes it to `self.__vike_streamed` (read by
+// Vike's client runtime, see client/shared/streamedValues.ts).
+// - HTML stream of react-streaming: the lines are injected into the stream as they're produced.
+// - HTML stream: the lines produced while the stream is running are sent after it ends, and the lines produced
+//   afterwards are sent as they're produced; the HTML ends once all values have ended.
+// - HTML string: the lines are appended to the HTML once all values have ended.
+// - Pre-rendering: the lines are also collected for `index.pageContext.json`, so that the values are read once.
+export { serializePageContextHtml };
+export { getStreamedValuesHtml };
+export { writeStreamedValuesHtmlAtStreamEnd };
+export { cancelStreamedValuesHtml };
+export { getStreamedValuesLinesPrerendered };
+import { assert } from '../../../../utils/assert.js';
+import { pumpStreamedValues } from '../streamedValues/pump.js';
+import { getPageContextClientSerialized } from './serializeContext.js';
+import { inferNonceAttr } from '../csp.js';
+import '../../../assertEnvServer.js';
+// The pageContext of `<script id="vike_pageContext">`, as `[pageContext]` if it has streamed values (which start streaming)
+function serializePageContextHtml(pageContext, streamFromReactStreamingPackage) {
+    const { pageContextSerialized, streamedValues } = getPageContextClientSerialized(pageContext, true);
+    if (streamedValues.length === 0)
+        return pageContextSerialized;
+    // The pageContext is serialized once per HTML
+    assert(!pageContext._streamedValuesHtml);
+    const { isPrerendering } = pageContext;
+    const write = (line) => {
+        streamedValuesHtml.lines?.push(line);
+        const script = getScript(line, pageContext);
+        if (streamedValuesHtml.writeHtml) {
+            streamedValuesHtml.writeHtml(script);
+        }
+        else if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
+            streamFromReactStreamingPackage.injectToStream(script, { flush: true });
+        }
+        else {
+            streamedValuesHtml.pending.push(script);
+        }
+    };
+    const streamedValuesHtml = {
+        // A pre-rendered page can't have a failed value
+        ...pumpStreamedValues(pageContext, streamedValues, write, { failFast: isPrerendering }),
+        pending: [],
+        writeHtml: null,
+        lines: isPrerendering ? [] : null,
+    };
+    // Pre-rendering: the error is thrown by getStreamedValuesLinesPrerendered()
+    streamedValuesHtml.done.catch(() => { });
+    pageContext._streamedValuesHtml = streamedValuesHtml;
+    return `[${pageContextSerialized}]`;
+}
+// HTML string
+async function getStreamedValuesHtml(pageContext) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return null;
+    await streamedValuesHtml.done.catch(() => { });
+    return streamedValuesHtml.pending.join('');
+}
+// HTML stream: `htmlEnd` is what Vike appends after the HTML stream ended. The lines are sent before `</body>`.
+async function writeStreamedValuesHtmlAtStreamEnd(pageContext, htmlEnd, writeHtml) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return htmlEnd;
+    let i = htmlEnd.lastIndexOf('</body>');
+    if (i === -1)
+        i = htmlEnd.length;
+    writeHtml(htmlEnd.slice(0, i) + streamedValuesHtml.pending.join(''));
+    streamedValuesHtml.writeHtml = writeHtml;
+    await streamedValuesHtml.done.catch(() => { });
+    return htmlEnd.slice(i);
+}
+// The HTML response was cancelled (e.g. the user closed the tab) or failed
+function cancelStreamedValuesHtml(pageContext) {
+    pageContext._streamedValuesHtml?.cancel();
+}
+// Pre-rendering: the lines for `index.pageContext.json` (the values are read once, while rendering the HTML)
+async function getStreamedValuesLinesPrerendered(pageContext) {
+    const streamedValuesHtml = pageContext._streamedValuesHtml;
+    if (!streamedValuesHtml)
+        return null;
+    await streamedValuesHtml.done;
+    assert(streamedValuesHtml.lines);
+    return streamedValuesHtml.lines;
+}
+function getScript(line, pageContext) {
+    // A JavaScript string literal: JSON.stringify() escapes quotes, backslashes and line breaks; `<` is escaped so that the
+    // script never contains `</script>` nor `<!--`; `/` is escaped for the same reason as in `<script id="vike_pageContext">`
+    // (https://github.com/vikejs/vike/pull/2603)
+    const literal = JSON.stringify(line).replaceAll('<', '\\u003c').replaceAll('/', '\\/');
+    return `<script${inferNonceAttr(pageContext)}>(self.__vike_streamed=self.__vike_streamed||[]).push(${literal})</script>`;
+}