vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/esm/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -0,0 +1,155 @@
+// Unit tests at ./injectHtmlTags.spec.ts
+export { injectHtmlTags };
+export { createHtmlHeadIfMissing };
+// Only needed for unit tests
+export { injectAtOpeningTag };
+export { injectAtClosingTag };
+import { assert, assertUsage, slice } from '../../utils.js';
+const POSITIONS = ['HTML_BEGIN', 'HTML_END', 'STREAM'];
+function injectHtmlTags(htmlString, htmlTags, injectToStream) {
+    POSITIONS.forEach((position) => {
+        const htmlFragment = htmlTags
+            .filter((h) => h.position === position)
+            .map((h) => resolveHtmlTag(h.htmlTag))
+            .join('');
+        if (htmlFragment) {
+            htmlString = injectHtmlFragment(position, htmlFragment, htmlString, injectToStream);
+        }
+    });
+    return htmlString;
+}
+function injectHtmlFragment(position, htmlFragment, htmlString, injectToStream) {
+    if (position === 'HTML_BEGIN') {
+        {
+            const res = injectAtPaceholder(htmlFragment, htmlString, true);
+            if (res)
+                return res;
+        }
+        assert(tagOpeningExists('head', htmlString));
+        htmlString = injectAtOpeningTag('head', htmlString, htmlFragment);
+        return htmlString;
+    }
+    if (position === 'HTML_END') {
+        {
+            const res = injectAtPaceholder(htmlFragment, htmlString, false);
+            if (res)
+                return res;
+        }
+        if (tagClosingExists('body', htmlString)) {
+            return injectAtClosingTag('body', htmlString, htmlFragment);
+        }
+        if (tagClosingExists('html', htmlString)) {
+            return injectAtClosingTag('html', htmlString, htmlFragment);
+        }
+        return htmlString + '\n' + htmlFragment;
+    }
+    if (position === 'STREAM') {
+        assert(injectToStream);
+        injectToStream(htmlFragment, { flush: true });
+        return htmlString;
+    }
+    assert(false);
+}
+function resolveHtmlTag(htmlTag) {
+    return typeof htmlTag !== 'string' ? htmlTag() : htmlTag;
+}
+function injectAtOpeningTag(tag, htmlString, htmlFragment) {
+    const openingTag = getTagOpening(tag);
+    const matches = htmlString.match(openingTag);
+    assert(matches && matches.length >= 1);
+    const tagInstance = matches[0];
+    assert(tagInstance);
+    const htmlParts = htmlString.split(tagInstance);
+    assert(htmlParts.length >= 2);
+    // Insert `htmlFragment` after first `tagInstance`
+    const before = slice(htmlParts, 0, 1)[0] + tagInstance;
+    const after = slice(htmlParts, 1, 0).join(tagInstance);
+    htmlFragment = injectBreakLines(htmlFragment, before, after);
+    return before + htmlFragment + after;
+}
+function injectAtClosingTag(tag, htmlString, htmlFragment) {
+    const tagClosing = getTagClosing(tag);
+    const matches = htmlString.match(tagClosing);
+    assert(matches && matches.length >= 1);
+    const tagInstance = matches[0];
+    assert(tagInstance);
+    const htmlParts = htmlString.split(tagInstance);
+    assert(htmlParts.length >= 2);
+    // Insert `htmlFragment` before last `tagClosing`
+    const before = slice(htmlParts, 0, -1).join(tagInstance);
+    const after = tagInstance + slice(htmlParts, -1, 0);
+    htmlFragment = injectBreakLines(htmlFragment, before, after);
+    return before + htmlFragment + after;
+}
+function injectBreakLines(htmlFragment, before, after) {
+    assert(htmlFragment.trim() === htmlFragment);
+    const currentLineBefore = before.split('\n').slice(-1)[0];
+    let paddingParent = currentLineBefore.match(/\s*$/)[0];
+    let isBlankLine = !!paddingParent;
+    if (!paddingParent) {
+        paddingParent = currentLineBefore.match(/^\s*/)[0];
+    }
+    if (!paddingParent)
+        return htmlFragment;
+    const whitespaceExtra = paddingParent ? '  ' : '';
+    const whitespace = `${paddingParent}${whitespaceExtra}`;
+    const padding = `\n${whitespace}`;
+    htmlFragment = htmlFragment.split(/<(?=[^\/])/).join(`${padding}<`);
+    if (isBlankLine) {
+        assert(htmlFragment.startsWith(padding), { htmlFragment });
+        htmlFragment = whitespaceExtra + htmlFragment.slice(padding.length);
+    }
+    const currentLineAfter = after.split('\n')[0];
+    if (currentLineAfter.trim().length > 0) {
+        htmlFragment += '\n' + paddingParent;
+    }
+    return htmlFragment;
+}
+function createHtmlHeadIfMissing(htmlString) {
+    const assertion = () => assert(tagOpeningExists('head', htmlString) && tagClosingExists('head', htmlString));
+    if (tagOpeningExists('head', htmlString) && tagClosingExists('head', htmlString)) {
+        assertion();
+        return htmlString;
+    }
+    const htmlFragment = '<head></head>';
+    if (tagOpeningExists('html', htmlString)) {
+        htmlString = injectAtOpeningTag('html', htmlString, htmlFragment);
+        assertion();
+        return htmlString;
+    }
+    if (tagOpeningExists('!doctype', htmlString)) {
+        htmlString = injectAtOpeningTag('!doctype', htmlString, htmlFragment);
+        assertion();
+        return htmlString;
+    }
+    htmlString = htmlFragment + '\n' + htmlString;
+    assertion();
+    return htmlString;
+}
+// Pay attention to performance when searching for tags
+// Use the most effective way to test or match tag existence
+// Use tag existence checking with caution as it is costly operation
+function tagOpeningExists(tag, htmlString) {
+    const tagOpeningRE = getTagOpening(tag);
+    return tagOpeningRE.test(htmlString);
+}
+function tagClosingExists(tag, htmlString) {
+    const tagClosingRE = getTagClosing(tag);
+    return tagClosingRE.test(htmlString);
+}
+function getTagOpening(tag) {
+    const tagOpening = new RegExp(`<${tag}(>| [^>]*>)`, 'i');
+    return tagOpening;
+}
+function getTagClosing(tag) {
+    const tagClosing = new RegExp(`</${tag}>`, 'i');
+    return tagClosing;
+}
+function injectAtPaceholder(htmlFragment, htmlString, isFirst) {
+    const placeholder = isFirst ? '__VITE_PLUGIN_SSR__ASSETS_FIRST__' : '__VITE_PLUGIN__SSR_ASSETS_LAST__';
+    const parts = htmlString.split(placeholder);
+    if (parts.length === 1)
+        return null;
+    assertUsage(parts.length === 2, "You're inserting assets twice into your HTML", { showStackTrace: true });
+    return [parts[0], htmlFragment, parts[1]].join('');
+}

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.d.ts

