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

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

@@ -142,7 +142,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);
@@ -155,9 +155,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(objectEntries(plusFilesAll).map(async ([locationId, plusFiles]) => {
@@ -193,13 +191,13 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         configValueSources: {}
     };
     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 = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
         .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
@@ -216,7 +214,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,
@@ -359,18 +358,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(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) {
+// 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(objectEntries(plusFilesAll)
         .sort(lowerFirst(([locationId]) => locationId.split('/').length))
         .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, plusFilesAll))));
@@ -384,22 +383,20 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
         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);
+            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.
@@ -576,6 +573,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) {
@@ -660,67 +666,103 @@ 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,
+            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).
+        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) {
@@ -834,7 +876,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`);

package/dist/esm/node/prerender/context.d.ts

@@ -1,10 +1,8 @@
-export { isPrerenderEnabled };
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
 import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function isPrerenderEnabled(vikeConfig: VikeConfigObject): boolean;
 declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
 declare function isPrerendering(): boolean;

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

@@ -1,19 +1,14 @@
-export { isPrerenderEnabled };
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
 export { isPrerendering };
 export { setContextIsPrerendering };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
-import { resolvePrerenderConfig } from './resolvePrerenderConfig.js';
+import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
-function isPrerenderEnabled(vikeConfig) {
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    return !!prerenderConfig;
-}
 function isPrerenderAutoRunEnabled(vikeConfig) {
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    return (isPrerenderEnabled(vikeConfig) &&
-        !(prerenderConfig || {}).disableAutoRun &&
+    const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
+    return (prerenderConfigGlobal.isEnabled &&
+        !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
         vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
 }

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -1,12 +1,16 @@
-export { resolvePrerenderConfig };
+export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import type { ConfigResolved } from '../../shared/page-configs/Config/PageContextConfig.js';
 import { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-type PrerenderConfigSemiResolved = ConfigResolved['prerender'];
-type PrerenderConfig = false | Exclude<Required<NonNullable<PrerenderConfigSemiResolved>[number]>, boolean>;
-declare function resolvePrerenderConfig(vikeConfig: VikeConfigObject): PrerenderConfig;
+declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
+    partial: boolean;
+    noExtraDir: boolean;
+    parallel: number | boolean;
+    disableAutoRun: boolean;
+} & {
+    defaultLocalValue: boolean;
+    isEnabled: boolean;
+};
 declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): {
     value: boolean;
-    configValueFilePathToShowToUser: string;
 } | null;

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

@@ -1,27 +1,30 @@
-export { resolvePrerenderConfig };
+export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { assert, isArray } from './utils.js';
+import { assert, isArray, objectAssign } from './utils.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
-import { getConfigValueFilePathToShowToUser } from '../../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);
-    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);
+    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);
+    objectAssign(prerenderConfigGlobal, {
+        defaultLocalValue,
+        isEnabled: defaultLocalValue || vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)
+    });
+    return prerenderConfigGlobal;
 }
 function resolvePrerenderConfigLocal(pageConfig) {
     const configValue = getConfigValueBuildTime(pageConfig, 'prerender');
@@ -32,9 +35,8 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const value = values[0];
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
-    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData[0]);
-    assert(configValueFilePathToShowToUser);
-    return { value, configValueFilePathToShowToUser };
+    const prerenderConfigLocal = { value };
+    return prerenderConfigLocal;
 }
 function isObject2(p) {
     return typeof p === 'object' && p !== null;

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -4,46 +4,24 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
-import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
-import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+import type { PageContextServer } from '../../shared/types.js';
 type ProvidedByHook = null | {
     hookFilePath: string;
     hookName: 'onBeforePrerenderStart' | 'prerender';
 };
-type TransformerHook = {
-    hookFilePath: string;
-    hookName: 'onPrerenderStart' | 'onBeforePrerender';
-};
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
 };
-type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
-type PrerenderContext = {
-    pageContexts: PageContext[];
-    pageContextInit: Record<string, unknown> | null;
-    noExtraDir: boolean;
-    prerenderedPageContexts: PrerenderedPageContexts;
-    output: Output;
-};
-type Output = {
+type Output<PageContext = PageContextPrerendered> = {
     filePath: string;
     fileType: FileType;
     fileContent: string;
-    pageContext: PageContextPrerendered;
+    pageContext: PageContext;
 }[];
 type FileType = 'HTML' | 'JSON';
-type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
-type PageContext = PageContextInitEnhanced & {
-    _urlRewrite: null;
-    _urlHandler: null;
-    _urlOriginalBeforeHook?: string;
-    _urlOriginalModifiedByHook?: TransformerHook;
-    _providedByHook: ProvidedByHook;
-    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -72,3 +50,7 @@ declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, c
     forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;
+type PrerenderContextPublic = {
+    output: Output<PageContextServer>;
+    pageContexts: PageContextServer[];
+};

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

@@ -26,7 +26,7 @@ import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { setContextIsPrerendering } from './context.js';
-import { resolvePrerenderConfig, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
+import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
@@ -82,15 +82,16 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
-    validatePrerenderConfig(prerenderConfig);
-    if (!prerenderConfig) {
+    const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
+    validatePrerenderConfig(prerenderConfigGlobal);
+    const { partial, noExtraDir, parallel, defaultLocalValue, isEnabled } = prerenderConfigGlobal;
+    if (!isEnabled) {
         assert(standaloneTrigger);
-        assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
+        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs whenever possible
+        assertWarning(prerenderConfigGlobal, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the config ${pc.cyan('prerender')} (${pc.underline('https://vike.dev/prerender')}) to enable it.`, {
             onlyOnce: true
         });
     }
