vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

package/dist/esm/node/runtime/renderPage/getPageAssets/retrievePageAssetsProd.js

@@ -1,75 +0,0 @@
-export { retrievePageAssetsProd };
-export { resolveIncludeAssetsImportedByServer };
-import { assert, isImportPathNpmPackage } from '../../utils.js';
-import { getManifestEntry } from './getManifestEntry.js';
-import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, config) {
-    const clientEntriesSrc = clientEntries.map((clientEntry) => getClientEntrySrcProd(clientEntry, assetsManifest));
-    const assetUrls = getAssetsUrl(clientDependencies, assetsManifest, config);
-    return { clientEntriesSrc, assetUrls };
-}
-function getClientEntrySrcProd(clientEntry, assetsManifest) {
-    const { manifestEntry } = getManifestEntry(clientEntry, assetsManifest);
-    assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
-    let { file } = manifestEntry;
-    assert(!file.startsWith('/'));
-    return '/' + file;
-}
-function getAssetsUrl(clientDependencies, assetsManifest, config) {
-    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(config);
-    let assetUrls = new Set();
-    assert(assetsManifest);
-    const visistedAssets = new Set();
-    clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
-        if (eagerlyImported)
-            return; // Eagerly imported assets aren't imported with import() and therefore don't create a new Rollup entry and aren't listed in the manifest file
-        // TO-DO/next-major-release: remove
-        if (includeAssetsImportedByServer &&
-            onlyAssets &&
-            id.includes('.page.server.') &&
-            // We assume that all npm packages have already built their files: bundlers (Rollup, esbuild, tsup, ...) extract the CSS out of JavaScript => we can assume JavaScript to not import any CSS/assets.
-            !isImportPathNpmPackage(id, {
-                // I presume Vite already resolves path aliases when Vite sets the module's id
-                cannotBePathAlias: true,
-            })) {
-            id = extractAssetsAddQuery(id);
-        }
-        const { manifestKey } = getManifestEntry(id, assetsManifest);
-        collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyAssets);
-    });
-    collectSingleStyle(assetUrls, assetsManifest);
-    return Array.from(assetUrls);
-}
-function collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyCollectStaticAssets) {
-    if (visistedAssets.has(manifestKey))
-        return;
-    visistedAssets.add(manifestKey);
-    const manifestEntry = assetsManifest[manifestKey];
-    assert(manifestEntry, { manifestKey });
-    const { file } = manifestEntry;
-    if (!onlyCollectStaticAssets) {
-        assetUrls.add(`/${file}`);
-    }
-    const { imports = [], assets = [], css = [] } = manifestEntry;
-    for (const manifestKey of imports) {
-        const importManifestEntry = assetsManifest[manifestKey];
-        assert(importManifestEntry);
-        collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyCollectStaticAssets);
-    }
-    for (const cssAsset of css) {
-        assetUrls.add(`/${cssAsset}`);
-    }
-    for (const asset of assets) {
-        assetUrls.add(`/${asset}`);
-    }
-}
-// Support `config.build.cssCodeSplit: false`, see https://github.com/vikejs/vike/issues/644
-function collectSingleStyle(assetUrls, assetsManifest) {
-    const style = assetsManifest['style.css'];
-    if (style && Object.values(assetsManifest).filter((asset) => asset.file.endsWith('.css')).length === 1) {
-        assetUrls.add(`/${style.file}`);
-    }
-}
-function resolveIncludeAssetsImportedByServer(config) {
-    return config.includeAssetsImportedByServer ?? true;
-}

package/dist/esm/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.js

