vike 0.4.223 → 0.4.224-commit-00ed9fe

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

@@ -5,7 +5,8 @@ export { vikeConfigDependencies };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst } from '../../../utils.js';
+export { isOverriden };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast } from '../../../utils.js';
 import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
@@ -20,7 +21,7 @@ import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
 import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
-import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
@@ -67,6 +68,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
+// TODO/soon: predominantly use getVikeConfigPublic() instead of getVikeConfig() then maybe refector?
 async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
@@ -85,8 +87,9 @@ async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doN
     }
     return await vikeConfigPromise;
 }
-async function isV1Design(config) {
-    const vikeConfig = await getVikeConfig(config);
+function isV1Design(config) {
+    const vikeConfig = config._vikeConfigObject;
+    assert(vikeConfig);
     const { pageConfigs } = vikeConfig;
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
@@ -140,7 +143,7 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     assertKnownConfigs(configDefinitionsResolved, plusFilesAll);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
-    // interop vike(options) in vite.config.js
+    // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
@@ -153,16 +156,23 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     return { pageConfigs, pageConfigGlobal, global, pages };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
+    const plusFilesAllOrdered = Object.values(plusFilesAll)
+        .flat()
+        .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesAll, null));
     const configDefinitionsGlobal = getConfigDefinitions(
-    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs.
-    sortForGlobal(plusFilesAll), (configDef) => !!configDef.global);
+    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
+    plusFilesAllOrdered, (configDef) => !!configDef.global);
     await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
     const configDefinitionsLocal = {};
-    await Promise.all(objectEntries(plusFilesAll).map(async ([locationId, plusFiles]) => {
-        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
+    await Promise.all(objectEntries(plusFilesAll).map(async ([locationIdPage, plusFiles]) => {
+        const plusFilesRelevant = objectEntries(plusFilesAll)
+            .filter(([locationId]) => isInherited(locationId, locationIdPage))
+            .map(([, plusFiles]) => plusFiles)
+            .flat()
+            .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, null));
         const configDefinitions = getConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
         await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
-        configDefinitionsLocal[locationId] = { configDefinitions, plusFiles, plusFilesRelevant };
+        configDefinitionsLocal[locationIdPage] = { configDefinitions, plusFiles, plusFilesRelevant };
     }));
     const configDefinitionsResolved = {
         configDefinitionsGlobal,
@@ -192,12 +202,15 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
     };
     objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, 
-        // We use `plusFilesAll` in order to allow local Vike extensions to set the value of global configs (e.g. `vite`).
-        sortForGlobal(plusFilesAll), userRootDir, true);
+        // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
+        Object.values(plusFilesAll).flat(), userRootDir, true);
         if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
     });
+    applyEffectsMetaEnv(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
+    applyEffectsConfVal(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
+    sortConfigValueSources(pageConfigGlobal.configValueSources, null);
     assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
     const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
         .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
@@ -208,13 +221,14 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
             .filter(([_configName, configDef]) => configDef.global !== true)
             .forEach(([configName, configDef]) => {
             const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false);
-            // sortConfigValueSources(sources, locationId)
             if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
         });
         const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitionsLocal);
+        applyEffectsMetaEnv(configValueSources, configDefinitionsLocal);
+        applyEffectsConfVal(configValueSources, configDefinitionsLocal);
+        sortConfigValueSources(configValueSources, locationId);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
@@ -351,110 +365,122 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
             },
             locationId: '/',
             plusFile: null,
-            isOverriden: configDef.cumulative ? false : sources.length > 0,
-            valueIsImportedAtRuntime: false,
-            valueIsDefinedByPlusFile: false
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false
         });
     });
 }
