vike 0.4.220-commit-a9f46b8 → 0.4.220-commit-5c7810f

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

@@ -9,7 +9,9 @@ exports.getVikeConfig2 = getVikeConfig2;
 exports.reloadVikeConfig = reloadVikeConfig;
 exports.isVikeConfigFile = isVikeConfigFile;
 exports.isV1Design = isV1Design;
-exports.getConfigValueInterfaceFile = getConfigValueInterfaceFile;
+exports.getConfVal = getConfVal;
+exports.getConfigDefinitionOptional = getConfigDefinitionOptional;
+exports.shouldBeLoadableAtBuildTime = shouldBeLoadableAtBuildTime;
 const utils_js_1 = require("../../../utils.js");
 const path_1 = __importDefault(require("path"));
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
@@ -114,7 +116,7 @@ async function loadInterfaceFiles(userRootDir) {
             valueFiles.push(f);
         }
     });
-    let interfaceFilesByLocationId = {};
+    let interfaceFilesAll = {};
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
@@ -124,8 +126,8 @@ async function loadInterfaceFiles(userRootDir) {
             (0, utils_js_1.assert)(filePath.filePathAbsoluteUserRootDir);
             const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathAbsoluteUserRootDir);
             const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
-            interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
+            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
+            interfaceFilesAll[locationId].push(interfaceFile);
             extendsConfigs.forEach((extendsConfig) => {
                 /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
                 ```js
@@ -145,7 +147,7 @@ async function loadInterfaceFiles(userRootDir) {
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
                 (0, assertExtensions_js_1.assertExtensionsConventions)(interfaceFile);
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
+                interfaceFilesAll[locationId].push(interfaceFile);
             });
         }),
         // Value files
@@ -158,30 +160,21 @@ async function loadInterfaceFiles(userRootDir) {
             const interfaceFile = {
                 locationId,
                 filePath,
-                fileExportsByConfigName: {
-                    [configName]: {}
-                },
                 isConfigFile: false,
                 isValueFile: true,
+                isValueLoaded: false,
                 configName
             };
-            {
-                // We don't have access to the custom config definitions defined by the user yet.
-                //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
-                //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-                const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-                if (configDef && isLoadableAtBuildTime(configDef)) {
-                    await (0, loadFileAtConfigTime_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
-                }
-            }
-            {
-                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
-            }
+            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
+            interfaceFilesAll[locationId].push(interfaceFile);
+            // We don't have access to the custom config definitions defined by the user yet.
+            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
+            await (0, loadFileAtConfigTime_js_1.loadValueFile)(interfaceFile, configDefinitionsBuiltIn, userRootDir);
         })
     ]);
-    assertAllConfigsAreKnown(interfaceFilesByLocationId);
-    return interfaceFilesByLocationId;
+    assertAllConfigsAreKnown(interfaceFilesAll);
+    return interfaceFilesAll;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -191,23 +184,27 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId)
         fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
+        isValueLoaded: true,
         isConfigExtend,
         extendsFilePaths
     };
     const fileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(fileExports, filePath.filePathToShowToUser);
     Object.entries(fileExport).forEach(([configName, configValue]) => {
-        interfaceFile.fileExportsByConfigName[configName] = { configValue };
+        interfaceFile.fileExportsByConfigName[configName] = configValue;
     });
     return interfaceFile;
 }
 /** Show error message upon unknown config */
-function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+function assertAllConfigsAreKnown(interfaceFilesAll) {
+    (0, utils_js_1.objectEntries)(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
+            const configNamesKnown = Object.keys(configDefinitions);
+            const { filePathToShowToUser } = interfaceFile.filePath;
+            const configNames = getDefiningConfigNames(interfaceFile);
+            configNames.forEach((configName) => {
+                assertConfigExists(configName, configNamesKnown, filePathToShowToUser);
             });
         });
     });
@@ -246,9 +243,9 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                 pageConfigs: [],
                 pageConfigGlobal: {
                     configDefinitions: {},
+                    interfaceFiles: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
                 global: (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues: {} })
             };
             return dummyData;
@@ -256,49 +253,86 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
+    const interfaceFilesAll = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const [globalConfigs, pageConfigs] = await Promise.all([
-        getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions),
-        getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded)
-    ]);
-    return { pageConfigs, ...globalConfigs };
+    const { pageConfigGlobal, pageConfigs } = await getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded);
+    // interop vike(options) in vite.config.js
+    temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
+    // global
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues });
+    return { pageConfigs, pageConfigGlobal, global };
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesByLocationId).filter(([locationId]) => {
-        return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
-    }));
+async function getGlobalConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    /* TODO/now: dedupe
     // Validate that global configs live in global interface files
     {
-        const interfaceFilesGlobalPaths = [];
-        (0, utils_js_1.objectEntries)(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-            (0, utils_js_1.assert)((0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-                if (filePathAbsoluteUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
-                }
-            });
-        });
-        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path_1.default.posix.dirname(p))));
-        (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!(0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds) && isGlobalConfig(configName)) {
-                        (0, utils_js_1.assertUsage)(false, [
-                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${picocolors_1.default.cyan(configName)} which is global:`,
-                            globalPaths.length
-                                ? `define ${picocolors_1.default.cyan(configName)} in ${(0, utils_js_1.joinEnglish)(globalPaths, 'or')} instead`
-                                : `create a global config (e.g. /pages/+config.js) and define ${picocolors_1.default.cyan(configName)} there instead`
-                        ].join(' '));
-                    }
-                });
-            });
-        });
+      const interfaceFilesGlobalPaths: string[] = []
+      objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+        assert(isGlobalLocation(locationId, locationIds))
+        interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+          if (filePathAbsoluteUserRootDir) {
+            interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir)
+          }
+        })
+      })
+      const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))))
+      objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        interfaceFiles.forEach((interfaceFile) => {
+          Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
+            if (!isGlobalLocation(locationId, locationIds) && isGlobalConfigOld(configName)) {
+              assertUsage(
+                false,
+                [
+                  `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(
+                    configName
+                  )} which is global:`,
+                  globalPaths.length
+                    ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
+                    : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
+                ].join(' ')
+              )
+            }
+          })
+        })
+      })
     }
