vike 0.4.247 → 0.4.248

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

@@ -1,45 +0,0 @@
-export { resolvePageContextCspNone };
-export { inferNonceAttr };
-export { addCspResponseHeader };
-import { import_ } from '@brillout/import';
-import { assert } from '../utils.js';
-async function resolvePageContextCspNone(pageContext) {
-    if (pageContext.cspNonce)
-        return null; // already set by user e.g. `renderPage({ cspNonce: '123456789' })`
-    const { csp } = pageContext.config;
-    const pageContextAddendum = { cspNonce: null };
-    if (csp?.nonce) {
-        if (csp.nonce === true) {
-            pageContextAddendum.cspNonce = await generateNonce();
-        }
-        else {
-            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
-        }
-    }
-    return pageContextAddendum;
-}
-// Generate a cryptographically secure nonce for Content Security Policy (CSP).
-// Returns a base64url-encoded nonce string (URL-safe, no padding).
-// https://github.com/vikejs/vike/issues/1554#issuecomment-3181128304
-async function generateNonce() {
-    let cryptoModule;
-    try {
-        cryptoModule = (await import_('crypto')).default;
-    }
-    catch {
-        return Math.random().toString(36).substring(2, 18);
-    }
-    return cryptoModule.randomBytes(16).toString('base64url');
-}
-function inferNonceAttr(pageContext) {
-    const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
-    return nonceAttr;
-}
-function addCspResponseHeader(pageContext, headersResponse) {
-    assert(pageContext.cspNonce === null || typeof pageContext.cspNonce === 'string'); // ensure resolvePageContextCspNone() is called before addCspResponseHeader()
-    if (!pageContext.cspNonce)
-        return;
-    if (headersResponse.get('Content-Security-Policy'))
-        return;
-    headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
-}

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

@@ -1,29 +0,0 @@
-export { execHookDataAndOnBeforeRender };
-import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
-import { execHookServer } from './execHookServer.js';
-async function execHookDataAndOnBeforeRender(pageContext) {
-    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
-        return;
-    }
-    const hooks = await execHookServer('data', pageContext);
-    const dataHook = hooks[0]; // TO-DO/soon/cumulative-hooks: support cumulative
-    if (dataHook) {
-        // Note: hookReturn can be anything (e.g. an object) and is to be assigned to pageContext.data
-        const pageContextFromHook = {
-            data: dataHook.hookReturn,
-        };
-        Object.assign(pageContext, pageContextFromHook);
-        // Execute +onData
-        if (!pageContext.isClientSideNavigation) {
-            await execHookServer('onData', pageContext);
-        }
-    }
-    const res = await execHookServer('onBeforeRender', pageContext);
-    const onBeforeRenderHook = res[0]; // TO-DO/soon/cumulative-hooks: support cumulative
-    if (onBeforeRenderHook) {
-        const { hookReturn } = onBeforeRenderHook;
-        assertOnBeforeRenderHookReturn(hookReturn, onBeforeRenderHook.hookFilePath);
-        const pageContextFromHook = hookReturn?.pageContext;
-        Object.assign(pageContext, pageContextFromHook);
-    }
-}

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

@@ -1,2 +0,0 @@
-export { execHookOnError };
-declare function execHookOnError(err: unknown): void;

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

@@ -1,26 +0,0 @@
-export { execHookOnError };
-import { isObject, getGlobalObject } from '../utils.js';
-import { getGlobalContextServerInternalOptional } from '../globalContext.js';
-import { getHookFromPageConfigGlobalCumulative } from '../../../shared/hooks/getHook.js';
-const globalObject = getGlobalObject('renderPage/execHookOnError.ts', {
-    seen: new WeakSet(),
-});
-function execHookOnError(err) {
-    if (isObject(err)) {
-        if (globalObject.seen.has(err))
-            return;
-        globalObject.seen.add(err);
-    }
-    const globalContext = getGlobalContextServerInternalOptional();
-    if (!globalContext)
-        return;
-    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
-    for (const hook of hooks) {
-        try {
-            hook.hookFn(err);
-        }
-        catch (hookErr) {
-            console.error(hookErr);
-        }
-    }
-}

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

