vike 0.4.266 → 0.4.267-commit-7884d91

package/dist/client/runtime-client-routing/streamedValues.d.ts

@@ -0,0 +1,5 @@
+export { readPageContextJson };
+export { cancelStreamedValues };
+import '../assertEnvClient.js';
+declare function readPageContextJson(response: Response): Promise<unknown>;
+declare function cancelStreamedValues(pageContext: object, isRendered: boolean): void;

package/dist/client/runtime-client-routing/streamedValues.js

@@ -0,0 +1,23 @@
+// Streamed pageContext values https://vike.dev/passToClient#streaming, upon client-side navigation: the decoder
+// (../shared/streamedValues.ts) is loaded only if the `.pageContext.json` response is a JSON array (see
+// server/runtime/renderPageServer/getPageContextJson.ts).
+export { readPageContextJson };
+export { cancelStreamedValues };
+import { parse } from '@brillout/json-serializer/parse';
+import '../assertEnvClient.js';
+let decoder;
+async function readPageContextJson(response) {
+    const reader = response.clone().body.getReader();
+    let chunk = await reader.read();
+    while (!chunk.done && !chunk.value.length)
+        chunk = await reader.read();
+    reader.cancel();
+    // A pageContext always serializes as `{…}`, so an array (`[` is 91) means streamed values
+    if (chunk.value?.[0] !== 91)
+        return parse(await response.text());
+    decoder ?? (decoder = await import('../shared/streamedValues.js'));
+    return decoder.readPageContextJsonStreamed(response);
+}
+function cancelStreamedValues(pageContext, isRendered) {
+    decoder?.cancelStreamedValues(pageContext, isRendered);
+}

package/dist/client/runtime-server-routing/createPageContextClient.d.ts