@@ -0,0 +1,2 @@
+export { mergeScriptTags };
+declare function mergeScriptTags(scriptTagsHtml: string, isProduction: boolean): string;

package/dist/esm/node/runtime/html/injectAssets/mergeScriptTags.js

@@ -0,0 +1,68 @@
+export { mergeScriptTags };
+import { assert } from '../../utils.js';
+const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims;
+const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
+const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
+function mergeScriptTags(scriptTagsHtml, isProduction) {
+    let scriptTag = '';
+    const scripts = parseScripts(scriptTagsHtml);
+    // We need to merge module scripts to ensure execution order
+    {
+        const scriptsModule = scripts.filter(({ isModule }) => isModule);
+        if (scriptsModule.length === 1) {
+            scriptTag += scriptsModule[0].outerHtml;
+        }
+        else {
+            const contents = [];
+            scriptsModule.forEach(({ src, innerHtml }) => {
+                const hasInnerHtml = !!innerHtml.trim();
+                if (src) {
+                    assert(!hasInnerHtml);
+                    if (isProduction) {
+                        contents.push(`import ${JSON.stringify(src)};`);
+                    }
+                    else {
+                        // Ensure HMR preamble code is executed before client entries
+                        contents.push(`import(${JSON.stringify(src)});`);
+                    }
+                }
+                else if (hasInnerHtml) {
+                    innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');
+                    contents.push(innerHtml);
+                }
+            });
+            if (contents.length > 0) {
+                scriptTag += `<script type="module" defer>\n${contents.join('\n')}\n</script>`;
+            }
+        }
+    }
+    // We don't need to merge ES5 scripts
+    {
+        const scriptsES5 = scripts.filter(({ isModule }) => !isModule);
+        scriptsES5.forEach(({ outerHtml }) => {
+            scriptTag += outerHtml;
+        });
+    }
+    return scriptTag;
+}
+function parseScripts(htmlString) {
+    const scripts = [];
+    let match;
+    while ((match = scriptRE.exec(htmlString))) {
+        const [outerHtml, openTag, innerHtml] = match;
+        assert(outerHtml && openTag && innerHtml !== undefined);
+        let isModule = false;
+        {
+            const typeMatch = openTag.match(typeRE);
+            const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
+            isModule = type === 'module';
+        }
+        let src = null;
+        {
+            const srcMatch = openTag.match(srcRE);
+            src = (srcMatch && (srcMatch[1] || srcMatch[2] || srcMatch[3])) || '';
+        }
+        scripts.push({ isModule, src, innerHtml, outerHtml });
+    }
+    return scripts;
+}