-    const pageConfigGlobalValues = {};
+    //*/
+}
+function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(vikeVitePluginOptions));
+    (0, utils_js_1.assertWarning)(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${picocolors_1.default.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+        var _a;
+        (0, utils_js_1.assert)((0, utils_js_1.includes)((0, utils_js_1.objectKeys)(configDefinitionsBuiltInGlobal), configName));
+        const configDef = configDefinitionsBuiltInGlobal[configName];
+        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        sources.push({
+            value,
+            configEnv: configDef.env,
+            definedAtFilePath: {
+                ...(0, getFilePath_js_1.getFilePathResolved)({
+                    userRootDir,
+                    filePathAbsoluteUserRootDir: '/vite.config.js'
+                }),
+                fileExportPathToShowToUser: null
+            },
+            locationId: '/',
+            interfaceFile: null,
+            isOverriden: configDef.cumulative ? false : sources.length > 0,
+            valueIsImportedAtRuntime: false,
+            valueIsDefinedByPlusFile: false
+        });
+    });
+}
+async function getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesAll);
+    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesAll).filter(([locationId]) => {
+        return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
+    }));
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
+        interfaceFiles: interfaceFilesGlobal,
         configValueSources: {}
     };
     await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -307,75 +341,17 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         if (!configValueSource)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
