vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/{plugin/plugins/extractAssetsPlugin.js → vite/plugins/pluginExtractAssets.js}

@@ -2,34 +2,35 @@
 //  - Remove this file then revert this commit: https://github.com/vikejs/vike/commit/805a18974f13420a78fcc30fdd676696e405c3ca
 // Workaround to make client-side bundles include the CSS imports living in server-side-only code.
 //  - This is needed for HTML-only pages, and React Server Components.
-//  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vike build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
-//  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
-export { extractAssetsPlugin };
+//  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:pluginExtractAssets pnpm exec vike build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
+//  - This approach supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
+export { pluginExtractAssets };
 export { extractAssetsRE };
-import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove } from '../utils.js';
-import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtual-files.js';
+import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, } from '../utils.js';
+import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtualFiles.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import pc from '@brillout/picocolors';
-import { handleAssetsManifest_isFixEnabled } from './build/handleAssetsManifest.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { handleAssetsManifest_isFixEnabled } from './pluginBuild/handleAssetsManifest.js';
+import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
+import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
-const debug = createDebugger('vike:extractAssets');
-function extractAssetsPlugin() {
+const debug = createDebugger('vike:pluginExtractAssets');
+function pluginExtractAssets() {
     let config;
     let vikeConfig;
     let isFixEnabled;
     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'`).
+        // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also static files imports e.g. `import logoURL from './logo.svg.js'`).
         {
-            name: 'vike:extractAssets:remove-javaScript',
+            name: 'vike:pluginExtractAssets:remove-javaScript',
             // In dev, things just work. (Because Vite's module graph erroneously conflates the Vite server-side importees with the client-side importees.)
             apply: 'build',
             enforce: 'post',
@@ -40,22 +41,22 @@ function extractAssetsPlugin() {
                 }
                 if (isFixEnabled) {
                     // I'm guessing isFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
-                    assertV1Design(vikeConfig.pageConfigs, true);
+                    assertV1Design(vikeConfig._pageConfigs, true);
                     assert(false);
                 }
-                // TODO/now: add meta.default
-                assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
+                const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
+                assert(includeAssetsImportedByServer);
                 assert(!isViteServerBuild_safe(config, options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
                 debugTransformResult(id, code, importStatements);
                 return rollupSourceMapRemove(code);
-            }
+            },
         },
         // This plugin appends `?extractAssets` to module IDs
         {
-            name: 'vike:extractAssets:append-extractAssets-query',
+            name: 'vike:pluginExtractAssets:append-extractAssets-query',
             apply: 'build',
             // We ensure this plugin to be run before:
             //  - rollup's `alias` plugin; https://github.com/rollup/plugins/blob/5363f55aa1933b6c650832b08d6a54cb9ea64539/packages/alias/src/index.ts
@@ -77,8 +78,8 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(importer)) {
                     return;
                 }
-                // TODO/now: add meta.default
-                assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
+                const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
+                assert(includeAssetsImportedByServer);
                 let resolution = null;
                 try {
                     resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
@@ -115,37 +116,37 @@ function extractAssetsPlugin() {
                     return emptyModule(file, importer);
                 }
                 return appendExtractAssetsQuery(file, importer);
-            }
+            },
         },
         {
-            name: 'vike:extractAssets-3',
+            name: 'vike:pluginExtractAssets-3',
             apply: 'build',
             load(id) {
                 if (!isVirtualFileId(id))
                     return undefined;
                 id = getVirtualFileId(id);
                 if (id === EMPTY_MODULE_ID) {
-                    return '// Erased by vike:extractAssets';
+                    return '// Erased by vike:pluginExtractAssets';
                 }
             },
             config() {
                 if (debug.isActivated) {
                     return { logLevel: 'silent' };
                 }
-            }
+            },
         },
         {
-            name: 'vike:extractAssets-4',
+            name: 'vike:pluginExtractAssets-4',
             async configResolved(config_) {
                 config = config_;
-                vikeConfig = await getVikeConfig(config);
+                vikeConfig = await getVikeConfigInternal();
                 isFixEnabled = handleAssetsManifest_isFixEnabled(config);
                 if (!isFixEnabled) {
                     // https://github.com/vikejs/vike/issues/1060
                     assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
                 }
-            }
-        }
+            },
+        },
     ];
 }
 function emptyModule(file, importer) {

package/dist/esm/node/{plugin/plugins/extractExportNamesPlugin.d.ts → vite/plugins/pluginExtractExportNames.d.ts}

@@ -1,7 +1,7 @@
-export { extractExportNamesPlugin };
+export { pluginExtractExportNames };
 export { isUsingClientRouter };
 export { extractExportNamesRE };
 import type { Plugin } from 'vite';
 declare const extractExportNamesRE: RegExp;
-declare function extractExportNamesPlugin(): Plugin;
+declare function pluginExtractExportNames(): Plugin;
 declare function isUsingClientRouter(): boolean;

package/dist/esm/node/{plugin/plugins/extractExportNamesPlugin.js → vite/plugins/pluginExtractExportNames.js}

@@ -1,17 +1,17 @@
-export { extractExportNamesPlugin };
+export { pluginExtractExportNames };
 export { isUsingClientRouter };
 export { extractExportNamesRE };
-import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove } from '../utils.js';
+import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove, } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_options } from '../shared/isViteServerBuild.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
-const debug = createDebugger('vike:extractExportNames');
-const globalObject = getGlobalObject('plugins/extractExportNamesPlugin.ts', {});
-function extractExportNamesPlugin() {
+const debug = createDebugger('vike:pluginExtractExportNames');
+const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
+function pluginExtractExportNames() {
     let isDev = false;
     return {
-        name: 'vike:extractExportNames',
+        name: 'vike:pluginExtractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
             id = normalizeId(id);
@@ -29,7 +29,7 @@ function extractExportNamesPlugin() {
             if (debug.isActivated) {
                 return { logLevel: 'silent' };
             }
-        }
+        },
     };
 }
 async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