package/dist/esm/node/runtime/html/injectAssets/sanitizeJson.d.ts

@@ -0,0 +1,2 @@
+export { sanitizeJson };
+declare function sanitizeJson(unsafe: string): string;

package/dist/esm/node/runtime/html/injectAssets/sanitizeJson.js

@@ -0,0 +1,6 @@
+// Prevent XSS attacks, see https://github.com/vikejs/vike/pull/181#issuecomment-952846026
+export { sanitizeJson };
+function sanitizeJson(unsafe) {
+    const safe = unsafe.replace(/</g, '\\u003c');
+    return safe;
+}

package/dist/esm/node/runtime/html/injectAssets.d.ts

@@ -0,0 +1,34 @@
+export { injectHtmlTagsToString };
+export { injectHtmlTagsToStream };
+export type { PageContextInjectAssets };
+export type { PageContextPromise };
+import type { PageAsset } from '../renderPage/getPageAssets.js';
+import type { HtmlPart } from './renderHtml.js';
+import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
+import type { InjectToStream } from './stream/react-streaming.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageContextSerialization } from './serializePageContextClientSide.js';
+type PageContextInjectAssets = {
+    urlPathname: string;
+    __getPageAssets: () => Promise<PageAsset[]>;
+    _pageId: string;
+    _isHtmlOnly: boolean;
+    _pageContextPromise: PageContextPromise;
+    _renderHook: {
+        hookFilePath: string;
+        hookName: 'onRenderHtml' | 'render';
+    };
+    _baseServer: string;
+    _pageConfigs: PageConfig[];
+    is404: null | boolean;
+} & PageContextSerialization;
+declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
+    _isStream: false;
+}, injectFilter: PreloadFilter): Promise<string>;
+declare function injectHtmlTagsToStream(pageContext: PageContextInjectAssets & {
+    _isStream: true;
+}, injectToStream: null | InjectToStream, injectFilter: PreloadFilter): {
+    injectAtStreamBegin: (htmlPartsBegin: HtmlPart[]) => Promise<string>;
+    injectAtStreamEnd: (htmlPartsEnd: HtmlPart[]) => Promise<string>;
+};
+type PageContextPromise = null | Promise<unknown> | (() => void | Promise<unknown>);

