vike 0.4.159 → 0.4.160-commit-30d535e

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

@@ -8,28 +8,29 @@ const utils_js_1 = require("../../../utils.js");
 const path_1 = __importDefault(require("path"));
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
 const filesystemRouting_js_1 = require("./getVikeConfig/filesystemRouting.js");
-const transpileAndExecuteFile_js_1 = require("./transpileAndExecuteFile.js");
-const replaceImportStatements_js_1 = require("./replaceImportStatements.js");
+const transpileAndExecuteFile_js_1 = require("./getVikeConfig/transpileAndExecuteFile.js");
 const isConfigInvalid_js_1 = require("../../../../runtime/renderPage/isConfigInvalid.js");
 const globalContext_js_1 = require("../../../../runtime/globalContext.js");
 const loggerNotProd_js_1 = require("../../../shared/loggerNotProd.js");
 const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/removeSuperfluousViteLog.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
-const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
 const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
+const getConfigFileExport_js_1 = require("./getConfigFileExport.js");
+const loadFileAtConfigTime_js_1 = require("./getVikeConfig/loadFileAtConfigTime.js");
+const resolveImportPath_js_1 = require("./getVikeConfig/resolveImportPath.js");
+const resolveFilePath_js_1 = require("./getVikeConfig/resolveFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
-const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
-    filesEnv.clear();
+    (0, resolveImportPath_js_1.clearFilesEnvMap)();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -87,108 +88,98 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         }
     });
     let interfaceFilesByLocationId = {};