@@ -51,7 +51,7 @@ function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id)
     code += '\n';
     code += `export const exportNames = [${[
         ...exportNames.map((n) => JSON.stringify(n)),
-        ...reExportVarNames.map((varName) => `...${varName}`)
+        ...reExportVarNames.map((varName) => `...${varName}`),
     ].join(', ')}];`;
     code = injectHmr(code, isClientSide, isProduction);
     return code;

package/dist/esm/node/vite/plugins/pluginFileEnv.d.ts

@@ -0,0 +1,3 @@
+export { pluginFileEnv };
+import type { Plugin } from 'vite';
+declare function pluginFileEnv(): Plugin;

package/dist/esm/node/{plugin/plugins/fileEnv.js → vite/plugins/pluginFileEnv.js}

@@ -1,22 +1,22 @@
-export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, joinEnglish, rollupSourceMapRemove } from '../utils.js';
-import { extractAssetsRE } from './extractAssetsPlugin.js';
-import { extractExportNamesRE } from './extractExportNamesPlugin.js';
+export { pluginFileEnv };
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
+import { extractAssetsRE } from './pluginExtractAssets.js';
+import { extractExportNamesRE } from './pluginExtractExportNames.js';
 import pc from '@brillout/picocolors';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
-import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
-function fileEnv() {
+import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
+function pluginFileEnv() {
     let config;
     let viteDevServer;
     return {
-        name: 'vike:fileEnv',
+        name: 'vike:pluginFileEnv',
         load(id, options) {
             // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
             if (!viteDevServer)
                 return;
-            if (!isV1Design(config))
+            if (!isV1Design())
                 return;
             if (skip(id))
                 return;
@@ -44,13 +44,13 @@ function fileEnv() {
             if (!isWrongEnv(id, isServerSide))
                 return;
             const { importers } = this.getModuleInfo(id);
-            // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code splitted.
+            // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
             const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
             // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
             const { exportNames } = await getExportNames(code);
             return rollupSourceMapRemove([
                 `throw new Error(${JSON.stringify(errMsg)});`,
-                ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
+                ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
             ].join('\n'));
         },
         generateBundle() {
@@ -74,7 +74,7 @@ function fileEnv() {
         },
         configureServer(viteDevServer_) {
             viteDevServer = viteDevServer_;
-        }
+        },
     };
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
         if (!isWrongEnv(moduleId, isServerSide))
@@ -98,9 +98,15 @@ function fileEnv() {
             modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
         }
         errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
-        if (importers.length > 0) {
-            const importPaths = importers.map((importer) => getModuleFilePathAbsolute(importer, config));
-            errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
+        {
+            const importPaths = importers
+                .filter((importer) => 
+            // Can be Vike's virtual module: https://github.com/vikejs/vike/issues/2483
+            isFilePathAbsolute(importer))
+                .map((importer) => getModuleFilePathAbsolute(importer, config));
+            if (importPaths.length > 0) {
+                errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
+            }
         }
         if (onlyWarn) {
             errMsg += ' and, therefore, Vike will prevent building your app for production.';

package/dist/esm/node/vite/plugins/pluginPreview.d.ts

@@ -0,0 +1,3 @@
+export { pluginPreview };
+import type { Plugin } from 'vite';
+declare function pluginPreview(): Plugin;

package/dist/esm/node/{plugin/plugins/previewConfig.js → vite/plugins/pluginPreview.js}

@@ -1,29 +1,30 @@
-export { previewConfig };
+export { pluginPreview };
 import { assertUsage, applyPreview } from '../utils.js';
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
-import { logDockerHint } from './devConfig/index.js';
+import { logDockerHint } from './pluginDev.js';
 import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
 import sirv from 'sirv';
-import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
-function previewConfig() {
+import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+function pluginPreview() {
     let config;
-    // let vikeConfig: VikeConfigObject
+    let vikeConfig;
     return {
-        name: 'vike:previewConfig',
+        name: 'vike:pluginPreview',
         apply: applyPreview,
         config(config) {
             return {
                 appType: 'custom',
                 build: {
-                    outDir: resolveOutDir(config)
-                }
+                    outDir: resolveOutDir(config),
+                },
             };
         },
         async configResolved(config_) {
             config = config_;
+            vikeConfig = await getVikeConfigInternal();
             logDockerHint(config.preview.host);
             // vikeConfig = await getVikeConfig(config)
         },
@@ -33,8 +34,7 @@ function previewConfig() {
             config.appType = 'mpa'
             */
             return () => {
-                const prerenderConfigGlobal = resolvePrerenderConfigGlobal(config._vikeConfigObject);
-                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = prerenderConfigGlobal;
+                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
                 assertDist(isPrerenderingEnabledForAllPages);
                 // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
                 addStaticAssetsMiddleware(server.middlewares);
@@ -43,7 +43,7 @@ function previewConfig() {
                 }
                 addStatic404Middleware(server.middlewares);
             };
-        }
+        },
     };
     function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config);

package/dist/esm/node/vite/plugins/pluginReplaceConstants.d.ts

@@ -0,0 +1,3 @@
+export { pluginReplaceConstants };
+import type { Plugin } from 'vite';
+declare function pluginReplaceConstants(): Plugin;

package/dist/esm/node/{plugin/plugins/replaceConstants.js → vite/plugins/pluginReplaceConstants.js}

@@ -1,13 +1,13 @@
-export { replaceConstants };
+export { pluginReplaceConstants };
 import MagicString from 'magic-string';
 import { assert, assertPosixPath } from '../utils.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
 import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
-function replaceConstants() {
+function pluginReplaceConstants() {
     let config;
     return {
-        name: 'vike:replaceConstants',
+        name: 'vike:pluginReplaceConstants',
         enforce: 'post',
         apply: 'build',
         configResolved(config_) {
@@ -34,7 +34,7 @@ function replaceConstants() {
             const constantsMap = [];
             constantsMap.push({
                 constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerBuild_safe(config, options)
+                replacement: !isViteServerBuild_safe(config, options),
             });
             constantsMap.forEach(({ constants, replacement }) => {
                 if (!constants.some((c) => code.includes(c)))
@@ -46,9 +46,9 @@ function replaceConstants() {
                 return null;
             return {
                 code: magicString.toString(),
-                map: magicString.generateMap({ hires: true, source: id })
+                map: magicString.generateMap({ hires: true, source: id }),
             };
-        }
+        },
     };
 }
 // Copied & adapted from:

package/dist/esm/node/vite/plugins/pluginSetGlobalContext.d.ts

@@ -0,0 +1,3 @@
+export { pluginSetGlobalContext };
+import type { Plugin } from 'vite';
+declare function pluginSetGlobalContext(): Plugin[];

package/dist/esm/node/{plugin/plugins/setGlobalContext.js → vite/plugins/pluginSetGlobalContext.js}

@@ -1,26 +1,24 @@
-export { setGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction } from '../../runtime/globalContext.js';
-import { assert, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
-import { reloadVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+export { pluginSetGlobalContext };
+import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction, } from '../../runtime/globalContext.js';
+import { isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
+import { reloadVikeConfig } from '../shared/resolveVikeConfigInternal.js';
 import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
-function setGlobalContext() {
+function pluginSetGlobalContext() {
     let isServerReload = false;
-    let config;
     return [
         {
-            name: 'vike:setGlobalContext:pre',
+            name: 'vike:pluginSetGlobalContext:pre',
             enforce: 'pre',
             // This hook is called not only at server start but also at server restart (a new `viteDevServer` instance is created)
             configureServer: {
                 order: 'pre',
                 handler(viteDevServer) {
-                    assert(config);
                     if (isServerReload)
-                        reloadVikeConfig(config);
+                        reloadVikeConfig();
                     isServerReload = true;
                     setGlobalContext_viteDevServer(viteDevServer);
                     markSetup_viteDevServer();
-                }
+                },
             },
             configurePreviewServer() {
                 markSetup_vitePreviewServer();
@@ -31,20 +29,19 @@ function setGlobalContext() {
                     const isViteDev = isDevCheck(env);
                     setGlobalContext_isProduction(!isViteDev);
                     markSetup_isViteDev(isViteDev);
-                }
-            }
+                },
+            },
         },
         {
-            name: 'vike:setGlobalContext:post',
+            name: 'vike:pluginSetGlobalContext:post',
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                async handler(config_) {
-                    config = config_;
+                async handler(config) {
                     const viteConfigRuntime = getViteConfigRuntime(config);
                     setGlobalContext_viteConfig(config, viteConfigRuntime);
-                }
-            }
-        }
+                },
+            },
+        },
     ];
 }

package/dist/esm/node/vite/plugins/pluginVirtualFiles/debug.js

@@ -0,0 +1,2 @@
+import { createDebugger } from '../../utils.js';
+export const debug = createDebugger('vike:virtualFiles');

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getVirtualFileEntry.d.ts

@@ -0,0 +1,5 @@
+export { getVirtualFileEntry };
+import type { ResolvedConfig } from 'vite';
+declare function getVirtualFileEntry(id: string, options: {
+    ssr?: boolean;
+} | undefined, config: ResolvedConfig, isDev: boolean): Promise<string>;

package/dist/esm/node/{plugin/plugins/importUserCode/getVirtualFileImportUserCode.js → vite/plugins/pluginVirtualFiles/getVirtualFileEntry.js}

@@ -1,22 +1,23 @@
-export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning } from '../../utils.js';
-import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+export { getVirtualFileEntry };
+import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning, } from '../../utils.js';
+import { isVirtualFileIdEntry } from '../../../shared/virtualFiles/virtualFileEntry.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
-import path from 'path';
-import { getVirtualFilePageConfigs } from './v1-design/virtual-files/getVirtualFilePageConfigs.js';
-import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
+import path from 'node:path';
+import { getVirtualFilePageConfigsEager } from './getVirtualFilePageConfigsEager.js';
+import { getVikeConfigInternal, isV1Design as isV1Design_ } from '../../shared/resolveVikeConfigInternal.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_options } from '../../shared/isViteServerBuild.js';
-async function getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev) {
-    const idParsed = isVirtualFileIdImportUserCode(id);
+import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets.js';
+async function getVirtualFileEntry(id, options, config, isDev) {
+    const idParsed = isVirtualFileIdEntry(id);
     assert(idParsed);
     const { isForClientSide, isClientRouting } = idParsed;
     assert(isForClientSide === !isViteServerBuild_options(options));
-    const code = await getCode(config, vikeConfig, isForClientSide, isClientRouting, isDev, id);
+    const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
 }
-async function getCode(config, vikeConfig, isForClientSide, isClientRouting, isDev, id) {
+async function getCode(config, isForClientSide, isClientRouting, isDev, id) {
     const { command } = config;
     assert(command === 'serve' || command === 'build');
     const isBuild = command === 'build';
@@ -25,18 +26,18 @@ async function getCode(config, vikeConfig, isForClientSide, isClientRouting, isD
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
-        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, config, isDev, id);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, isDev, id);
     }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
 }
-function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
+function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild, }) {
     if (!isForClientSide) {
         return {
             includeImport: fileType === '.page.server' || fileType === '.page' || fileType === '.page.route',
             includeExportNames: isPrerendering && isBuild
                 ? fileType === '.page.client' || fileType === '.page.server' || fileType === '.page' // We extensively use `PageFile['exportNames']` while pre-rendering, in order to avoid loading page files unnecessarily, and therefore reducing memory usage.
-                : fileType === '.page.client'
+                : fileType === '.page.client',
         };
     }
     else {
@@ -44,19 +45,19 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         if (!isClientRouting) {
             return {
                 includeImport,
-                includeExportNames: false
+                includeExportNames: false,
             };
         }
         else {
             return {
                 includeImport: includeImport || fileType === '.page.route',
-                includeExportNames: fileType === '.page.client' || fileType === '.page.server' || fileType === '.page'
+                includeExportNames: fileType === '.page.client' || fileType === '.page.server' || fileType === '.page',
             };
         }
     }
 }