-        // TODO/now
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            (0, utils_js_1.assert)(!('value' in configValueSource));
-        }
-        else {
-            (0, utils_js_1.assert)('value' in configValueSource);
-            // TODO/now
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            pageConfigGlobalValues[configName] = configValueSource.value;
-        }
     }));
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
-    {
-        (0, utils_js_1.assert)((0, utils_js_1.isObject)(vikeVitePluginOptions));
-        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-            var _a;
-            (0, utils_js_1.assert)((0, utils_js_1.includes)((0, utils_js_1.objectKeys)(configDefinitionsBuiltInGlobal), configName));
-            const configDef = configDefinitionsBuiltInGlobal[configName];
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.push({
-                value,
-                configEnv: configDef.env,
-                definedAtFilePath: {
-                    ...(0, getFilePath_js_1.getFilePathResolved)({
-                        userRootDir,
-                        filePathAbsoluteUserRootDir: '/vite.config.js'
-                    }),
-                    fileExportPathToShowToUser: null
-                },
-                locationId: '/',
-                isOverriden: configDef.cumulative ? false : sources.length > 0,
-                valueIsImportedAtRuntime: false,
-                valueIsDefinedByPlusFile: false
-            });
-        });
-    }
-    const configValues = getConfigValues(pageConfigGlobal);
-    const global = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues });
-    return { pageConfigGlobal, vikeConfigGlobal, global };
-}
-async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const pageConfigs = await Promise.all((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
-        .map(async ([locationId]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);
-        (0, assertExtensions_js_1.assertExtensionsPeerDependencies)(interfaceFilesRelevantList);
+    const pageConfigs = [];
+    await Promise.all(getPageLocationIds(interfaceFilesAll).map(async (locationId) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        // Load value files of custom config-only configs
-        await Promise.all(interfaceFilesRelevantList.map(async (interfaceFile) => {
-            if (!interfaceFile.isValueFile)
-                return;
-            const { configName } = interfaceFile;
-            if (isGlobalConfig(configName))
-                return;
-            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!isLoadableAtBuildTime(configDef))
-                return;
-            const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
-            if (isAlreadyLoaded)
-                return;
-            // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
-            (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn));
-            await (0, loadFileAtConfigTime_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
-        }));
+        // Load value files (with `env.config===true`) of *custom* configs.
+        // - The value files of *built-in* configs are already loaded at `loadInterfaceFiles()`.
+        await (0, loadFileAtConfigTime_js_1.loadValueFiles)(interfaceFilesRelevant, configDefinitions, userRootDir);
         let configValueSources = {};
         await Promise.all((0, utils_js_1.objectEntries)(configDefinitions)
-            .filter(([configName]) => !isGlobalConfig(configName))
+            .filter(([configName]) => !isGlobalConfigOld(configName))
             .map(async ([configName, configDef]) => {
             const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
             if (sources.length === 0)
@@ -386,53 +362,43 @@ async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedF
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitions);
         const configValuesComputed = getComputed(configValueSources, configDefinitions);
-        assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
             configDefinitions,
+            interfaceFiles: interfaceFilesRelevant,
             configValueSources,
             configValuesComputed
         };
-        return pageConfig;
+        pageConfigs.push(pageConfig);
     }));
-    assertPageConfigs(pageConfigs);
-    return pageConfigs;
+    assertPageConfigs(pageConfigs, interfaceFilesAll);
+    return { pageConfigs, pageConfigGlobal };
 }
-function getConfigValues(pageConfig) {
-    const configValues = {};
-    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
-        if (entry.configValueBase.type === 'computed') {
-            (0, utils_js_1.assert)('value' in entry); // Help TS
-            const { configValueBase, value, configName } = entry;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'standard') {
-            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
-            const { configValueBase, sourceRelevant, configName } = entry;
-            (0, utils_js_1.assert)('value' in sourceRelevant);
-            const { value } = sourceRelevant;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'cumulative') {
-            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
-            const { configValueBase, sourcesRelevant, configName } = entry;
-            const values = [];
-            sourcesRelevant.forEach((source) => {
-                (0, utils_js_1.assert)('value' in source);
-                values.push(source.value);
-            });
-            configValues[configName] = { ...configValueBase, value: values };
+function getPageLocationIds(interfaceFilesAll) {
+    const locationIds = new Set();
+    (0, utils_js_1.objectEntries)(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        if (isDefiningPage(interfaceFiles)) {
+            locationIds.add(locationId);
         }
     });
-    return configValues;
+    return Array.from(locationIds);
+}
+function assertPageConfigs(pageConfigs, interfaceFilesAll) {
+    pageConfigs.forEach((pageConfig) => {
+        assertGlobalConfigs(pageConfig, interfaceFilesAll);
+        (0, assertExtensions_js_1.assertExtensionsRequire)(pageConfig);
+        assertOnBeforeRenderEnv(pageConfig);
+    });
 }
 // TODO/now: refactor
-//  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
+//  - Dedupe: most of the assertGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
 //    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
 // Global configs should be defined at global locations
-function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId) {
+function assertGlobalConfigs(pageConfig, interfaceFilesAll) {
+    const interfaceFilesRelevantList = Object.values(pageConfig.interfaceFiles).flat(1);
+    const { configDefinitions } = pageConfig;
     interfaceFilesRelevantList.forEach((interfaceFile) => {
         const configNames = [];
         if (interfaceFile.isValueFile) {
@@ -442,13 +408,13 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
             configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
         }
         configNames.forEach((configName) => {
-            if (isGlobalConfig(configName))
+            if (isGlobalConfigOld(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (configDef.global === true) {
-                const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesByLocationId);
+                const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesAll);
                 if (!(0, filesystemRouting_js_1.isGlobalLocation)(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesByLocationId).filter(([locationId]) => {
+                    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesAll).filter(([locationId]) => {
                         return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
                     }));
                     const configFilesGlobal = [];
@@ -474,11 +440,6 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
         });
     });
 }
-function assertPageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        assertOnBeforeRenderEnv(pageConfig);
-    });
-}
 function assertOnBeforeRenderEnv(pageConfig) {
     const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
     if (!onBeforeRenderConfig)
@@ -488,16 +449,36 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     (0, utils_js_1.assertUsage)(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${picocolors_1.default.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
-function interfacefileIsAlreaydLoaded(interfaceFile) {
-    const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
-    const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
-    if (isAlreadyLoaded) {
-        (0, utils_js_1.assert)(configMapValues.every((conf) => 'configValue' in conf));
-    }
-    return isAlreadyLoaded;
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            (0, utils_js_1.assert)('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            (0, utils_js_1.assert)('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                (0, utils_js_1.assert)('value' in source);
+                values.push(source.value);
+            });
+            configValues[configName] = { ...configValueBase, value: values };
+        }
+    });
+    return configValues;
 }