-    // Config files
-    await Promise.all(configFiles.map(async (filePath) => {
-        const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, []);
-        const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
-        const locationId = (0, filesystemRouting_js_1.getLocationId)(filePath.filePathAbsoluteVite);
-        interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-        interfaceFilesByLocationId[locationId].push(interfaceFile);
-        extendsConfigs.forEach((extendsConfig) => {
-            const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true);
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
-        });
-    }));
-    // Value files
-    await Promise.all(valueFiles.map(async (filePath) => {
-        const configName = getConfigName(filePath.filePathAbsoluteVite);
-        (0, utils_js_1.assert)(configName);
-        const interfaceFile = {
-            filePath,
-            configMap: {
-                [configName]: {}
-            },
-            isConfigFile: false,
-            isValueFile: true,
-            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_js_1.configDefinitionsBuiltIn, configName);
-            if (configDef && isConfigEnv(configDef, configName)) {
-                await loadValueFile(interfaceFile, configName, userRootDir);
-            }
-        }
-        {
-            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePath.filePathAbsoluteVite);
+    await Promise.all([
+        // Config files
+        ...configFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
+            const { configFile, extendsConfigs } = await (0, loadFileAtConfigTime_js_1.loadConfigFile)(filePath, userRootDir, [], false);
+            (0, utils_js_1.assert)(filePath.filePathRelativeToUserRootDir);
+            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir);
+            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[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
+                // /pages/admin/+config.h.js
+        
+                import vikeVue from 'vike-vue/config'
+                // Should only apply to /pages/admin/**
+                export default { extends: [vikeVue] }
+                ```
+                ```js
+                // /pages/marketing/+config.h.js
+        
+                import vikeReact from 'vike-react/config'
+                // Should only apply to /pages/marketing/**
+                export default { extends: [vikeReact] }
+                ```
+                */
+                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            });
+        }),
+        // Value files
+        ...valueFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
+            const configName = getConfigName(filePathRelativeToUserRootDir);
+            (0, utils_js_1.assert)(configName);
+            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir);
+            const interfaceFile = {
+                locationId,
+                filePath,
+                fileExportsByConfigName: {
+                    [configName]: {}
+                },
+                isConfigFile: false,
+                isValueFile: true,
+                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_js_1.configDefinitionsBuiltIn, configName);
+                if (configDef && isConfigEnv(configDef, configName)) {
+                    await (0, loadFileAtConfigTime_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
+                }
+            }
+            {
+                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
+                interfaceFilesByLocationId[locationId].push(interfaceFile);
+            }
+        })
+    ]);
     assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
-function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
-    const configDef = configDefinitionsRelevant[configName];
-    assertConfigExists(configName, Object.keys(configDefinitionsRelevant), filePathToShowToUser);
-    (0, utils_js_1.assert)(configDef);
-    return configDef;
-}
-function getConfigDefinitionOptional(configDefinitions, configName) {
-    return configDefinitions[configName] ?? null;
-}
-async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, true, userRootDir);
-    const { filePathToShowToUser } = interfaceValueFile.filePath;
-    (0, assertExports_js_1.assertExportsOfValueFile)(fileExports, filePathToShowToUser, configName);
-    Object.entries(fileExports).forEach(([exportName, configValue]) => {
-        const configName_ = exportName === 'default' ? configName : exportName;
-        interfaceValueFile.configMap[configName_] = { configValue };
-    });
-}
-async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
-    const f = filePath.filePathAbsoluteFilesystem;
-    if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(filePath, true, userRootDir).then((r) => r.fileExports);
-    }
-    const fileExports = await importedFilesLoaded[f];
-    return fileExports;
-}
-function isConfigEnv(configDef, configName) {
-    const configEnv = configDef.env;
-    if (configDef.cumulative) {
-        // In principle we could lift that requirement (but it requires non-trivial modifications)
-        (0, utils_js_1.assertUsage)(configEnv.config, `Config ${picocolors_1.default.cyan(configName)} needs its ${picocolors_1.default.cyan('env')} to have ${picocolors_1.default.cyan('{ config: true }')} (because ${picocolors_1.default.cyan(configName)} is a ${picocolors_1.default.cyan('cumulative')} config)`);
-    }
-    return !!configEnv.config;
-}
-function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
+function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
+        locationId,
         filePath,
-        configMap: {},
+        fileExportsByConfigName: {},
         isConfigFile: true,
         isValueFile: false,
         isConfigExtend,
         extendsFilePaths
     };
-    const { filePathToShowToUser } = filePath;
-    (0, assertExports_js_1.assertExportsOfConfigFile)(fileExports, filePathToShowToUser);
-    Object.entries(fileExports.default).forEach(([configName, configValue]) => {
-        interfaceFile.configMap[configName] = { configValue };
+    const fileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(fileExports, filePath.filePathToShowToUser);
+    Object.entries(fileExport).forEach(([configName, configValue]) => {
+        interfaceFile.fileExportsByConfigName[configName] = { configValue };
     });
     return interfaceFile;
 }
 /** Show error message upon unknown config */
 function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+    (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.configMap).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+            Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
+                assertConfigExists(configName, Object.keys(configDefinitions), interfaceFile.filePath.filePathToShowToUser);
             });
         });
     });
@@ -238,11 +229,11 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
+    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 configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         // Load value files of custom config-only configs
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
@@ -250,7 +241,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             const { configName } = interfaceFile;
             if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, interfaceFile.filePath.filePathToShowToUser);
+            const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
@@ -258,10 +249,10 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
                 return;
             // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
             (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configName, userRootDir);
+            await (0, loadFileAtConfigTime_js_1.loadValueFile)(interfaceFile, configName, userRootDir);
         }));
-        const configValueSources = {};
-        await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsRelevant)
+        let configValueSources = {};
+        await Promise.all((0, utils_js_1.objectEntries)(configDefinitions)
             .filter(([configName]) => !isGlobalConfig(configName))
             .map(async ([configName, configDef]) => {
             const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
@@ -269,10 +260,12 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
                 return;
             configValueSources[configName] = sources;
         }));
+        configValueSources = sortConfigValueSources(configValueSources, locationId);
+        console.log(JSON.stringify(configValueSources, null, 2));
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitionsRelevant);
-        const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
-        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant);
+        applyEffectsAll(configValueSources, configDefinitions);
+        const configValuesComputed = getComputed(configValueSources, configDefinitions);
+        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitions);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
@@ -301,7 +294,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     (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.configMap);
+    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));
@@ -309,7 +302,7 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     return isAlreadyLoaded;
 }
 function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(Object.entries(interfaceFilesByLocationId)
+    const interfaceFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
         .filter(([locationId]) => {
         return (0, filesystemRouting_js_1.isInherited)(locationId, locationIdPage);
     })
@@ -324,14 +317,14 @@ function getInterfaceFileList(interfaceFilesByLocationId) {
     return interfaceFiles;
 }
 async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const locationIds = Object.keys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = Object.fromEntries(Object.entries(interfaceFilesByLocationId).filter(([locationId]) => {
+    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);
     }));
     // Validate that global configs live in global interface files
     {
         const interfaceFilesGlobalPaths = [];
-        Object.entries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+        (0, utils_js_1.objectEntries)(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             (0, utils_js_1.assert)((0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds));
             interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
                 if (filePathRelativeToUserRootDir) {
@@ -340,9 +333,9 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             });
         });
         const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path_1.default.posix.dirname(p))));
-        Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
             interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.configMap).forEach((configName) => {
+                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:`,
@@ -383,7 +376,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.configMap[configName]);
+        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.fileExportsByConfigName[configName]);
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
         const visited = new WeakSet();
@@ -461,19 +454,21 @@ function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
-    const conf = interfaceFile.configMap[configName];
+    const conf = interfaceFile.fileExportsByConfigName[configName];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
+    const { locationId } = interfaceFile;
     const definedAtConfigFile = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
+    // +client.js
     if (configDef._valueIsFilePath) {
         let definedAt;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
             const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, { definedAt: definedAtConfigFile });
             (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
             valueFilePath = import_.filePathAbsoluteVite;
@@ -488,6 +483,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
+            locationId,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
@@ -496,22 +492,27 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         };
         return configValueSource;
     }
+    // +config.js
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+        // fake import
+        const import_ = (0, resolveImportPath_js_1.resolveImport)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
             const configValueSource = {
+                locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
             };
-            // Load config value
-            if (isConfigEnv(configDef, configName)) {
+            // Load fake import
+            if (isConfigEnv(configDef, configName) &&
+                // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+                configName !== 'extends') {
                 if (import_.filePathAbsoluteFilesystem) {
                     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExports[import_.fileExportName];
+                    const fileExport = await (0, loadFileAtConfigTime_js_1.loadImportedFile)(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExport;
                 }
                 else {
                     const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
@@ -520,20 +521,22 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
             return configValueSource;
         }
-        else {
-            const configValueSource = {
-                value: configValue,
-                configEnv,
-                valueIsImportedAtRuntime: false,
-                definedAt: definedAtConfigFile
-            };
-            return configValueSource;
-        }
+        // Defined by config file, i.e. +config.js file
+        const configValueSource = {
+            locationId,
+            value: configValue,
+            configEnv,
+            valueIsImportedAtRuntime: false,
+            definedAt: definedAtConfigFile
+        };
+        return configValueSource;
     }
-    else if (interfaceFile.isValueFile) {
+    // Defined by value file, i.e. +{configName}.js
+    if (interfaceFile.isValueFile) {
         const valueAlreadyLoaded = 'configValue' in conf;
         (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
+            locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             definedAt: {
@@ -551,25 +554,9 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     (0, utils_js_1.assert)(false);
 }
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
-    if (!filesEnv.has(filePathForEnvCheck)) {
-        filesEnv.set(filePathForEnvCheck, []);
-    }
-    const fileEnv = filesEnv.get(filePathForEnvCheck);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
-    if (configDifferentEnv) {
-        (0, utils_js_1.assertUsage)(false, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
-        ].join('\n'));
-    }
-}
 function isDefiningPage(interfaceFiles) {
     for (const interfaceFile of interfaceFiles) {
-        const configNames = Object.keys(interfaceFile.configMap);
+        const configNames = Object.keys(interfaceFile.fileExportsByConfigName);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -579,90 +566,13 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
-    if (typeof configValue !== 'string')
-        return null;
-    const importData = (0, replaceImportStatements_js_1.parseImportData)(configValue);
-    if (!importData)
-        return null;
-    const { importPath, exportName } = importData;
-    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
-    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    if (importPath.startsWith('.')) {
-        // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
-        // ```
-        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
-        // ```
-        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
-    }
-    else {
-        // importPath can be:
-        //  - an npm package import
-        //  - a path alias
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir: null,
-            filePathAbsoluteVite: importPath,
-            filePathToShowToUser: importPath,
-            importPathAbsolute: importPath
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
-    }
-}
-function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    let filePathRelativeToUserRootDir;
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${picocolors_1.default.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
-        // None of the following works. Seems to be a Vite bug?
-        // /*
-        // assert(filePathAbsoluteFilesystem.startsWith('/'))
-        // filePath = `/@fs${filePathAbsoluteFilesystem}`
-        // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
-        // assert(filePathRelativeToUserRootDir.startsWith('../'))
-        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
-        // //*/
-    }
-    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
-    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
-}
-function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPosixPath)(root);
-    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(root));
-    let vitePath = path_1.default.posix.relative(root, filePathAbsoluteFilesystem);
-    (0, utils_js_1.assert)(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
-    vitePath = '/' + vitePath;
-    return vitePath;
-}
 function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitions = { ...configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn };
-    Object.entries(interfaceFilesRelevant).forEach(([_locationId, interfaceFiles]) => {
+    const configDefinitionsMerged = { ...configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn };
+    Object.entries(interfaceFilesRelevant)
+        .reverse()
+        .forEach(([_locationId, interfaceFiles]) => {
         interfaceFiles.forEach((interfaceFile) => {
-            const configMeta = interfaceFile.configMap['meta'];
+            const configMeta = interfaceFile.fileExportsByConfigName['meta'];
             if (!configMeta)
                 return;
             const meta = configMeta.configValue;
@@ -679,13 +589,14 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             });
             (0, utils_js_1.objectEntries)(meta).forEach(([configName, configDefinition]) => {
                 // User can override an existing config definition
-                configDefinitions[configName] = {
-                    ...configDefinitions[configName],
+                configDefinitionsMerged[configName] = {
+                    ...configDefinitionsMerged[configName],
                     ...configDefinition
                 };
             });
         });
     });
+    const configDefinitions = configDefinitionsMerged;
     return configDefinitions;
 }
 function assertMetaValue(metaVal, configMetaDefinedAt) {
@@ -724,8 +635,8 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
-    (0, utils_js_1.objectEntries)(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+function applyEffectsAll(configValueSources, configDefinitions) {
+    (0, utils_js_1.objectEntries)(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef.effect)
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
@@ -784,9 +695,9 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         }
     });
 }
-function getComputed(configValueSources, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitions) {
     const configValuesComputed = {};
-    (0, utils_js_1.objectEntries)(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+    (0, utils_js_1.objectEntries)(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
         const value = configDef._computed(configValueSources);
@@ -801,15 +712,7 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
     const files = await (0, crawlPlusFiles_js_1.crawlPlusFiles)(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-    });
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => (0, resolveFilePath_js_1.resolveFilePathRelativeToUserRootDir)(filePathRelativeToUserRootDir, userRootDir));
     // TODO/v1-release: remove
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -845,125 +748,22 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsoluteFilesystem } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
-        ...visited,
-        filePathAbsoluteFilesystem
-    ]);
-    const configFile = {
-        fileExports,
-        filePath: configFilePath,
-        extendsFilePaths
-    };
-    return { configFile, extendsConfigs };
-}
-function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
-    const idx = visited.indexOf(filePathAbsoluteFilesystem);
-    if (idx === -1)
-        return;
-    const loop = visited.slice(idx);
-    (0, utils_js_1.assert)(loop[0] === filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertUsage)(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
-}
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
-    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
-    const extendsConfigFiles = [];
-    extendsImportData.map((importData) => {
-        const { importPath: importPath } = importData;
-        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
-        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
-        assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
-        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
-        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
-        extendsConfigFiles.push({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteVite,
-            filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathAbsoluteVite,
-            importPathAbsolute: importPath
-        });
-    });
-    const extendsConfigs = [];
-    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
-        const result = await loadConfigFile(configFilePath, userRootDir, visited);
-        extendsConfigs.push(result.configFile);
-        extendsConfigs.push(...result.extendsConfigs);
-    }));
-    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
-    return { extendsConfigs, extendsFilePaths };
-}
-function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPosixPath)(userRootDir);
-    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        return null;
-    }
-    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
-    if (!filePathRelativeToUserRootDir.startsWith('/'))
-        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
-    return filePathRelativeToUserRootDir;
-}
-function assertExtendsImportPath(importPath, filePath, configFilePath) {
-    if ((0, utils_js_1.isNpmPackageImport)(importPath)) {
-        const fileDir = path_1.default.posix.dirname(filePath) + '/';
-        const fileName = path_1.default.posix.basename(filePath);
-        const fileNameBaseCorrect = '+config';
-        const [fileNameBase, ...fileNameRest] = fileName.split('.');
-        const fileNameCorrect = [fileNameBaseCorrect, ...fileNameRest].join('.');
-        (0, utils_js_1.assertWarning)(fileNameBase === fileNameBaseCorrect, `Rename ${fileName} to ${fileNameCorrect} in ${fileDir}`, {
-            onlyOnce: true
-        });
-    }
-    else {
-        (0, utils_js_1.assertWarning)(false, `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this feature.`, { onlyOnce: true });
-    }
-}
-function getExtendsImportData(configFileExports, configFilePath) {
-    const { filePathToShowToUser } = configFilePath;
-    (0, assertExports_js_1.assertExportsOfConfigFile)(configFileExports, filePathToShowToUser);
-    const defaultExports = configFileExports.default;
-    const wrongUsage = `${filePathToShowToUser} sets the config ${picocolors_1.default.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
-    let extendList;
-    if (!('extends' in defaultExports)) {
-        return [];
-    }
-    else if ((0, utils_js_1.hasProp)(defaultExports, 'extends', 'string')) {
-        extendList = [defaultExports.extends];
-    }
-    else if ((0, utils_js_1.hasProp)(defaultExports, 'extends', 'string[]')) {
-        extendList = defaultExports.extends;
-    }
-    else {
-        (0, utils_js_1.assertUsage)(false, wrongUsage);
-    }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = (0, replaceImportStatements_js_1.parseImportData)(importDataSerialized);
-        (0, utils_js_1.assertUsage)(importData, wrongUsage);
-        return importData;
-    });
-    return extendsImportData;
-}
-function isGlobalConfig(configName) {
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return (0, utils_js_1.arrayIncludes)(configNamesGlobal, configName);
-}
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal);
-}
-function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
-    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
-    if (configNames.includes(configName))
-        return;
-    handleUnknownConfig(configName, configNames, filePathToShowToUser);
-    (0, utils_js_1.assert)(false);
-}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/
 function handleUnknownConfig(configName, configNames, filePathToShowToUser) {
     let errMsg = `${filePathToShowToUser} defines an unknown config ${picocolors_1.default.cyan(configName)}`;
     let configNameSimilar = null;
@@ -1030,37 +830,11 @@ function determineIsErrorPage(routeFilesystem) {
     (0, utils_js_1.assertPosixPath)(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
-    const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
-    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
-    return filePathAbsoluteFilesystem;
-}
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} exist?`);
-        }
-    }
-}
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
 exports.isVikeConfigFile = isVikeConfigFile;
