vike 0.4.159 → 0.4.160-commit-30d535e

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

@@ -2,31 +2,32 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, mergeCumulativeValues, requireResolve, getOutDirs, deepEqual, assertKeys } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, mergeCumulativeValues, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTmpFile, transpileAndExecuteFile } from './transpileAndExecuteFile.js';
-import { parseImportData } from './replaceImportStatements.js';
+import { isTmpFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
-import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
+import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
+import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
+import { resolveFilePathRelativeToUserRootDir } from './getVikeConfig/resolveFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
-    filesEnv.clear();
+    clearFilesEnvMap();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -82,108 +83,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 = 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);
-        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, configName);
-            if (configDef && isConfigEnv(configDef, configName)) {
-                await loadValueFile(interfaceFile, configName, userRootDir);
-            }
-        }
-        {
-            const locationId = getLocationId(filePath.filePathAbsoluteVite);
+    await Promise.all([
+        // Config files
+        ...configFiles.map(async (filePath) => {
+            const { filePathRelativeToUserRootDir } = filePath;
+            assert(filePathRelativeToUserRootDir);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
+            assert(filePath.filePathRelativeToUserRootDir);
+            const locationId = 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;
+            assert(filePathRelativeToUserRootDir);
+            const configName = getConfigName(filePathRelativeToUserRootDir);
+            assert(configName);
+            const locationId = 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, configName);
+                if (configDef && isConfigEnv(configDef, configName)) {
+                    await 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);
-    assert(configDef);
-    return configDef;
-}
-function getConfigDefinitionOptional(configDefinitions, configName) {
-    return configDefinitions[configName] ?? null;
-}
-async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
-    const { filePathToShowToUser } = interfaceValueFile.filePath;
-    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] = 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)
-        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.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;
-    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
-    Object.entries(fileExports.default).forEach(([configName, configValue]) => {
-        interfaceFile.configMap[configName] = { configValue };
+    const fileExport = 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]) => {
+    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);
             });
         });
     });
