vike 0.4.247 → 0.4.249

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

@@ -1,52 +0,0 @@
-export { inferAssetTag };
-export { inferPreloadTag };
-export { inferEarlyHintLink };
-export { scriptCommonAttrs };
-import { assert } from '../../../utils.js';
-import { inferNonceAttr } from '../../csp.js';
-// We can't use `defer` here. With `defer`, the entry script won't start before `</body>` has been parsed, preventing progressive hydration during SSR streaming, see https://github.com/vikejs/vike/pull/1271
-const scriptCommonAttrs = 'type="module" async';
-function inferPreloadTag(pageAsset) {
-    const { src, assetType, mediaType } = pageAsset;
-    const rel = getRel(pageAsset);
-    const attributes = [
-        `rel="${rel}"`,
-        `href="${src}"`,
-        !assetType ? null : `as="${assetType}"`,
-        !mediaType ? null : `type="${mediaType}"`,
-        // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
-        !isCrossOrigin(pageAsset) ? null : 'crossorigin',
-    ]
-        .filter(Boolean)
-        .join(' ');
-    return `<link ${attributes}>`;
-}
-function inferAssetTag(pageAsset, pageContext) {
-    const { src, assetType, mediaType } = pageAsset;
-    if (assetType === 'script') {
-        assert(mediaType === 'text/javascript');
-        const nonceAttr = inferNonceAttr(pageContext);
-        return `<script src="${src}" ${scriptCommonAttrs}${nonceAttr}></script>`;
-    }
-    if (assetType === 'style') {
-        // WARNING: if changing following line, then also update https://github.com/vikejs/vike/blob/fae90a15d88e5e87ca9fcbb54cf2dc8773d2f229/vike/client/shared/removeFoucBuster.ts#L29
-        return `<link rel="stylesheet" type="text/css" href="${src}">`;
-    }
-    assert(false, { pageAsset });
-}
-// We ignore crossorigin, it seems like Early Hints doesn't have a "crossorigin" property: https://github.com/vikejs/vike/issues/618#issuecomment-1415752222
-function inferEarlyHintLink(pageAsset) {
-    const { src, assetType } = pageAsset;
-    const rel = getRel(pageAsset);
-    return [`<${src}>`, `rel=${rel}`, !assetType ? null : `as=${assetType}`].filter(Boolean).join('; ');
-}
-function getRel({ assetType }) {
-    if (assetType === 'script') {
-        // Vite transpiles all browser-side JavaScript to ESM
-        return 'modulepreload';
-    }
-    return 'preload';
-}
-function isCrossOrigin({ src, assetType }) {
-    return assetType === 'font' || src.startsWith('http://') || src.startsWith('https://');
-}

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

@@ -1,29 +0,0 @@
-export { injectAssets__public };
-import { assertUsage, assertWarning, castProp, hasProp } from '../../../utils.js';
-import { injectHtmlTagsToString } from '../injectAssets.js';
-// TO-DO/next-major-release: remove
-async function injectAssets__public(htmlString, pageContext) {
-    assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
-    assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
-    assertUsage(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
-        showStackTrace: true,
-    });
-    const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
-        body +
-        '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
-    assertUsage(hasProp(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
-        showStackTrace: true,
-    });
-    assertUsage(hasProp(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
-        showStackTrace: true,
-    });
-    assertUsage(hasProp(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
-        showStackTrace: true,
-    });
-    assertUsage(hasProp(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
-        showStackTrace: true,
-    });
-    castProp(pageContext, '__getPageAssets');
-    htmlString = await injectHtmlTagsToString([htmlString], pageContext, null);
-    return htmlString;
-}

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

@@ -1,160 +0,0 @@
-// Unit tests at ./injectHtmlTags.spec.ts
-export { injectHtmlTags };
-export { injectHtmlTagsUsingStream };
-export { createHtmlHeadIfMissing };
-export { joinHtmlTags };
-// Only needed for unit tests
-export { injectAtOpeningTag };
-export { injectAtClosingTag };
-import { assert, assertUsage, slice } from '../../../utils.js';
-function injectHtmlTags(htmlString, htmlTags, position) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === position));
-    if (htmlFragment) {
-        htmlString = injectHtmlFragment(position, htmlFragment, htmlString);
-    }
-    return htmlString;
-}
-// Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
-function injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'HTML_STREAM'));
-    if (htmlFragment) {
-        assert(!streamFromReactStreamingPackage.hasStreamEnded());
-        streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });
-    }
-}
-function joinHtmlTags(htmlTags) {
-    const htmlFragment = htmlTags.map((h) => resolveHtmlTag(h.htmlTag)).join('');
-    return htmlFragment;
-}
-function injectHtmlFragment(position, htmlFragment, htmlString) {
-    if (position === 'HTML_BEGIN') {
-        {
-            const res = injectAtPlaceholder(htmlFragment, htmlString, true);
-            if (res)
-                return res;
-        }
-        assert(tagOpeningExists('head', htmlString));
-        htmlString = injectAtOpeningTag('head', htmlString, htmlFragment);
-        return htmlString;
-    }
-    if (position === 'HTML_END') {
-        {
-            const res = injectAtPlaceholder(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;
-    }
-    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.replace(/<[^\/]/g, (match) => `${padding}${match}`);
-    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 injectAtPlaceholder(htmlFragment, htmlString, isFirst) {
-    // TO-DO/eventually: soft deprecate in favor of https://github.com/vikejs/vike/issues/695
-    // Used by BurdaForward https://github.com/vikejs/vike/discussions/2528#discussioncomment-13637156
-    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/renderPage/html/injectAssets/mergeScriptTags.js

@@ -1,71 +0,0 @@
-export { mergeScriptTags };
-import { inferNonceAttr } from '../../csp.js';
-import { assert } from '../../../utils.js';
-import { scriptCommonAttrs } from './inferHtmlTags.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, pageContext) {
-    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);
-                    // - We don't use a static import because static imports are hoisted => React's HMR preamble can be executed after user land code => triggering this error:
-                    //   ```
-                    //   [22:28:57.885][/test-dev.test.ts][pnpm run dev][Browser Error] Error: @vitejs/plugin-react-swc can't detect preamble. Something is wrong.
-                    //       at http://localhost:3000/@fs/home/rom/code/docpress/src/renderer/usePageContext.tsx:9:11
-                    //   ```
-                    // - We don't use `await` the dynamic import() to avoid waterfall
-                    contents.push(`import(${JSON.stringify(src)});`);
-                }
-                else if (hasInnerHtml) {
-                    innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');
-                    contents.push(innerHtml);
-                }
-            });
-            if (contents.length > 0) {
-                const nonceAttr = inferNonceAttr(pageContext);
-                scriptTag += `<script ${scriptCommonAttrs}${nonceAttr}>\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/renderPage/html/injectAssets.js

@@ -1,91 +0,0 @@
-export { injectHtmlTagsToString };
-export { injectHtmlTagsToStream };
-import { assert, isCallable, isPromise } from '../../utils.js';
-import { assertPageContextProvidedByUser } from '../../../../shared/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/esm/node/runtime/renderPage/html/propKeys.js

@@ -1,45 +0,0 @@
-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
-}