package/dist/esm/node/runtime/html/injectAssets.js

@@ -0,0 +1,73 @@
+export { injectHtmlTagsToString };
+export { injectHtmlTagsToStream };
+import { assert, isCallable, isPromise } from '../utils.js';
+import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
+import { injectHtmlTags, createHtmlHeadIfMissing } from './injectAssets/injectHtmlTags.js';
+import { getHtmlTags } from './injectAssets/getHtmlTags.js';
+async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
+    const htmlTags = await getHtmlTags(pageContext, null, injectFilter);
+    const pageAssets = await pageContext.__getPageAssets();
+    let htmlString = htmlPartsToString(htmlParts, pageAssets);
+    htmlString = injectToHtmlBegin(htmlString, htmlTags, null);
+    htmlString = injectToHtmlEnd(htmlString, htmlTags);
+    return htmlString;
+}
+function injectHtmlTagsToStream(pageContext, injectToStream, injectFilter) {
+    let htmlTags;
+    return {
+        injectAtStreamBegin,
+        injectAtStreamEnd
+    };
+    async function injectAtStreamBegin(htmlPartsBegin) {
+        htmlTags = await getHtmlTags(pageContext, injectToStream, injectFilter);
+        const pageAssets = await pageContext.__getPageAssets();
+        let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
+        htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags, injectToStream);
+        return htmlBegin;
+    }
+    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, injectToStream) {
+    const htmlTagsAtBegin = htmlTags.filter((snippet) => snippet.position !== 'HTML_END');
+    // Ensure existence of `<head>`
+    htmlBegin = createHtmlHeadIfMissing(htmlBegin);
+    htmlBegin = injectHtmlTags(htmlBegin, htmlTagsAtBegin, injectToStream);
+    return htmlBegin;
+}
+function injectToHtmlEnd(htmlEnd, htmlTags) {
+    const htmlTagsAtEnd = htmlTags.filter((snippet) => snippet.position === 'HTML_END');
+    htmlEnd = injectHtmlTags(htmlEnd, htmlTagsAtEnd, null);
+    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/esm/node/runtime/html/renderHtml.d.ts

@@ -0,0 +1,33 @@
+export { escapeInject };
+export { dangerouslySkipEscape };
+export { renderDocumentHtml };
+export { isDocumentHtml };
+export { getHtmlString };
+export type { HtmlRender };
+export type { HtmlPart };
+export type { DocumentHtml };
+export type { TemplateWrapped };
+import type { PageContextInjectAssets } from './injectAssets.js';
+import { StreamProviderAny, StreamTypePatch, StreamProviderNormalized } from './stream.js';
+import type { PageAsset } from '../renderPage/getPageAssets.js';
+import type { PreloadFilter } from './injectAssets/getHtmlTags.js';
+type DocumentHtml = TemplateWrapped | EscapedString | StreamProviderAny;
+type HtmlRender = string | StreamProviderNormalized;
+type TemplateStrings = TemplateStringsArray;
+type TemplateVariable = string | EscapedString | StreamProviderAny | TemplateWrapped;
+type TemplateWrapped = {
+    _template: TemplateContent;
+};
+type TemplateContent = {
+    templateStrings: TemplateStrings;
+    templateVariables: TemplateVariable[];
+};
+declare function isDocumentHtml(something: unknown): something is DocumentHtml;
+declare function renderDocumentHtml(documentHtml: DocumentHtml, pageContext: PageContextInjectAssets, onErrorWhileStreaming: (err: unknown) => void, injectFilter: PreloadFilter): Promise<HtmlRender>;
+declare function escapeInject(templateStrings: TemplateStrings, ...templateVariables: (TemplateVariable | StreamTypePatch)[]): TemplateWrapped;
+type EscapedString = {
+    _escaped: string;
+};
+declare function dangerouslySkipEscape(alreadyEscapedString: string): EscapedString;
+type HtmlPart = string | ((pageAssets: PageAsset[]) => string);
+declare function getHtmlString(htmlRender: HtmlRender): Promise<string>;

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

@@ -0,0 +1,231 @@
+export { escapeInject };
+export { dangerouslySkipEscape };
+export { renderDocumentHtml };
+export { isDocumentHtml };
+export { getHtmlString };
+import { assert, assertUsage, assertWarning, checkType, hasProp, isHtml, isPromise, objectAssign } from '../utils.js';
+import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
+import { processStream, isStream, streamToString } from './stream.js';
+import { isStreamReactStreaming } from './stream/react-streaming.js';
+import { getGlobalContext } from '../globalContext.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 = await 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 opts = {
+        onErrorWhileStreaming,
+        enableEagerStreaming: pageContext.enableEagerStreaming
+    };
+    if (injectString) {
+        let injectToStream = null;
+        if (isStreamReactStreaming(streamOriginal) && !streamOriginal.disabled) {
+            injectToStream = streamOriginal.injectToStream;
+        }
+        const { injectAtStreamBegin, injectAtStreamEnd } = injectHtmlTagsToStream(pageContext, injectToStream, injectFilter);
+        objectAssign(opts, {
+            injectStringAtBegin: async () => {
+                return await injectAtStreamBegin(injectString.htmlPartsBegin);
+            },
+            injectStringAtEnd: async () => {
+                return await injectAtStreamEnd(injectString.htmlPartsEnd);
+            }
+        });
+    }
+    const streamWrapper = await processStream(streamOriginal, opts);
+    return streamWrapper;
+}
+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) };
+}
+async 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 = await 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 = (typeText, end) => {
+            const { hookName, hookFilePath } = pageContext._renderHook;
+            const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
+            return [`The ${nth} HTML variable is ${typeText}, see ${hookName}() hook defined by ${hookFilePath}.`, end]
+                .filter(Boolean)
+                .join(' ');
+        };
+        assertUsage(!isPromise(templateVar), getErrMsg('a promise', `Did you forget to ${pc.cyan('await')} the promise?`));
+        if (templateVar === undefined || templateVar === null) {
+            assertWarning(false, getErrMsg(`${pc.cyan(String(templateVar))} which will be converted to an empty string`, `Pass an empty string instead of ${pc.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            templateVar = '';
+        }
+        {
+            const varType = typeof templateVar;
+            const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
+                ? null
+                : '(See https://vike.dev/stream for HTML streaming.)';
+            assertUsage(varType === 'string', getErrMsg(pc.cyan(`typeof htmlVar === "${varType}"`), streamNote));
+        }
+        {
+            const { isProduction } = getGlobalContext();
+            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) {
+                assertWarning(false, getErrMsg(`${pc.cyan(templateVar)} which seems to be HTML code`, 'Did you forget to wrap the value with dangerouslySkipEscape()?'), { 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
+    };
+}
+function escapeHtml(unsafeString) {
+    // Source: https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript/6234804#6234804
+    const safe = unsafeString
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+    return safe;
+}
+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/html/serializePageContextClientSide.d.ts

@@ -0,0 +1,22 @@
+export { serializePageContextClientSide };
+export { serializePageContextAbort };
+export type { PageContextSerialization };
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { UrlRedirect } from '../../../shared/route/abort.js';
+type PageContextSerialization = {
+    _pageId: string;
+    _passToClient: string[];
+    _pageConfigs: PageConfig[];
+    is404: null | boolean;
+    pageProps?: Record<string, unknown>;
+    _isError?: true;
+    _pageContextInit: Record<string, unknown>;
+};
+declare function serializePageContextClientSide(pageContext: PageContextSerialization): string;
+declare function serializePageContextAbort(pageContext: Record<string, unknown> & ({
+    _urlRedirect: UrlRedirect;
+} | {
+    _urlRewrite: string;
+} | {
+    abortStatusCode: number;
+})): string;