vike 0.4.223-commit-59f3966 → 0.4.223-commit-535bde1

package/dist/cjs/node/api/prepareViteApiCall.js

@@ -40,7 +40,6 @@ exports.prepareViteApiCall = prepareViteApiCall;
 exports.getViteRoot = getViteRoot;
 exports.assertViteRoot = assertViteRoot;
 exports.normalizeViteRoot = normalizeViteRoot;
-// TODO: enable Vike extensions to add Vite plugins
 const vite_1 = require("vite");
 const context_js_1 = require("./context.js");
 const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -18,6 +18,7 @@ const context_js_1 = require("../../api/context.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 const prepareViteApiCall_js_1 = require("../../api/prepareViteApiCall.js");
 const context_js_2 = require("../../prerender/context.js");
+const resolvePrerenderConfig_js_1 = require("../../prerender/resolvePrerenderConfig.js");
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -43,7 +44,7 @@ function commonConfig(vikeVitePluginOptions) {
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: (0, context_js_2.isPrerenderEnabled)(vikeConfig)
+                            prerender: (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig).isEnabled
                         })
                     };
                 }

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

@@ -44,6 +44,7 @@ function getLogicalPath(locationId, ignoredDirs, removeParenthesesDirs) {
     assertIsPath(logicalPath);
     return logicalPath;
 }
+// See getPlusFilesRelevant() and getPlusFilesOrdered()
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     assertLocationId(locationId1);
     assertLocationId(locationId2);
@@ -52,7 +53,7 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     const inheritanceRoot1 = getInheritanceRoot(locationId1);
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     const inheritanceRootPage = getInheritanceRoot(locationIdPage);
-    // sortAfterInheritanceOrder() only works if both locationId1 and locationId2 are inherited by the same page
+    // Only works if both locationId1 and locationId2 are inherited by the same page
     (0, utils_js_1.assert)(isInherited(locationId1, locationIdPage));
     (0, utils_js_1.assert)(isInherited(locationId2, locationIdPage));
     // Equivalent assertion (see isInherited() implementation)

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

@@ -148,7 +148,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);
@@ -161,9 +161,7 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     return { pageConfigs, pageConfigGlobal, global, pages };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
-    const configDefinitionsGlobal = getConfigDefinitions(
-    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs.
-    sortForGlobal(plusFilesAll), (configDef) => !!configDef.global);
+    const configDefinitionsGlobal = getConfigDefinitions(sortAfterInheritanceOrderGlobal(plusFilesAll), (configDef) => !!configDef.global);
     await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
     const configDefinitionsLocal = {};
     await Promise.all((0, utils_js_1.objectEntries)(plusFilesAll).map(async ([locationId, plusFiles]) => {
@@ -199,13 +197,13 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         configValueSources: {}
     };
     (0, utils_js_1.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);
+        const sources = resolveConfigValueSources(configName, configDef, sortAfterInheritanceOrderGlobal(plusFilesAll), userRootDir, true);
         if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
     });
+    applyEffectsMetaEnv(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
+    applyEffectsConfVal(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal);
     assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
     const pageConfigs = (0, utils_js_1.objectEntries)(configDefinitionsResolved.configDefinitionsLocal)
         .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
@@ -222,7 +220,8 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
             configValueSources[configName] = sources;
         });
         const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
-        applyEffectsAll(configValueSources, configDefinitionsLocal);
+        applyEffectsMetaEnv(configValueSources, configDefinitionsLocal);
+        applyEffectsConfVal(configValueSources, configDefinitionsLocal);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
@@ -365,18 +364,18 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
         });
     });
 }
+// Together with getPlusFilesOrdered() this implements the whole config inheritance ordering for non-global configs. See sortAfterInheritanceOrderGlobal() for global configs.
 function getPlusFilesRelevant(plusFilesAll, locationIdPage) {
     const plusFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(plusFilesAll)
         .filter(([locationId]) => {
         return (0, filesystemRouting_js_1.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]) => (0, filesystemRouting_js_1.sortAfterInheritanceOrder)(locationId1, locationId2, locationIdPage)));
     return plusFilesRelevant;
 }