-function getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant) {
+function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
     const configValues = {};
     Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
         configValues[configName] = {
@@ -1069,7 +843,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
         };
     });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitionsRelevant[configName];
+        const configDef = configDefinitions[configName];
         (0, utils_js_1.assert)(configDef);
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
@@ -1183,3 +957,48 @@ function getConfigEnvValue(val, errMsgIntro) {
     */
     return val;
 }
+function getConfigDefinition(configDefinitions, configName, filePathToShowToUser) {
+    const configDef = configDefinitions[configName];
+    assertConfigExists(configName, Object.keys(configDefinitions), filePathToShowToUser);
+    (0, utils_js_1.assert)(configDef);
+    return configDef;
+}
+function getConfigDefinitionOptional(configDefinitions, configName) {
+    return configDefinitions[configName] ?? null;
+}
+function isConfigEnv(configDef, configName) {
+    const configEnv = configDef.env;
+    if (configDef.cumulative) {
+        // In principle we could lift that requirement (but it requires non-trivial modifications)
+        (0, utils_js_1.assertUsage)(configEnv.config, `Config ${picocolors_1.default.cyan(configName)} needs its ${picocolors_1.default.cyan('env')} to have ${picocolors_1.default.cyan('{ config: true }')} (because ${picocolors_1.default.cyan(configName)} is a ${picocolors_1.default.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
+}
+function isGlobalConfig(configName) {
+    if (configName === 'prerender')
+        return false;
+    const configNamesGlobal = getConfigNamesGlobal();
+    return (0, utils_js_1.arrayIncludes)(configNamesGlobal, configName);
+}
+function getConfigNamesGlobal() {
+    return Object.keys(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal);
+}
+function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
+    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
+    if (configNames.includes(configName))
+        return;
+    handleUnknownConfig(configName, configNames, filePathToShowToUser);
+    (0, utils_js_1.assert)(false);
+}
+function sortConfigValueSources(configValueSources, locationIdPage) {
+    return Object.fromEntries(Object.entries(configValueSources)
+        // Make order deterministic (no other purpose)
+        .sort(([, [source1]], [, [source2]]) => source1.definedAt.filePathAbsoluteVite < source2.definedAt.filePathAbsoluteVite ? -1 : 1)
+        // Sort after whether the config value was defined by an npm package
+        .sort((0, utils_js_1.makeFirst)(([, [source]]) => {
+        const { importPathAbsolute } = source.definedAt;
+        return !!importPathAbsolute && (0, utils_js_1.isNpmPackageImport)(importPathAbsolute);
+    }))
+        // 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))));
+}