@@ -1,24 +0,0 @@
-export { execHookOnRenderHtml };
-export type { RenderHook };
-import { type HtmlRender } from './html/renderHtml.js';
-import { type Hook } from '../../../shared/hooks/getHook.js';
-import type { PageAsset } from './getPageAssets.js';
-import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import type { PageContextSerialization } from './html/serializeContext.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
-type GetPageAssets = () => Promise<PageAsset[]>;
-type RenderHook = Hook & {
-    hookName: HookName;
-};
-type HookName = 'onRenderHtml' | 'render';
-declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
-    pageId: string;
-    _globalContext: GlobalContextServerInternal;
-    __getPageAssets: GetPageAssets;
-    _isHtmlOnly: boolean;
-    _baseServer: string;
-    _httpRequestId: number | null;
-}): Promise<{
-    renderHook: RenderHook;
-    htmlRender: HtmlRender;
-}>;

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

@@ -1,115 +0,0 @@
-export { execHookOnRenderHtml };
-import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape, } from './html/renderHtml.js';
-import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
-import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
-import { isStream } from './html/stream.js';
-import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
-import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
-import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
-import { logRuntimeError } from '../loggerRuntime.js';
-import pc from '@brillout/picocolors';
-import { execHookDirectSingleWithReturn } from '../../../shared/hooks/execHook.js';
-async function execHookOnRenderHtml(pageContext) {
-    const hook = getRenderHook(pageContext);
-    objectAssign(pageContext, { _renderHook: hook });
-    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
-    Object.assign(pageContext, pageContextProvidedByRenderHook);
-    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
-    const onErrorWhileStreaming = (err) => {
-        // Should the stream inject the following?
-        // ```
-        // <script>console.error("An error occurred on the server side while streaming the page to HTML, see server logs.")</script>
-        // ```
-        logRuntimeError(err, pageContext._httpRequestId);
-        if (!pageContext.errorWhileRendering) {
-            pageContext.errorWhileRendering = err;
-        }
-    };
-    const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
-    assert(typeof htmlRender === 'string' || isStream(htmlRender));
-    return { htmlRender, renderHook: hook };
-}
-function getRenderHook(pageContext) {
-    let hookFound;
-    {
-        let hook;
-        let hookName = undefined;
-        hook = getHookFromPageContext(pageContext, 'onRenderHtml');
-        if (hook) {
-            hookName = 'onRenderHtml';
-        }
-        else {
-            hook = getHookFromPageContext(pageContext, 'render');
-            if (hook) {
-                hookName = 'render';
-            }
-        }
-        if (hook) {
-            assert(hookName);
-            const { hookFilePath, hookFn, hookTimeout } = hook;
-            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
-        }
-    }
-    if (!hookFound) {
-        const hookName = pageContext._globalContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
-        assertUsage(false, `No ${hookName}() hook found, see https://vike.dev/${hookName}`);
-    }
-    return hookFound;
-}
-function processHookReturnValue(hookReturnValue, renderHook) {
-    let documentHtml;
-    let pageContextPromise = null;
-    let pageContextProvidedByRenderHook = null;
-    let injectFilter = null;
-    if (isDocumentHtml(hookReturnValue)) {
-        documentHtml = hookReturnValue;
-        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
-    }
-    const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
-    const errSuffix = `a string generated with ${pc.cyan('escapeInject`<html>...</html>`')} or the value returned by ${pc.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
-    if (typeof hookReturnValue === 'string') {
-        assertWarning(false, [
-            errPrefix,
-            `returned a plain JavaScript string which is ${pc.red(pc.bold('dangerous'))}: it should instead return`,
-            errSuffix,
-        ].join(' '), { onlyOnce: true });
-        hookReturnValue = dangerouslySkipEscape(hookReturnValue);
-    }
-    const wrongReturnValue = `should return the value ${pc.cyan('documentHtml')} or an object ${pc.cyan('{ documentHtml }')} where ${pc.cyan('documentHtml')} is ${errSuffix}`;
-    assertUsage(isObject(hookReturnValue), `${errPrefix} ${wrongReturnValue}`);
-    assertHookReturnedObject(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);
-    assertUsage(hookReturnValue.documentHtml, `${errPrefix} returned an object that is missing the ${pc.code('documentHtml')} property: it ${wrongReturnValue}`);
-    if (hookReturnValue.injectFilter) {
-        assertUsage(isCallable(hookReturnValue.injectFilter), 'injectFilter should be a function');
-        injectFilter = hookReturnValue.injectFilter;
-    }
-    {
-        let val = hookReturnValue.documentHtml;
-        const errBegin = `${errPrefix} returned ${pc.cyan('{ documentHtml }')}, but ${pc.cyan('documentHtml')}`;
-        if (typeof val === 'string') {
-            assertWarning(false, [
-                errBegin,
-                `is a plain JavaScript string which is ${pc.bold(pc.red('dangerous'))}: ${pc.cyan('documentHtml')} should be`,
-                errSuffix,
-            ].join(' '), { onlyOnce: true });
-            val = dangerouslySkipEscape(val);
-        }
-        assertUsage(isDocumentHtml(val), [errBegin, 'should be', errSuffix].join(' '));
-        documentHtml = val;
-    }
-    if (hookReturnValue.pageContext) {
-        const val = hookReturnValue.pageContext;
-        const errBegin = `${errPrefix} returned ${pc.cyan('{ pageContext }')}, but ${pc.cyan('pageContext')}`;
-        if (isPromise(val) || isCallable(val)) {
-            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
-            pageContextPromise = val;
-        }
-        else {
-            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
-            assertPageContextProvidedByUser(val, renderHook);
-            pageContextProvidedByRenderHook = val;
-        }
-    }
-    return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
-}

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

@@ -1,12 +0,0 @@
-export { execHookServer };
-export type { PageContextExecHookServer };
-import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import type { PageContextConfig } from '../../../shared/getPageFiles.js';
-import type { HookName } from '../../../types/Config.js';
-type PageContextExecHookServer = PageContextConfig & PageContextForPublicUsageServer;
-declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
-    hookFn: (arg: import("../../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum) => unknown;
-    hookTimeout: import("../../../shared/hooks/getHook.js").HookTimeout;
-} & {
-    hookReturn: unknown;
-})[]>;

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

@@ -1,6 +0,0 @@
-export { execHookServer };
-import { execHook } from '../../../shared/hooks/execHook.js';
-import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
-async function execHookServer(hookName, pageContext) {
-    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
-}

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

@@ -1,21 +0,0 @@
-export { getCacheControl };
-export { cacheControlDisable };
-import { getPageConfig } from '../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
-const cacheControlDisable = 'no-store, max-age=0';
-function getCacheControl(pageId, pageConfigs) {
-    // TO-DO/next-major-release: remove this line
-    if (pageConfigs.length === 0)
-        return cacheControlDisable;
-    if (pageId) {
-        const pageConfig = getPageConfig(pageId, pageConfigs);
-        const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
-        const value = configValue?.value;
-        if (value)
-            return value;
-    }
-    // - Disabling caching by default is the safest strategy, because caching is problematic with authentication as described in https://github.com/vikejs/vike/issues/1275#issuecomment-1824366875
-    // - Are there use cases when we don't need to disable caching?
-    //   - When there isn't any <script id="vike_pageContext" type="application/json"> then we can safely have caching. (We don't implement this exception because we're lazy and it's quite a rare situation.)
-    return cacheControlDisable;
-}

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

@@ -1,132 +0,0 @@
-export { getHttpResponseBody };
-export { getHttpResponseBodyStreamHandlers };
-import { isStream, getStreamName, inferStreamName, isStreamWritableWeb, isStreamWritableNode, isStreamReadableWeb, isStreamReadableNode, isStreamPipeWeb, isStreamPipeNode, getStreamReadableNode, getStreamReadableWeb, pipeToStreamWritableWeb, pipeToStreamWritableNode, } from './html/stream.js';
-import { assert, assertUsage, assertWarning } from '../utils.js';
-import { getHtmlString } from './html/renderHtml.js';
-import pc from '@brillout/picocolors';
-const streamDocs = 'See https://vike.dev/streaming for more information.';
-function getHttpResponseBody(htmlRender, renderHook) {
-    if (typeof htmlRender !== 'string') {
-        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
-    }
-    const body = htmlRender;
-    return body;
-}
-function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
-    return {
-        pipe(writable) {
-            const getErrMsgMixingStreamTypes = (writableType) => `The ${getErrMsgBody(htmlRender, renderHook)} while a ${writableType} was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.`;
-            if (isStreamWritableWeb(writable)) {
-                const success = pipeToStreamWritableWeb(htmlRender, writable);
-                if (success) {
-                    return;
-                }
-                else {
-                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
-                    assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
-                }
-            }
-            if (isStreamWritableNode(writable)) {
-                const success = pipeToStreamWritableNode(htmlRender, writable);
-                if (success) {
-                    return;
-                }
-                else {
-                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
-                    assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
-                }
-            }
-            assertUsage(false, `The argument ${pc.cyan('writable')} passed to ${pc.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${getStreamName('writable', 'web')} nor ${getStreamName('writable', 'node')}.`);
-        },
-        getReadableWebStream() {
-            const webStream = getStreamReadableWeb(htmlRender);
-            if (webStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
-            }
-            return webStream;
-        },
-        async getReadableNodeStream() {
-            const nodeStream = await getStreamReadableNode(htmlRender);
-            if (nodeStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableNodeStream()', getFixMsg('readable', 'node')));
-            }
-            return nodeStream;
-        },
-        async getBody() {
-            const body = await getHtmlString(htmlRender);
-            return body;
-        },
-        // TO-DO/next-major-release: remove
-        async getNodeStream() {
-            assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.getReadableNodeStream()` instead. ' +
-                streamDocs, { onlyOnce: true, showStackTrace: true });
-            const nodeStream = await getStreamReadableNode(htmlRender);
-            if (nodeStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getNodeStream()', getFixMsg('readable', 'node')));
-            }
-            return nodeStream;
-        },
-        // TO-DO/next-major-release: remove
-        getWebStream() {
-            assertWarning(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
-                streamDocs, { onlyOnce: true, showStackTrace: true });
-            const webStream = getStreamReadableWeb(htmlRender);
-            if (webStream === null) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getWebStream()', getFixMsg('readable', 'web')));
-            }
-            return webStream;
-        },
-        // TO-DO/next-major-release: remove
-        pipeToWebWritable(writable) {
-            assertWarning(false, '`pageContext.httpResponse.pipeToWebWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
-                streamDocs, { onlyOnce: true, showStackTrace: true });
-            const success = pipeToStreamWritableWeb(htmlRender, writable);
-            if (!success) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToWebWritable()'));
-            }
-        },
-        // TO-DO/next-major-release: remove
-        pipeToNodeWritable(writable) {
-            assertWarning(false, '`pageContext.httpResponse.pipeToNodeWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
-                streamDocs, { onlyOnce: true, showStackTrace: true });
-            const success = pipeToStreamWritableNode(htmlRender, writable);
-            if (!success) {
-                assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToNodeWritable()'));
-            }
-        },
-    };
-    function getFixMsg(kind, type) {
-        const streamName = getStreamName(kind, type);
-        assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
-        assert(renderHook);
-        const { hookFilePath, hookName } = renderHook;
-        return `Make sure the ${hookName}() hook defined by ${hookFilePath} provides ${streamName} instead`;
-    }
-}
-function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
-    assert(!msgAddendum || !msgAddendum.endsWith('.'));
-    const errMsgBody = getErrMsgBody(htmlRender, renderHook);
-    return [`pageContext.httpResponse.${method} can't be used because the ${errMsgBody}`, msgAddendum, streamDocs]
-        .filter(Boolean)
-        .join('. ');
-}
-function getErrMsgBody(htmlRender, renderHook) {
-    assert(renderHook);
-    const { hookFilePath, hookName } = renderHook;
-    const hookReturnType = getHookReturnType(htmlRender);
-    assert(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
-    const errMsgBody = `${hookName}()\ hook defined by ${hookFilePath} provides ${hookReturnType}`;
-    assert(!errMsgBody.endsWith(' '));
-    return errMsgBody;
-}
-function getHookReturnType(htmlRender) {
-    if (typeof htmlRender === 'string') {
-        return 'an HTML string';
-    }
-    else if (isStream(htmlRender)) {
-        return inferStreamName(htmlRender);
-    }
-    else {
-        assert(false);
-    }
-}

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

@@ -1,123 +0,0 @@
-export { getManifestEntry };
-import { assert, slice, assertIsImportPathNpmPackage } from '../../utils.js';
-import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
-import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
-function getManifestEntry(id, assetsManifest) {
-    const debugInfo = getDebugInfo(id, assetsManifest);
-    // Vike client entry
-    if (id.startsWith('@@vike/')) {
-        const manifestKeyEnd = slice(id, '@@vike'.length, 0);
-        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
-        assert(manifestEntry && manifestKey, debugInfo);
-        return { manifestEntry, manifestKey };
-    }
-    // Page code importer
-    const virtualFile = parseVirtualFileId(id);
-    if (virtualFile && virtualFile.type === 'page-entry') {
-        {
-            const manifestKey = id;
-            const manifestEntry = assetsManifest[manifestKey];
-            if (manifestEntry) {
-                return { manifestEntry, manifestKey };
-            }
-        }
-        // Workaround for what seems to be a Vite bug when process.cwd() !== config.root
-        //  - Manifest key is:
-        //       ../../virtual:vike:page-entry:client:/pages/index
-        //    But it should be this instead:
-        //      virtual:vike:page-entry:client:/pages/index
-        //  - This workaround was implemented to support Vitest running /tests/*
-        //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
-        const manifestKeyEnd = id;
-        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
-        assert(manifestEntry, debugInfo);
-        return { manifestEntry, manifestKey };
-    }
-    // User files
-    if (id.startsWith('/')) {
-        const manifestKey = id.slice(1);
-        let manifestEntry = assetsManifest[manifestKey];
-        assert(manifestEntry, debugInfo);
-        return { manifestEntry, manifestKey };
-    }
-    // npm package import
-    assertIsImportPathNpmPackage(id);
-    const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
-    assert(found);
-    const [manifestKey, manifestEntry] = found;
-    return { manifestEntry, manifestKey };
-    /* Can we remove this?
-    // extensions[number].pageConfigsSrcDir
-    if (id.startsWith('/node_modules/') || id.startsWith('/../')) {
-      let manifestKeyEnd = id.split('/node_modules/').slice(-1)[0]
-      assert(manifestKeyEnd, debugInfo)
-      assert(!manifestKeyEnd.startsWith('/'), debugInfo)
-      manifestKeyEnd = '/' + manifestKeyEnd
-      {
-        const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
-        if (manifestEntry) {
-          assert(manifestKey, debugInfo)
-          return { manifestEntry, manifestKey }
-        }
-      }
-      {
-        assert(manifestKeyEnd.startsWith('/'), debugInfo)
-        const dirS = manifestKeyEnd.split('/')
-        assert(dirS[0] === '', debugInfo)
-        manifestKeyEnd = '/' + dirS.slice(2).join('/')
-        assert(manifestKeyEnd.startsWith('/'), debugInfo)
-      }
-      {
-        const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
-        if (manifestEntry) {
-          assert(manifestKey, debugInfo)
-          return { manifestEntry, manifestKey }
-        }
-      }
-      assert(false, debugInfo)
-    }
-    */
-}
-function findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
-    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
-    assert(manifestKeyEnd.startsWith('/'), debugInfo);
-    const manifestKeys = [];
-    for (const manifestKey in assetsManifest) {
-        if (manifestKey.endsWith(manifestKeyEnd)) {
-            manifestKeys.push(manifestKey);
-        }
-    }
-    const manifestKeysRelative = manifestKeys.filter((k) => k.startsWith('../'));
-    assert(manifestKeysRelative.length <= 1, debugInfo);
-    const manifestKey = manifestKeysRelative[0] ?? manifestKeys[0] ?? null;
-    if (!manifestKey) {
-        return { manifestEntry: null, manifestKey: null };
-    }
-    const manifestEntry = assetsManifest[manifestKey];
-    return { manifestEntry, manifestKey };
-}
-function getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
-    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
-    const manifestKeys = [];
-    for (const manifestKey in assetsManifest) {
-        if (manifestKey.endsWith(manifestKeyEnd)) {
-            manifestKeys.push(manifestKey);
-        }
-    }
-    assert(manifestKeys.length <= 1, debugInfo);
-    const manifestKey = manifestKeys[0];
-    if (!manifestKey) {
-        return { manifestEntry: null, manifestKey: null };
-    }
-    const manifestEntry = assetsManifest[manifestKey];
-    return { manifestEntry, manifestKey };
-}
-function getDebugInfo(id, assetsManifest, manifestKeyEnd) {
-    const manifestKeys = Object.keys(assetsManifest);
-    if (manifestKeyEnd === undefined) {
-        return { manifestKeys, id };
-    }
-    else {
-        return { manifestKeys, manifestKeyEnd, id };
-    }
-}

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

