vike 0.4.161-commit-ba539a4 → 0.4.161-commit-6a208ab

package/dist/esm/node/plugin/plugins/envVars.js

@@ -3,6 +3,7 @@ export { envVarsPlugin };
 export { applyEnvVar };
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
+import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -62,8 +63,11 @@ function envVarsPlugin() {
                 // Apply
                 code = applyEnvVar(envName, envVal, code);
             });
-            // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
-            return code;
+            // Line numbers didn't change.
+            //  - We only break the column number of a couple of lines, wich is acceptable.
+            //  - Anyways, I'm not even sure Vite supports high-resolution column number source mapping.
+            const ret = sourceMapPassthrough(code);
+            return ret;
         }
     };
 }

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -11,10 +11,11 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import pc from '@brillout/picocolors';
 import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertV1Design } from '../../shared/assertV1Design.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -25,6 +26,7 @@ const debugEnabled = isDebugEnabled(debugNamespace);
 function extractAssetsPlugin() {
     let config;
     let configVike;
+    let vikeConfig;
     let isServerAssetsFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
@@ -37,14 +39,18 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
-                assert(!isServerAssetsFixEnabled);
+                if (isServerAssetsFixEnabled) {
+                    // I'm guessing isServerAssetsFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
+                    assertV1Design(true, vikeConfig.pageConfigs);
+                    assert(false);
+                }
                 assert(configVike.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
                 debugTransformResult(id, code, importStatements);
-                return removeSourceMap(code);
+                return sourceMapRemove(code);
             }
         },
         // This plugin appends `?extractAssets` to module IDs
@@ -135,6 +141,7 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 configVike = await getConfigVike(config_);
                 config = config_;
+                vikeConfig = await getVikeConfig(config, false);
                 isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
             },
             load(id) {

package/dist/esm/node/plugin/plugins/extractExportNamesPlugin.js

@@ -3,7 +3,7 @@ export { isUsingClientRouter };
 export { extractExportNamesRE };
 import { assert, getFileExtension, viteIsSSR_options, createDebugger, isDebugEnabled, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debugNamespace = 'vike:extractExportNames';
 const debug = createDebugger(debugNamespace);
@@ -38,7 +38,7 @@ async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
         globalObject.usesClientRouter = true;
     }
     const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
-    return removeSourceMap(code);
+    return sourceMapRemove(code);
 }
 function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
     let code = '';

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

@@ -1,5 +1,4 @@
 export { getVikeManifest };
-import { ResolvedConfig } from 'vite';
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
-declare function getVikeManifest(config: ResolvedConfig, configVike: ConfigVikeResolved): PluginManifest;
+declare function getVikeManifest(configVike: ConfigVikeResolved): PluginManifest;

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -1,32 +1,15 @@
 export { getVikeManifest };
-import { projectInfo, toPosixPath, assertPosixPath, isNotNullish } from '../../utils.js';
+import { projectInfo } from '../../utils.js';
 import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
-import path from 'path';
 import { getRuntimeManifest } from '../../../runtime/globalContext.js';
