vike 0.4.247 → 0.4.249

package/dist/esm/node/runtime/renderPage/html/renderHtml.js

@@ -1,240 +0,0 @@
-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/esm/node/runtime/renderPage/html/serializeContext.d.ts

@@ -1,36 +0,0 @@
-export { getPageContextClientSerialized };
-export { getPageContextClientSerializedAbort };
-export { getGlobalContextClientSerialized };
-export type { PageContextSerialization };
-export type { PassToClient };
-export type { PassToClientPublic };
-import type { UrlRedirect } from '../../../../shared/route/abort.js';
-import type { GlobalContextServerInternal } from '../../globalContext.js';
-import type { PageContextCreated } from '../createPageContextServerSide.js';
-import type { PageContextBegin } from '../../renderPage.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/esm/node/runtime/renderPage/html/serializeContext.js

@@ -1,192 +0,0 @@
-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/error-page.js';
-import { addIs404ToPageProps } from '../../../../shared/addIs404ToPageProps.js';
-import pc from '@brillout/picocolors';
-import { NOT_SERIALIZABLE } from '../../../../shared/NOT_SERIALIZABLE.js';
-import { pageContextInitIsPassedToClient } from '../../../../shared/misc/pageContextInitIsPassedToClient.js';
-import { isServerSideError } from '../../../../shared/misc/isServerSideError.js';
-import { getPropKeys, getPropVal, setPropVal } from './propKeys.js';
-import { assertRouteParams } from '../../../../shared/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/esm/node/runtime/renderPage/html/stream/react-streaming.js

@@ -1,34 +0,0 @@
-// 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);
-}