-function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
+function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
+    const interfaceFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(interfaceFilesAll)
         .filter(([locationId]) => {
         return (0, filesystemRouting_js_1.isInherited)(locationId, locationIdPage);
     })
@@ -508,7 +489,7 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
     const sourcesInfo = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
     for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
-        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.fileExportsByConfigName[configName]);
+        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => getDefiningConfigNames(interfaceFile).includes(configName));
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
         const visited = new WeakSet();
@@ -595,9 +576,12 @@ function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
-    const conf = interfaceFile.fileExportsByConfigName[configName];
-    (0, utils_js_1.assert)(conf);
-    const { locationId } = interfaceFile;
+    const confVal = getConfVal(interfaceFile, configName);
+    (0, utils_js_1.assert)(confVal);
+    const configValueSourceCommon = {
+        locationId: interfaceFile.locationId,
+        interfaceFile
+    };
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -609,7 +593,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             // Defined over pointer import
-            const resolved = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
+            (0, utils_js_1.assert)(confVal.configValueLoaded);
+            const resolved = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(confVal.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
             const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, definedAtFilePath_);
             (0, utils_js_1.assertUsage)(resolved, `${configDefinedAt} should be an import`);
             valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
@@ -625,7 +610,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -638,13 +623,13 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // +config.js
     if (interfaceFile.isConfigFile) {
-        (0, utils_js_1.assert)('configValue' in conf);
-        const { configValue } = conf;
+        (0, utils_js_1.assert)(confVal.configValueLoaded);
+        const { configValue } = confVal;
         // Defined over pointer import
         const resolved = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
         if (resolved) {
             const configValueSource = {
-                locationId,
+                ...configValueSourceCommon,
                 configEnv: resolved.configEnvResolved,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
@@ -652,7 +637,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 definedAtFilePath: resolved.pointerImport
             };
             // Load pointer import
-            if (isLoadableAtBuildTime(configDef) &&
+            if (shouldBeLoadableAtBuildTime(configDef) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
                 if (resolved.pointerImport.filePathAbsoluteFilesystem) {
@@ -668,7 +653,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined inside +config.js
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -681,10 +666,10 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     // Defined by value file, i.e. +{configName}.js
     if (interfaceFile.isValueFile) {
         const configEnvResolved = (0, resolvePointerImport_js_1.resolveConfigEnvWithFileName)(configDef.env, interfaceFile.filePath);
-        const valueAlreadyLoaded = 'configValue' in conf;
+        const valueAlreadyLoaded = confVal.configValueLoaded;
         (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
@@ -698,7 +683,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
         };
         if (valueAlreadyLoaded) {
-            configValueSource.value = conf.configValue;
+            configValueSource.value = confVal.configValue;
         }
         return configValueSource;
     }
@@ -706,7 +691,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
 }
 function isDefiningPage(interfaceFiles) {
     for (const interfaceFile of interfaceFiles) {
-        const configNames = Object.keys(interfaceFile.fileExportsByConfigName);
+        const configNames = getDefiningConfigNames(interfaceFile);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -716,16 +701,28 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
+function getDefiningConfigNames(interfaceFile) {
+    let configNames = [];
+    if (interfaceFile.isValueFile) {
+        configNames.push(interfaceFile.configName);
+    }
+    if (interfaceFile.isValueLoaded) {
+        configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
+    }
+    configNames = (0, utils_js_1.unique)(configNames);
+    return configNames;
+}
 function getConfigDefinitions(interfaceFilesRelevant) {
     const configDefinitionsMerged = { ...configDefinitionsBuiltIn };
     Object.entries(interfaceFilesRelevant)
         .reverse()
         .forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
-            if (!configMeta)
+            const confVal = getConfVal(interfaceFile, 'meta');
+            if (!confVal)
                 return;
-            const meta = configMeta.configValue;
+            (0, utils_js_1.assert)(confVal.configValueLoaded);
+            const meta = confVal.configValue;
             assertMetaUsage(meta, `Config ${picocolors_1.default.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
@@ -1042,16 +1039,28 @@ function getConfigDefinition(configDefinitions, configName, filePathToShowToUser
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-function isLoadableAtBuildTime(configDef) {
+function shouldBeLoadableAtBuildTime(configDef) {
     return !!configDef.env.config && !configDef._valueIsFilePath;
 }
-function isGlobalConfig(configName) {
+// TODO/now: remove
+function isGlobalConfigOld(configName) {
     // TODO/now
     if (configName === 'prerender')
         return false;
     const configNamesGlobal = getConfigNamesGlobal();
     return (0, utils_js_1.includes)(configNamesGlobal, configName);
 }
+// TODO/now
+function isGlobalConfig(configName, configDefinitions, value) {
+    const configSpec = configDefinitions[configName];
+    (0, utils_js_1.assert)(configSpec);
+    const globalValue = configSpec.global;
+    if (!globalValue)
+        return false;
+    if (globalValue === true)
+        return true;
+    return globalValue(value);
+}
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
@@ -1084,38 +1093,12 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => (0, utils_js_1.reverse)((0, filesystemRouting_js_1.sortAfterInheritanceOrder)(source1.locationId, source2.locationId, locationIdPage))));
 }
-function getConfigValueInterfaceFile(interfaceFile, configName) {
-    return interfaceFile.fileExportsByConfigName[configName]?.configValue;
-}
-// TODO/now: refactor code below
-function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
-    const configs = [vikeVitePluginOptions, pageConfigGlobalValues];
-    const vikeConfigGlobal = {
-        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
-        prerender: resolvePrerenderOptions(configs),
-        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
-        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
-        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
-        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
-        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
-    };
-    return vikeConfigGlobal;
-}
-function resolvePrerenderOptions(configs) {
-    if (!configs.some((c) => c.prerender)) {
-        return false;
-    }
-    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
-    return {
-        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
-    };
-}
-function isObject2(p) {
-    return typeof p === 'object';
-}
-function pickFirst(arr) {
-    return arr.filter((v) => v !== undefined)[0];
+function getConfVal(interfaceFile, configName) {
+    const configNames = getDefiningConfigNames(interfaceFile);
+    if (!configNames.includes(configName))
+        return null;
+    if (!interfaceFile.isValueLoaded)
+        return { configValueLoaded: false };
+    const confVal = { configValue: interfaceFile.fileExportsByConfigName[configName], configValueLoaded: true };
+    return confVal;
 }