vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

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

@@ -2,30 +2,26 @@ export { getVikeConfig };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
-export { isVikeConfigFile };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse, unique, isCallable } from '../../../utils.js';
-import path from 'path';
-import { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst } from '../../../utils.js';
+import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTemporaryBuildFile } 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 { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
-import { getConfigFileExport } from './getConfigFileExport.js';
-import { loadConfigFile, loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
+import { loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { assertExtensionsRequire, assertExtensionsConventions } from './assertExtensions.js';
+import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -94,106 +90,6 @@ async function isV1Design(config) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, esbuildCache) {
-    const plusFiles = await findPlusFiles(userRootDir, null);
-    const configFiles = [];
-    const valueFiles = [];
-    plusFiles.forEach((f) => {
-        if (getConfigName(f.filePathAbsoluteFilesystem) === 'config') {
-            configFiles.push(f);
-        }
-        else {
-            valueFiles.push(f);
-        }
-    });
-    let interfaceFilesAll = {};
-    await Promise.all([
-        // Config files
-        ...configFiles.map(async (filePath) => {
-            const { filePathAbsoluteUserRootDir } = filePath;
-            assert(filePathAbsoluteUserRootDir);
-            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
-            assert(filePath.filePathAbsoluteUserRootDir);
-            const locationId = getLocationId(filePathAbsoluteUserRootDir);
-            const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId, userRootDir);
-            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
-            interfaceFilesAll[locationId].push(interfaceFile);
-            extendsConfigs.forEach((extendsConfig) => {
-                /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
-                ```js
-                // /pages/admin/+config.js
-        
-                import vikeVue from 'vike-vue/config'
-                // Should only apply to /pages/admin/**
-                export default { extends: [vikeVue] }
-                ```
-                ```js
-                // /pages/marketing/+config.js
-        
-                import vikeReact from 'vike-react/config'
-                // Should only apply to /pages/marketing/**
-                export default { extends: [vikeReact] }
-                ```
-                */
-                const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId, userRootDir);
-                assertExtensionsConventions(interfaceFile);
-                interfaceFilesAll[locationId].push(interfaceFile);
-            });
-        }),
-        // Value files
-        ...valueFiles.map(async (filePath) => {
-            const { filePathAbsoluteUserRootDir } = filePath;
-            assert(filePathAbsoluteUserRootDir);
-            const configName = getConfigName(filePathAbsoluteUserRootDir);
-            assert(configName);
-            const locationId = getLocationId(filePathAbsoluteUserRootDir);
-            const interfaceFile = {
-                locationId,
-                filePath,
-                isConfigFile: false,
-                isValueFile: true,
-                isValueFileLoaded: false,
-                configName
-            };
-            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
-            interfaceFilesAll[locationId].push(interfaceFile);
-            // We don't have access to the custom config definitions defined by the user yet.
-            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
-            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
-            await loadValueFile(interfaceFile, configDefinitionsBuiltInAll, userRootDir, esbuildCache);
-        })
-    ]);
-    assertKnownConfigs(interfaceFilesAll);
-    return interfaceFilesAll;
-}
-function getInterfaceFileFromConfigFile(configFile, isConfigExtension, locationId, userRootDir) {
-    const { fileExports, filePath, extendsFilePaths } = configFile;
-    const fileExportsByConfigName = {};
-    const pointerImportsByConfigName = {};
-    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
-    Object.entries(fileExport).forEach(([configName, configValue]) => {
-        fileExportsByConfigName[configName] = configValue;
-        const pointerImport = resolvePointerImport(configValue, configFile.filePath, userRootDir, configName);
-        if (pointerImport) {
-            pointerImportsByConfigName[configName] = {
-                ...pointerImport,
-                fileExportValueLoaded: false
-            };
-        }
-    });
-    const interfaceFile = {
-        locationId,
-        filePath,
-        fileExportsByConfigName,
-        pointerImportsByConfigName,
-        isConfigFile: true,
-        isValueFile: false,
-        isValueFileLoaded: true,
-        isConfigExtension,
-        extendsFilePaths
-    };
-    return interfaceFile;
-}
 async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     let hasError = false;
     let ret;