-function getVikeManifest(config, configVike) {
+function getVikeManifest(configVike) {
     const runtimeManifest = getRuntimeManifest(configVike);
     const manifest = {
         version: projectInfo.projectVersion,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
-        manifestKeyMap: getManifestKeyMap(configVike, config),
         ...runtimeManifest
     };
     assertPluginManifest(manifest);
     return manifest;
 }
-function getManifestKeyMap(configVike, config) {
-    const manifestKeyMap = {};
-    configVike.extensions
-        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-        .flat()
-        .filter(isNotNullish)
-        .forEach(({ importPath, filePath }) => {
-        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
-        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
-        assertPosixPath(filePathRelative);
-        assertPosixPath(importPath);
-        manifestKeyMap[importPath] = filePathRelative;
-    });
-    return manifestKeyMap;
-}

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -34,7 +34,7 @@ function importBuild() {
 }
 function getEntryCode(config, configVike) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(config, configVike);
+    const vikeManifest = getVikeManifest(configVike);
     const importerCode = [
         `  import { setImportBuildGetters } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,10 +1,10 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob, getOutDirs } from '../../utils.js';
+import { assert, assertPosixPath, viteIsSSR_options, scriptFileExtensions, debugGlob, getOutDirs, isVersionOrAbove } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
+import { version as viteVersion } from 'vite';
+import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
-import { generateEagerImport } from './generateEagerImport.js';
 async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
@@ -21,53 +21,13 @@ async function getCode(config, configVike, isForClientSide, isClientRouting, isP
     assert(isDev === !isBuild);
     let content = '';
     {
-        const globRoots = getGlobRoots(config, configVike);
+        const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
         content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
     }
-    {
-        const extensionsImportPaths = configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(isNotNullish)
-            .map(({ importPath }) => importPath);
-        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
-    }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
 }
-function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
-    let fileContent = '\n\n';
-    extensionsImportPaths
-        .filter((importPath) => {
-        assert(
-        // V1 design
-        importPath.includes('+') ||
-            // V0.4 design
-            importPath.includes('.page.'));
-        return !importPath.includes('+');
-    })
-        .forEach((importPath) => {
-        const fileType = determineFileType(importPath);
-        const { includeImport, includeExportNames } = determineInjection({
-            fileType,
-            isForClientSide,
-            isClientRouting,
-            isPrerendering,
-            isBuild
-        });
-        if (includeImport) {
-            fileContent += addImport(importPath, fileType, false, isBuild);
-        }
-        if (includeExportNames) {
-            fileContent += addImport(importPath, fileType, true, isBuild);
-        }
-        if (!includeImport && !includeExportNames && !isForClientSide) {
-            fileContent += `pageFilesList.push("${importPath}");` + '\n';
-        }
-    });
-    return fileContent;
-}
 function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
     if (!isForClientSide) {
         return {
@@ -93,42 +53,6 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-function addImport(importPath, fileType, exportNames, isBuild) {
-    const pageFilesVar = (() => {
-        if (exportNames) {
-            if (isBuild) {
-                return 'pageFilesExportNamesEager';
-            }
-            else {
-                return 'pageFilesExportNamesLazy';
-            }
-        }
-        else {
-            if (fileType === '.page.route') {
-                return 'pageFilesEager';
-            }
-            else {
-                return 'pageFilesLazy';
-            }
-        }
-    })();
-    const query = !exportNames ? '' : '?extractExportNames';
-    let fileContent = '';
-    const mapVar = `${pageFilesVar}['${fileType}']`;
-    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
-    const value = (() => {
-        if (!pageFilesVar.endsWith('Eager')) {
-            return `() => import('${importPath}${query}')`;
-        }
-        else {
-            const { importName, importStatement } = generateEagerImport(`${importPath}${query}`);
-            fileContent += importStatement + '\n';
-            return importName;
-        }
-    })();
-    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
-    return fileContent;
-}
 async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
     let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
 
@@ -206,10 +130,15 @@ function getGlobs(globRoots, isBuild, fileType, query) {
             varNameLocals.push(varNameLocal);
             const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
-            const globOptions = JSON.stringify({ eager: isEager, as: query });
-            assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globOptions = { eager: isEager };
+            if (isVersionOrAbove(viteVersion, '5.1.0')) {
+                globOptions.as = query;
+            }
+            else {
+                globOptions.query = `?${query}`;
+            }
             const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${JSON.stringify(globOptions)});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -217,22 +146,13 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ''
     ].join('\n');
 }
-function getGlobRoots(config, configVike) {
+function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
             excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
         }
     ];
-    configVike.extensions
-        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
-        .filter(isNotNullish)
-        .forEach((pageConfigsSrcDir) => {
-        const globRoot = {
-            includeDir: path.posix.relative(config.root, pageConfigsSrcDir)
-        };
-        globRoots.push(globRoot);
-    });
     return globRoots;
 }
 function getGlobPath(globRootDir, fileType) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -3,6 +3,7 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
+export type { VikeConfig };
 export type { InterfaceValueFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -72,7 +72,9 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
     return await vikeConfigPromise;
 }
 async function isV1Design(config, isDev) {
-    const isV1Design = (await getVikeConfig(config, isDev)).pageConfigs.length > 0;
+    const vikeConfig = await getVikeConfig(config, isDev);
+    const { pageConfigs } = vikeConfig;
+    const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {

package/dist/esm/node/plugin/plugins/setGlobalContext.js

@@ -1,5 +1,5 @@
 export { setGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_vitePreviewServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { setGlobalContext_viteDevServer } from '../../runtime/globalContext.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -9,20 +9,6 @@ function setGlobalContext() {
             handler(viteDevServer) {
                 setGlobalContext_viteDevServer(viteDevServer);
             }
-        },
-        configurePreviewServer: {
-            order: 'pre',
-            handler(vitePreviewServer) {
-                setGlobalContext_vitePreviewServer(
-                // Type cast won't be necessary after https://github.com/vitejs/vite/pull/14119 is released in Vite 5
-                vitePreviewServer);
-            }
-        },
-        configResolved: {
-            order: 'pre',
-            handler(config) {
-                setGlobalContext_viteConfig(config);
-            }
         }
     };
 }

package/dist/esm/node/plugin/shared/rollupSourceMap.d.ts

@@ -0,0 +1,14 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+/** Remove entire source mapping, to save KBs. */
+declare function sourceMapRemove(code: string): {
+    code: string;
+    map: {
+        mappings: '';
+    };
+};
+/** Don't provide any source map, pass through current source map instead. */
+declare function sourceMapPassthrough(code: string): {
+    code: string;
+    map: null;
+};

package/dist/esm/node/plugin/shared/rollupSourceMap.js

@@ -0,0 +1,17 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+// https://rollupjs.org/guide/en/#source-code-transformations
+/** Remove entire source mapping, to save KBs. */
+function sourceMapRemove(code) {
+    return {
+        code,
+        map: { mappings: '' }
+    };
+}
+/** Don't provide any source map, pass through current source map instead. */
+function sourceMapPassthrough(code) {
+    return {
+        code,
+        map: null
+    };
+}

package/dist/esm/node/prerender/runPrerender.js

@@ -10,7 +10,7 @@ import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext } from '../runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext, setGlobalContext_prerender } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
@@ -62,6 +62,7 @@ async function runPrerender(options, manuallyTriggered) {
     handleNodeEnv();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
+    setGlobalContext_prerender(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
     const { outDirClient, outDirRoot } = getOutDirs(viteConfig);

package/dist/esm/node/runtime/globalContext.d.ts

@@ -3,11 +3,10 @@ export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
 export { setGlobalContext_viteDevServer };
-export { setGlobalContext_vitePreviewServer };
-export { setGlobalContext_viteConfig };
+export { setGlobalContext_prerender };
 export { getRuntimeManifest };
 import type { ViteManifest } from '../shared/ViteManifest.js';
-import type { ResolvedConfig, ViteDevServer, PreviewServer as VitePreviewServer } from 'vite';
+import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
@@ -22,9 +21,7 @@ type GlobalContext = {
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
-    configVike: ConfigVikeResolved;
     viteDevServer: ViteDevServer;
-    vitePreviewServer: null;
     clientManifest: null;
     pluginManifest: null;
 } | ({
@@ -32,21 +29,17 @@ type GlobalContext = {
     clientManifest: ViteManifest;
     pluginManifest: PluginManifest;
     viteDevServer: null;
-    vitePreviewServer: null | VitePreviewServer;
 } & ({
     isPrerendering: false;
     viteConfig: null;
-    configVike: null;
 } | {
     isPrerendering: true;
     viteConfig: ResolvedConfig;
-    configVike: ConfigVikeResolved;
 })));
 declare function getGlobalContext(): GlobalContext;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
-declare function setGlobalContext_vitePreviewServer(vitePreviewServer: VitePreviewServer): void;
 declare function getViteDevServer(): ViteDevServer | null;
-declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig): void;
+declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;
 declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext(isPrerendering?: boolean, outDir?: string): Promise<void>;
 declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;

package/dist/esm/node/runtime/globalContext.js

@@ -3,8 +3,7 @@ export { getGlobalContext };
 export { getViteDevServer };
 export { getViteConfig };
 export { setGlobalContext_viteDevServer };
-export { setGlobalContext_vitePreviewServer };
-export { setGlobalContext_viteConfig };
+export { setGlobalContext_prerender };
 export { getRuntimeManifest };
 import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
@@ -22,18 +21,14 @@ function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
     assert(!globalObject.globalContext);
-    globalObject.viteDevServer = viteDevServer;
-}
-function setGlobalContext_vitePreviewServer(vitePreviewServer) {
-    if (globalObject.vitePreviewServer)
-        return;
     assert(!globalObject.globalContext);
-    globalObject.vitePreviewServer = vitePreviewServer;
+    globalObject.viteConfig = viteDevServer.config;
+    globalObject.viteDevServer = viteDevServer;
 }
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
 }
-function setGlobalContext_viteConfig(viteConfig) {
+function setGlobalContext_prerender(viteConfig) {
     if (globalObject.viteConfig)
         return;
     assert(!globalObject.globalContext);
@@ -45,13 +40,12 @@ function getViteConfig() {
 async function initGlobalContext(isPrerendering = false, outDir) {
     if (globalObject.globalContext)
         return;
-    const { viteDevServer, vitePreviewServer, viteConfig } = globalObject;
+    const { viteDevServer, viteConfig } = globalObject;
     assertNodeEnv(!!viteDevServer);
     const isProduction = !viteDevServer;
     if (!isProduction) {
         assert(viteConfig);
         assert(!isPrerendering);
-        assert(!vitePreviewServer);
         const configVike = await getConfigVike(viteConfig);
         const pluginManifest = getRuntimeManifest(configVike);
         globalObject.globalContext = {
@@ -60,9 +54,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             clientManifest: null,
             pluginManifest: null,
             viteDevServer,
-            vitePreviewServer: null,
             viteConfig,
-            configVike,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -83,7 +75,6 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             clientManifest,
             pluginManifest,
             viteDevServer: null,
-            vitePreviewServer: vitePreviewServer ?? null,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -97,16 +88,14 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             assert(configVike);
             objectAssign(globalContext, {
                 isPrerendering: true,
-                viteConfig,
-                configVike
+                viteConfig
             });
             globalObject.globalContext = globalContext;
         }
         else {
             objectAssign(globalContext, {
                 isPrerendering: false,
-                viteConfig: null,
-                configVike: null
+                viteConfig: null
             });
             globalObject.globalContext = globalContext;
         }

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

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import type { ViteManifest, ViteManifestEntry } from '../../../shared/ViteManifest.js';
-declare function getManifestEntry(id: string, clientManifest: ViteManifest, manifestKeyMap: Record<string, string>): {
+declare function getManifestEntry(id: string, clientManifest: ViteManifest): {
     manifestKey: string;
     manifestEntry: ViteManifestEntry;
 };

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

@@ -3,9 +3,7 @@ import { assert, slice, isNpmPackageImport } from '../../utils.js';
 import { assertClientEntryId } from './assertClientEntryId.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
-function getManifestEntry(id, clientManifest, 
-// TODO: remove
-manifestKeyMap) {
+function getManifestEntry(id, clientManifest) {
     assertClientEntryId(id);
     const debugInfo = getDebugInfo(id, clientManifest);
     // Vike client entry

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

@@ -1,4 +1,4 @@
 export { retrieveAssetsProd };
 import type { ViteManifest } from '../../../shared/ViteManifest.js';
 import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean, manifestKeyMap: Record<string, string>): string[];
+declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];

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

@@ -2,7 +2,7 @@ export { retrieveAssetsProd };
 import { assert, isNpmPackageImport } from '../../utils.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer, manifestKeyMap) {
+function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImportedByServer) {
     let assetUrls = new Set();
     assert(clientManifest);
     const visistedAssets = new Set();
@@ -19,7 +19,7 @@ function retrieveAssetsProd(clientDependencies, clientManifest, includeAssetsImp
                 id = extractAssetsAddQuery(id);
             }
         }
-        const { manifestKey } = getManifestEntry(id, clientManifest, manifestKeyMap);
+        const { manifestKey } = getManifestEntry(id, clientManifest);
         collectAssets(manifestKey, assetUrls, visistedAssets, clientManifest, onlyAssets);
     });
     collectSingleStyle(assetUrls, clientManifest);

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

@@ -14,15 +14,14 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
-        const { viteDevServer, configVike } = globalContext;
-        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer, configVike)));
+        const { viteDevServer } = globalContext;
+        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer)));
         assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
     }
     else {
-        const { pluginManifest, clientManifest } = globalContext;
-        const manifestKeyMap = pluginManifest.manifestKeyMap;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap));
-        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer, manifestKeyMap);
+        const { clientManifest } = globalContext;
+        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest));
+        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer);
     }
     let pageAssets = [];
     unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
@@ -56,7 +55,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     sortPageAssetsForEarlyHintsHeader(pageAssets);
     return pageAssets;
 }
-async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
+async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     assertClientEntryId(clientEntry);
     let root = viteDevServer.config.root;
     assert(root);
@@ -117,8 +116,8 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
     assertPosixPath(filePath);
     return filePath;
 }
-function resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap) {
-    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest, manifestKeyMap);
+function resolveClientEntriesProd(clientEntry, clientManifest) {
+    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest);
     assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
     let { file } = manifestEntry;
     assert(!file.startsWith('/'));