-function sortForGlobal(plusFilesAll) {
+// This implements the whole config inheritance ordering for global configs.
+// 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).
+function sortAfterInheritanceOrderGlobal(plusFilesAll) {
     const plusFilesAllSorted = Object.fromEntries((0, utils_js_1.objectEntries)(plusFilesAll)
         .sort((0, utils_js_1.lowerFirst)(([locationId]) => locationId.split('/').length))
         .sort((0, utils_js_1.makeFirst)(([locationId]) => isGlobalLocation(locationId, plusFilesAll))));
@@ -390,22 +389,20 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
         return configValueSource;
     });
     if ((0, utils_js_1.isCallable)(configDef.global)) {
-        const isGlobalValue = configDef.global;
         (0, utils_js_1.assert)(configDef.env.config);
         sources = sources.filter((source) => {
             (0, utils_js_1.assert)(source.configEnv.config);
             (0, utils_js_1.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.
+// Together with getPlusFilesRelevant() this implements the whole config inheritance ordering.
 function getPlusFilesOrdered(configName, plusFilesRelevant) {
     const plusFilesOrdered = [];
-    // `plusFilesRelevant` is already sorted by sortAfterInheritanceOrder() at getPlusFilesRelevant()
-    // `plusFilesAtLocationId` is already sorted by sortMakeDeterministic() at getPlusFilesAll()
+    // `plusFilesRelevant` is already deterministic, see 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.
@@ -582,6 +579,15 @@ function isDefiningPage(plusFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
+function resolveIsGlobalValue(configDefGlobal, configValue) {
+    let isGlobal;
+    if ((0, utils_js_1.isCallable)(configDefGlobal))
+        isGlobal = configDefGlobal(configValue);
+    else
+        isGlobal = configDefGlobal ?? false;
+    (0, utils_js_1.assert)(typeof isGlobal === 'boolean');
+    return isGlobal;
+}
 function getDefiningConfigNames(plusFile) {
     let configNames = [];
     if (!plusFile.isConfigFile) {
@@ -666,67 +672,103 @@ function assertMetaUsage(metaVal, metaConfigDefinedAt) {
         }
     });
 }
-function applyEffectsAll(configValueSources, configDefinitions) {
-    (0, utils_js_1.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) {
+    (0, utils_js_1.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.)
-        (0, utils_js_1.assertUsage)(configDef.env.config, [
-            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(JSON.stringify(configDef.env))}: effects can only be added to configs with an ${picocolors_1.default.cyan('env')} with ${picocolors_1.default.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``
-        (0, utils_js_1.assert)('value' in source);
-        // Call effect
-        const configModFromEffect = configDef.effect({
-            configValue: source.value,
-            configDefinedAt: (0, getConfigDefinedAt_js_1.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) {
+    (0, utils_js_1.objectEntries)(configDefinitions).forEach(([configNameEffect, configDefEffect]) => {
+        const sourceEffect = configValueSources[configNameEffect]?.[0];
+        if (!sourceEffect)
+            return;
+        const effect = runEffect(configNameEffect, configDefEffect, sourceEffect);
+        if (!effect)
             return;
-        (0, utils_js_1.assert)((0, utils_js_1.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 ${picocolors_1.default.cyan('env')} of a config.`;
-    (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configName, configValue]) => {
-        if (configName === 'meta') {
-            let configDefinedAt;
-            if (configDefEffect._userEffectDefinedAtFilePath) {
-                configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, configDefEffect._userEffectDefinedAtFilePath);
-            }
-            else {
-                configDefinedAt = null;
-            }
-            assertMetaUsage(configValue, configDefinedAt);
-            (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
-                {
-                    const keys = Object.keys(configTargetDef);
-                    (0, utils_js_1.assertUsage)(keys.includes('env'), notSupported);
-                    (0, utils_js_1.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.
+    (0, utils_js_1.assertUsage)(configDef.env.config, [
+        `Cannot add meta.effect to ${picocolors_1.default.cyan(configName)} because its meta.env is ${picocolors_1.default.cyan(JSON.stringify(configDef.env))} but an effect can only be added to a config that has a meta.env with ${picocolors_1.default.cyan('{ config: true }')}.`
+    ].join(' '));
+    (0, utils_js_1.assert)(source.valueIsLoaded);
+    const configValueEffectSource = source.value;
+    // Call effect
+    const configModFromEffect = configDef.effect({
+        configValue: configValueEffectSource,
+        configDefinedAt: (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, source.definedAtFilePath)
+    });
+    if (!configModFromEffect)
+        return null;
+    return { configModFromEffect, configValueEffectSource };
+}
+function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, configValueEffectSource) {
+    (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configNameTarget, configValue]) => {
+        if (configNameTarget === 'meta')
+            return;
+        const configDef = configDefinitions[configNameTarget];
+        (0, utils_js_1.assert)(configDef);
+        (0, utils_js_1.assert)(configDefEffect._userEffectDefinedAtFilePath);
+        const configValueSource = {
+            definedAtFilePath: configDefEffect._userEffectDefinedAtFilePath,
+            plusFile: sourceEffect.plusFile,
+            locationId: sourceEffect.locationId,
+            configEnv: configDef.env,
+            isOverriden: false, // TODO/now check
+            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).
+        (0, utils_js_1.assertUsage)(isValueGlobalSource === isValueGlobalTarget, `The configuration ${picocolors_1.default.cyan(configNameEffect)} is set to ${picocolors_1.default.cyan(JSON.stringify(configValueEffectSource))} which is considered ${isGlobalHumanReadable(isValueGlobalSource)}. However, it has a meta.effect that sets the configuration ${picocolors_1.default.cyan(configNameTarget)} to ${picocolors_1.default.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 = `${picocolors_1.default.cyan('meta.effect')} currently only supports setting the value of a config, or modifying the ${picocolors_1.default.cyan('meta.env')} of a config.`;
+    (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configNameTarget, configValue]) => {
+        if (configNameTarget !== 'meta')
+            return;
+        let configDefinedAt;
+        if (configDefEffect._userEffectDefinedAtFilePath) {
+            configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configNameTarget, configDefEffect._userEffectDefinedAtFilePath);
         }
         else {
-            (0, utils_js_1.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);
+        (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
+            {
+                const keys = Object.keys(configTargetDef);
+                (0, utils_js_1.assertUsage)(keys.includes('env'), notSupported);
+                (0, utils_js_1.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) {
@@ -840,7 +882,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv.config);
     // Eagerly loaded since it's config-only
-    (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
+    (0, utils_js_1.assert)(configFilesystemRoutingRoot.valueIsLoaded);
     const { value } = configFilesystemRoutingRoot;
     const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
     (0, utils_js_1.assertUsage)(typeof value === 'string', `${configDefinedAt} should be a string`);

package/dist/cjs/node/prerender/context.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPrerenderEnabled = isPrerenderEnabled;
 exports.isPrerenderAutoRunEnabled = isPrerenderAutoRunEnabled;
 exports.temp_disablePrerenderAutoRun = temp_disablePrerenderAutoRun;
 exports.isPrerendering = isPrerendering;
@@ -8,14 +7,10 @@ exports.setContextIsPrerendering = setContextIsPrerendering;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
 const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('prerender/context.ts', {});
-function isPrerenderEnabled(vikeConfig) {
-    const prerenderConfig = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfig)(vikeConfig);
-    return !!prerenderConfig;
-}
 function isPrerenderAutoRunEnabled(vikeConfig) {
-    const prerenderConfig = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfig)(vikeConfig);
-    return (isPrerenderEnabled(vikeConfig) &&
-        !(prerenderConfig || {}).disableAutoRun &&
+    const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
+    return (prerenderConfigGlobal.isEnabled &&
+        !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
         vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
 }

package/dist/cjs/node/prerender/resolvePrerenderConfig.js

@@ -1,29 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePrerenderConfig = resolvePrerenderConfig;
+exports.resolvePrerenderConfigGlobal = resolvePrerenderConfigGlobal;
 exports.resolvePrerenderConfigLocal = resolvePrerenderConfigLocal;
 const utils_js_1 = require("./utils.js");
 const getConfigValueBuildTime_js_1 = require("../../shared/page-configs/getConfigValueBuildTime.js");
-const helpers_js_1 = require("../../shared/page-configs/helpers.js");
-// TODO/now:
-// - prerender.value
-function resolvePrerenderConfig(vikeConfig) {
+function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderConfigs = vikeConfig.global.config.prerender;
-    if (!prerenderConfigs &&
-        !vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)) {
-        return false;
-    }
-    let prerenderSettings = prerenderConfigs || [];
+    let prerenderConfigList = prerenderConfigs || [];
     // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
-    prerenderSettings = prerenderSettings.filter(isObject2);
-    (0, utils_js_1.assert)(prerenderSettings.every(isObject2));
-    const prerenderConfig = {
-        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+    prerenderConfigList = prerenderConfigList.filter(isObject2);
+    (0, utils_js_1.assert)(prerenderConfigList.every(isObject2)); // Help TS
+    const prerenderConfigGlobal = {
+        partial: pickFirst(prerenderConfigList.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderConfigList.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderConfigList.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderConfigList.map((c) => c.disableAutoRun)) ?? false
     };
-    return prerenderConfig;
+    const prerenderConfigGlobalLocalValue = prerenderConfigList.map((c) => c.value).filter((v) => v !== null);
+    const defaultLocalValue = pickFirst(prerenderConfigGlobalLocalValue) ??
+        (prerenderConfigGlobalLocalValue.length > 0 ||
+            // Backwards compatibility for with vike({ prerender: true }) in vite.config.js
+            prerenderConfigs?.some((p) => p === true) ||
+            false);
+    (0, utils_js_1.objectAssign)(prerenderConfigGlobal, {
+        defaultLocalValue,
+        isEnabled: defaultLocalValue || vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)
+    });
+    return prerenderConfigGlobal;
 }
 function resolvePrerenderConfigLocal(pageConfig) {
     const configValue = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, 'prerender');
@@ -34,9 +37,8 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const value = values[0];
     (0, utils_js_1.assert)(typeof value === 'boolean');
     (0, utils_js_1.assert)((0, utils_js_1.isArray)(configValue.definedAtData));
-    const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData[0]);
-    (0, utils_js_1.assert)(configValueFilePathToShowToUser);
-    return { value, configValueFilePathToShowToUser };
+    const prerenderConfigLocal = { value };
+    return prerenderConfigLocal;
 }
 function isObject2(p) {
     return typeof p === 'object' && p !== null;

package/dist/cjs/node/prerender/runPrerender.js

@@ -120,15 +120,16 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
     const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfig)(vikeConfig);
-    validatePrerenderConfig(prerenderConfig);
-    if (!prerenderConfig) {
+    const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
+    validatePrerenderConfig(prerenderConfigGlobal);
+    const { partial, noExtraDir, parallel, defaultLocalValue, isEnabled } = prerenderConfigGlobal;
+    if (!isEnabled) {
         (0, utils_js_1.assert)(standaloneTrigger);
-        (0, utils_js_1.assertWarning)(prerenderConfig, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but the config ${picocolors_1.default.cyan('prerender')} isn't set to true`, {
+        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs whenever possible
+        (0, utils_js_1.assertWarning)(prerenderConfigGlobal, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the config ${picocolors_1.default.cyan('prerender')} (${picocolors_1.default.underline('https://vike.dev/prerender')}) to enable it.`, {
             onlyOnce: true
         });
     }
-    const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
     const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
@@ -141,7 +142,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
         output: []
     };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext);
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, globalContext);
@@ -164,20 +165,21 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const prerenderContextPublic = makePublic(prerenderContext);
     return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit, globalContext) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
-        const configValue = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigLocal)(pageConfig);
-        if (!configValue)
-            return;
-        const { value, configValueFilePathToShowToUser } = configValue;
-        if (value === false) {
-            doNotPrerenderList.push({
-                pageId: pageConfig.pageId,
-                setByConfigName: 'prerender',
-                setByConfigValue: false,
-                setByConfigFile: configValueFilePathToShowToUser
-            });
+        const prerenderConfigLocal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigLocal)(pageConfig);
+        const { pageId } = pageConfig;
+        if (!prerenderConfigLocal) {
+            if (!defaultLocalValue) {
+                doNotPrerenderList.push({ pageId });
+            }
+        }
+        else {
+            const { value } = prerenderConfigLocal;
+            if (value === false) {
+                doNotPrerenderList.push({ pageId });
+            }
         }
     });
     // Old design
@@ -210,12 +212,7 @@ async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurr
             }
             else {
                 // Don't pre-render `pageId`
-                doNotPrerenderList.push({
-                    pageId,
-                    setByConfigFile: p.filePath,
-                    setByConfigName: 'doNotPrerender',
-                    setByConfigValue: doNotPrerender
-                });
+                doNotPrerenderList.push({ pageId });
             }
         }
     });
@@ -568,8 +565,7 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
             if (!isContradictory)
                 return;
         }
-        const { setByConfigName, setByConfigValue, setByConfigFile } = doNotPrerenderListEntry;
-        (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))} or remove the URL ${picocolors_1.default.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)} matching the route of the page ${picocolors_1.default.cyan(pageId)} which isn't configured to be pre-rendered. This is contradictory: either enable pre-rendering for ${picocolors_1.default.cyan(pageId)} or remove the URL ${picocolors_1.default.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
 async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
@@ -816,8 +812,8 @@ prerenderConfig) {
 }
 function makePublic(prerenderContext) {
     const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
-        'pageContexts',
-        'output'
+        'output', // vite-plugin-vercel
+        'pageContexts' // https://vike.dev/i18n#pre-rendering
     ]);
     return prerenderContextPublic;
 }

package/dist/cjs/node/prerender/utils.js

@@ -33,3 +33,4 @@ __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
 __exportStar(require("../../utils/makePublicCopy.js"), exports);
+__exportStar(require("../../utils/isNotNullish.js"), exports);

package/dist/cjs/shared/page-configs/getConfigValueBuildTime.js

@@ -31,7 +31,7 @@ function getConfigValue(pageConfig, configName) {
         (0, utils_js_1.assert)(configValueSource);
         (0, utils_js_1.assert)(configValueSource.isOverriden === false);
         (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
-        (0, utils_js_1.assert)('value' in configValueSource);
+        (0, utils_js_1.assert)(configValueSource.valueIsLoaded);
         return {
             type: 'standard',
             value: configValueSource.value,
@@ -54,7 +54,7 @@ function mergeCumulative(configValueSources) {
     configValueSources.forEach((configValueSource) => {
         (0, utils_js_1.assert)(configValueSource.isOverriden === false);
         (0, utils_js_1.assert)(configValueSource.configEnv.config === true);
-        (0, utils_js_1.assert)('value' in configValueSource);
+        (0, utils_js_1.assert)(configValueSource.valueIsLoaded);
         value.push(configValueSource.value);
         definedAtData.push(getDefinedAtFile(configValueSource));
     });

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -66,7 +66,9 @@ function parseConfigValuesSerialized_tmp(configValuesSerialized) {
             const { valueSerialized, ...common } = configValueSeriliazed;
             const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
                 (0, utils_js_1.assert)(configValueSeriliazed.type !== 'computed');
-                return configValueSeriliazed.definedAtData;
+                const { definedAtData } = configValueSeriliazed;
+                const definedAtFile = Array.isArray(definedAtData) ? definedAtData[0] : definedAtData;
+                return definedAtFile;
             });
             addSideExports(sideExports);
             configValue = { value, ...common };

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -51,7 +51,7 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatc
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     (0, utils_js_1.assert)(configValueSource.isOverriden === false);
     let valueData;
-    if ('value' in configValueSource && !configValueSource.valueIsLoadedWithImport) {
+    if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
         valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.223-commit-59f3966';
+exports.PROJECT_VERSION = '0.4.223-commit-535bde1';

package/dist/esm/node/api/prepareViteApiCall.js

@@ -2,7 +2,6 @@ export { prepareViteApiCall };
 export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
-// TODO: enable Vike extensions to add Vite plugins
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -12,7 +12,8 @@ import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
-import { isPrerenderEnabled, temp_disablePrerenderAutoRun } from '../../prerender/context.js';
+import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
+import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -38,7 +39,7 @@ function commonConfig(vikeVitePluginOptions) {
                         },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
-                            prerender: isPrerenderEnabled(vikeConfig)
+                            prerender: resolvePrerenderConfigGlobal(vikeConfig).isEnabled
                         })
                     };
                 }

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

@@ -40,6 +40,7 @@ function getLogicalPath(locationId, ignoredDirs, removeParenthesesDirs) {
     assertIsPath(logicalPath);
     return logicalPath;
 }
+// See getPlusFilesRelevant() and getPlusFilesOrdered()
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     assertLocationId(locationId1);
     assertLocationId(locationId2);
@@ -48,7 +49,7 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     const inheritanceRoot1 = getInheritanceRoot(locationId1);
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     const inheritanceRootPage = getInheritanceRoot(locationIdPage);
-    // sortAfterInheritanceOrder() only works if both locationId1 and locationId2 are inherited by the same page
+    // Only works if both locationId1 and locationId2 are inherited by the same page
     assert(isInherited(locationId1, locationIdPage));
     assert(isInherited(locationId2, locationIdPage));
     // Equivalent assertion (see isInherited() implementation)