@@ -1,34 +0,0 @@
-export { sortPageAssetsForEarlyHintsHeader };
-import { higherFirst } from '../../utils.js';
-async function sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction) {
-    pageAssets.sort(higherFirst(({ assetType }) => {
-        // In dev, we load scripts first in order to parallelize I/O and CPU
-        if (!isProduction && assetType === 'script') {
-            return 1;
-        }
-        let priority = 0;
-        // CSS has highest priority
-        if (assetType === 'style')
-            return priority;
-        priority--;
-        // Visual assets have high priority
-        if (assetType === 'font')
-            return priority;
-        priority--;
-        if (assetType === 'image')
-            return priority;
-        priority--;
-        if (assetType === 'video')
-            return priority;
-        priority--;
-        if (assetType === 'audio')
-            return priority;
-        priority--;
-        // Others
-        if (assetType !== 'script')
-            return priority;
-        priority--;
-        // JavaScript has lowest priority
-        return priority;
-    }));
-}

package/dist/esm/node/runtime/renderPage/getPageAssets.d.ts

@@ -1,18 +0,0 @@
-export { getPageAssets };
-export type { PageAsset };
-export type { GetPageAssets };
-import { type MediaType } from './inferMediaType.js';
-import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageAsset = {
-    src: string;
-    assetType: null | NonNullable<MediaType>['assetType'];
-    mediaType: null | NonNullable<MediaType>['mediaType'];
-    isEntry: boolean;
-};
-type GetPageAssets = () => Promise<PageAsset[]>;
-declare function getPageAssets(pageContext: {
-    _baseServer: string;
-    _baseAssets: string | null;
-    _globalContext: GlobalContextServerInternal;
-}, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;

package/dist/esm/node/runtime/renderPage/getPageAssets.js

@@ -1,48 +0,0 @@
-export { getPageAssets };
-import { retrievePageAssetsProd } from './getPageAssets/retrievePageAssetsProd.js';
-import { retrievePageAssetsDev } from './getPageAssets/retrievePageAssetsDev.js';
-import { inferMediaType } from './inferMediaType.js';
-import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
-import { assert, prependBase, toPosixPath, unique, getViteRPC } from '../utils.js';
-async function getPageAssets(pageContext, clientDependencies, clientEntries) {
-    const globalContext = pageContext._globalContext;
-    const { _isProduction: isProduction } = globalContext;
-    const isDev = !isProduction;
-    const { assetUrls, clientEntriesSrc } = isDev
-        ? !globalContext._viteDevServer
-            ? await getViteRPC().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
-            : await retrievePageAssetsDev(globalContext._viteDevServer, clientDependencies, clientEntries)
-        : retrievePageAssetsProd(globalContext.assetsManifest, clientDependencies, clientEntries, globalContext.config);
-    let pageAssets = [];
-    unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
-        const { mediaType = null, assetType = null } = inferMediaType(src) || {};
-        if (isDev && assetType === 'style') {
-            // https://github.com/vikejs/vike/issues/449
-            if (src.endsWith('?inline')) {
-                return;
-            }
-            // https://github.com/vikejs/vike/issues/401
-            // WARNING: if changing following line, then also update https://github.com/vikejs/vike/blob/fae90a15d88e5e87ca9fcbb54cf2dc8773d2f229/vike/client/shared/removeFoucBuster.ts#L28
-            src = src + '?direct';
-        }
-        const isEntry = clientEntriesSrc.includes(src) ||
-            // Vite automatically injects CSS, not only in development, but also in production (albeit with a FOUC). Therefore, strictly speaking, CSS aren't entries. We still, however, set `isEntry: true` for CSS, in order to denote page assets that should absolutely be injected in the HTML, regardless of preload strategy (not injecting CSS leads to FOUC).
-            assetType === 'style';
-        pageAssets.push({
-            src,
-            assetType,
-            mediaType,
-            isEntry,
-        });
-    });
-    pageAssets.forEach(({ src }) => {
-        assert(1 === pageAssets.filter((p) => p.src === src).length);
-    });
-    pageAssets = pageAssets.map((pageAsset) => {
-        const baseServerAssets = pageContext._baseAssets || pageContext._baseServer;
-        pageAsset.src = prependBase(toPosixPath(pageAsset.src), baseServerAssets);
-        return pageAsset;
-    });
-    await sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction);
-    return pageAssets;
-}

package/dist/esm/node/runtime/renderPage/handleErrorWithoutErrorPage.d.ts