-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 plusFilesRelevant;
-}
-function sortForGlobal(plusFilesAll) {
-    const plusFilesAllSorted = Object.fromEntries(objectEntries(plusFilesAll)
-        .sort(lowerFirst(([locationId]) => locationId.split('/').length))
-        .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, plusFilesAll))));
-    return plusFilesAllSorted;
+function sortConfigValueSources(configValueSources, locationIdPage) {
+    Object.entries(configValueSources).forEach(([configName, sources]) => {
+        sources
+            .sort((source1, source2) => {
+            if (!source1.plusFile || !source2.plusFile)
+                return 0;
+            const isGlobal = !locationIdPage;
+            if (isGlobal) {
+                return sortAfterInheritanceOrderGlobal(source1.plusFile, source2.plusFile, null, configName);
+            }
+            else {
+                return sortAfterInheritanceOrderPage(source1.plusFile, source2.plusFile, locationIdPage, configName);
+            }
+        })
+            // TODO/next-major: remove
+            // Interop with vike(options) in vite.config.js — make it least precedence.
+            .sort(makeLast((source) => !source.plusFile));
+    });
+}
+function sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, configName) {
+    {
+        const ret = sortAfterInheritanceOrder(plusFile1.locationId, plusFile2.locationId, locationIdPage);
+        if (ret !== 0)
+            return ret;
+        assert(plusFile1.locationId === plusFile2.locationId);
+    }
+    if (configName) {
+        const ret = sortPlusFilesSameLocationId(plusFile1, plusFile2, configName);
+        if (ret !== 0)
+            return ret;
+    }
+    return 0;
+}
+function sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesAll, configName) {
+    if (plusFilesAll) {
+        const ret = makeFirst((plusFile) => isGlobalLocation(plusFile.locationId, plusFilesAll))(plusFile1, plusFile2);
+        if (ret !== 0)
+            return ret;
+    }
+    {
+        const ret = lowerFirst((plusFile) => plusFile.locationId.split('/').length)(plusFile1, plusFile2);
+        if (ret !== 0)
+            return ret;
+    }
+    if (plusFile1.locationId !== plusFile2.locationId) {
+        // Same as `sort()` in `['some', 'string', 'array'].sort()`
+        return plusFile1.locationId > plusFile2.locationId ? 1 : -1;
+    }
+    if (configName) {
+        assert(plusFile1.locationId === plusFile2.locationId);
+        const ret = sortPlusFilesSameLocationId(plusFile1, plusFile2, configName);
+        if (ret !== 0)
+            return ret;
+    }
+    return 0;
+}
+function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
+    assert(plusFile1.locationId === plusFile2.locationId);
+    assert(isDefiningConfig(plusFile1, configName));
+    assert(isDefiningConfig(plusFile2, configName));
+    // Config set by extensions (lowest precedence)
+    {
+        const ret = makeLast((plusFile) => !!plusFile.isExtensionConfig)(plusFile1, plusFile2);
+        if (ret !== 0)
+            return ret;
+    }
+    // Config set by side-export (lower precedence)
+    {
+        // - For example `export { frontmatter }` of `.mdx` files.
+        // - This only considers side-export 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.)
+        const ret = makeLast((plusFile) => !plusFile.isConfigFile &&
+            // Is side-export
+            plusFile.configName !== configName)(plusFile1, plusFile2);
+        if (ret !== 0)
+            return ret;
+    }
+    // Config set by +config.js
+    {
+        const ret = makeLast((plusFile) => plusFile.isConfigFile)(plusFile1, plusFile2);
+        if (ret !== 0)
+            return ret;
+    }
+    // Config set by +{configName}.js (highest precedence)
+    // No need to make it deterministic: the overall order is arleady deterministic, see sortMakeDeterministic() at getPlusFilesAll()
+    return 0;
 }
 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;
+    let sources = plusFilesRelevant
+        .filter((plusFile) => isDefiningConfig(plusFile, configName))
+        .map((plusFile) => getConfigValueSource(configName, plusFile, configDef, userRootDir));
+    // Filter hydrid global-local configs
+    if (!isCallable(configDef.global)) {
+        // Already filtered
+        assert((configDef.global ?? false) === isGlobal);
+    }
+    else {
+        // We cannot filter earlier
         assert(configDef.env.config);
         sources = sources.filter((source) => {
             assert(source.configEnv.config);
             assert(source.valueIsLoaded);
-            const valueIsGlobal = isGlobalValue(source.value);
+            const valueIsGlobal = resolveIsGlobalValue(configDef.global, source.value);
             return isGlobal ? valueIsGlobal : !valueIsGlobal;
         });
     }
     return sources;
 }