-async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, config, isDev, id) {
-    let fileContent = `// Generated by https://github.com/vikejs/vike/blob/main/vike/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.ts
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, isDev, id) {
+    let fileContent = `// Generated by Vike
 
 export const pageFilesLazy = {};
 export const pageFilesEager = {};
@@ -65,13 +66,14 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config)}
+${await getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting)}
 
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
-    const isV1Design = isV1Design_(config);
+    const isV1Design = isV1Design_();
+    const vikeConfig = await getVikeConfigInternal();
     // Old design => no + files => only to enable pre-rendering is setting `vike({prerender})` in vite.config.js
-    const isPrerendering = !!vikeConfig.global.config.prerender;
+    const isPrerendering = !!vikeConfig.config.prerender;
     fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
@@ -80,7 +82,7 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             isForClientSide,
             isClientRouting,
             isPrerendering,
-            isBuild
+            isBuild,
         });
         if (includeImport) {
             fileContent += getGlobs(globRoots, isBuild, fileType, null, isV1Design);
@@ -89,8 +91,7 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
-    // TODO/now: add meta.default
-    const includeAssetsImportedByServer = vikeConfig.global.config.includeAssetsImportedByServer ?? true;
+    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
     if (includeAssetsImportedByServer && isForClientSide) {
         fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
@@ -149,7 +150,7 @@ function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
                     const msg = [
                         "Update to the new V1 design to get rid of Vite's warning:",
                         'The glob option "as" has been deprecated in favour of "query".',
-                        'See https://vike.dev/migration/v1-design for how to migrate.'
+                        'See https://vike.dev/migration/v1-design for how to migrate.',
                     ].join(' ');
                     assertWarning(!isNewViteInterface, msg, { onlyOnce: true });
                 }
@@ -160,15 +161,15 @@ function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
         `${pageFilesVar}['${fileType}'] = ${varName};`,
-        ''
+        '',
     ].join('\n');
 }
 function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
-            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
-        }
+            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot),
+        },
     ];
     return globRoots;
 }

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigLazy.d.ts

@@ -0,0 +1,3 @@
+export { getVirtualFilePageConfigLazy };
+import type { ResolvedConfig } from 'vite';
+declare function getVirtualFilePageConfigLazy(id: string, isDev: boolean, config: ResolvedConfig): Promise<string>;