@@ -1,11 +0,0 @@
-export { handleErrorWithoutErrorPage };
-import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextAfterRender } from './renderPageAfterRoute.js';
-import type { PageContextCreated } from './createPageContextServerSide.js';
-declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreated & {
-    errorWhileRendering: null | Error;
-    is404: null | boolean;
-    pageId: null;
-    _globalContext: GlobalContextServerInternal;
-    urlOriginal: string;
-}>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

package/dist/esm/node/runtime/renderPage/handleErrorWithoutErrorPage.js

@@ -1,36 +0,0 @@
-export { handleErrorWithoutErrorPage };
-import { stringify } from '@brillout/json-serializer/stringify';
-import { assert, assertWarning, objectAssign } from '../utils.js';
-import { createHttpResponsePage, createHttpResponseError } from './createHttpResponse.js';
-import pc from '@brillout/picocolors';
-// When the user hasn't defined _error.page.js
-async function handleErrorWithoutErrorPage(pageContext) {
-    assert(pageContext.pageId === null);
-    assert(pageContext.errorWhileRendering || pageContext.is404);
-    {
-        const isV1 = pageContext._globalContext._pageConfigs.length > 0;
-        await warnMissingErrorPage(isV1, pageContext._globalContext._isProduction);
-    }
-    if (!pageContext.isClientSideNavigation) {
-        const httpResponse = createHttpResponseError(pageContext);
-        objectAssign(pageContext, { httpResponse });
-        return pageContext;
-    }
-    else {
-        const __getPageAssets = async () => [];
-        objectAssign(pageContext, { __getPageAssets });
-        const httpResponse = await createHttpResponsePage(stringify({ serverSideError: true }), null, pageContext);
-        objectAssign(pageContext, { httpResponse });
-        return pageContext;
-    }
-}
-async function warnMissingErrorPage(isV1, isProduction) {
-    if (!isProduction) {
-        const msg = [
-            `No ${isV1 ? 'error page' : pc.cyan('_error.page.js')} found,`,
-            'we recommend defining one',
-            'https://vike.dev/error-page',
-        ].join(' ');
-        assertWarning(false, msg, { onlyOnce: true });
-    }
-}

package/dist/esm/node/runtime/renderPage/handlePageContextRequestUrl.js

@@ -1,66 +0,0 @@
-export { handlePageContextRequestUrl };
-import { pageContextJsonFileExtension, doNotCreateExtraDirectory } from '../../../shared/getPageContextRequestUrl.js';
-import { modifyUrl } from '../../../shared/modifyUrl.js';
-import { baseServer, parseUrl, assert, slice, isObject, hasProp } from '../utils.js';
-// See also shared/getPageContextRequestUrl.ts
-function handlePageContextRequestUrl(url) {
-    const urlParsed = parseUrl(url, baseServer);
-    if (!isMatch(urlParsed)) {
-        return {
-            isPageContextJsonRequest: false,
-            urlWithoutPageContextRequestSuffix: url,
-        };
-    }
-    else {
-        const { urlWithoutPageContextRequestSuffix, searchVikeArgs } = processUrl(urlParsed, url);
-        const previousUrl = parseSearchVikeArgs(searchVikeArgs);
-        return {
-            /* TO-DO/soon/once: pass & use previousUrl
-            isPageContextJsonRequest: { previousUrl },
-            /*/
-            isPageContextJsonRequest: true,
-            //*/
-            urlWithoutPageContextRequestSuffix,
-        };
-    }
-}
-function isMatch(urlParsed) {
-    const { pathnameOriginal, pathname } = urlParsed;
-    assert(pathname.endsWith(pageContextJsonFileExtension) === pathnameOriginal.endsWith(pageContextJsonFileExtension));
-    return pathname.endsWith(pageContextJsonFileExtension);
-}
-function processUrl(urlParsed, url) {
-    // We cannot use `urlParsed.pathname` because it would break the `urlParsed.pathnameOriginal` value of subsequent `parseUrl()` calls.
-    const { pathnameOriginal, search } = urlParsed;
-    assert(doNotCreateExtraDirectory === false);
-    const urlSuffix = `/index${pageContextJsonFileExtension}`;
-    assert(pathnameOriginal.endsWith(urlSuffix), { url });
-    let pathnameModified = slice(pathnameOriginal, 0, -1 * urlSuffix.length);
-    if (pathnameModified === '')
-        pathnameModified = '/';
-    const searchVikeArgs = search?._vike;
-    const urlWithoutPageContextRequestSuffix = modifyUrl(url, {
-        pathname: pathnameModified,
-        search: {
-            _vike: searchVikeArgs ? null : undefined,
-        },
-    });
-    return {
-        searchVikeArgs,
-        urlWithoutPageContextRequestSuffix,
-    };
-}
-function parseSearchVikeArgs(searchVikeArgs) {
-    const args = {
-        previousUrl: null,
-    };
-    if (searchVikeArgs) {
-        const parsed = JSON.parse(searchVikeArgs);
-        assert(isObject(parsed));
-        if ('previousUrl' in parsed) {
-            assert(hasProp(parsed, 'previousUrl', 'string'));
-            args.previousUrl = parsed.previousUrl;
-        }
-    }
-    return args;
-}