-// 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);
-        };
-        const visited = new WeakSet();
-        // ========================
-        // User-land config (first)
-        // ========================
-        {
-            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)
-                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);
-            [...plusFilesValue, ...plusFilesConfig].forEach((plusFile) => {
-                assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
-                populate(plusFile);
-            });
-        }
-        // ==========================
-        // 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
-            plusFile.configName !== configName)
-            .forEach((plusFile) => {
-            assert(plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it's a user-land plus file
-            populate(plusFile);
-        });
-        // ========================
-        // Extensions config (last)
-        // ========================
-        plusFilesForConfigName
-            .filter((plusFile) => plusFile.isConfigFile && plusFile.isExtensionConfig)
-            // Extension config files are already sorted by inheritance order
-            .forEach((plusFile) => {
-            assert(!plusFile.filePath.filePathAbsoluteUserRootDir); // ensure it isn't a user-land plus file
-            populate(plusFile);
-        });
-        // ======
-        // Assert we didn't miss any config.
-        // ======
-        plusFilesForConfigName.forEach((plusFile) => {
-            assert(visited.has(plusFile));
-        });
-    }
-    return plusFilesOrdered;
+function isDefiningConfig(plusFile, configName) {
+    return getDefiningConfigNames(plusFile).includes(configName);
 }
