vike 0.4.247 → 0.4.248

package/dist/server/runtime/renderPageServer/getHttpResponseBody.js

@@ -0,0 +1,132 @@
+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/server/runtime/renderPageServer/getPageAssets/getManifestEntry.js

@@ -0,0 +1,123 @@
+export { getManifestEntry };
+import { assert, slice, assertIsImportPathNpmPackage } from '../../../utils.js';
+import { parseVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
+import { prependEntriesDir } from '../../../../shared-server-node/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/server/runtime/renderPageServer/getPageAssets/retrievePageAssetsDev.d.ts

@@ -0,0 +1,10 @@
+export { retrievePageAssetsDev };
+export { setGetClientEntrySrcDev };
+import type { ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../../shared-server-client/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { GetClientEntrySrcDev } from '../../../../node/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/server/runtime/renderPageServer/getPageAssets/retrievePageAssetsDev.js

@@ -0,0 +1,84 @@
+export { retrievePageAssetsDev };
+export { setGetClientEntrySrcDev };
+import { assert, getGlobalObject, styleFileRE } from '../../../utils.js';
+import { parseVirtualFileId } from '../../../../shared-server-node/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/server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.d.ts

@@ -0,0 +1,10 @@
+export { retrievePageAssetsProd };
+export { resolveIncludeAssetsImportedByServer };
+import type { ViteManifest } from '../../../../types/ViteManifest.js';
+import type { ClientDependency } from '../../../../shared-server-client/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;

package/dist/server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js

@@ -0,0 +1,75 @@
+export { retrievePageAssetsProd };
+export { resolveIncludeAssetsImportedByServer };
+import { assert, isImportPathNpmPackage } from '../../../utils.js';
+import { getManifestEntry } from './getManifestEntry.js';
+import { extractAssetsAddQuery } from '../../../../shared-server-node/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/server/runtime/renderPageServer/getPageAssets/sortPageAssetsForEarlyHintsHeader.js

@@ -0,0 +1,34 @@
+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/server/runtime/renderPageServer/getPageAssets.d.ts

@@ -0,0 +1,18 @@
+export { getPageAssets };
+export type { PageAsset };
+export type { GetPageAssets };
+import { type MediaType } from './inferMediaType.js';
+import type { ClientDependency } from '../../../shared-server-client/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/server/runtime/renderPageServer/getPageAssets.js

@@ -0,0 +1,48 @@
+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/server/runtime/renderPageServer/handleErrorWithoutErrorPage.d.ts

@@ -0,0 +1,12 @@
+export { handleErrorWithoutErrorPage };
+import type { GlobalContextServerInternal } from '../globalContext.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 & {
+    httpResponse: import("./createHttpResponse.js").HttpResponse;
+}>;

package/dist/server/runtime/renderPageServer/handleErrorWithoutErrorPage.js

@@ -0,0 +1,36 @@
+export { handleErrorWithoutErrorPage };
+import { stringify } from '@brillout/json-serializer/stringify';
+import { assert, assertWarning, objectAssign } from '../../utils.js';
+import { createHttpResponsePage, createHttpResponseErrorFallback } 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;
+        warnMissingErrorPage(isV1, pageContext._globalContext._isProduction);
+    }
+    if (!pageContext.isClientSideNavigation) {
+        const httpResponse = createHttpResponseErrorFallback(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;
+    }
+}
+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/server/runtime/renderPageServer/handlePageContextRequestUrl.js

@@ -0,0 +1,67 @@
+export { handlePageContextRequestUrl };
+import { pageContextJsonFileExtension, doNotCreateExtraDirectory, } from '../../../shared-server-client/getPageContextRequestUrl.js';
+import { modifyUrl } from '../../../shared-server-client/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);
+        // @ts-ignore
+        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;
+}