npm - vike - Versions diffs - 0.4.247 → 0.4.248 - Mend

vike 0.4.247 → 0.4.248

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1082) hide show

package/dist/server/runtime/renderPageServer/html/injectAssets.js ADDED Viewed

@@ -0,0 +1,91 @@
+export { injectHtmlTagsToString };
+export { injectHtmlTagsToStream };
+import { assert, isCallable, isPromise } from '../../../utils.js';
+import { assertPageContextProvidedByUser } from '../../../../shared-server-client/assertPageContextProvidedByUser.js';
+import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream, } from './injectAssets/injectHtmlTags.js';
+import { getHtmlTags } from './injectAssets/getHtmlTags.js';
+import { getViteDevScript } from './injectAssets/getViteDevScript.js';
+async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
+    const pageAssets = await pageContext.__getPageAssets();
+    const viteDevScript = await getViteDevScript(pageContext);
+    const htmlTags = await getHtmlTags(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
+    let htmlString = htmlPartsToString(htmlParts, pageAssets);
+    htmlString = injectToHtmlBegin(htmlString, htmlTags);
+    htmlString = injectToHtmlEnd(htmlString, htmlTags);
+    assert(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
+    return htmlString;
+}
+function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter) {
+    let htmlTags;
+    return {
+        injectAtStreamBegin,
+        injectAtStreamAfterFirstChunk,
+        injectAtStreamEnd,
+    };
+    async function injectAtStreamBegin(htmlPartsBegin) {
+        const pageAssets = await pageContext.__getPageAssets();
+        const viteDevScript = await getViteDevScript(pageContext);
+        htmlTags = await getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
+        let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
+        htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
+        if (streamFromReactStreamingPackage) {
+            injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage);
+        }
+        return htmlBegin;
+    }
+    // Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
+    function injectAtStreamAfterFirstChunk() {
+        // React has its own stream injection mechanism, see injectHtmlTagsUsingStream()
+        if (streamFromReactStreamingPackage)
+            return null;
+        assert(htmlTags);
+        const tags = htmlTags.filter((h) => h.position === 'HTML_STREAM');
+        if (tags.length === 0)
+            return null;
+        const htmlFragment = joinHtmlTags(tags);
+        return htmlFragment;
+    }
+    async function injectAtStreamEnd(htmlPartsEnd) {
+        assert(htmlTags);
+        await resolvePageContextPromise(pageContext);
+        const pageAssets = await pageContext.__getPageAssets();
+        let htmlEnd = htmlPartsToString(htmlPartsEnd, pageAssets);
+        htmlEnd = injectToHtmlEnd(htmlEnd, htmlTags);
+        return htmlEnd;
+    }
+}
+function injectToHtmlBegin(htmlBegin, htmlTags) {
+    // Ensure existence of `<head>`
+    htmlBegin = createHtmlHeadIfMissing(htmlBegin);
+    htmlBegin = injectHtmlTags(htmlBegin, htmlTags, 'HTML_BEGIN');
+    return htmlBegin;
+}
+function injectToHtmlEnd(htmlEnd, htmlTags) {
+    htmlEnd = injectHtmlTags(htmlEnd, htmlTags, 'HTML_END');
+    return htmlEnd;
+}
+async function resolvePageContextPromise(pageContext) {
+    const pageContextPromise = pageContext._pageContextPromise;
+    if (!pageContextPromise) {
+        return;
+    }
+    let pageContextProvidedByUser;
+    if (isCallable(pageContextPromise)) {
+        pageContextProvidedByUser = await pageContextPromise();
+    }
+    else if (isPromise(pageContextPromise)) {
+        pageContextProvidedByUser = await pageContextPromise;
+    }
+    else {
+        assert(false);
+    }
+    assertPageContextProvidedByUser(pageContextProvidedByUser, pageContext._renderHook);
+    Object.assign(pageContext, pageContextProvidedByUser);
+}
+function htmlPartsToString(htmlParts, pageAssets) {
+    let htmlString = '';
+    htmlParts.forEach((p) => {
+        htmlString += typeof p === 'string' ? p : p(pageAssets);
+    });
+    return htmlString;
+}