@@ -238,9 +134,10 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const esbuildCache = {};
-    const interfaceFilesAll = await loadInterfaceFiles(userRootDir, esbuildCache);
-    const configDefinitionsResolved = await resolveConfigDefinitions(interfaceFilesAll, userRootDir, esbuildCache);
-    const { pageConfigGlobal, pageConfigs } = getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDir);
+    const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
+    assertKnownConfigs(plusFilesAll);
+    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
+    const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
@@ -248,19 +145,17 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const global = getPageConfigUserFriendlyNew({ configValues });
     return { pageConfigs, pageConfigGlobal, global };
 }
-async function resolveConfigDefinitions(interfaceFilesAll, userRootDir, esbuildCache) {
+async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const configDefinitionsGlobal = getConfigDefinitions(
-    // We use `interfaceFilesAll` in order to allow local Vike extensions to create global configs.
-    interfaceFilesAll, // TODO/now sort
-    (configDef) => !!configDef.global);
-    await loadCustomConfigBuildTimeFiles(interfaceFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
+    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs.
+    sortForGlobal(plusFilesAll), (configDef) => !!configDef.global);
+    await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
     const configDefinitionsLocal = {};
-    await Promise.all(objectEntries(interfaceFilesAll).map(async ([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
-        //    configDefinitions = getConfigDefinitions(interfaceFilesRelevant, (configDef) => configDef.global !== true) // TODO/now
-        const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        await loadCustomConfigBuildTimeFiles(interfaceFiles, configDefinitions, userRootDir, esbuildCache);
-        configDefinitionsLocal[locationId] = { configDefinitions, interfaceFiles, interfaceFilesRelevant };
+    await Promise.all(objectEntries(plusFilesAll).map(async ([locationId, plusFiles]) => {
+        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
+        const configDefinitions = getConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
+        await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
+        configDefinitionsLocal[locationId] = { configDefinitions, plusFiles, plusFilesRelevant };
     }));
     const configDefinitionsResolved = {
         configDefinitionsGlobal,
@@ -269,50 +164,48 @@ async function resolveConfigDefinitions(interfaceFilesAll, userRootDir, esbuildC
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
-// - The value files of *built-in* configs are already loaded at `loadInterfaceFiles()`.
-async function loadCustomConfigBuildTimeFiles(interfaceFiles, configDefinitions, userRootDir, esbuildCache) {
-    const interfaceFileList = Object.values(interfaceFiles).flat(1);
-    await Promise.all(interfaceFileList.map(async (interfaceFile) => {
-        if (interfaceFile.isValueFile) {
-            await loadValueFile(interfaceFile, configDefinitions, userRootDir, esbuildCache);
+// - The value files of *built-in* configs are already loaded at `getPlusFilesAll()`.
+async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
+    const plusFileList = Object.values(plusFiles).flat(1);
+    await Promise.all(plusFileList.map(async (plusFile) => {
+        if (!plusFile.isConfigFile) {
+            await loadValueFile(plusFile, configDefinitions, userRootDir, esbuildCache);
         }
         else {
-            await Promise.all(Object.entries(interfaceFile.pointerImportsByConfigName).map(async ([configName, pointerImport]) => {
+            await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImport]) => {
                 await loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache);
             }));
         }
     }));
 }
-function getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDir) {
+function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir) {
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsResolved.configDefinitionsGlobal,
         configValueSources: {}
     };
     objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, 
-        // We use `interfaceFilesAll` in order to allow local Vike extensions to set the value of global configs (e.g. `vite`).
-        interfaceFilesAll, // TODO/now check sort order
-        userRootDir, true);
+        // We use `plusFilesAll` in order to allow local Vike extensions to set the value of global configs (e.g. `vite`).
+        sortForGlobal(plusFilesAll), userRootDir, true);
         if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
     });
-    assertPageConfigGlobal(pageConfigGlobal, interfaceFilesAll);
+    assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
     const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
-        .filter(([_locationId, { interfaceFiles }]) => isDefiningPage(interfaceFiles))
-        .map(([locationId, { configDefinitions, interfaceFilesRelevant }]) => {
+        .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
+        .map(([locationId, { configDefinitions, plusFilesRelevant }]) => {
         const configDefinitionsLocal = configDefinitions;
-        let configValueSources = {};
+        const configValueSources = {};
         objectEntries(configDefinitionsLocal)
             .filter(([_configName, configDef]) => configDef.global !== true)
             .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, false);
+            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false);
+            // sortConfigValueSources(sources, locationId)
             if (sources.length === 0)
                 return;
-            // assertUsage(!isGlobalConfig(configName, configDefinitionsLocal, sources), 'TODO') // TODO/now
             configValueSources[configName] = sources;
         });
-        configValueSources = sortConfigValueSources(configValueSources, locationId);
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitionsLocal);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
@@ -321,7 +214,7 @@ function getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDi
             isErrorPage,
             routeFilesystem,
             configDefinitions: configDefinitionsLocal,
-            interfaceFiles: interfaceFilesRelevant,
+            plusFiles: plusFilesRelevant,
             configValueSources,
             configValuesComputed
         };
@@ -330,34 +223,34 @@ function getPageConfigs(configDefinitionsResolved, interfaceFilesAll, userRootDi
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
-function assertPageConfigGlobal(pageConfigGlobal, interfaceFilesAll) {
+function assertPageConfigGlobal(pageConfigGlobal, plusFilesAll) {
     Object.entries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
-        assertGlobalConfigLocation(configName, sources, interfaceFilesAll, pageConfigGlobal.configDefinitions);
+        assertGlobalConfigLocation(configName, sources, plusFilesAll, pageConfigGlobal.configDefinitions);
     });
 }
-function assertGlobalConfigLocation(configName, sources, interfaceFilesAll, configDefinitionsGlobal) {
-    const locationIdsAll = objectKeys(interfaceFilesAll);
+function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDefinitionsGlobal) {
+    const locationIdsAll = objectKeys(plusFilesAll);
     // Determine existing global +config.js files
     const configFilePathsGlobal = [];
-    const interfaceFilesGlobal = Object.values(objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => isGlobalLocation(locationId, locationIdsAll)))).flat();
-    interfaceFilesGlobal
+    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesAll).filter(([locationId]) => isGlobalLocation(locationId, locationIdsAll)))).flat();
+    plusFilesGlobal
         .filter((i) => i.isConfigFile)