-function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHighestInheritancePrecedence) {
+function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
     const confVal = getConfVal(plusFile, configName);
     assert(confVal);
     const configValueSourceCommon = {
@@ -465,15 +491,14 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
         ...plusFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
     };
-    const isOverriden = configDef.cumulative ? false : !isHighestInheritancePrecedence;
     // +client.js
     if (configDef._valueIsFilePath) {
         let definedAtFilePath;
         let valueFilePath;
         if (plusFile.isConfigFile) {
             // Defined over pointer import
-            assert(confVal.configValueLoaded);
-            const pointerImport = resolvePointerImport(confVal.configValue, plusFile.filePath, userRootDir, configName);
+            assert(confVal.valueIsLoaded);
+            const pointerImport = resolvePointerImport(confVal.value, plusFile.filePath, userRootDir, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
             assertUsage(pointerImport, `${configDefinedAt} should be an import`);
             valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;
@@ -494,17 +519,15 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
-            valueIsImportedAtRuntime: true,
-            valueIsDefinedByPlusFile: false,
-            isOverriden,
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false,
             definedAtFilePath
         };
         return configValueSource;
     }
     // +config.js
     if (plusFile.isConfigFile) {
-        assert(confVal.configValueLoaded);
-        const { configValue } = confVal;
+        assert(confVal.valueIsLoaded);
         // Defined over pointer import
         const pointerImport = plusFile.pointerImportsByConfigName[configName];
         if (pointerImport) {
@@ -520,9 +543,8 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
                 ...configValueSourceCommon,
                 ...value,
                 configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
-                valueIsImportedAtRuntime: true,
-                valueIsDefinedByPlusFile: false,
-                isOverriden,
+                valueIsLoadedWithImport: true,
+                valueIsDefinedByPlusValueFile: false,
                 definedAtFilePath: pointerImport.fileExportPath
             };
             return configValueSource;
@@ -531,11 +553,10 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
         const configValueSource = {
             ...configValueSourceCommon,
             valueIsLoaded: true,
-            value: configValue,
+            value: confVal.value,
             configEnv: configDef.env,
-            valueIsImportedAtRuntime: false,
-            valueIsDefinedByPlusFile: false,
-            isOverriden,
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false,
             definedAtFilePath: definedAtFilePath_
         };
         return configValueSource;
@@ -543,23 +564,13 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir, isHi
     // Defined by value file, i.e. +{configName}.js
     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
-            };
+        assert(confVal.valueIsLoaded === !!configEnvResolved.config);
         const configValueSource = {
             ...configValueSourceCommon,
-            ...value,
+            ...confVal,
             configEnv: configEnvResolved,
-            valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            valueIsDefinedByPlusFile: true,
-            isOverriden,
+            valueIsLoadedWithImport: !confVal.valueIsLoaded || !isJsonValue(confVal.value),
+            valueIsDefinedByPlusValueFile: true,
             definedAtFilePath: {
                 ...plusFile.filePath,
                 fileExportPathToShowToUser: configName === plusFile.configName
@@ -584,6 +595,15 @@ function isDefiningPage(plusFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
+function resolveIsGlobalValue(configDefGlobal, configValue) {
+    let isGlobal;
+    if (isCallable(configDefGlobal))
+        isGlobal = configDefGlobal(configValue);
+    else
+        isGlobal = configDefGlobal ?? false;
+    assert(typeof isGlobal === 'boolean');
+    return isGlobal;
+}
 function getDefiningConfigNames(plusFile) {
     let configNames = [];
     if (!plusFile.isConfigFile) {
@@ -598,33 +618,32 @@ function getDefiningConfigNames(plusFile) {
 function getConfigDefinitions(plusFilesRelevant, filter) {
     let configDefinitions = { ...configDefinitionsBuiltIn };
     // Add user-land meta configs
-    Object.entries(plusFilesRelevant)
+    plusFilesRelevant
+        .slice()
         .reverse()
-        .forEach(([_locationId, plusFiles]) => {
-        plusFiles.forEach((plusFile) => {
-            const confVal = getConfVal(plusFile, 'meta');
-            if (!confVal)
+        .forEach((plusFile) => {
+        const confVal = getConfVal(plusFile, 'meta');
+        if (!confVal)
+            return;
+        assert(confVal.valueIsLoaded);
+        const meta = confVal.value;
+        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(confVal.configValueLoaded);
-            const meta = confVal.configValue;
-            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(plusFile.isConfigFile);
-                configDef._userEffectDefinedAtFilePath = {
-                    ...plusFile.filePath,
-                    fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
-                };
-            });
-            objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
-                // User can override an existing config definition
-                configDefinitions[configName] = {
-                    ...configDefinitions[configName],
-                    ...configDefinitionUserLand
-                };
-            });
+            assert(plusFile.isConfigFile);
+            configDef._userEffectDefinedAtFilePath = {
+                ...plusFile.filePath,
+                fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
+            };
+        });
+        objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
+            // User can override an existing config definition
+            configDefinitions[configName] = {
+                ...configDefinitions[configName],
+                ...configDefinitionUserLand
+            };
         });
     });
     if (filter) {
@@ -668,67 +687,102 @@ function assertMetaUsage(metaVal, metaConfigDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitions) {
-    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
-        if (!configDef.effect)
+// Test: https://github.com/vikejs/vike/blob/441a37c4c1a3b07bb8f6efb1d1f7be297a53974a/test/playground/vite.config.ts#L39
+function applyEffectsConfVal(configValueSources, configDefinitions) {
+    objectEntries(configDefinitions).forEach(([configNameEffect, configDefEffect]) => {
+        const sourceEffect = configValueSources[configNameEffect]?.[0];
+        if (!sourceEffect)
             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.
-        // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
-        assertUsage(configDef.env.config, [
-            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(JSON.stringify(configDef.env))}: effects can only be added to configs with an ${pc.cyan('env')} with ${pc.cyan('{ config: true }')}.`
-        ].join(' '));
-        const source = configValueSources[configName]?.[0];
-        if (!source)
+        const effect = runEffect(configNameEffect, configDefEffect, sourceEffect);
+        if (!effect)
             return;
-        // The config value is eagerly loaded since `configDef.env === 'config-only``
-        assert('value' in source);
-        // Call effect
-        const configModFromEffect = configDef.effect({
-            configValue: source.value,
-            configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAtFilePath)
-        });
-        if (!configModFromEffect)
+        const { configModFromEffect, configValueEffectSource } = effect;
+        applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, configValueEffectSource);
+    });
+}
+// Test: https://github.com/vikejs/vike/blob/441a37c4c1a3b07bb8f6efb1d1f7be297a53974a/test/playground/pages/config-meta/effect/e2e-test.ts#L16
+function applyEffectsMetaEnv(configValueSources, configDefinitions) {
+    objectEntries(configDefinitions).forEach(([configNameEffect, configDefEffect]) => {
+        const sourceEffect = configValueSources[configNameEffect]?.[0];
+        if (!sourceEffect)
+            return;
+        const effect = runEffect(configNameEffect, configDefEffect, sourceEffect);
+        if (!effect)
             return;
-        assert(hasProp(source, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, configValueSources, configDef);
+        const { configModFromEffect } = effect;
+        applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEffect);
     });
 }
-function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
-    const notSupported = `Effects currently only supports modifying the the ${pc.cyan('env')} of a config.`;
-    objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
-        if (configName === 'meta') {
-            let configDefinedAt;
-            if (configDefEffect._userEffectDefinedAtFilePath) {
-                configDefinedAt = getConfigDefinedAt('Config', configName, configDefEffect._userEffectDefinedAtFilePath);
-            }
-            else {
-                configDefinedAt = null;
-            }
-            assertMetaUsage(configValue, configDefinedAt);
-            objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
-                {
-                    const keys = Object.keys(configTargetDef);
-                    assertUsage(keys.includes('env'), notSupported);
-                    assertUsage(keys.length === 1, notSupported);
-                }
-                const envOverriden = configTargetDef.env;
-                const sources = configValueSources[configTargetName];
-                sources?.forEach((configValueSource) => {
-                    // Apply effect
-                    configValueSource.configEnv = envOverriden;
-                });
-            });
+function runEffect(configName, configDef, source) {
+    if (!configDef.effect)
+        return null;
+    // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
+    assertUsage(configDef.env.config, [
+        `Cannot add meta.effect to ${pc.cyan(configName)} because its meta.env is ${pc.cyan(JSON.stringify(configDef.env))} but an effect can only be added to a config that has a meta.env with ${pc.cyan('{ config: true }')}.`
+    ].join(' '));
+    assert(source.valueIsLoaded);
+    const configValueEffectSource = source.value;
+    // Call effect
+    const configModFromEffect = configDef.effect({
+        configValue: configValueEffectSource,
+        configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAtFilePath)
+    });
+    if (!configModFromEffect)
+        return null;
+    return { configModFromEffect, configValueEffectSource };
+}
+function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, configValueEffectSource) {
+    objectEntries(configModFromEffect).forEach(([configNameTarget, configValue]) => {
+        if (configNameTarget === 'meta')
+            return;
+        const configDef = configDefinitions[configNameTarget];
+        assert(configDef);
+        assert(configDefEffect._userEffectDefinedAtFilePath);
+        const configValueSource = {
+            definedAtFilePath: configDefEffect._userEffectDefinedAtFilePath,
+            plusFile: sourceEffect.plusFile,
+            locationId: sourceEffect.locationId,
+            configEnv: configDef.env,
+            valueIsLoadedWithImport: false,
+            valueIsDefinedByPlusValueFile: false,
+            valueIsLoaded: true,
+            value: configValue
+        };
+        const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, configValueEffectSource);
+        const isValueGlobalTarget = resolveIsGlobalValue(configDef.global, configValue);
+        const isGlobalHumanReadable = (isGlobal) => `${isGlobal ? 'non-' : ''}global`;
+        // The error message make it sound like it's an inherent limitation, it actually isn't (both ways can make senses).
+        assertUsage(isValueGlobalSource === isValueGlobalTarget, `The configuration ${pc.cyan(configNameEffect)} is set to ${pc.cyan(JSON.stringify(configValueEffectSource))} which is considered ${isGlobalHumanReadable(isValueGlobalSource)}. However, it has a meta.effect that sets the configuration ${pc.cyan(configNameTarget)} to ${pc.cyan(JSON.stringify(configValue))} which is considered ${isGlobalHumanReadable(isValueGlobalTarget)}. This is contradictory: make sure the values are either both non-global or both global.`);
+        configValueSources[configNameTarget] ?? (configValueSources[configNameTarget] = []);
+        configValueSources[configNameTarget].push(configValueSource);
+    });
+}
+function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEffect) {
+    const notSupported = `${pc.cyan('meta.effect')} currently only supports setting the value of a config, or modifying the ${pc.cyan('meta.env')} of a config.`;
+    objectEntries(configModFromEffect).forEach(([configNameTarget, configValue]) => {
+        if (configNameTarget !== 'meta')
+            return;
+        let configDefinedAt;
+        if (configDefEffect._userEffectDefinedAtFilePath) {
+            configDefinedAt = getConfigDefinedAt('Config', configNameTarget, configDefEffect._userEffectDefinedAtFilePath);
         }
         else {
-            assertUsage(false, notSupported);
-            /* To implement being able to set a config value in an effect:
-             * - Copy and append definedAtFile.fileExportPathToShowToUser with ['meta', configName, 'effect']
-             *   - Copying the definedAtFile of the config that defines the effect
-             * - Same precedence as the config that sets the value triggering the effect (not the config defining the effect)
-             *   - Apply sortConfigValueSources() again?
-            configValueSources.push()
-            */
+            configDefinedAt = null;
         }
+        assertMetaUsage(configValue, configDefinedAt);
+        objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
+            {
+                const keys = Object.keys(configTargetDef);
+                assertUsage(keys.includes('env'), notSupported);
+                assertUsage(keys.length === 1, notSupported);
+            }
+            const envOverriden = configTargetDef.env;
+            const sources = configValueSources[configTargetName];
+            sources?.forEach((configValueSource) => {
+                // Apply effect
+                configValueSource.configEnv = envOverriden;
+            });
+        });
     });
 }
 function getComputed(configValueSources, configDefinitions) {
@@ -748,7 +802,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 // Show error message upon unknown config
 function assertKnownConfigs(configDefinitionsResolved, plusFilesAll) {
-    const configDefinitionsAll = getConfigDefinitions(plusFilesAll);
+    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesAll).flat());
     const configNamesKnownAll = Object.keys(configDefinitionsAll);
     const configNamesGlobal = Object.keys(configDefinitionsResolved.configDefinitionsGlobal);
     objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configDefinitions, plusFiles }]) => {
@@ -842,7 +896,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     assert(configFilesystemRoutingRoot.configEnv.config);
     // Eagerly loaded since it's config-only
-    assert('value' in configFilesystemRoutingRoot);
+    assert(configFilesystemRoutingRoot.valueIsLoaded);
     const { value } = configFilesystemRoutingRoot;
     const configDefinedAt = getConfigDefinedAt('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
@@ -902,8 +956,8 @@ function getConfVal(plusFile, configName) {
     if (!configNames.includes(configName))
         return null;
     if (plusFile.isNotLoaded)
-        return { configValueLoaded: false };
-    const confVal = { configValue: plusFile.fileExportsByConfigName[configName], configValueLoaded: true };
+        return { valueIsLoaded: false };
+    const confVal = { value: plusFile.fileExportsByConfigName[configName], valueIsLoaded: true };
     return confVal;
 }
 function resolveConfigEnv(configEnv, filePath) {
@@ -932,3 +986,14 @@ function isGlobalLocation(locationId, plusFilesAll) {
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));
 }
+function isOverriden(source, configName, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    assert(configDef);
+    if (configDef.cumulative)
+        return false;
+    const sources = pageConfig.configValueSources[configName];
+    assert(sources);
+    const idx = sources.indexOf(source);
+    assert(idx >= 0);
+    return idx > 0;
+}