package/dist/esm/node/runtime/renderPage/headersResponse.js

@@ -1,46 +0,0 @@
-export { resolveHeadersResponseEarly };
-export { resolveHeadersResponseFinal };
-import { addCspResponseHeader } from './csp.js';
-import { isCallable } from '../utils.js';
-import { cacheControlDisable, getCacheControl } from './getCacheControl.js';
-function resolveHeadersResponseFinal(pageContext, statusCode) {
-    const headersResponse = pageContext.headersResponse || new Headers();
-    // 5xx error pages are temporary and shouldn't be cached.
-    // This overrides any previously set Cache-Control value.
-    if (statusCode >= 500)
-        headersResponse.set('Cache-Control', cacheControlDisable);
-    const headers = [];
-    headersResponse.forEach((value, key) => {
-        headers.push([key, value]);
-    });
-    return headers;
-}
-async function resolveHeadersResponseEarly(pageContext) {
-    const headersResponse = await resolveHeadersResponseConfig(pageContext);
-    if (!headersResponse.get('Cache-Control')) {
-        const cacheControl = getCacheControl(pageContext.pageId, pageContext._globalContext._pageConfigs);
-        if (cacheControl)
-            headersResponse.set('Cache-Control', cacheControl);
-    }
-    addCspResponseHeader(pageContext, headersResponse);
-    const pageContextAddendum = {
-        headersResponse,
-    };
-    return pageContextAddendum;
-}
-async function resolveHeadersResponseConfig(pageContext) {
-    const headersMerged = new Headers();
-    await Promise.all((pageContext.config.headersResponse ?? []).map(async (headers) => {
-        let headersInit;
-        if (isCallable(headers)) {
-            headersInit = await headers(pageContext);
-        }
-        else {
-            headersInit = headers;
-        }
-        new Headers(headersInit).forEach((value, key) => {
-            headersMerged.append(key, value);
-        });
-    }));
-    return headersMerged;
-}

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