-        .forEach((interfaceFile) => {
-        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
+        .forEach((plusFile) => {
+        const { filePathAbsoluteUserRootDir } = plusFile.filePath;
         if (filePathAbsoluteUserRootDir) {
             configFilePathsGlobal.push(filePathAbsoluteUserRootDir);
         }
     });
     // Call assertWarning()
     sources.forEach((source) => {
-        const { interfaceFile } = source;
+        const { plusFile } = source;
         // It's `null` when the config is defined by `vike(options)` in vite.config.js
-        assert(interfaceFile);
-        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
+        assert(plusFile);
+        const { filePathAbsoluteUserRootDir } = plusFile.filePath;
         // Allow local Vike extensions to set gloabl configs (`filePathAbsoluteUserRootDir===null` for Vike extension)
         if (!filePathAbsoluteUserRootDir)
             return;
-        assert(!interfaceFile.isConfigExtension);
+        assert(!plusFile.isExtensionConfig);
         if (!isGlobalLocation(source.locationId, locationIdsAll)) {
             const configDef = configDefinitionsGlobal[configName];
             assert(configDef);
@@ -424,10 +317,11 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
     assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
     Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
         var _a;
-        assert(includes(objectKeys(configDefinitionsBuiltInAll), configName));
-        const configDef = configDefinitionsBuiltInAll[configName];
+        assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
+        const configDef = configDefinitionsBuiltIn[configName];
         const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
         sources.push({
+            valueIsLoaded: true,
             value,
             configEnv: configDef.env,
             definedAtFilePath: {
@@ -438,108 +332,130 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
                 fileExportPathToShowToUser: null
             },
             locationId: '/',
-            interfaceFile: null,
+            plusFile: null,
             isOverriden: configDef.cumulative ? false : sources.length > 0,
             valueIsImportedAtRuntime: false,
             valueIsDefinedByPlusFile: false
         });
     });
 }
-function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesAll)
+function getPlusFilesRelevant(plusFilesAll, locationIdPage) {
+    const plusFilesRelevant = Object.fromEntries(objectEntries(plusFilesAll)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
+        // Sort after config inheritance.
+        // - Together with getPlusFilesOrdered() this implements the whole order of config inheritance.
+        // - See sortForGlobal() for global configs order.
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
-    return interfaceFilesRelevant;
+    return plusFilesRelevant;
+}
+function sortForGlobal(plusFilesAll) {
+    const locationIdsAll = objectKeys(plusFilesAll);
+    const plusFilesAllSorted = Object.fromEntries(objectEntries(plusFilesAll)
+        .sort(lowerFirst(([locationId]) => locationId.split('/').length))
+        .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, locationIdsAll))));
+    return plusFilesAllSorted;
+}
+function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal) {
+    const plusFilesOrdered = getPlusFilesOrdered(configName, plusFilesRelevant);
+    let sources = plusFilesOrdered.map((plusFile, i) => {
+        const isHighestInheritancePrecedence = i === 0;
+        const configValueSource = getConfigValueSource(configName, plusFile, configDef, userRootDir, isHighestInheritancePrecedence);
+        return configValueSource;
+    });
+    if (isCallable(configDef.global)) {
+        const isGlobalValue = configDef.global;
+        assert(configDef.env.config);
+        sources = sources.filter((source) => {
+            assert(source.configEnv.config);
+            assert(source.valueIsLoaded);
+            const valueIsGlobal = isGlobalValue(source.value);
+            return isGlobal ? valueIsGlobal : !valueIsGlobal;
+        });
+    }
+    return sources;
 }
