vike 0.4.267 → 0.4.268-commit-45c1759

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

@@ -13,6 +13,7 @@ import { objectAssign } from '../../utils/objectAssign.js';
 import { redirectHard } from '../../utils/redirectHard.js';
 import { updateType } from '../../utils/updateType.js';
 import { getPageContextFromHooksClient, getPageContextFromHooksServer, getPageContextFromHooksClient_firstRender, getPageContextFromHooksServer_firstRender, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
+import { cancelStreamedValues } from './streamedValues.js';
 import { createPageContextClient } from './createPageContextClient.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
@@ -101,7 +102,7 @@ async function renderPageClient(renderArgs) {
         }
         // Get pageContext serialized in <script id="vike_pageContext" type="application/json">
         if (isFirstRender) {
-            const pageContextSerialized = getPageContextFromHooksServer_firstRender();
+            const pageContextSerialized = await getPageContextFromHooksServer_firstRender();
             // TO-DO/eventually: create helper assertPageContextFromHook()
             assert(!('urlOriginal' in pageContextSerialized));
             objectAssign(pageContext, pageContextSerialized);
@@ -226,8 +227,10 @@ async function renderPageClient(renderArgs) {
                     return;
                 }
             }
-            if (isRenderOutdated())
+            if (isRenderOutdated()) {
+                cancelStreamedValues(pageContextFromHooksServer, false);
                 return;
+            }
             // TO-DO/eventually: create helper assertPageContextFromHook()
             assert(!('urlOriginal' in pageContextFromHooksServer));
             objectAssign(pageContext, pageContextFromHooksServer);
@@ -308,13 +311,6 @@ async function renderPageClient(renderArgs) {
         else {
             objectAssign(pageContext, { is404: false });
         }
-        const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
-        if (isRenderOutdated())
-            return;
-        if (!isClientRoutable) {
-            redirectHard(urlOriginal);
-            return;
-        }
         if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
             assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
         }
@@ -363,7 +359,7 @@ async function renderPageClient(renderArgs) {
         const errAbort = err;
         logAbort(err, !import.meta.env.DEV, pageContext);
         const pageContextAbort = errAbort._pageContextAbort;
-        addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort);
+        addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort, getPageContextPublicClientMinimal);
         // throw render('/some-url')
         if (pageContextAbort._urlRewrite) {
             await renderPageClient({
@@ -447,6 +443,7 @@ async function renderPageClient(renderArgs) {
         // We purposely abort *after* onHydrationEnd() is called (see comment above).
         if (isRenderOutdated(true))
             return;
+        cancelStreamedValues(pageContext, true);
         // onPageTransitionEnd()
         if (globalObject.isTransitioning) {
             globalObject.isTransitioning = undefined;
@@ -491,7 +488,9 @@ async function renderPageClient(renderArgs) {
     }
 }
 async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, isHistoryNavigation, pageContextsAborted, isClientSideNavigation, pageContextInitClient, isFirstRender, }) {
-    const previousPageContext = globalObject.previousPageContext ?? null;
+    const previousPageContext = globalObject.previousPageContext
+        ? getPageContextPublicClient(globalObject.previousPageContext)
+        : null;
     const pageContext = await createPageContextClient(urlOriginal);
     objectAssign(pageContext, {
         isBackwardNavigation,
@@ -527,21 +526,12 @@ function stampFinished(urlOriginal) {
     window._vike ?? (window._vike = {});
     window._vike.fullyRenderedUrl = urlOriginal;
 }
-function disableClientRouting(err, log) {
+function disableClientRouting(err, logError) {
     globalObject.clientRoutingIsDisabled = true;
     assert(isErrorFetchingStaticAssets(err));
-    if (log) {
-        // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
-        console.log(err);
-    }
-    assertInfo(false, [
-        'Failed to fetch static asset.',
-        import.meta.env.PROD ? 'This usually happens when a new frontend is deployed.' : null,
-        'Falling back to Server Routing.',
-        '(The next page navigation will use Server Routing instead of Client Routing.)',
-    ]
-        .filter(Boolean)
-        .join(' '), { onlyOnce: true });
+    if (logError)
+        console.log(err); // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
+    assertInfo(false, 'Failed to fetch static asset (due to a connection issue, or a new deployment) — falling back to Server Routing', { onlyOnce: true });
 }
 function getIsRenderOutdated() {
     const renderNumber = ++globalObject.renderCounter;
@@ -581,7 +571,7 @@ function getKeepScrollPositionSetting(pageContext) {
     assert(configDefinedAt);
     const routeParameterList = getRouteStringParameterList(configDefinedAt);
     if (isCallable(val))
-        val = val(pageContext, {
+        val = val(getPageContextPublicClient(pageContext), {
             configDefinedAt: c.definedAt,
             /* We don't pass routeParameterList because it's useless: the user knows the parameter list.
             routeParameterList
@@ -628,17 +618,14 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
     catch (err_) {
         err = err_;
         hasErr = true;
-        if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-            return { skip: true };
-        }
-        else {
-            // Syntax error in user file
-        }
     }
     if (isRenderOutdated())
         return { skip: true };
-    if (hasErr)
+    if (hasErr) {
+        if (await handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
+            return { skip: true };
         return { err };
+    }
     objectAssign(pageContext, pageContextAddendum);
     try {
         await execHook('onCreatePageContext', pageContext, getPageContextPublicClient);
@@ -653,21 +640,109 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
         return { err };
     return { pageContext };
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
-    if (!isErrorFetchingStaticAssets(err)) {
+async function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+    if (import.meta.env.DEV)
         return false;
-    }
-    if (isFirstRender) {
+    if (!isErrorFetchingStaticAssets(err))
+        return false; // Syntax error in user file
+    // *******************************************
+    // ******* The three possible actions ********
+    // *******************************************
+    /** Show Vike's error page */
+    const showErrorPage = () => {
         disableClientRouting(err, false);
-        // This may happen if the frontend was newly deployed during hydration.
-        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        // Vike handles the error like any other error: Vike logs it with `console.error()` and renders Vike's error page
+        return false;
+    };
+    /** Show the rendered HTML (with broken hydration) */
+    const showCurrentBrokenPage = () => {
+        disableClientRouting(err, false);
+        // Abort rendering (and don't show error page), not gracefully: the error throws (i.e. the error is handled by the browser and shown in the browser's developer console)
         throw err;
+    };
+    /** Do a full (re-)load of the page */
+    const hardReload = (url) => {
+        disableClientRouting(err, true);
+        if (url) {
+            redirectHard(url);
+        }
+        else {
+            // We use `location.reload()` instead of redirectHard(): navigating with `location.href = url` creates a `type: 'navigate'` entry, which would lead to an infinite reload loop — see isPageReload()
+            window.location.reload();
+        }
+        // Abort rendering (and don't show error page), gracefully (i.e. without throwing nor logging any error)
+        return true;
+    };
+    // **************************
+    // ******* The logic ********
+    // **************************
+    // Possible causes that lead to this point:
+    // - New deployment
+    // - Connection problem
+    // === Client-side navigation ===
+    // We hard load the next page:
+    // - New deployment => fully reloading the website is exactly what we want
+    // - Connection problem => next page isn't shown => only useful action is to try again with a hard reload
+    //   - It's usually better to show the browser's offline page than to leave the user stuck on the old page. (This way, the user knows there's a connection problem instead of wondering whether the website is broken.)
+    if (!isFirstRender) {
+        return hardReload(pageContext.urlOriginal);
+    }
+    // === First render ===
+    // Avoid infinite reload loop: we don't reload a page that was itself loaded by a reload
+    if (isPageReload()) {
+        if (isBlankPage()) {
+            return showErrorPage();
+        }
+        else {
+            return showCurrentBrokenPage();
+        }
+    }
+    if (isBlankPage()) {
+        return hardReload();
     }
     else {
-        disableClientRouting(err, true);
+        globalObject.clientRoutingIsDisabled = true; // Eagerly disable before connection check
+        if (!(await isConnectionDown())) {
+            // Most likely a new deployment (or the connection is back): either way, reloading fixes the page
+            return hardReload();
+        }
+        else {
+            // - Reloading is counterproductive since it would likely get another connection error, resulting in either: the browser's offline page, or repeating this asset loading failure.
+            // - Handling flaky connections is the browser's job (e.g. the user reloads the page)
+            // - Showing the rendered HTML is usually more useful to the user (even when unhydrated thus broken) than showing Vike's error page
+            return showCurrentBrokenPage();
+        }
     }
-    redirectHard(pageContext.urlOriginal);
-    return true;
+}
+// Whether fetching static assets fails because of the connection. (The error thrown by `import()` doesn't tell: it's the same whether a new frontend was deployed, i.e. the static assets don't exist anymore, or the connection is down.)
+async function isConnectionDown() {
+    try {
+        await fetch(window.location.href, {
+            method: 'HEAD',
+            cache: 'no-store',
+            // On a flaky connection, the request may hang and succeed much later: we don't want to reload the page long after it was shown (e.g. while the user is filling a form)
+            signal: AbortSignal.timeout(4000),
+        });
+        // The server responds
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+// The page shows nothing (e.g. SPA)
+function isBlankPage() {
+    return !document.body.innerText.trim();
+}
+// Whether the current page was loaded by a page reload
+function isPageReload() {
+    // The browser records how the current document was loaded (Navigation Timing API)
+    const navigation = performance.getEntriesByType('navigation')[0];
+    return (
+    // Cannot be determined (e.g. older browsers)
+    !navigation ||
+        // A document loaded by `location.reload()` has `type: 'reload'`
+        navigation.type === 'reload');
 }
 // [HMR] If error page is shown => re-render whole page
 if (import.meta.env.DEV && import.meta.hot)

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,9 +35,14 @@ 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;
+        devMiddleware: null;
     };
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
 } & import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic>;

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,7 +25,12 @@ 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;
+    devMiddleware: null;
 }>;

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[];
 } & {
     /**
@@ -39,6 +43,7 @@ declare function getGlobalContextClientInternalShared(): Promise<{
      * https://vike.dev/globalContext#isClientSide
      */
     isClientSide: true;
+    devMiddleware: null;
 }>;
 type TypeIsNotExported = never;
 declare function getGlobalContext(): Promise<TypeIsNotExported>;

package/dist/client/shared/getGlobalContextClientInternalShared.js

@@ -36,6 +36,8 @@ async function getGlobalContextClientInternalShared() {
              * https://vike.dev/globalContext#isClientSide
              */
             isClientSide: true,
+            // https://vike.dev/globalContext#devMiddleware
+            devMiddleware: null,
         };
         objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
         return globalContextAddendum;

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/loadPageConfigsLazyClientSide.js

@@ -53,10 +53,6 @@ function isFetchError(err) {
         'error loading dynamically imported module',
         // safari
         'Importing a module script failed',
-        // ??
-        'error resolving module specifier',
-        // ??
-        'failed to resolve module',
     ];
     return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
 }

package/dist/client/shared/removeFoucBuster.js

@@ -38,9 +38,20 @@ function clean() {
         const href = linkVike.getAttribute('href');
         assert(href && href.endsWith(suffix));
         let filePathAbsoluteUserRootDir = href.slice(0, -suffix.length);
-        const prefix = '/@fs/';
-        if (filePathAbsoluteUserRootDir.startsWith(prefix))
-            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefix.length);
+        const prefixFs = '/@fs/';
+        if (filePathAbsoluteUserRootDir.startsWith(prefixFs))
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefixFs.length);
+        // CSS virtual module:
+        // ```js
+        // import 'virtual:some.css'
+        // ```
+        // ID becomes:
+        // ```
+        // <link href="/@id/__x00__virtual:some.css?direct" rel="stylesheet" type="text/css">
+        // ```
+        const prefixId = '/@id/';
+        if (filePathAbsoluteUserRootDir.startsWith(prefixId))
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefixId.length).replace('__x00__', '\0');
         if (injectedByVite.some((filePathAbsoluteFilesystem) => filePathAbsoluteFilesystem.endsWith(filePathAbsoluteUserRootDir))) {
             linkVike.remove();
         }

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;