vike 0.4.267 → 0.4.268-commit-45c1759

package/dist/server/runtime/renderPageServer/renderPageServerAfterRoute.js

@@ -1,15 +1,16 @@
 export { renderPageServerAfterRoute };
 export { prerenderPage };
-export { prerenderPageEntry };
 import { getErrorPageId } from '../../../shared-server-client/error-page.js';
 import { getHtmlString } from './html/renderHtml.js';
+import { isStreamReadableWeb, streamReadableWebToBytes } from './html/stream.js';
 import { assert, assertUsage } from '../../../utils/assert.js';
 import { hasProp } from '../../../utils/hasProp.js';
 import { isSameErrorMessage } from '../../../utils/isSameErrorMessage.js';
 import { objectAssign } from '../../../utils/objectAssign.js';
 import { updateType } from '../../../utils/updateType.js';
-import { getPageContextClientSerialized } from './html/serializeContext.js';
-import { createHttpResponsePage, createHttpResponsePageJson } from './createHttpResponse.js';
+import { getStreamedValuesLinesPrerendered } from './html/streamedValuesHtml.js';
+import { getPageContextJson, getPageContextJsonFile } from './getPageContextJson.js';
+import { createHttpResponsePageHtml, createHttpResponsePageContent, createHttpResponsePageJson, } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
@@ -50,14 +51,14 @@ async function renderPageServerAfterRoute(pageContext) {
         if (isError) {
             objectAssign(pageContext, { [isServerSideError]: true });
         }
-        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(getPageContextJson(pageContext), pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await execHookOnRenderHtml(pageContext);
-    const { htmlRender, renderHook } = renderHookResult;
-    const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
+    const { htmlRender, content, renderHook } = await execHookOnRenderHtml(pageContext);
+    const httpResponse = content !== null
+        ? createHttpResponsePageContent(content, renderHook, pageContext)
+        : await createHttpResponsePageHtml(htmlRender, renderHook, pageContext);
     objectAssign(pageContext, { httpResponse });
     return pageContext;
 }
@@ -85,15 +86,23 @@ async function prerenderPageEntry(pageContext) {
     await execHookGuard(pageContext, (pageContext) => getPageContextPublicServer(pageContext))
     */
     await execHookDataAndOnBeforeRender(pageContext);
-    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
+    const { htmlRender, content, renderHook } = await execHookOnRenderHtml(pageContext);
+    if (content !== null) {
+        // Rejects if the stream errors
+        const fileContent = isStreamReadableWeb(content) ? await streamReadableWebToBytes(content) : content;
+        return { documentHtml: null, content: fileContent, pageContextSerialized: null, pageContext };
+    }
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     const documentHtml = await getHtmlString(htmlRender);
     assert(typeof documentHtml === 'string');
+    // The streamed pageContext values were read while rendering the HTML: the same lines go into `index.pageContext.json`, and
+    // a value that failed makes pre-rendering fail (also without Client Routing)
+    const streamedValuesLines = await getStreamedValuesLinesPrerendered(pageContext);
     if (!pageContext._usesClientRouter) {
-        return { documentHtml, pageContextSerialized: null, pageContext };
+        return { documentHtml, content: null, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        return { documentHtml, pageContextSerialized, pageContext };
+        const pageContextSerialized = getPageContextJsonFile(pageContext, streamedValuesLines);
+        return { documentHtml, content: null, pageContextSerialized, pageContext };
     }
 }

package/dist/server/runtime/renderPageServer/streamedValues/asyncIterable.d.ts

@@ -0,0 +1,4 @@
+export { asyncIterable };
+import type { StreamedValueType } from './registry.js';
+import '../../../assertEnvServer.js';
+declare const asyncIterable: StreamedValueType<AsyncIterable<unknown>, IteratorResult<unknown>>;

package/dist/server/runtime/renderPageServer/streamedValues/asyncIterable.js

@@ -0,0 +1,12 @@
+export { asyncIterable };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { chunkToLine } from './lines.js';
+import '../../../assertEnvServer.js';
+const asyncIterable = {
+    marker: markers.asyncIterable,
+    is: (value) => typeof value === 'object' && value !== null && Symbol.asyncIterator in value,
+    read(value) {
+        const iterator = value[Symbol.asyncIterator]();
+        return { next: () => iterator.next(), toLine: chunkToLine, cancel: () => iterator.return?.() };
+    },
+};

package/dist/server/runtime/renderPageServer/streamedValues/lines.d.ts

@@ -0,0 +1,10 @@
+export { serializeLine };
+export { chunkToLine };
+import { type Replacer } from '@brillout/json-serializer/stringify';
+import type { Line, LineContent } from '../../../../shared-server-client/streamedValues.js';
+import '../../../assertEnvServer.js';
+declare function serializeLine(line: Line, replacer: Replacer): string;
+declare function chunkToLine(result: IteratorResult<unknown>): {
+    line: LineContent;
+    isLast: boolean;
+};

package/dist/server/runtime/renderPageServer/streamedValues/lines.js

@@ -0,0 +1,49 @@
+// The encoding of the lines (see shared-server-client/streamedValues.ts)
+export { serializeLine };
+export { chunkToLine };
+import { stringify } from '@brillout/json-serializer/stringify';
+import { assert } from '../../../../utils/assert.js';
+import '../../../assertEnvServer.js';
+// `replacer` replaces the streamed values that a `v` line's value contains
+function serializeLine(line, replacer) {
+    const lineStr = 'v' in line
+        ? `{"s":${line.s},"v":${stringify(line.v, {
+            forbidReactElements: true,
+            valueName: 'a streamed pageContext value',
+            replacer,
+            htmlScriptSafe: { escapeScripts: true, escapeURLs: false },
+        })}}`
+        : JSON.stringify(line);
+    // JSON.stringify() escapes line breaks: one line per JSON value
+    assert(!lineStr.includes('\n'));
+    return lineStr;
+}
+// A ReadableStream / async iterable: one line per chunk, then an `end` line
+function chunkToLine(result) {
+    if (result.done)
+        return { line: { end: true }, isLast: true };
+    return { line: encodeChunk(result.value), isLast: false };
+}
+function encodeChunk(chunk) {
+    if (!(chunk instanceof Uint8Array))
+        return { v: chunk };
+    const text = decodeUtf8(chunk);
+    return text !== null ? { t: text } : { b: encodeBase64url(chunk) };
+}
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+function decodeUtf8(bytes) {
+    try {
+        return utf8Decoder.decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+function encodeBase64url(bytes) {
+    let binary = '';
+    // In slices: spreading a large array into a single call overflows the stack
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+}

package/dist/server/runtime/renderPageServer/streamedValues/promise.d.ts

@@ -0,0 +1,4 @@
+export { promise };
+import type { StreamedValueType } from './registry.js';
+import '../../../assertEnvServer.js';
+declare const promise: StreamedValueType<Promise<unknown>>;

package/dist/server/runtime/renderPageServer/streamedValues/promise.js

@@ -0,0 +1,14 @@
+export { promise };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { isPromise } from '../../../../utils/isPromise.js';
+import '../../../assertEnvServer.js';
+// One `v` line
+const promise = {
+    marker: markers.promise,
+    is: isPromise,
+    read: (value) => ({
+        next: () => value,
+        toLine: (v) => ({ line: { v }, isLast: true }),
+        cancel: () => { },
+    }),
+};

package/dist/server/runtime/renderPageServer/streamedValues/pump.d.ts

@@ -0,0 +1,10 @@
+export { pumpStreamedValues };
+import { type PageContext_logRuntime } from '../../loggerRuntime.js';
+import { type StreamedValue } from './registry.js';
+import '../../../assertEnvServer.js';
+declare function pumpStreamedValues(pageContext: NonNullable<PageContext_logRuntime>, streamedValues: StreamedValue[], write: (line: string) => void, { failFast }: {
+    failFast: boolean;
+}): {
+    done: Promise<void>;
+    cancel: () => void;
+};

package/dist/server/runtime/renderPageServer/streamedValues/pump.js

@@ -0,0 +1,67 @@
+// Reads the streamed values of a response concurrently and writes their lines.
+// - `failFast: false` (responses): a value that fails is logged and sent as an `error` line.
+// - `failFast: true` (pre-rendering): a value that fails rejects `done`.
+export { pumpStreamedValues };
+import { logRuntimeError } from '../../loggerRuntime.js';
+import { getReplacer } from './registry.js';
+import { serializeLine } from './lines.js';
+import { genPromise } from '../../../../utils/genPromise.js';
+import '../../../assertEnvServer.js';
+function pumpStreamedValues(pageContext, streamedValues, write, { failFast }) {
+    // Stop the values being read: when the response ends early, or when the value fails
+    const cancels = new Set();
+    let pending = 0;
+    let isEnded = false;
+    const { promise: done, resolve, reject } = genPromise({ timeout: null });
+    const end = (settle) => {
+        if (isEnded)
+            return;
+        isEnded = true;
+        cancels.forEach((cancel) => cancel());
+        settle();
+    };
+    const start = (streamedValue) => {
+        pending++;
+        send(streamedValue).then(() => {
+            if (--pending === 0)
+                end(resolve);
+        }, (err) => end(() => reject(err)));
+    };
+    // A line's value can contain new streamed values: they're started after the line is written
+    const writeLine = (line) => {
+        const { replacer, streamedValues } = getReplacer(pageContext);
+        write(serializeLine(line, replacer));
+        streamedValues.forEach(start);
+    };
+    const send = async ({ id: s, type, value }) => {
+        let cancel = () => { };
+        try {
+            const reader = type.read(value);
+            cancel = () => void Promise.resolve(reader.cancel()).catch(() => { });
+            cancels.add(cancel);
+            while (true) {
+                const result = await reader.next();
+                if (isEnded)
+                    return;
+                const { line, isLast } = reader.toLine(result);
+                writeLine({ s, ...line });
+                if (isLast)
+                    return;
+            }
+        }
+        catch (err) {
+            if (isEnded)
+                return;
+            cancel();
+            if (failFast)
+                throw err;
+            logRuntimeError(err, pageContext);
+            writeLine({ s, error: true });
+        }
+        finally {
+            cancels.delete(cancel);
+        }
+    };
+    streamedValues.forEach(start);
+    return { done, cancel: () => end(resolve) };
+}

package/dist/server/runtime/renderPageServer/streamedValues/readableStream.d.ts

@@ -0,0 +1,4 @@
+export { readableStream };
+import type { StreamedValueType } from './registry.js';
+import '../../../assertEnvServer.js';
+declare const readableStream: StreamedValueType<ReadableStream<unknown>, ReadableStreamReadResult<unknown>>;

package/dist/server/runtime/renderPageServer/streamedValues/readableStream.js

@@ -0,0 +1,12 @@
+export { readableStream };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { chunkToLine } from './lines.js';
+import '../../../assertEnvServer.js';
+const readableStream = {
+    marker: markers.readableStream,
+    is: (value) => value instanceof ReadableStream,
+    read(value) {
+        const reader = value.getReader();
+        return { next: () => reader.read(), toLine: chunkToLine, cancel: () => reader.cancel() };
+    },
+};

package/dist/server/runtime/renderPageServer/streamedValues/registry.d.ts

@@ -0,0 +1,28 @@
+export { getReplacer };
+export type { StreamedValue };
+export type { StreamedValueType };
+import type { Replacer } from '@brillout/json-serializer/stringify';
+import type { LineContent } from '../../../../shared-server-client/streamedValues.js';
+import '../../../assertEnvServer.js';
+type StreamedValueType<Value = any, Result = any> = {
+    marker: string;
+    is: (value: unknown) => value is Value;
+    read: (value: Value) => {
+        next: () => Promise<Result>;
+        /** `isLast`: the value ended */
+        toLine: (result: Result) => {
+            line: LineContent;
+            isLast: boolean;
+        };
+        cancel: () => unknown;
+    };
+};
+type StreamedValue = {
+    id: number;
+    type: StreamedValueType;
+    value: unknown;
+};
+declare function getReplacer(pageContext: object): {
+    replacer: Replacer;
+    streamedValues: StreamedValue[];
+};

package/dist/server/runtime/renderPageServer/streamedValues/registry.js

@@ -0,0 +1,33 @@
+// The types of streamed pageContext values (see shared-server-client/streamedValues.ts), and the serializer's replacer
+// that replaces them with their marker and id.
+export { getReplacer };
+import { readableStream } from './readableStream.js';
+import { promise } from './promise.js';
+import { asyncIterable } from './asyncIterable.js';
+import '../../../assertEnvServer.js';
+// A ReadableStream is also an async iterable
+const types = [readableStream, promise, asyncIterable];
+// Per pageContext: the HTML and the `index.pageContext.json` of a pre-rendered page reference the same values with the
+// same ids.
+const idsByPageContext = new WeakMap();
+// `streamedValues`: the values not seen before, filled while serializing
+function getReplacer(pageContext) {
+    let ids = idsByPageContext.get(pageContext);
+    if (!ids)
+        idsByPageContext.set(pageContext, (ids = { byValue: new Map(), idNext: 0 }));
+    const streamedValues = [];
+    const replacer = (_key, value) => {
+        const type = types.find((type) => type.is(value));
+        if (!type)
+            return undefined;
+        let streamedValue = ids.byValue.get(value);
+        if (!streamedValue) {
+            streamedValue = { id: ids.idNext++, type, value };
+            ids.byValue.set(value, streamedValue);
+            // The same value referenced twice is sent once (a stream can be read only once)
+            streamedValues.push(streamedValue);
+        }
+        return { replacement: type.marker + streamedValue.id };
+    };
+    return { replacer, streamedValues };
+}

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

@@ -1,21 +1,72 @@
 export { renderPageServer };
+export { renderPageServer_userLand };
 export { getRequestTag };
 export type { PageContextInit };
-export type { PageContextInitInternal };
 export type { PageContextBegin };
 export type { RequestTag };
 import { type PageContextAborted } from '../../shared-server-client/route/abort.js';
 import { type GlobalContextServerInternal } from './globalContext.js';
 import { type HttpResponse } from './renderPageServer/createHttpResponse.js';
 import type { PageContextServer } from '../../types/index.js';
-import type { PageContextInit, PageContextInitInternal } from '../../types/PageContext.js';
+import type { PageContextInit, PageContextInternalServer } from '../../types/PageContext.js';
 import { type AsyncStore } from './asyncHook.js';
 import '../assertEnvServer.js';
 type PageContextBegin = ReturnType<typeof getPageContextBegin>;
-declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInitInternal>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+declare function renderPageServer_userLand<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+    httpResponse: HttpResponse;
+} & Partial<import("../../shared-server-client/getPageFiles.js").PageContextConfig & {
+    isPageContext: true;
+    Page: import("../../types/Config.js").Config['Page'];
+    routeParams: Record<string, string>;
+    data: unknown;
+    headersResponse: Headers;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared-server-client/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+    source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    sources: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+} & PageContextInit & {
+    urlOriginal: string;
+} & {
+    urlParsed: import("../../utils/parseUrl.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    urlParsed: Omit<import("../../utils/parseUrl.js").UrlPublic, "hash" | "hashOriginal" | "hashString"> & {
+        hash: '';
+        hashString: null;
+        hashOriginal: null;
+    };
+} & {
+    headers: Record<string, string> | null;
+    isClientSide: false;
+    isPrerendering: boolean;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextServer;
+    cspNonce: string | null;
+    pageContextsAborted: Partial<PageContextServer<unknown>>[];
+    environments?: Record<string, {
+        config: import("../../shared-server-client/getPageFiles.js").PageContextConfig['config'];
+        pageContext: PageContextServer<unknown>;
+    }> | undefined;
+    isHydration?: undefined;
+    isBackwardNavigation?: undefined;
+    isHistoryNavigation?: undefined;
+    previousPageContext?: undefined;
+} & {
+    dangerouslyUseInternals: import("../../shared-server-client/getPublicProxy.js").DangerouslyUseInternals<PageContextInternalServer & import("./renderPageServer/renderPageServerAfterRoute.js").PageContextAfterRender & import("./renderPageServer/getPageContextPublicServer.js").PageContextPublicServer>;
+} & Vike.PageContext & Vike.PageContextServer & {
+    content?: string | Uint8Array | ReadableStream<Uint8Array>;
+} & PageContextUserAdded>>;
+declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser, isCalledDirectlyByUser: boolean): Promise<PageContextInitUser & {
     httpResponse: HttpResponse;
 } & Partial<PageContextServer & PageContextUserAdded>>;
-declare function getPageContextBegin(pageContextInit: PageContextInitInternal, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
     _isOriginalObject: true;
     isPageContext: true;
 } & {
@@ -23,12 +74,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
     isPrerendering: boolean;
     _requestId: number;
 } & PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-} & {
     _globalContext: ({
         config: import("../../types/index.js").ConfigResolved;
         _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
@@ -52,6 +97,10 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _pageFilesAll: import("../__internal/index.js").PageFile[];
         _pageConfigs: import("../__internal/index.js").PageConfig[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../__internal/index.js").PageConfig[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;
@@ -61,6 +110,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: import("vite").ResolvedConfig | undefined;
     } | {
         isClientSide: false;
@@ -69,6 +119,7 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -79,12 +130,11 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     }) & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -95,6 +145,9 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        middlewares: import("./universal-middleware/core.js").Middleware[];
     })) & {
         prerenderContext: import("../../types/index.js").PrerenderContext | undefined;
     };
@@ -102,12 +155,6 @@ declare function getPageContextBegin(pageContextInit: PageContextInitInternal, g
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: PageContextInit & {
-        _nodeDev?: {
-            req: import("http").IncomingMessage;
-            res: import("http").ServerResponse;
-        };
-        _reqWeb?: Request;
-    } & {
         headers?: Record<string, unknown>;
     };
     _urlHandler: ((url: string) => string) | null;