@@ -35,6 +35,10 @@ declare function createPageContextClient(): Promise<{
         _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: true;

package/dist/client/runtime-server-routing/entry.js

@@ -23,7 +23,7 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClient();
-    objectAssign(pageContext, getPageContextSerializedInHtml());
+    objectAssign(pageContext, await getPageContextSerializedInHtml());
     // Sets pageContext.config using non-global configs — overrides the pageContext.config set using global configs at createPageContextClient()
     const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
     objectAssign(pageContext, pageContextAddendum);

package/dist/client/runtime-server-routing/getGlobalContextClientInternal.d.ts

@@ -25,6 +25,10 @@ declare function getGlobalContextClientInternal(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & {
     isClientSide: true;

package/dist/client/shared/getGlobalContextClientInternalShared.d.ts

@@ -29,6 +29,10 @@ declare function getGlobalContextClientInternalShared(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & {
     /**

package/dist/client/shared/getJsonSerializedInHtml.d.ts

@@ -1,8 +1,8 @@
 export { getPageContextSerializedInHtml };
 export { getGlobalContextSerializedInHtml };
 import '../assertEnvClient.js';
-declare function getPageContextSerializedInHtml(): {
+declare function getPageContextSerializedInHtml(): Promise<{
     pageId: string;
     routeParams: Record<string, string>;
-};
+}>;
 declare function getGlobalContextSerializedInHtml(): object;

package/dist/client/shared/getJsonSerializedInHtml.js

@@ -9,23 +9,26 @@ import '../assertEnvClient.js';
 // 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
 // 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
 // See https://github.com/vikejs/vike/pull/1271
-function getPageContextSerializedInHtml() {
-    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+async function getPageContextSerializedInHtml() {
+    const pageContextJson = findJson(htmlElementId_pageContext);
+    // A pageContext always serializes as `{…}`, so an array means streamed values https://vike.dev/passToClient#streaming
+    const pageContextSerializedInHtml = pageContextJson[0] === '['
+        ? (await import('./streamedValues.js')).parsePageContextHtml(pageContextJson)
+        : parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
     assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }
 function getGlobalContextSerializedInHtml() {
-    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    const globalContextSerializedInHtml = parse(findJson(htmlElementId_globalContext));
     return globalContextSerializedInHtml;
 }
-function findAndParseJson(id) {
+function findJson(id) {
     const elem = document.getElementById(id);
     assertUsage(elem, 
     // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
     `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
     const jsonStr = elem.textContent;
     assert(jsonStr);
-    const json = parse(jsonStr);
-    return json;
+    return jsonStr;
 }

package/dist/client/shared/streamedValues/asyncIterable.d.ts

@@ -0,0 +1,4 @@
+export { asyncIterable };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const asyncIterable: StreamedValueType;

package/dist/client/shared/streamedValues/asyncIterable.js

@@ -0,0 +1,26 @@
+export { asyncIterable };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { readableStream } from './readableStream.js';
+import '../../assertEnvClient.js';
+// A ReadableStream, consumed as an async iterable: `for await (const chunk of pageContext.someAsyncIterable)` (Safari's
+// ReadableStream isn't async-iterable)
+const asyncIterable = {
+    marker: markers.asyncIterable,
+    revive(parseValue) {
+        const streamedValue = readableStream.revive(parseValue);
+        return { ...streamedValue, value: toAsyncIterable(streamedValue.value) };
+    },
+};
+function toAsyncIterable(stream) {
+    const reader = stream.getReader();
+    const iterator = {
+        next: () => reader.read(),
+        // Called upon `break` in `for await`
+        async return(value) {
+            await reader.cancel();
+            return { done: true, value };
+        },
+        [Symbol.asyncIterator]: () => iterator,
+    };
+    return iterator;
+}

package/dist/client/shared/streamedValues/lines.d.ts

@@ -0,0 +1,11 @@
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+declare function decodeChunk(line: {
+    t: string;
+} | {
+    b: string;
+} | {
+    v: unknown;
+}, parseValue: (value: unknown) => unknown): unknown;
+declare function getLineError(): Error;

package/dist/client/shared/streamedValues/lines.js

@@ -0,0 +1,19 @@
+// The decoding of the lines (see shared-server-client/streamedValues.ts)
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+const textEncoder = new TextEncoder();
+function decodeChunk(line, parseValue) {
+    if ('t' in line)
+        return textEncoder.encode(line.t);
+    if ('b' in line)
+        return decodeBase64url(line.b);
+    return parseValue(line.v);
+}
+function getLineError() {
+    return new Error('A streamed pageContext value failed on the server-side (see the server logs)');
+}
+function decodeBase64url(str) {
+    const binary = atob(str.replaceAll('-', '+').replaceAll('_', '/'));
+    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}

package/dist/client/shared/streamedValues/promise.d.ts

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

package/dist/client/shared/streamedValues/promise.js

@@ -0,0 +1,19 @@
+export { promise };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { getLineError } from './lines.js';
+import { genPromise } from '../../../utils/genPromise.js';
+import '../../assertEnvClient.js';
+// Settled by its `v` or `error` line
+const promise = {
+    marker: markers.promise,
+    revive(parseValue) {
+        const { promise: value, resolve, reject } = genPromise({ timeout: null });
+        // Avoid an unhandled rejection if the user doesn't use the promise
+        value.catch(() => { });
+        return {
+            value,
+            push: (line) => ('v' in line ? resolve(parseValue(line.v)) : reject(getLineError())),
+            fail: reject,
+        };
+    },
+};

package/dist/client/shared/streamedValues/readableStream.d.ts

@@ -0,0 +1,4 @@
+export { readableStream };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const readableStream: StreamedValueType;

package/dist/client/shared/streamedValues/readableStream.js

@@ -0,0 +1,44 @@
+export { readableStream };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { decodeChunk, getLineError } from './lines.js';
+import '../../assertEnvClient.js';
+// Fed by its chunk lines, until its `end` or `error` line
+const readableStream = {
+    marker: markers.readableStream,
+    revive(parseValue) {
+        let controller;
+        let isClosed = false;
+        const value = new ReadableStream({
+            start(controller_) {
+                controller = controller_;
+            },
+            cancel() {
+                // Released by its consumer: the rest is ignored
+                isClosed = true;
+            },
+        });
+        const close = (err) => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            if (err)
+                controller.error(err);
+            else
+                controller.close();
+        };
+        return {
+            value,
+            push(line) {
+                if (isClosed)
+                    return;
+                if ('end' in line)
+                    close();
+                else if ('error' in line)
+                    close(getLineError());
+                else
+                    controller.enqueue(decodeChunk(line, parseValue));
+            },
+            fail: close,
+        };
+    },
+};

package/dist/client/shared/streamedValues/registry.d.ts

@@ -0,0 +1,21 @@
+export { createReceiver };
+export type { StreamedValueType };
+import { type Reviver } from '@brillout/json-serializer/parse';
+import type { Line } from '../../../shared-server-client/streamedValues.js';
+import '../../assertEnvClient.js';
+type StreamedValueType = {
+    marker: string;
+    /** `parseValue()` parses the value of a `v` line, which can contain further streamed values */
+    revive: (parseValue: (value: unknown) => unknown) => StreamedValue;
+};
+type StreamedValue = {
+    value: unknown;
+    push: (line: Line) => void;
+    fail: (err: unknown) => void;
+};
+declare function createReceiver(): {
+    reviver: Reviver;
+    onLine(lineStr: string): void;
+    /** The response failed, ended or was cancelled: the values that didn't end fail */
+    fail(err: unknown): void;
+};

package/dist/client/shared/streamedValues/registry.js

@@ -0,0 +1,40 @@
+// The types of streamed pageContext values (see shared-server-client/streamedValues.ts), and the receiver: its reviver
+// replaces the markers with values, which it then feeds with their lines.
+export { createReceiver };
+import { parseTransform } from '@brillout/json-serializer/parse';
+import { assert } from '../../../utils/assert.js';
+import { readableStream } from './readableStream.js';
+import { promise } from './promise.js';
+import { asyncIterable } from './asyncIterable.js';
+import '../../assertEnvClient.js';
+const types = [readableStream, promise, asyncIterable];
+function createReceiver() {
+    const streamedValues = new Map();
+    const parseValue = (value) => parseTransform(value, { reviver });
+    const reviver = (_path, value) => {
+        const type = types.find((type) => value.startsWith(type.marker));
+        if (!type)
+            return undefined;
+        const id = value.slice(type.marker.length);
+        assert(/^\d+$/.test(id));
+        // The same value referenced twice
+        let streamedValue = streamedValues.get(Number(id));
+        if (!streamedValue) {
+            streamedValue = type.revive(parseValue);
+            streamedValues.set(Number(id), streamedValue);
+        }
+        return { replacement: streamedValue.value };
+    };
+    return {
+        reviver,
+        onLine(lineStr) {
+            const line = JSON.parse(lineStr);
+            // Unknown if contained in a chunk nobody read
+            streamedValues.get(line.s)?.push(line);
+        },
+        /** The response failed, ended or was cancelled: the values that didn't end fail */
+        fail(err) {
+            streamedValues.forEach((streamedValue) => streamedValue.fail(err));
+        },
+    };
+}

package/dist/client/shared/streamedValues.d.ts

@@ -0,0 +1,7 @@
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import '../assertEnvClient.js';
+declare function parsePageContextHtml(pageContextJson: string): unknown;
+declare function readPageContextJsonStreamed(response: Response): Promise<Record<string, unknown>>;
+declare function cancelStreamedValues(pageContext: object, isRendered: boolean): void;

package/dist/client/shared/streamedValues.js

@@ -0,0 +1,82 @@
+// Streamed pageContext values, client-side (see shared-server-client/streamedValues.ts): the lines that follow the
+// serialized pageContext feed the values of a receiver (see ./streamedValues/registry.ts).
+//
+// Loaded only if the pageContext has streamed values (see getJsonSerializedInHtml.ts and
+// ../runtime-client-routing/streamedValues.ts).
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import { parse } from '@brillout/json-serializer/parse';
+import { assert } from '../../utils/assert.js';
+import { isObject } from '../../utils/isObject.js';
+import { createReceiver } from './streamedValues/registry.js';
+import '../assertEnvClient.js';
+// First render: the `<script>` tags that follow `<script id="vike_pageContext">` push the lines to `self.__vike_streamed`,
+// before and after Vike's client runtime is loaded.
+function parsePageContextHtml(pageContextJson) {
+    const receiver = createReceiver();
+    const [pageContext] = parse(pageContextJson, { reviver: receiver.reviver });
+    const g = self;
+    const linesQueued = Array.isArray(g.__vike_streamed) ? g.__vike_streamed : [];
+    g.__vike_streamed = { push: receiver.onLine };
+    linesQueued.forEach(receiver.onLine);
+    return pageContext;
+}
+// Client-side navigation: the `.pageContext.json` response (see server/runtime/renderPageServer/getPageContextJson.ts),
+// `[pageContext` then one `,line` per line then `]`. The pageContext is returned as soon as its line arrives.
+async function readPageContextJsonStreamed(response) {
+    const reader = response.body.getReader();
+    const lines = readLines(reader);
+    const { done, value: lineFirst } = await lines.next();
+    assert(!done && lineFirst[0] === '[');
+    const receiver = createReceiver();
+    const pageContextFromServer = parse(lineFirst.slice(1), { reviver: receiver.reviver });
+    assert(isObject(pageContextFromServer));
+    responsesStreaming.push(reader);
+    (async () => {
+        try {
+            for await (const line of lines) {
+                if (line !== ']')
+                    receiver.onLine(line.slice(1));
+            }
+            receiver.fail(new Error('The pageContext.json response ended before the streamed pageContext values ended'));
+        }
+        catch (err) {
+            // E.g. the server aborted the response
+            receiver.fail(err);
+        }
+    })();
+    return { ...pageContextFromServer, _streamedValuesReader: reader };
+}
+async function* readLines(reader) {
+    const decoder = new TextDecoder();
+    // Joined once per line: joining upon each chunk would be quadratic
+    let parts = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            return;
+        const chunk = decoder.decode(value, { stream: true });
+        let lineStart = 0;
+        let lineEnd;
+        while ((lineEnd = chunk.indexOf('\n', lineStart)) !== -1) {
+            yield parts.join('') + chunk.slice(lineStart, lineEnd);
+            parts = [];
+            lineStart = lineEnd + 1;
+        }
+        parts.push(chunk.slice(lineStart));
+    }
+}
+// Once a page is rendered, the streamed values fetched before it are cancelled (the previous page's, and superseded
+// navigations'): the previous page keeps its values while it's shown.
+let responsesStreaming = [];
+// Cancels the streamed values of `pageContext` (a superseded navigation), or, once `pageContext` is rendered, all the others
+function cancelStreamedValues(pageContext, isRendered) {
+    const { _streamedValuesReader } = pageContext;
+    responsesStreaming = responsesStreaming.filter((reader) => {
+        if ((reader === _streamedValuesReader) === isRendered)
+            return true;
+        reader.cancel().catch(() => { });
+        return false;
+    });
+}

package/dist/node/api/resolveViteConfigUser.js

@@ -15,7 +15,7 @@ import { toPosixPath } from '../../utils/path.js';
 import pc from '@brillout/picocolors';
 import { getEnvVarObject } from '../../utils/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
-import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
+import { getViteCliCommand, getViteCliArgsMinimal } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';
 const globalObject = getGlobalObject('resolveViteConfigUser.ts', {});
 const debug = createDebug('vike:vite-config-user');
@@ -83,7 +83,7 @@ async function resolve(viteContext) {
     // Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
     // - Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and ends up with the wrong root when those Vite CLI args are used.
     {
-        const viteConfigFromViteCli = getViteCliArgs();
+        const viteConfigFromViteCli = getViteCliArgsMinimal();
         addConfig(viteConfigFromViteCli);
         if (debug.isActivated)
             debug('viteConfigFromViteCli', viteConfigFromViteCli);

package/dist/node/prerender/runPrerender.d.ts

@@ -32,13 +32,17 @@ type PrerenderContext = {
     _userRootDir: string;
     _outDirClient: string;
 };
-type Output<PageContext = PageContextPrerendered> = {
+type Output<PageContext = PageContextPrerendered> = ({
     filePath: string;
-    fileType: FileType;
+    fileType: 'HTML' | 'JSON';
     fileContent: string;
     pageContext: PageContext;
-}[];
-type FileType = 'HTML' | 'JSON';
+} | {
+    filePath: string;
+    fileType: 'CONTENT';
+    fileContent: string | Uint8Array;
+    pageContext: PageContext;
+})[];
 type PageContext = Awaited<ReturnType<typeof createPageContextPrerendering>> & {
     _urlOriginalBeforeHook?: string;
 };
@@ -101,6 +105,10 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;