-function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, isGlobal) {
-    const interfaceFilesSource = [];
-    // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
-    for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
-        const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => getDefiningConfigNames(interfaceFile).includes(configName));
-        if (interfaceFilesDefiningConfig.length === 0)
-            continue;
-        const visited = new WeakSet();
-        const add = (interfaceFile) => {
-            assert(!visited.has(interfaceFile));
-            visited.add(interfaceFile);
-            const isHighestInheritancePrecedence = interfaceFilesSource.length === 0;
-            interfaceFilesSource.push({ interfaceFile, isHighestInheritancePrecedence });
+// Together with sortAfterInheritanceOrder() this implements the whole order of config inheritance.
+function getPlusFilesOrdered(configName, plusFilesRelevant) {
+    const plusFilesOrdered = [];
+    // `plusFilesRelevant` is already sorted by sortAfterInheritanceOrder() at getPlusFilesRelevant()
+    // `plusFilesAtLocationId` is already sorted by sortMakeDeterministic() at getPlusFilesAll()
+    for (const plusFilesAtLocationId of Object.values(plusFilesRelevant)) {
+        const plusFilesForConfigName = plusFilesAtLocationId.filter((plusFile) => getDefiningConfigNames(plusFile).includes(configName));
+        // We populate `plusFilesOrdered` with inheritance order.
+        const populate = (plusFile) => {
+            assert(!visited.has(plusFile));
+            visited.add(plusFile);
+            plusFilesOrdered.push(plusFile);
         };
-        // Main resolution logic
+        const visited = new WeakSet();
+        // ========================
+        // User-land config (first)
+        // ========================
         {
-            const interfaceValueFiles = interfaceFilesDefiningConfig
-                .filter((interfaceFile) => interfaceFile.isValueFile &&
+            const plusFilesValue = plusFilesForConfigName.filter((plusFile) => !plusFile.isConfigFile &&
                 // We consider side-effect configs (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
-                interfaceFile.configName === configName)
-                .sort(makeOrderDeterministic);
-            const interfaceConfigFiles = interfaceFilesDefiningConfig
-                .filter((interfaceFile) => interfaceFile.isConfigFile &&
-                // We consider values from extensions (e.g. vike-react) later (i.e. with less priority)
-                !interfaceFile.isConfigExtension)
-                .sort(makeOrderDeterministic);
-            const interfaceValueFile = interfaceValueFiles[0];
-            const interfaceConfigFile = interfaceConfigFiles[0];
+                plusFile.configName === configName);
+            const plusFilesConfig = plusFilesForConfigName.filter((plusFile) => plusFile.isConfigFile &&
+                // We consider extensions (e.g. vike-react) later (i.e. with less priority)
+                !plusFile.isExtensionConfig);
             // Make this value:
             //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
             //   /pages/some-page/+config.js > `export default { someConfig }`
-            const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
-            if (interfaceFileWinner) {
-                const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
-                // A user-land conflict of interfaceFiles with the same locationId means that the user has superfluously defined the config twice; the user should remove such redundancy making things unnecessarily ambiguous
-                warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName);
-                [interfaceFileWinner, ...interfaceFilesOverriden].forEach((interfaceFile) => {
-                    add(interfaceFile);
+            const plusFileWinner = plusFilesValue[0] ?? plusFilesConfig[0];
+            if (plusFileWinner) {
+                const plusFilesOverriden = [...plusFilesValue, ...plusFilesConfig].filter((f) => f !== plusFileWinner);
+                // A user-land conflict of plusFiles with the same `locationId` (we are iterating over `plusFilesRelevant: PlusFilesByLocationId`) means that the user has superfluously defined the config twice; the user should remove such redundancy as it makes things unnecessarily ambiguous.
+                assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName);
+                [plusFileWinner, ...plusFilesOverriden].forEach((plusFile) => {
+                    assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
+                    populate(plusFile);
                 });
             }
         }
-        // Side-effect configs such as `export { frontmatter }` in .mdx files
-        interfaceFilesDefiningConfig
-            .filter((interfaceFile) => interfaceFile.isValueFile &&
+        // ==========================
+        // Side-effect configs (next)
+        // ==========================
+        // - For example `export { frontmatter }` of `.mdx` files.
+        // - This only considers side-effect configs that are already loaded at build-time. (E.g. it actually doesn't consider `export { frontmatter }` of .mdx files since .mdx files are loaded only at runtime.)
+        plusFilesForConfigName
+            .filter((plusFile) => !plusFile.isConfigFile &&
             // Is side-effect config
-            interfaceFile.configName !== configName)
-            .forEach((interfaceValueFileSideEffect) => {
-            add(interfaceValueFileSideEffect);
+            plusFile.configName !== configName)
+            .forEach((plusFile) => {
+            assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
+            populate(plusFile);
         });
-        // extends
-        interfaceFilesDefiningConfig
-            .filter((interfaceFile) => interfaceFile.isConfigFile && interfaceFile.isConfigExtension)
+        // ========================
+        // Extensions config (last)
+        // ========================
+        plusFilesForConfigName
+            .filter((plusFile) => plusFile.isConfigFile && plusFile.isExtensionConfig)
             // Extension config files are already sorted by inheritance order
-            .forEach((interfaceFile) => {
-            add(interfaceFile);
-        });
-        interfaceFilesDefiningConfig.forEach((interfaceFile) => {
-            assert(visited.has(interfaceFile));
+            .forEach((plusFile) => {
+            assert(!plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it isn't a user-land plus file
+            populate(plusFile);
         });
-    }
-    let sources = interfaceFilesSource.map(({ interfaceFile, isHighestInheritancePrecedence }) => {
-        const configValueSource = getConfigValueSource(configName, interfaceFile, configDef, userRootDir, isHighestInheritancePrecedence);
-        return configValueSource;
-    });
-    if (isCallable(configDef.global)) {
-        const isGlobalValue = configDef.global;
-        assert(configDef.env.config);
-        sources = sources.filter((source) => {
-            assert(source.configEnv.config);
-            // TODO/now: source.valueIsDefined
-            assert('value' in source);
-            const valueIsGlobal = isGlobalValue(source.value);
-            return isGlobal ? valueIsGlobal : !valueIsGlobal;
+        // ======
+        // Assert we didn't miss any config.
+        // ======
+        plusFilesForConfigName.forEach((plusFile) => {
+            assert(visited.has(plusFile));
         });
     }
-    return sources;
+    return plusFilesOrdered;
 }
-function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, isHighestInheritancePrecedence) {
-    const confVal = getConfVal(interfaceFile, configName);
+function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHighestInheritancePrecedence) {
+    const confVal = getConfVal(plusFile, configName);
     assert(confVal);
     const configValueSourceCommon = {
-        locationId: interfaceFile.locationId,
-        interfaceFile
+        locationId: plusFile.locationId,
+        plusFile
     };
     const definedAtFilePath_ = {
-        ...interfaceFile.filePath,
+        ...plusFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
     const isOverriden = configDef.cumulative ? false : !isHighestInheritancePrecedence;
@@ -547,10 +463,10 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir,
     if (configDef._valueIsFilePath) {
         let definedAtFilePath;
         let valueFilePath;
-        if (interfaceFile.isConfigFile) {
+        if (plusFile.isConfigFile) {
             // Defined over pointer import
             assert(confVal.configValueLoaded);
-            const pointerImport = resolvePointerImport(confVal.configValue, interfaceFile.filePath, userRootDir, configName);
+            const pointerImport = resolvePointerImport(confVal.configValue, plusFile.filePath, userRootDir, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
             assertUsage(pointerImport, `${configDefinedAt} should be an import`);
             valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;
@@ -558,15 +474,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir,
         }
         else {
             // Defined by value file, i.e. +{configName}.js
-            assert(interfaceFile.isValueFile);
-            valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
+            assert(!plusFile.isConfigFile);
+            valueFilePath = plusFile.filePath.filePathAbsoluteVite;
             definedAtFilePath = {
-                ...interfaceFile.filePath,
+                ...plusFile.filePath,
                 fileExportPathToShowToUser: []
             };
         }
         const configValueSource = {
             ...configValueSourceCommon,
+            valueIsLoaded: true,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -578,29 +495,35 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir,
         return configValueSource;
     }
     // +config.js
-    if (interfaceFile.isConfigFile) {
+    if (plusFile.isConfigFile) {
         assert(confVal.configValueLoaded);
         const { configValue } = confVal;
         // Defined over pointer import
-        const pointerImport = interfaceFile.pointerImportsByConfigName[configName];
+        const pointerImport = plusFile.pointerImportsByConfigName[configName];
         if (pointerImport) {
+            const value = pointerImport.fileExportValueLoaded
+                ? {
+                    valueIsLoaded: true,
+                    value: pointerImport.fileExportValue
+                }
+                : {
+                    valueIsLoaded: false
+                };
             const configValueSource = {
                 ...configValueSourceCommon,
+                ...value,
                 configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
                 isOverriden,
                 definedAtFilePath: pointerImport.fileExportPath
             };
-            if (pointerImport.fileExportValueLoaded) {
-                configValueSource.value = pointerImport.fileExportValue;
-                assert('fileExportValue' in pointerImport);
-            }
             return configValueSource;
         }
         // Defined inside +config.js
         const configValueSource = {
             ...configValueSourceCommon,
+            valueIsLoaded: true,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -611,53 +534,48 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir,
         return configValueSource;
     }
     // Defined by value file, i.e. +{configName}.js
-    if (interfaceFile.isValueFile) {
-        const configEnvResolved = resolveConfigEnv(configDef.env, interfaceFile.filePath);
+    if (!plusFile.isConfigFile) {
+        const configEnvResolved = resolveConfigEnv(configDef.env, plusFile.filePath);
         const valueAlreadyLoaded = confVal.configValueLoaded;
         assert(valueAlreadyLoaded === !!configEnvResolved.config);
+        const value = valueAlreadyLoaded
+            ? {
+                valueIsLoaded: true,
+                value: confVal.configValue
+            }
+            : {
+                valueIsLoaded: false
+            };
         const configValueSource = {
             ...configValueSourceCommon,
+            ...value,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
             isOverriden,
             definedAtFilePath: {
-                ...interfaceFile.filePath,
-                fileExportPathToShowToUser: configName === interfaceFile.configName
+                ...plusFile.filePath,
+                fileExportPathToShowToUser: configName === plusFile.configName
                     ? []
                     : // Side-effect config (e.g. `export { frontmatter }` of .md files)
                         [configName]
             }
         };
-        if (valueAlreadyLoaded) {
-            configValueSource.value = confVal.configValue;
-        }
         return configValueSource;
     }
     assert(false);
 }
-function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
-    return lowerFirst((interfaceFile) => {
-        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
-        assert(isInterfaceFileUserLand(interfaceFile));
-        assert(filePathAbsoluteUserRootDir);
-        return filePathAbsoluteUserRootDir.length;
-    })(interfaceFile1, interfaceFile2);
-}
-function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
-    interfaceFilesOverriden.forEach((interfaceFileLoser) => {
-        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
-        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
+function assertOverwrittenConfigFile(plusFileWinner, plusFilesOverriden, configName) {
+    plusFilesOverriden.forEach((plusFileLoser) => {
+        const loserFilePath = plusFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = plusFileWinner.filePath.filePathToShowToUser;
         const confName = pc.cyan(configName);
         assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
     });
 }
-function isInterfaceFileUserLand(interfaceFile) {
-    return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtension) || interfaceFile.isValueFile;
-}
-function isDefiningPage(interfaceFiles) {
-    for (const interfaceFile of interfaceFiles) {
-        const configNames = getDefiningConfigNames(interfaceFile);
+function isDefiningPage(plusFiles) {
+    for (const plusFile of plusFiles) {
+        const configNames = getDefiningConfigNames(plusFile);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -667,37 +585,37 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getDefiningConfigNames(interfaceFile) {
+function getDefiningConfigNames(plusFile) {
     let configNames = [];
-    if (interfaceFile.isValueFile) {
-        configNames.push(interfaceFile.configName);
+    if (!plusFile.isConfigFile) {
+        configNames.push(plusFile.configName);
     }
-    if (interfaceFile.isValueFileLoaded) {
-        configNames.push(...Object.keys(interfaceFile.fileExportsByConfigName));
+    if (!plusFile.isNotLoaded) {
+        configNames.push(...Object.keys(plusFile.fileExportsByConfigName));
     }
     configNames = unique(configNames);
     return configNames;
 }
-function getConfigDefinitions(interfaceFilesRelevant, filter) {
-    let configDefinitions = { ...configDefinitionsBuiltInAll };
+function getConfigDefinitions(plusFilesRelevant, filter) {
+    let configDefinitions = { ...configDefinitionsBuiltIn };
     // Add user-land meta configs
-    Object.entries(interfaceFilesRelevant)
+    Object.entries(plusFilesRelevant)
         .reverse()
-        .forEach(([_locationId, interfaceFiles]) => {
-        interfaceFiles.forEach((interfaceFile) => {
-            const confVal = getConfVal(interfaceFile, 'meta');
+        .forEach(([_locationId, plusFiles]) => {
+        plusFiles.forEach((plusFile) => {
+            const confVal = getConfVal(plusFile, 'meta');
             if (!confVal)
                 return;
             assert(confVal.configValueLoaded);
             const meta = confVal.configValue;
-            assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
+            assertMetaUsage(meta, `Config ${pc.cyan('meta')} defined at ${plusFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAtFilePath
             Object.entries(meta).forEach(([configName, configDef]) => {
                 if (!configDef.effect)
                     return;
-                assert(interfaceFile.isConfigFile);
+                assert(plusFile.isConfigFile);
                 configDef._userEffectDefinedAtFilePath = {
-                    ...interfaceFile.filePath,
+                    ...plusFile.filePath,
                     fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
                 };
             });
@@ -829,66 +747,29 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
-    return plusFiles;
-}
-function getConfigName(filePath) {
-    assertPosixPath(filePath);
-    if (isTemporaryBuildFile(filePath))
-        return null;
-    const fileName = path.posix.basename(filePath);
-    // assertNoUnexpectedPlusSign(filePath, fileName)
-    const basename = fileName.split('.')[0];
-    if (!basename.startsWith('+')) {
-        return null;
-    }
-    else {
-        const configName = basename.slice(1);
-        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
-        return configName;
-    }
-}
-/* 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`
-  )
-}
-*/
 // Show error message upon unknown config
-function assertKnownConfigs(interfaceFilesAll) {
-    const configDefinitionsAll = getConfigDefinitions(interfaceFilesAll);
+function assertKnownConfigs(plusFilesAll) {
+    const configDefinitionsAll = getConfigDefinitions(plusFilesAll);
     const configNamesKnownAll = Object.keys(configDefinitionsAll);
-    objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
-        const configDefinitionsLocal = getConfigDefinitions(interfaceFilesRelevant);
+    objectEntries(plusFilesAll).forEach(([locationId, plusFiles]) => {
+        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
+        const configDefinitionsLocal = getConfigDefinitions(plusFilesRelevant);
         const configNamesKnownLocal = Object.keys(configDefinitionsLocal);
-        interfaceFiles.forEach((interfaceFile) => {
-            const configNames = getDefiningConfigNames(interfaceFile);
+        plusFiles.forEach((plusFile) => {
+            const configNames = getDefiningConfigNames(plusFile);
             configNames.forEach((configName) => {
-                assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, interfaceFile);
+                assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile);
                 assert(configNamesKnownLocal.includes(configName));
                 assert(configNamesKnownAll.includes(configName));
             });
         });
     });
 }
-function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, interfaceFile) {
+function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile) {
     if (configNamesKnownLocal.includes(configName))
         return;
     const configNameColored = pc.cyan(configName);
-    const { locationId, filePath: { filePathToShowToUser } } = interfaceFile;
+    const { locationId, filePath: { filePathToShowToUser } } = plusFile;
     const errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}`;
     // Inheritance issue: config is known but isn't defined at `locationId`
     if (configNamesKnownAll.includes(configName)) {
@@ -978,9 +859,6 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function isVikeConfigFile(filePath) {
-    return !!getConfigName(filePath);
-}
 function getConfigEnvValue(val, errMsgIntro) {
     const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
     // Legacy outdated values
@@ -1020,29 +898,13 @@ function getConfigEnvValue(val, errMsgIntro) {
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-function sortConfigValueSources(configValueSources, locationIdPage) {
-    return Object.fromEntries(Object.entries(configValueSources)
-        // Make order deterministic (no other purpose)
-        .sort(([, [source1]], [, [source2]]) => source1.definedAtFilePath.filePathAbsoluteVite < source2.definedAtFilePath.filePathAbsoluteVite ? -1 : 1)
-        // Sort after whether the config value was defined by an npm package
-        .sort(makeFirst(([, [source]]) => {
-        const { importPathAbsolute } = source.definedAtFilePath;
-        return (!!importPathAbsolute &&
-            isNpmPackageImport(importPathAbsolute, {
-                // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
-                cannotBePathAlias: true
-            }));
-    }))
-        // Sort after the filesystem inheritance of the config value
-        .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));
-}
-function getConfVal(interfaceFile, configName) {
-    const configNames = getDefiningConfigNames(interfaceFile);
+function getConfVal(plusFile, configName) {
+    const configNames = getDefiningConfigNames(plusFile);
     if (!configNames.includes(configName))
         return null;
-    if (!interfaceFile.isValueFileLoaded)
+    if (plusFile.isNotLoaded)
         return { configValueLoaded: false };
-    const confVal = { configValue: interfaceFile.fileExportsByConfigName[configName], configValueLoaded: true };
+    const confVal = { configValue: plusFile.fileExportsByConfigName[configName], configValueLoaded: true };
     return confVal;
 }
 function resolveConfigEnv(configEnv, filePath) {