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

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

@@ -4,8 +4,10 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
-export { getConfigValueInterfaceFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
+export { getConfVal };
+export { getConfigDefinitionOptional };
+export { shouldBeLoadableAtBuildTime };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse, unique } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -18,11 +20,11 @@ import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
-import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
+import { loadConfigFile, loadImportedFile, loadValueFile, loadValueFiles } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
+import { assertExtensionsRequire, assertExtensionsConventions } from './assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
@@ -108,7 +110,7 @@ async function loadInterfaceFiles(userRootDir) {
             valueFiles.push(f);
         }
     });
-    let interfaceFilesByLocationId = {};
+    let interfaceFilesAll = {};
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
@@ -118,8 +120,8 @@ async function loadInterfaceFiles(userRootDir) {
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = 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
@@ -139,7 +141,7 @@ async function loadInterfaceFiles(userRootDir) {
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
                 assertExtensionsConventions(interfaceFile);
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
+                interfaceFilesAll[locationId].push(interfaceFile);
             });
         }),
         // Value files
@@ -152,30 +154,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 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 loadValueFile(interfaceFile, configDefinitionsBuiltIn, userRootDir);
         })
     ]);
-    assertAllConfigsAreKnown(interfaceFilesByLocationId);
-    return interfaceFilesByLocationId;
+    assertAllConfigsAreKnown(interfaceFilesAll);
+    return interfaceFilesAll;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -185,23 +178,27 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId)
         fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
+        isValueLoaded: true,
         isConfigExtend,
         extendsFilePaths
     };
     const fileExport = 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) {
-    objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+function assertAllConfigsAreKnown(interfaceFilesAll) {
+    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);
             });
         });
     });
@@ -240,9 +237,9 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                 pageConfigs: [],
                 pageConfigGlobal: {
                     configDefinitions: {},
+                    interfaceFiles: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
                 global: getPageConfigUserFriendlyNew({ configValues: {} })
             };
             return dummyData;