@@ -233,11 +224,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(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)
@@ -245,7 +236,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);
@@ -255,8 +246,8 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             assert(!(configName in configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
-        const configValueSources = {};
-        await Promise.all(objectEntries(configDefinitionsRelevant)
+        let configValueSources = {};
+        await Promise.all(objectEntries(configDefinitions)
             .filter(([configName]) => !isGlobalConfig(configName))
             .map(async ([configName, configDef]) => {
             const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
@@ -264,10 +255,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,
@@ -296,7 +289,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     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.configMap);
+    const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
     if (isAlreadyLoaded) {
         assert(configMapValues.every((conf) => 'configValue' in conf));
@@ -304,7 +297,7 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     return isAlreadyLoaded;
 }
 function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(Object.entries(interfaceFilesByLocationId)
+    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
@@ -319,14 +312,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 = objectKeys(interfaceFilesByLocationId);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
     }));
     // Validate that global configs live in global interface files
     {
         const interfaceFilesGlobalPaths = [];
-        Object.entries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             assert(isGlobalLocation(locationId, locationIds));
             interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
                 if (filePathRelativeToUserRootDir) {
@@ -335,9 +328,9 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             });
         });
         const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
-        Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
             interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.configMap).forEach((configName) => {
+                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:`,
@@ -378,7 +371,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();
@@ -456,13 +449,15 @@ 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];
     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;
@@ -483,6 +478,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
+            locationId,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
@@ -491,22 +487,27 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         };
         return configValueSource;
     }
+    // +config.js
     if (interfaceFile.isConfigFile) {
         assert('configValue' in conf);
         const { configValue } = conf;
+        // fake import
         const import_ = 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) {
                     assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
-                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
-                    configValueSource.value = fileExports[import_.fileExportName];
+                    const fileExport = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExport;
                 }
                 else {
                     const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
@@ -515,20 +516,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;
         assert(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
+            locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             definedAt: {
@@ -546,25 +549,9 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     assert(false);
 }
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    assertPosixPath(filePathForEnvCheck);
-    if (!filesEnv.has(filePathForEnvCheck)) {
-        filesEnv.set(filePathForEnvCheck, []);
-    }
-    const fileEnv = filesEnv.get(filePathForEnvCheck);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
-    if (configDifferentEnv) {
-        assertUsage(false, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.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;
         }
@@ -574,90 +561,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 = 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) {
-    assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir;
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
-    }
-    else {
-        assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.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
-        // //*/
-    }
-    assertPosixPath(filePathRelativeToUserRootDir);
-    assert(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
-}
-function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(root);
-    assert(filePathAbsoluteFilesystem.startsWith(root));
-    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
-    assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
-    vitePath = '/' + vitePath;
-    return vitePath;
-}
 function getConfigDefinitions(interfaceFilesRelevant) {
-    const configDefinitions = { ...configDefinitionsBuiltIn };
-    Object.entries(interfaceFilesRelevant).forEach(([_locationId, interfaceFiles]) => {
+    const configDefinitionsMerged = { ...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;
@@ -674,13 +584,14 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             });
             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) {
@@ -719,8 +630,8 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+function applyEffectsAll(configValueSources, configDefinitions) {
+    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.
@@ -779,9 +690,9 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         }
     });
 }
-function getComputed(configValueSources, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitions) {
     const configValuesComputed = {};
-    objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
+    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
         const value = configDef._computed(configValueSources);
@@ -796,15 +707,7 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-    });
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
     // TODO/v1-release: remove
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -840,125 +743,22 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsoluteFilesystem } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await 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);
-    assert(loop[0] === filePathAbsoluteFilesystem);
-    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) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    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 (isNpmPackageImport(importPath)) {
-        const fileDir = path.posix.dirname(filePath) + '/';
-        const fileName = path.posix.basename(filePath);
-        const fileNameBaseCorrect = '+config';
-        const [fileNameBase, ...fileNameRest] = fileName.split('.');
-        const fileNameCorrect = [fileNameBaseCorrect, ...fileNameRest].join('.');
-        assertWarning(fileNameBase === fileNameBaseCorrect, `Rename ${fileName} to ${fileNameCorrect} in ${fileDir}`, {
-            onlyOnce: true
-        });
-    }
-    else {
-        assertWarning(false, `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.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;
-    assertExportsOfConfigFile(configFileExports, filePathToShowToUser);
-    const defaultExports = configFileExports.default;
-    const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
-    let extendList;
-    if (!('extends' in defaultExports)) {
-        return [];
-    }
-    else if (hasProp(defaultExports, 'extends', 'string')) {
-        extendList = [defaultExports.extends];
-    }
-    else if (hasProp(defaultExports, 'extends', 'string[]')) {
-        extendList = defaultExports.extends;
-    }
-    else {
-        assertUsage(false, wrongUsage);
-    }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = parseImportData(importDataSerialized);
-        assertUsage(importData, wrongUsage);
-        return importData;
-    });
-    return extendsImportData;
-}
-function isGlobalConfig(configName) {
-    if (configName === 'prerender')
-        return false;
-    const configNamesGlobal = getConfigNamesGlobal();
-    return arrayIncludes(configNamesGlobal, configName);
-}
-function getConfigNamesGlobal() {
-    return Object.keys(configDefinitionsBuiltInGlobal);
-}
-function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
-    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
-    if (configNames.includes(configName))
-        return;
-    handleUnknownConfig(configName, configNames, filePathToShowToUser);
-    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 ${pc.cyan(configName)}`;
     let configNameSimilar = null;
@@ -1025,36 +825,10 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    assertPosixPath(importerFilePathAbsolute);
-    const cwd = path.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 = requireResolve(importData.importPath, cwd);
-    return filePathAbsoluteFilesystem;
-}
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = pc.cyan(`'${importPath}'`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            assertUsage(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            assertUsage(false, `${errIntro2} exist?`);
-        }
-    }
-}
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant) {
+function getConfigValues(configValueSources, configValuesComputed, configDefinitions) {
     const configValues = {};
     Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
         configValues[configName] = {
@@ -1063,7 +837,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
         };
     });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
-        const configDef = configDefinitionsRelevant[configName];
+        const configDef = configDefinitions[configName];
         assert(configDef);
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
@@ -1177,3 +951,48 @@ function getConfigEnvValue(val, errMsgIntro) {
     */
     return val;
 }
+function getConfigDefinition(configDefinitions, configName, filePathToShowToUser) {
+    const configDef = configDefinitions[configName];
+    assertConfigExists(configName, Object.keys(configDefinitions), filePathToShowToUser);
+    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)
+        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
+}
+function isGlobalConfig(configName) {
+    if (configName === 'prerender')
+        return false;
+    const configNamesGlobal = getConfigNamesGlobal();
+    return arrayIncludes(configNamesGlobal, configName);
+}
+function getConfigNamesGlobal() {
+    return Object.keys(configDefinitionsBuiltInGlobal);
+}
+function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
+    const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
+    if (configNames.includes(configName))
+        return;
+    handleUnknownConfig(configName, configNames, filePathToShowToUser);
+    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(makeFirst(([, [source]]) => {
+        const { importPathAbsolute } = source.definedAt;
+        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+    }))
+        // Sort after the filesystem inheritance of the config value
+        .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
+}