package/dist/server/runtime/renderPageServer/html/propKeys.js ADDED Viewed

@@ -0,0 +1,45 @@
+export { getPropVal };
+export { setPropVal };
+export { getPropKeys };
+import { isObject } from '../../../utils.js';
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if (isObject(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!isObject(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see getPageContextClientSerialized.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

package/dist/server/runtime/renderPageServer/html/renderHtml.js ADDED Viewed

@@ -0,0 +1,240 @@
+export { escapeInject };
+export { dangerouslySkipEscape };
+export { renderDocumentHtml };
+export { isDocumentHtml };
+export { getHtmlString };
+import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign, } from '../../../utils.js';
+import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
+import { processStream, isStream, streamToString, } from './stream.js';
+import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
+import pc from '@brillout/picocolors';
+function isDocumentHtml(something) {
+    if (isTemplateWrapped(something) || isEscapedString(something) || isStream(something)) {
+        checkType(something);
+        return true;
+    }
+    return false;
+}
+async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter) {
+    if (isEscapedString(documentHtml)) {
+        objectAssign(pageContext, { _isStream: false });
+        let htmlString = getEscapedString(documentHtml);
+        htmlString = await injectHtmlTagsToString([htmlString], pageContext, injectFilter);
+        return htmlString;
+    }
+    if (isStream(documentHtml)) {
+        objectAssign(pageContext, { _isStream: true });
+        const stream = documentHtml;
+        const streamWrapper = await renderHtmlStream(stream, null, pageContext, onErrorWhileStreaming, injectFilter);
+        return streamWrapper;
+    }
+    if (isTemplateWrapped(documentHtml)) {
+        const templateContent = documentHtml._template;
+        const render = renderTemplate(templateContent, pageContext);
+        if (!('htmlStream' in render)) {
+            objectAssign(pageContext, { _isStream: false });
+            const { htmlPartsAll } = render;
+            const htmlString = await injectHtmlTagsToString(htmlPartsAll, pageContext, injectFilter);
+            return htmlString;
+        }
+        else {
+            objectAssign(pageContext, { _isStream: true });
+            const { htmlStream } = render;
+            const streamWrapper = await renderHtmlStream(htmlStream, {
+                htmlPartsBegin: render.htmlPartsBegin,
+                htmlPartsEnd: render.htmlPartsEnd,
+            }, pageContext, onErrorWhileStreaming, injectFilter);
+            return streamWrapper;
+        }
+    }
+    checkType(documentHtml);
+    assert(false);
+}
+async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
+    const processStreamOptions = {
+        onErrorWhileStreaming,
+        enableEagerStreaming: pageContext.enableEagerStreaming,
+    };
+    if (injectString) {
+        let streamFromReactStreamingPackage = null;
+        if (isStreamFromReactStreamingPackage(streamOriginal) && !streamOriginal.disabled) {
+            streamFromReactStreamingPackage = streamOriginal;
+        }
+        const { injectAtStreamBegin, injectAtStreamAfterFirstChunk, injectAtStreamEnd } = injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter);
+        processStreamOptions.injectStringAtBegin = async () => {
+            return await injectAtStreamBegin(injectString.htmlPartsBegin);
+        };
+        processStreamOptions.injectStringAtEnd = async () => {
+            return await injectAtStreamEnd(injectString.htmlPartsEnd);
+        };
+        processStreamOptions.injectStringAfterFirstChunk = () => {
+            return injectAtStreamAfterFirstChunk();
+        };
+    }
+    let makeClosableAgain = () => { };
+    if (isStreamFromReactStreamingPackage(streamOriginal)) {
+        // Make sure Vike injects its HTML fragments, such as `<script id="vike_pageContext" type="application/json">`, before the stream is closed (if React/Vue finishes its stream before the promise below resolves).
+        makeClosableAgain = streamOriginal.doNotClose();
+    }
+    try {
+        const streamWrapper = await processStream(streamOriginal, processStreamOptions);
+        return streamWrapper;
+    }
+    finally {
+        makeClosableAgain();
+    }
+}
+function isTemplateWrapped(something) {
+    return hasProp(something, '_template');
+}
+function isEscapedString(something) {
+    const result = hasProp(something, '_escaped');
+    if (result) {
+        assert(hasProp(something, '_escaped', 'string'));
+        checkType(something);
+    }
+    return result;
+}
+function getEscapedString(escapedString) {
+    let htmlString;
+    assert(hasProp(escapedString, '_escaped'));
+    htmlString = escapedString._escaped;
+    assert(typeof htmlString === 'string');
+    return htmlString;
+}
+function escapeInject(templateStrings, ...templateVariables) {
+    assertUsage(templateStrings.length === templateVariables.length + 1 && templateStrings.every((str) => typeof str === 'string'), `You're using ${pc.cyan('escapeInject')} as a function, but ${pc.cyan('escapeInject')} is a string template tag, see https://vike.dev/escapeInject`, { showStackTrace: true });
+    return {
+        _template: {
+            templateStrings,
+            templateVariables: templateVariables,
+        },
+    };
+}
+function dangerouslySkipEscape(alreadyEscapedString) {
+    return _dangerouslySkipEscape(alreadyEscapedString);
+}
+function _dangerouslySkipEscape(arg) {
+    if (hasProp(arg, '_escaped')) {
+        assert(isEscapedString(arg));
+        return arg;
+    }
+    assertUsage(!isPromise(arg), `[dangerouslySkipEscape(${pc.cyan('str')})] Argument ${pc.cyan('str')} is a promise. It should be a string instead (or a stream). Make sure to ${pc.cyan('await str')}.`, { showStackTrace: true });
+    if (typeof arg === 'string') {
+        return { _escaped: arg };
+    }
+    assertWarning(false, `[dangerouslySkipEscape(${pc.cyan('str')})] Argument ${pc.cyan('str')} should be a string but we got ${pc.cyan(`typeof str === "${typeof arg}"`)}.`, {
+        onlyOnce: false,
+        showStackTrace: true,
+    });
+    return { _escaped: String(arg) };
+}
+function renderTemplate(templateContent, pageContext) {
+    const htmlPartsBegin = [];
+    const htmlPartsEnd = [];
+    let htmlStream = null;
+    const addHtmlPart = (htmlPart) => {
+        if (htmlStream === null) {
+            htmlPartsBegin.push(htmlPart);
+        }
+        else {
+            htmlPartsEnd.push(htmlPart);
+        }
+    };
+    const setStream = (stream) => {
+        const { hookName, hookFilePath } = pageContext._renderHook;
+        assertUsage(!htmlStream, `Injecting two streams in ${pc.cyan('escapeInject')} template tag of ${hookName}() hook defined by ${hookFilePath}. Inject only one stream instead.`);
+        htmlStream = stream;
+    };
+    const { templateStrings, templateVariables } = templateContent;
+    for (let i = 0; i < templateVariables.length; i++) {
+        addHtmlPart(templateStrings[i]);
+        let templateVar = templateVariables[i];
+        // Process `dangerouslySkipEscape()`
+        if (isEscapedString(templateVar)) {
+            const htmlString = getEscapedString(templateVar);
+            // User used `dangerouslySkipEscape()` so we assume the string to be safe
+            addHtmlPart(htmlString);
+            continue;
+        }
+        // Process `escapeInject` fragments
+        if (isTemplateWrapped(templateVar)) {
+            const templateContentInner = templateVar._template;
+            const result = renderTemplate(templateContentInner, pageContext);
+            if (!('htmlStream' in result)) {
+                result.htmlPartsAll.forEach(addHtmlPart);
+            }
+            else {
+                result.htmlPartsBegin.forEach(addHtmlPart);
+                setStream(result.htmlStream);
+                result.htmlPartsEnd.forEach(addHtmlPart);
+            }
+            continue;
+        }
+        if (isStream(templateVar)) {
+            setStream(templateVar);
+            continue;
+        }
+        const getErrMsg = (msg) => {
+            const { hookName, hookFilePath } = pageContext._renderHook;
+            const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
+            return [
+                `The ${nth} HTML variable is ${msg}`,
+                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`,
+            ]
+                .filter(Boolean)
+                .join(' ');
+        };
+        assertUsage(!isPromise(templateVar), getErrMsg(`a promise, did you forget to ${pc.cyan('await')} the promise?`));
+        if (templateVar === undefined || templateVar === null) {
+            const msgVal = pc.cyan(String(templateVar));
+            const msgEmptyString = pc.cyan("''");
+            const msg = `${msgVal} which will be converted to an empty string. Pass the empty string ${msgEmptyString} instead of ${msgVal} to remove this warning.`;
+            assertWarning(false, getErrMsg(msg), { onlyOnce: false });
+            templateVar = '';
+        }
+        {
+            const varType = typeof templateVar;
+            if (varType !== 'string') {
+                const msgType = pc.cyan(`typeof htmlVariable === "${varType}"`);
+                const msg = `${msgType} but a string or stream (https://vike.dev/streaming) is expected instead.`;
+                assertUsage(false, getErrMsg(msg));
+            }
+        }
+        {
+            const { _isProduction: isProduction } = pageContext._globalContext;
+            if (isHtml(templateVar) &&
+                // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
+                !isProduction) {
+                const msgVal = pc.cyan(String(templateVar));
+                const msg = `${msgVal} which seems to be HTML code. Did you forget to wrap the value with dangerouslySkipEscape()?`;
+                assertWarning(false, getErrMsg(msg), { onlyOnce: false });
+            }
+        }
+        // Escape untrusted template variable
+        addHtmlPart(escapeHtml(templateVar));
+    }
+    assert(templateStrings.length === templateVariables.length + 1);
+    addHtmlPart(templateStrings[templateStrings.length - 1]);
+    if (htmlStream === null) {
+        assert(htmlPartsEnd.length === 0);
+        return {
+            htmlPartsAll: htmlPartsBegin,
+        };
+    }
+    return {
+        htmlStream,
+        htmlPartsBegin,
+        htmlPartsEnd,
+    };
+}
+async function getHtmlString(htmlRender) {
+    if (typeof htmlRender === 'string') {
+        return htmlRender;
+    }
+    if (isStream(htmlRender)) {
+        return streamToString(htmlRender);
+    }
+    checkType(htmlRender);
+    assert(false);
+}

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

@@ -0,0 +1,36 @@
+export { getPageContextClientSerialized };
+export { getPageContextClientSerializedAbort };
+export { getGlobalContextClientSerialized };
+export type { PageContextSerialization };
+export type { PassToClient };
+export type { PassToClientPublic };
+import type { UrlRedirect } from '../../../../shared-server-client/route/abort.js';
+import type { GlobalContextServerInternal } from '../../globalContext.js';
+import type { PageContextCreated } from '../createPageContextServerSide.js';
+import type { PageContextBegin } from '../../renderPageServer.js';
+import type { PageContextCspNonce } from '../csp.js';
+type PageContextSerialization = PageContextCreated & {
+    pageId: string;
+    routeParams: Record<string, string>;
+    _passToClient: PassToClient;
+    is404: null | boolean;
+    pageProps?: Record<string, unknown>;
+    _pageContextInit: Record<string, unknown>;
+    _globalContext: GlobalContextServerInternal;
+    _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
+} & PageContextCspNonce;
+declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+type PassToClient = string[];
+type PassToClientPublic = (string | {
+    prop: string;
+    /** @deprecated The passToClient once setting is deprecated and no longer has any effect. Instead, see the upcoming .once.js suffix (see https://github.com/vikejs/vike/issues/2566 for more information). */
+    once?: boolean;
+})[];
+declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({
+    _urlRedirect: UrlRedirect;
+} | {
+    _urlRewrite: string;
+} | {
+    abortStatusCode: number;
+}), isHtmlJsonScript: false): string;

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