@@ -250,49 +247,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 = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, global };
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = objectKeys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
-    }));
+async function getGlobalConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    /* TODO/now: dedupe
     // Validate that global configs live in global interface files
     {
-        const interfaceFilesGlobalPaths = [];
-        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(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(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 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) {
+    assert(isObject(vikeVitePluginOptions));
+    assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+        var _a;
+        assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
+        const configDef = configDefinitionsBuiltInGlobal[configName];
+        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        sources.push({
+            value,
+            configEnv: configDef.env,
+            definedAtFilePath: {
+                ...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 = objectKeys(interfaceFilesAll);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
+        return isGlobalLocation(locationId, locationIds);
+    }));
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
+        interfaceFiles: interfaceFilesGlobal,
         configValueSources: {}
     };
     await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -301,75 +335,17 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         if (!configValueSource)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
-        // TODO/now
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            assert(!('value' in configValueSource));
-        }
-        else {
-            assert('value' in configValueSource);
-            // TODO/now
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            pageConfigGlobalValues[configName] = configValueSource.value;
-        }
     }));
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
-    {
-        assert(isObject(vikeVitePluginOptions));
-        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-            var _a;
-            assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
-            const configDef = configDefinitionsBuiltInGlobal[configName];
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.push({
-                value,
-                configEnv: configDef.env,
-                definedAtFilePath: {
-                    ...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 = getPageConfigUserFriendlyNew({ configValues });
-    return { pageConfigGlobal, vikeConfigGlobal, global };
-}
-async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
-        .map(async ([locationId]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(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()
-            assert(!(configName in configDefinitionsBuiltIn));
-            await 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 loadValueFiles(interfaceFilesRelevant, configDefinitions, userRootDir);
         let configValueSources = {};
         await Promise.all(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)
@@ -380,53 +356,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 = {};
-    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
-        if (entry.configValueBase.type === 'computed') {
-            assert('value' in entry); // Help TS
-            const { configValueBase, value, configName } = entry;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'standard') {
-            assert('sourceRelevant' in entry); // Help TS
-            const { configValueBase, sourceRelevant, configName } = entry;
-            assert('value' in sourceRelevant);
-            const { value } = sourceRelevant;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'cumulative') {
-            assert('sourcesRelevant' in entry); // Help TS
-            const { configValueBase, sourcesRelevant, configName } = entry;
-            const values = [];
-            sourcesRelevant.forEach((source) => {
-                assert('value' in source);
-                values.push(source.value);
-            });
-            configValues[configName] = { ...configValueBase, value: values };
+function getPageLocationIds(interfaceFilesAll) {
+    const locationIds = new Set();
+    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);
+        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) {
@@ -436,13 +402,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 = objectKeys(interfaceFilesByLocationId);
+                const locationIds = objectKeys(interfaceFilesAll);
                 if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
                         return isGlobalLocation(locationId, locationIds);
                     }));
                     const configFilesGlobal = [];
@@ -468,11 +434,6 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
         });
     });
 }
-function assertPageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        assertOnBeforeRenderEnv(pageConfig);
-    });
-}
 function assertOnBeforeRenderEnv(pageConfig) {
     const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
     if (!onBeforeRenderConfig)
@@ -482,16 +443,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
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.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) {
-        assert(configMapValues.every((conf) => 'configValue' in conf));
-    }
-    return isAlreadyLoaded;
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            assert('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                assert('value' in source);
+                values.push(source.value);
+            });
+            configValues[configName] = { ...configValueBase, value: values };
+        }
+    });
+    return configValues;
 }
-function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
+function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
+    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesAll)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
@@ -502,7 +483,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();
@@ -589,9 +570,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];
-    assert(conf);
-    const { locationId } = interfaceFile;
+    const confVal = getConfVal(interfaceFile, configName);
+    assert(confVal);
+    const configValueSourceCommon = {
+        locationId: interfaceFile.locationId,
+        interfaceFile
+    };
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -603,7 +587,8 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             // Defined over pointer import
-            const resolved = resolvePointerImportOfConfig(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
+            assert(confVal.configValueLoaded);
+            const resolved = resolvePointerImportOfConfig(confVal.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
             assertUsage(resolved, `${configDefinedAt} should be an import`);
             valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
@@ -619,7 +604,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -632,13 +617,13 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // +config.js
     if (interfaceFile.isConfigFile) {
-        assert('configValue' in conf);
-        const { configValue } = conf;
+        assert(confVal.configValueLoaded);
+        const { configValue } = confVal;
         // Defined over pointer import
         const resolved = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
         if (resolved) {
             const configValueSource = {
-                locationId,
+                ...configValueSourceCommon,
                 configEnv: resolved.configEnvResolved,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
@@ -646,7 +631,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) {
@@ -662,7 +647,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined inside +config.js
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -675,10 +660,10 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     // Defined by value file, i.e. +{configName}.js
     if (interfaceFile.isValueFile) {
         const configEnvResolved = resolveConfigEnvWithFileName(configDef.env, interfaceFile.filePath);
-        const valueAlreadyLoaded = 'configValue' in conf;
+        const valueAlreadyLoaded = confVal.configValueLoaded;
         assert(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
@@ -692,7 +677,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
         };
         if (valueAlreadyLoaded) {
-            configValueSource.value = conf.configValue;
+            configValueSource.value = confVal.configValue;
         }
         return configValueSource;
     }
@@ -700,7 +685,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;
         }
@@ -710,16 +695,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 = 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;
+            assert(confVal.configValueLoaded);
+            const meta = confVal.configValue;
             assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
@@ -1036,16 +1033,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 includes(configNamesGlobal, configName);
 }
+// TODO/now
+function isGlobalConfig(configName, configDefinitions, value) {
+    const configSpec = configDefinitions[configName];
+    assert(configSpec);
+    const globalValue = configSpec.global;
+    if (!globalValue)
+        return false;
+    if (globalValue === true)
+        return true;
+    return globalValue(value);
+}
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
@@ -1078,38 +1087,12 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(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;
 }