@@ -1,264 +0,0 @@
-export { getHtmlTags };
-import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../../utils.js';
-import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
-import { sanitizeJson } from './sanitizeJson.js';
-import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
-import { mergeScriptTags } from './mergeScriptTags.js';
-import { getPageConfig } from '../../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../../shared/page-configs/getConfigValueRuntime.js';
-import pc from '@brillout/picocolors';
-import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { htmlElementId_globalContext, htmlElementId_pageContext } from '../../../../../shared/htmlElementIds.js';
-import { isFontFallback } from '../../isFontFallback.js';
-import { inferNonceAttr } from '../../csp.js';
-const stamp = '__injectFilterEntry';
-async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
-    assert([true, false].includes(pageContext._isHtmlOnly));
-    const isHtmlOnly = pageContext._isHtmlOnly;
-    const { _isProduction: isProduction } = pageContext._globalContext;
-    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._globalContext._pageConfigs);
-    const injectFilterEntries = [];
-    pageAssets
-        .filter((asset) => {
-        if (asset.isEntry && asset.assetType === 'script') {
-            // We could allow the user to change the position of <script> but we currently don't:
-            //  - Because of mergeScriptEntries()
-            //  - We would need to add HTML_STREAM to to PreloadFilterInject
-            // To support this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
-            return false;
-        }
-        return true;
-    })
-        .forEach((asset) => {
-        const inject = (() => {
-            if (!isProduction) {
-                // In development, we should always load assets as soon as possible, in order to eagerly process assets (e.g. applying the transform() hooks of Vite plugins) which are lazily discovered.
-                return 'HTML_BEGIN';
-            }
-            if (asset.assetType === 'style') {
-                return 'HTML_BEGIN';
-            }
-            if (asset.assetType === 'font') {
-                return !isFontFallback(asset, injectFilterEntries) ? 'HTML_BEGIN' : false;
-            }
-            if (asset.assetType === 'script') {
-                if (isHtmlOnly)
-                    return false;
-                return 'HTML_END';
-            }
-            return false;
-        })();
-        const entry = {
-            ...asset,
-            inject,
-            // @ts-ignore
-            [stamp]: true,
-        };
-        injectFilterEntries.push(entry);
-    });
-    assertInjectFilterEntries(injectFilterEntries);
-    // ==============
-    // injectFilter()
-    // ==============
-    if (injectFilter && isProduction) {
-        Object.seal(injectFilterEntries); // `Object.seal()` instead of `Object.freeze()` to allow the user to `assets.sort()`
-        Object.values(injectFilterEntries).forEach((entry) => freezePartial(entry, { inject: (val) => val === false || val === 'HTML_BEGIN' || val === 'HTML_END' }));
-        // Call the user's injectFilter() hook https://vike.dev/injectFilter
-        const res = injectFilter(injectFilterEntries);
-        assertUsage(res === undefined, `injectFilter() should return ${pc.cyan('undefined')}, see https://vike.dev/injectFilter`);
-        assertInjectFilterUsage(injectFilterEntries);
-    }
-    const htmlTags = [];
-    // ==============
-    // Non-JavaScript
-    // ==============
-    injectFilterEntries
-        .filter((asset) => asset.assetType !== 'script' && asset.inject)
-        .forEach((asset) => {
-        if (!asset.inject)
-            return;
-        const htmlTag = asset.isEntry ? inferAssetTag(asset, pageContext) : inferPreloadTag(asset);
-        htmlTags.push({ htmlTag, position: asset.inject });
-    });
-    // ==========
-    // JavaScript
-    // ==========
-    // - By default, we place the entry <script> towards the end of the HTML for better performance.
-    //   - Performance-wise, it's more interesting to start showing the page (parse HTML and load CSS) before starting loading scripts.
-    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected earlier instead.
-    // - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
-    // - `<script id="vike_pageContext" type="application/json">` (the `pageContext` JSON) should be fully sent before Vike's client runtime starts executing.
-    //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/vikejs/vike/issues/567
-    //   - `<script id="vike_pageContext" type="application/json">` must appear before the entry <script> (which loads Vike's client runtime).
-    //   - `<script id="vike_pageContext" type="application/json">` can't be async nor defer.
-    const positionJavaScriptDefault = 'HTML_END';
-    const positionJavaScriptEntry = (() => {
-        if (injectScriptsAt !== null) {
-            if (pageContext._pageContextPromise) {
-                assertWarning(injectScriptsAt === 'HTML_END' || !isStream, `You're setting injectScriptsAt to ${pc.code(JSON.stringify(injectScriptsAt))} while using HTML streaming with a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`, { onlyOnce: true });
-            }
-            if (injectScriptsAt === 'HTML_STREAM' && !isStream) {
-                return positionJavaScriptDefault;
-            }
-            return injectScriptsAt;
-        }
-        if (pageContext._pageContextPromise) {
-            // - If there is a pageContext._pageContextPromise then <script id="vike_pageContext" type="application/json"> needs to await for it.
-            // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
-            // - https://vike.dev/streaming#initial-data-after-stream-end
-            return positionJavaScriptDefault;
-        }
-        if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
-            // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
-            return 'HTML_STREAM';
-        }
-        return positionJavaScriptDefault;
-    })();
-    if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
-        // - Should we show this warning for Solid as well? Solid seems to also support progressive rendering.
-        //   - https://github.com/vikejs/vike-solid/issues/95
-        // - Vue doesn't seem to support progressive rendering yet.
-        //   - https://github.com/vikejs/vike-vue/issues/85
-        assertWarning(false, "We recommend against using HTML streaming and a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://vike.dev/streaming#progressive-rendering) won't work.", { onlyOnce: true });
-    }
-    if (!isHtmlOnly) {
-        // <script id="vike_pageContext" type="application/json">
-        htmlTags.push({
-            htmlTag: () => 
-            // Needs to be called after resolvePageContextPromise()
-            getPageContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry,
-        });
-        // <script id="vike_globalContext" type="application/json">
-        htmlTags.push({
-            htmlTag: () => 
-            // Needs to be called after resolvePageContextPromise()
-            getGlobalContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry,
-        });
-    }
-    // The JavaScript entry <script> tag
-    const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript, pageContext);
-    if (scriptEntry) {
-        htmlTags.push({
-            htmlTag: scriptEntry,
-            position: positionJavaScriptEntry,
-        });
-    }
-    // Preload tags
-    injectFilterEntries
-        .filter((asset) => asset.assetType === 'script')
-        .forEach((asset) => {
-        assert(!asset.isEntry); // Users cannot re-order JavaScript entries, see creation of injectFilterEntries
-        const htmlTag = inferPreloadTag(asset);
-        if (!asset.inject)
-            return;
-        // Ideally, instead of this conditional ternary operator, we should add HTML_STREAM to PreloadFilterInject
-        const position = asset.inject === 'HTML_END' ? positionJavaScriptEntry : asset.inject;
-        htmlTags.push({ htmlTag, position });
-    });
-    return htmlTags;
-}
-function mergeScriptEntries(pageAssets, viteDevScript, pageContext) {
-    const scriptEntries = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
-    let scriptEntry = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset, pageContext)).join('')}`;
-    // We merge scripts to avoid the infamous HMR preamble error.
-    // - Infamous HMR preamble error:
-    //   ```browser-console
-    //   usePageContext.tsx:10 Uncaught (in promise) Error: @vitejs/plugin-react can't detect preamble. Something is wrong.
-    //       at usePageContext.tsx:10:10
-    //   ```
-    // - Note the following race condition. Maybe making the second script non-async ensures execution order?
-    //   ```html
-    //   <script type="module">console.log("I can be printed *after* the other log")</script>
-    //   <script src="entry.js" type="module" async></script>
-    //   ```
-    //   ```js
-    //   // entry.js
-    //   console.log("I can be printed *before* the other log")
-    //   ```
-    // - Maybe an alternative would be to make Vike's client runtime entry <script> tag non-async. Would that work? Would it be a performance issue?
-    //   - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
-    scriptEntry = mergeScriptTags(scriptEntry, pageContext);
-    return scriptEntry;
-}
-function getPageContextJsonScriptTag(pageContext) {
-    const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext, true));
-    const nonceAttr = inferNonceAttr(pageContext);
-    const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json"${nonceAttr}>${pageContextClientSerialized}</script>`;
-    // Used by contra.com https://github.com/gajus
-    // @ts-expect-error
-    pageContext._pageContextHtmlTag = htmlTag;
-    return htmlTag;
-}
-function getGlobalContextJsonScriptTag(pageContext) {
-    const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext, true));
-    const nonceAttr = inferNonceAttr(pageContext);
-    const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json"${nonceAttr}>${globalContextClientSerialized}</script>`;
-    return htmlTag;
-}
-function assertInjectFilterEntries(injectFilterEntries) {
-    try {
-        checkForWrongUsage(injectFilterEntries);
-    }
-    catch (err) {
-        if (err?.message.includes('[Wrong Usage]')) {
-            assert(false);
-        }
-        throw err;
-    }
-}
-function assertInjectFilterUsage(injectFilterEntries) {
-    checkForWrongUsage(injectFilterEntries);
-    checkForWarnings(injectFilterEntries);
-}
-function checkForWrongUsage(injectFilterEntries) {
-    injectFilterEntries.forEach((entry, i) => {
-        assertUsage(isObject(entry), `[injectFilter()] Entry ${i} isn't an object`);
-        assertUsage(typeof entry.src === 'string', `[injectFilter()] Entry ${i} is missing property ${pc.cyan('src')}`);
-        assertUsage(entry[stamp] === true, `[injectFilter()] Entry ${i} (${entry.src}) isn't the original object, see https://vike.dev/injectFilter`);
-        assert([false, 'HTML_BEGIN', 'HTML_END'].includes(entry.inject));
-        assert(entry.assetType === null || typeof entry.assetType === 'string');
-        assert(entry.mediaType === null || typeof entry.mediaType === 'string');
-        assert(typeof entry.isEntry === 'boolean');
-        assert(Object.keys(entry).length === 6);
-    });
-}
-function checkForWarnings(injectFilterEntries) {
-    injectFilterEntries.forEach((a) => {
-        /*
-        if (a.assetType === 'script' && a.isEntry) {
-          assertUsage(a.inject, `[injectFilter()] ${a.src} needs to be injected`)
-        }
-        */
-        if (a.assetType === 'style' && a.isEntry) {
-            // In development, Vite automatically inject styles, but we still inject `<link rel="stylesheet" type="text/css" href="${src}">` tags in order to avoid FOUC (flash of unstyled content).
-            //  - https://github.com/vitejs/vite/issues/2282
-            //  - https://github.com/vikejs/vike/issues/261
-            assertWarning(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
-                onlyOnce: true,
-            });
-        }
-        if (a.assetType === 'script') {
-            assertWarning(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
-                onlyOnce: true,
-            });
-        }
-    });
-}
-function getInjectScriptsAt(pageId, pageConfigs) {
-    if (pageConfigs.length === 0)
-        return null; // only support V1 design
-    const pageConfig = getPageConfig(pageId, pageConfigs);
-    const configValue = getConfigValueRuntime(pageConfig, 'injectScriptsAt');
-    if (!configValue)
-        return null;
-    const injectScriptsAt = configValue.value;
-    assert(configValue.definedAtData);
-    const configDefinedAt = getConfigDefinedAt('Config', 'injectScriptsAt', configValue.definedAtData);
-    assertUsage(injectScriptsAt === null ||
-        injectScriptsAt === 'HTML_BEGIN' ||
-        injectScriptsAt === 'HTML_END' ||
-        injectScriptsAt === 'HTML_STREAM', `${configDefinedAt} has an invalid value`);
-    return injectScriptsAt;
-}

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

@@ -1,27 +0,0 @@
-export { getViteDevScript };
-import { assert, assertUsage, assertWarning, getViteRPC } from '../../../utils.js';
-import pc from '@brillout/picocolors';
-const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
-async function getViteDevScript(pageContext) {
-    const globalContext = pageContext._globalContext;
-    if (globalContext._isProduction) {
-        return '';
-    }
-    const { _viteDevServer: viteDevServer } = globalContext;
-    const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
-    const fakeHtmlEnd = '</head><body></body></html>';
-    let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
-    fakeHtml = viteDevServer
-        ? await viteDevServer.transformIndexHtml('/', fakeHtml)
-        : await getViteRPC().transformIndexHtmlRPC(fakeHtml);
-    assertUsage(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${pc.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
-    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
-    assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), `You are using a Vite Plugin that transforms the HTML in a way that conflicts with Vike. ${reachOutCTA}`);
-    const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
-    assert(viteInjection.includes('script'));
-    assertWarning(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
-        onlyOnce: true,
-    });
-    const viteDevScript = viteInjection;
-    return viteDevScript;
-}