@@ -0,0 +1,192 @@
+export { getPageContextClientSerialized };
+export { getPageContextClientSerializedAbort };
+export { getGlobalContextClientSerialized };
+import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../../../utils.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 { assertRouteParams } from '../../../../shared-server-client/route/resolveRouteFunction.js';
+const passToClientBuiltInPageContext = [
+    'abortReason',
+    '_urlRewrite',
+    '_urlRedirect',
+    'abortStatusCode',
+    '_abortCall',
+    /* Not needed on the client-side
+    '_abortCaller',
+    */
+    pageContextInitIsPassedToClient,
+    'pageId',
+    'routeParams',
+    'data', // for data() hook
+];
+const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
+function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
+    const passToClientPageContext = getPassToClientPageContext(pageContext);
+    const res = applyPassToClient(passToClientPageContext, pageContext);
+    const pageContextClient = res.objClient;
+    const pageContextClientProps = res.objClientProps;
+    if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
+        pageContextClient[pageContextInitIsPassedToClient] = true;
+    }
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
+    return pageContextClientSerialized;
+}
+function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
+    const passToClient = pageContext._passToClient;
+    const globalContext = pageContext._globalContext;
+    const res = applyPassToClient(passToClient, globalContext);
+    const globalContextClient = res.objClient;
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
+    return globalContextClientSerialized;
+}
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
+    let serialized;
+    try {
+        serialized = serializeValue(obj, isHtmlJsonScript);
+    }
+    catch (err) {
+        const h = (s) => pc.cyan(s);
+        let hasWarned = false;
+        const propsNonSerializable = [];
+        passToClient.forEach((prop) => {
+            const res = getPropVal(obj, prop);
+            if (!res)
+                return;
+            const { value } = res;
+            const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
+            try {
+                serializeValue(value, isHtmlJsonScript, varName);
+            }
+            catch (err) {
+                propsNonSerializable.push(prop);
+                // useConfig() wrong usage
+                if (prop === '_configFromHook') {
+                    let pathString = '';
+                    if (isJsonSerializerError(err)) {
+                        pathString = err.pathString;
+                    }
+                    // There used to be a `## Serialization Error` section in the docs but we removed it at:
+                    // https://github.com/vikejs/vike/commit/c9da2f577db01bd1c8f72265ff83e78484ddc2c0
+                    assertUsage(false, `Cannot serialize config value ${h(pathString)} set by useConfig()`);
+                }
+                // Non-serializable property set by the user
+                let msg = [
+                    `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`,
+                ].join(' ');
+                if (isJsonSerializerError(err)) {
+                    msg = `${msg} Serialization error: ${err.messageCore}.`;
+                }
+                else {
+                    // When a property getter throws an error
+                    console.warn('Serialization error:');
+                    console.warn(err);
+                    msg = `${msg} The serialization failed because of the error printed above.`;
+                }
+                // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
+                assertWarning(false, msg, { onlyOnce: false });
+                hasWarned = true;
+            }
+        });
+        assert(hasWarned);
+        propsNonSerializable.forEach((prop) => {
+            obj[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
+        });
+        try {
+            serialized = serializeValue(obj, isHtmlJsonScript);
+        }
+        catch (err) {
+            assert(false);
+        }
+    }
+    return serialized;
+}
+function serializeValue(value, isHtmlJsonScript, varName) {
+    return stringify(value, {
+        forbidReactElements: true,
+        valueName: varName,
+        // Prevent Google from crawling URLs in JSON:
+        // - https://github.com/vikejs/vike/pull/2603
+        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
+        replacer: !isHtmlJsonScript
+            ? undefined
+            : (_key, value) => {
+                if (typeof value === 'string') {
+                    return { replacement: value.replaceAll('/', '\\/'), resolved: false };
+                }
+            },
+    });
+}
+function getPassToClientPageContext(pageContext) {
+    assertPageContext(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);
+    return passToClient;
+}
+function getPageContextClientSerializedAbort(pageContext, isHtmlJsonScript) {
+    assert(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
+    assert(pageContext._abortCall);
+    assert(pageContext._abortCaller);
+    // Not needed on the client-side
+    delete pageContext._abortCaller;
+    const unknownProps = Object.keys(pageContext).filter((prop) => ![
+        // prettier-ignore
+        // biome-ignore format:
+        '_abortCall',
+        /* Not needed on the client-side
+        '_abortCaller',
+        */
+        '_urlRedirect',
+        '_urlRewrite',
+        'abortStatusCode',
+        'abortReason',
+        'is404',
+        'pageProps',
+    ].includes(prop));
+    if (!pageContext._isLegacyRenderErrorPage) {
+        assert(unknownProps.length === 0);
+    }
+    else {
+        // TO-DO/next-major-release: remove
+        assertWarning(unknownProps.length === 0, [
+            "The following pageContext values won't be available on the client-side:",
+            unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
+            'Use `throw render()` instead of `throw RenderErrorPage()`',
+        ].join('\n'), {
+            onlyOnce: false,
+        });
+    }
+    return serializeValue(pageContext, isHtmlJsonScript);
+}
+function applyPassToClient(passToClient, obj) {
+    const objClient = {};
+    const objClientProps = [];
+    passToClient.forEach((prop) => {
+        // Get value from pageContext
+        const res = getPropVal(obj, prop);
+        if (!res)
+            return;
+        const { value } = res;
+        // Set value to pageContextClient
+        setPropVal(objClient, prop, value);
+        objClientProps.push(prop);
+    });
+    return { objClient, objClientProps };
+}
+// Ensure the following client-side assert() don't fail:
+// https://github.com/vikejs/vike/blob/a33b6e6319a9a0e34ea78e23c5aa156022e3745c/packages/vike/client/shared/getJsonSerializedInHtml.ts#L15-L16
+function assertPageContext(pageContext) {
+    assertUsage(hasProp(pageContext, 'pageId', 'string'), `${pc.bold('pageContext.pageId')} should be a ${pc.bold('string')}`);
+    assertRouteParams(pageContext, `${pc.bold('pageContext.routeParams')} should`);
+}

package/dist/server/runtime/renderPageServer/html/stream/react-streaming.js ADDED Viewed

@@ -0,0 +1,34 @@
+// Zero-config support for https://www.npmjs.com/package/react-streaming
+export { isStreamFromReactStreamingPackage };
+export { streamFromReactStreamingPackageToString };
+export { getStreamOfReactStreamingPackage };
+import { assert, assertUsage, hasProp, isVikeReactApp } from '../../../../utils.js';
+import { streamPipeNodeToString, streamReadableWebToString } from '../stream.js';
+function streamFromReactStreamingPackageToString(stream) {
+    if (stream.pipe) {
+        return streamPipeNodeToString(stream.pipe);
+    }
+    if (stream.readable) {
+        return streamReadableWebToString(stream.readable);
+    }
+    assert(false);
+}
+function isStreamFromReactStreamingPackage(thing) {
+    if (hasProp(thing, 'injectToStream', 'function')) {
+        assertUsage(hasProp(thing, 'hasStreamEnded', 'function'), isVikeReactApp()
+            ? //
+                'Update vike-react to its latest version'
+            : 'Update react-streaming to its latest version');
+        return true;
+    }
+    return false;
+}
+function getStreamOfReactStreamingPackage(stream) {
+    if (stream.pipe) {
+        return { __streamPipeNode: stream.pipe };
+    }
+    if (stream.readable) {
+        return stream.readable;
+    }
+    assert(false);
+}