-    const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
     const globalContext = await getGlobalContextInternal();
@@ -103,7 +104,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);
@@ -126,20 +127,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 = 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 = resolvePrerenderConfigLocal(pageConfig);
+        const { pageId } = pageConfig;
+        if (!prerenderConfigLocal) {
+            if (!defaultLocalValue) {
+                doNotPrerenderList.push({ pageId });
+            }
+        }
+        else {
+            const { value } = prerenderConfigLocal;
+            if (value === false) {
+                doNotPrerenderList.push({ pageId });
+            }
         }
     });
     // Old design
@@ -172,12 +174,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 });
             }
         }
     });
@@ -530,8 +527,7 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
             if (!isContradictory)
                 return;
         }
-        const { setByConfigName, setByConfigValue, setByConfigFile } = doNotPrerenderListEntry;
-        assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
+        assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)} matching the route of the page ${pc.cyan(pageId)} which isn't configured to be pre-rendered. This is contradictory: either enable pre-rendering for ${pc.cyan(pageId)} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
 async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPrerenderList, partial) {
@@ -778,8 +774,8 @@ prerenderConfig) {
 }
 function makePublic(prerenderContext) {
     const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
-        'pageContexts',
-        'output'
+        'output', // vite-plugin-vercel
+        'pageContexts' // https://vike.dev/i18n#pre-rendering
     ]);
     return prerenderContextPublic;
 }

package/dist/esm/node/prerender/utils.d.ts

@@ -15,3 +15,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/isNotNullish.js';

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

@@ -17,3 +17,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
+export * from '../../utils/isNotNullish.js';

package/dist/esm/node/runtime/globalContext.d.ts

@@ -23,7 +23,6 @@ import type { ResolvedConfig, ViteDevServer } from 'vite';
 import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
 type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
@@ -57,6 +56,8 @@ declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
+type GlobalContextPublic = ReturnType<typeof makePublic>;
+declare function makePublic(globalContext: GlobalContext): Pick<GlobalContext, "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): Promise<void>;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
 declare function setGlobalContext_isPrerendering(): void;