@@ -1,10 +0,0 @@
-export { retrievePageAssetsDev };
-export { setGetClientEntrySrcDev };
-import type { ViteDevServer } from 'vite';
-import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { GetClientEntrySrcDev } from '../../../vite/shared/getClientEntrySrcDev.js';
-declare function retrievePageAssetsDev(viteDevServer: ViteDevServer, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
-    clientEntriesSrc: string[];
-    assetUrls: string[];
-}>;
-declare function setGetClientEntrySrcDev(getClientEntrySrcDev: GetClientEntrySrcDev): void;

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

@@ -1,84 +0,0 @@
-export { retrievePageAssetsDev };
-export { setGetClientEntrySrcDev };
-import { assert, getGlobalObject, styleFileRE } from '../../utils.js';
-import { parseVirtualFileId } from '../../../shared/virtualFileId.js';
-const globalObject = getGlobalObject('getPageAssets/retrievePageAssetsDev.ts', {
-    // We cannot define getClientEntrySrcDev() in this file because it depends on utils/requireResolve.ts which isn't available in production
-    getClientEntrySrcDev: null,
-});
-async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
-    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.getClientEntrySrcDev(clientEntry, viteDevServer));
-    const assetUrls = await getAssetUrls(clientDependencies, viteDevServer);
-    return { clientEntriesSrc, assetUrls };
-}
-function setGetClientEntrySrcDev(getClientEntrySrcDev) {
-    globalObject.getClientEntrySrcDev = getClientEntrySrcDev;
-}
-async function getAssetUrls(clientDependencies, viteDevServer) {
-    const assetUrls = new Set();
-    await Promise.all(clientDependencies.map(async ({ id }) => {
-        if (id.startsWith('@@vike'))
-            return; // vike doesn't have any CSS
-        assert(id);
-        const virtualFile = parseVirtualFileId(id);
-        assert(!virtualFile || virtualFile.type !== 'global-entry');
-        const { moduleGraph } = viteDevServer;
-        const [_, graphId] = await moduleGraph.resolveUrl(id);
-        assert(graphId, { id });
-        const mod = moduleGraph.getModuleById(graphId);
-        if (!mod) {
-            /* Not sure when the assertion fails. So let's just remove it for now.
-             *  - https://github.com/vikejs/vike/issues/391
-            // `moduleGraph` is missing `.page.client.js` files on the very first render
-            assert(id.includes('.page.client.'), { id })
-            */
-            return;
-        }
-        assert(mod, { id });
-        collectCss(mod, assetUrls, new Set());
-    }));
-    return Array.from(assetUrls);
-}
-// Collect the CSS to be injected to the HTML to avoid FLOUC
-//  - We only collect the root import: https://github.com/vikejs/vike/issues/400
-function collectCss(mod, styleUrls, visitedModules, importer) {
-    assert(mod);
-    if (!mod.url)
-        return;
-    if (visitedModules.has(mod.url))
-        return;
-    visitedModules.add(mod.url);
-    const virtualFile = parseVirtualFileId(mod.id || mod.url);
-    if (virtualFile && virtualFile.type === 'global-entry')
-        return; // virtual:vike:global-entry:server dependency list includes all pages
-    if (isStyle(mod) && (!importer || !isStyle(importer))) {
-        if (mod.url.startsWith('/')) {
-            styleUrls.add(mod.url);
-        }
-        else if (mod.url.startsWith('\0')) {
-            // Virtual modules
-            //  - https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
-            //    - I believe some Vite plugins don't respect the \0 virtual module convention. What should we do then?
-            //  - https://github.com/vikejs/vike/issues/1327
-            //  - https://github.com/vikejs/vike/commit/3f7b9916dddc84e29e2c20d2b0df7211b6f1acbd
-            //  - https://github.com/vikejs/vike/issues/479#issuecomment-1870043943
-            styleUrls.add(`/@id/__x00__${mod.url.substring(1)}`);
-        }
-        else {
-            // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
-            styleUrls.add(`/@id/${mod.url}`);
-        }
-    }
-    mod.importedModules.forEach((dep) => {
-        collectCss(dep, styleUrls, visitedModules, mod);
-    });
-}
-function isStyle(mod) {
-    return (
-    // CSS-in-JS libraries such as [wyw-in-js](https://github.com/vikejs/vike/issues/2039)
-    mod.type === 'css' ||
-        // .css, .less, ...
-        styleFileRE.test(mod.url) ||
-        // CSS of .vue files
-        (mod.id && /\?vue&type=style/.test(mod.id)));
-}

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

@@ -1,10 +0,0 @@
-export { retrievePageAssetsProd };
-export { resolveIncludeAssetsImportedByServer };
-import type { ViteManifest } from '../../../../types/ViteManifest.js';
-import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { ConfigResolved } from '../../../../types/index.js';
-declare function retrievePageAssetsProd(assetsManifest: ViteManifest, clientDependencies: ClientDependency[], clientEntries: string[], config: ConfigResolved): {
-    clientEntriesSrc: string[];
-    assetUrls: string[];
-};
-declare function resolveIncludeAssetsImportedByServer(config: ConfigResolved): boolean;