vike 0.4.218 → 0.4.220-commit-a9f46b8

package/dist/esm/shared/page-configs/Config/PageContextConfig.d.ts

@@ -1,11 +1,15 @@
 export type { PageContextConfig };
+export type { ConfigResolved };
 import type { VikePackages } from '../../VikeNamespace.js';
-import type { ConfigBuiltIn, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
 import type { Combine, IsNotEmpty, XOR5 } from './helpers.js';
-type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
-};
-type PageContextConfig = ConfigBuiltIn & Vike.ConfigResolved & WithoutImportString<Omit<Vike.Config, keyof Vike.ConfigResolved>> & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type PageContextConfig = ConfigResolved & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
+type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
+type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type ConfigVikePackagesIntersection = VikePackages.ConfigVikeReact & VikePackages.ConfigVikeVue & VikePackages.ConfigVikeSolid & VikePackages.ConfigVikeSvelte & VikePackages.ConfigVikeAngular;
 type ConfigVikePackagesCombined = Combine<VikePackages.ConfigVikeReact, Combine<VikePackages.ConfigVikeVue, Combine<VikePackages.ConfigVikeSolid, Combine<VikePackages.ConfigVikeSvelte, VikePackages.ConfigVikeAngular>>>>;
 type ConfigVikePackagesNotEmptyXor = XOR5<IsNotEmpty<VikePackages.ConfigVikeReact>, IsNotEmpty<VikePackages.ConfigVikeVue>, IsNotEmpty<VikePackages.ConfigVikeSolid>, IsNotEmpty<VikePackages.ConfigVikeSvelte>, IsNotEmpty<VikePackages.ConfigVikeAngular>>;
+type WithoutImportString<T> = {
+    [K in keyof T]: Exclude<T[K], ImportString>;
+};

package/dist/esm/shared/page-configs/Config.d.ts

@@ -1,6 +1,8 @@
 export type { Config };
 export type { ConfigBuiltIn };
+export type { ConfigBuiltInResolved };
 export type { ConfigNameBuiltIn };
+export type { ConfigNameGlobal };
 export type { ConfigMeta };
 export type { HookName };
 export type { HookNamePage };
@@ -35,15 +37,17 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
+import type { InlineConfig } from 'vite';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
 /** Hook for fetching data.
  *
@@ -344,6 +348,16 @@ type ConfigBuiltIn = {
      * https://vike.dev/meta
      */
     meta?: ConfigMeta | ImportString;
+    /** Vite configuration.
+     *
+     * https://vite.dev/config/
+     */
+    vite?: InlineConfig;
+    /** Permanent redirections (HTTP status code 301)
+     *
+     * https://vike.dev/redirects
+     */
+    redirects?: Record<string, string>;
     /**
      * @experimental DON'T USE: the API *will* have breaking changes upon any minor version release.
      *
@@ -390,5 +404,9 @@ type ConfigBuiltIn = {
      */
     keepScrollPosition?: KeepScrollPosition;
 };
+type ConfigBuiltInResolved = {
+    passToClient?: string[][];
+    redirects?: Record<string, string>[];
+};
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -32,9 +32,12 @@ type PageConfigBase = {
 type PageConfigRuntime = PageConfigBase & {
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
-    loadConfigValuesAll: () => Promise<{
-        configValuesSerialized: Record<string, ConfigValueSerialized>;
-    }>;
+    loadConfigValuesAll: () => {
+        moduleId: string;
+        moduleExports: Promise<{
+            configValuesSerialized: Record<string, ConfigValueSerialized>;
+        }>;
+    };
 };
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {
@@ -54,6 +57,7 @@ type PageConfigGlobalRuntime = {
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
     configDefinitions: ConfigDefinitions;
+    configValuesComputed?: undefined;
 };
 /** In what environment(s) the config value is loaded.
  *
@@ -70,6 +74,8 @@ type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
     /** Load value only in production, or only in development. */
     production?: boolean;
 };
+type ConfigValueSources = Record<string, // configName
+ConfigValueSource[]>;
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
@@ -85,11 +91,13 @@ type ConfigValueSource = {
 type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;
 };
-type ConfigValueSources = Record<string, ConfigValueSource[]>;
-type ConfigValuesComputed = Record<string, {
+type ConfigValuesComputed = Record<string, // configName
+{
     configEnv: ConfigEnvInternal;
     value: unknown;
 }>;
+type ConfigValues = Record<string, // configName
+ConfigValue>;
 type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComputed;
 /** Defined by a unique source (thus unique file path). */
 type ConfigValueStandard = {
@@ -109,7 +117,6 @@ type ConfigValueComputed = {
     value: unknown;
     definedAtData: null;
 };
-type ConfigValues = Record<string, ConfigValue>;
 type DefinedAtData = DefinedAtFile | DefinedAtFile[] | null;
 type DefinedAtFile = {
     filePathToShowToUser: string;

package/dist/esm/shared/{getPageFiles/getExports.d.ts → page-configs/getPageConfigUserFriendly.d.ts}

@@ -1,14 +1,17 @@
-export { getPageContextExports };
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyNew };
+export type { ConfigUserFriendly };
+export type { PageConfigUserFriendly };
+export type { Source };
+export type { Sources };
+export type { From };
 export type { ExportsAll };
-export type { PageContextExports };
 export type { ConfigEntries };
-export type { From };
-export type { Sources };
-export type { Source };
-import type { FileType } from './fileTypes.js';
-import type { PageConfigRuntimeLoaded } from './../page-configs/PageConfig.js';
-import type { PageFile } from './getPageFileObject.js';
-import { type ConfigDefinedAtOptional } from '../page-configs/getConfigDefinedAt.js';
+import type { FileType } from '../getPageFiles/fileTypes.js';
+import type { PageFile } from '../getPageFiles/getPageFileObject.js';
+import type { ConfigValues, PageConfigRuntimeLoaded } from './PageConfig.js';
+import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
+import type { ConfigResolved } from './Config/PageContextConfig.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
@@ -29,11 +32,11 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type PageContextExports = {
+type PageConfigUserFriendly = {
+    config: Record<string, unknown>;
     source: Source;
     sources: Sources;
     from: From;
-    config: Record<string, unknown>;
     configEntries: ConfigEntries;
     exports: Record<string, unknown>;
     exportsAll: ExportsAll;
@@ -70,4 +73,15 @@ type SourceConfigsComputed = {
     type: 'configsComputed';
     value: unknown;
 };
-declare function getPageContextExports(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageContextExports;
+declare function getPageConfigUserFriendly(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null): PageConfigUserFriendly;
+type ConfigUserFriendly = {
+    config: ConfigResolved;
+    configEntries: ConfigEntries;
+    exportsAll: ExportsAll;
+    source: Source;
+    sources: Sources;
+    from: From;
+};
+declare function getPageConfigUserFriendlyNew(pageConfig: {
+    configValues: ConfigValues;
+}): ConfigUserFriendly;

package/dist/esm/shared/{getPageFiles/getExports.js → page-configs/getPageConfigUserFriendly.js}

@@ -1,14 +1,14 @@
-export { getPageContextExports };
-import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
-import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
-import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
-import { getConfigDefinedAtOptional, getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
-import { getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
+export { getPageConfigUserFriendly };
+export { getPageConfigUserFriendlyNew };
+import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
+import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
+import { getConfigValueFilePathToShowToUser } from './helpers.js';
+import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getPageContextExports(pageFiles, pageConfig) {
-    const configEntries = {};
+function getPageConfigUserFriendly(pageFiles, pageConfig) {
     const config = {};
-    const exportsAll = {};
+    const configEntries = {}; // TODO/v1-release: remove
+    const exportsAll = {}; // TODO/v1-release: remove
     // V0.4 design
     // TODO/v1-release: remove
     pageFiles.forEach((pageFile) => {
@@ -26,78 +26,26 @@ function getPageContextExports(pageFiles, pageConfig) {
             });
         });
     });
-    // V1 design
-    const source = {};
-    const sources = {};
-    const addSrc = (src, configName) => {
-        source[configName] = src;
-        sources[configName] ?? (sources[configName] = []);
-        sources[configName].push(src);
-    };
-    const from = {
-        configsStandard: {},
-        configsCumulative: {},
-        configsComputed: {}
-    };
+    let source;
+    let sources;
+    let from;
     if (pageConfig) {
-        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value } = configValue;
-            const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-            const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
-            config[configName] = config[configName] ?? value;
-            configEntries[configName] = configEntries[configName] ?? [];
-            // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
-            assert(configEntries[configName].length === 0);
-            configEntries[configName].push({
-                configValue: value,
-                configDefinedAt,
-                configDefinedByFile: configValueFilePathToShowToUser
-            });
-            if (configValue.type === 'standard') {
-                const src = {
-                    type: 'configsStandard',
-                    value: configValue.value,
-                    definedAt: getDefinedAtString(configValue.definedAtData, configName)
-                };
-                addSrc(src, configName);
-                from.configsStandard[configName] = src;
-            }
-            if (configValue.type === 'cumulative') {
-                const src = {
-                    type: 'configsCumulative',
-                    values: configValue.value.map((value, i) => {
-                        const definedAtFile = configValue.definedAtData[i];
-                        assert(definedAtFile);
-                        const definedAt = getDefinedAtString(definedAtFile, configName);
-                        return {
-                            value,
-                            definedAt
-                        };
-                    })
-                };
-                addSrc(src, configName);
-                from.configsCumulative[configName] = src;
-            }
-            if (configValue.type === 'computed') {
-                const src = {
-                    type: 'configsComputed',
-                    value: configValue.value
-                };
-                addSrc(src, configName);
-                from.configsComputed[configName] = src;
-            }
-            // TODO/v1-release: remove
-            const exportName = configName;
-            exportsAll[exportName] = exportsAll[exportName] ?? [];
-            exportsAll[exportName].push({
-                exportValue: value,
-                exportSource: configDefinedAt,
-                filePath: configValueFilePathToShowToUser,
-                _filePath: configValueFilePathToShowToUser,
-                _fileType: null,
-                _isFromDefaultExport: null
-            });
-        });
+        const res = getPageConfigUserFriendlyNew(pageConfig);
+        source = res.source;
+        sources = res.sources;
+        from = res.from;
+        Object.assign(config, res.config);
+        Object.assign(configEntries, res.configEntries);
+        Object.assign(exportsAll, res.exportsAll);
+    }
+    else {
+        source = {};
+        sources = {};
+        from = {
+            configsStandard: {},
+            configsCumulative: {},
+            configsComputed: {}
+        };
     }
     const pageExports = createObjectWithDeprecationWarning();
     const exports = {};
@@ -127,6 +75,90 @@ function getPageContextExports(pageFiles, pageConfig) {
     };
     return pageContextExports;
 }
+// V1 design
+function getPageConfigUserFriendlyNew(pageConfig) {
+    const config = {};
+    const configEntries = {};
+    const exportsAll = {};
+    const source = {};
+    const sources = {};
+    const from = {
+        configsStandard: {},
+        configsCumulative: {},
+        configsComputed: {}
+    };
+    const addSrc = (src, configName) => {
+        source[configName] = src;
+        sources[configName] ?? (sources[configName] = []);
+        sources[configName].push(src);
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
+        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
+        config[configName] = config[configName] ?? value;
+        configEntries[configName] = configEntries[configName] ?? [];
+        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
+        assert(configEntries[configName].length === 0);
+        configEntries[configName].push({
+            configValue: value,
+            configDefinedAt,
+            configDefinedByFile: configValueFilePathToShowToUser
+        });
+        if (configValue.type === 'standard') {
+            const src = {
+                type: 'configsStandard',
+                value: configValue.value,
+                definedAt: getDefinedAtString(configValue.definedAtData, configName)
+            };
+            addSrc(src, configName);
+            from.configsStandard[configName] = src;
+        }
+        if (configValue.type === 'cumulative') {
+            const src = {
+                type: 'configsCumulative',
+                values: configValue.value.map((value, i) => {
+                    const definedAtFile = configValue.definedAtData[i];
+                    assert(definedAtFile);
+                    const definedAt = getDefinedAtString(definedAtFile, configName);
+                    return {
+                        value,
+                        definedAt
+                    };
+                })
+            };
+            addSrc(src, configName);
+            from.configsCumulative[configName] = src;
+        }
+        if (configValue.type === 'computed') {
+            const src = {
+                type: 'configsComputed',
+                value: configValue.value
+            };
+            addSrc(src, configName);
+            from.configsComputed[configName] = src;
+        }
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    });
+    return {
+        config,
+        configEntries,
+        exportsAll,
+        source,
+        sources,
+        from
+    };
+}
 function getExportValues(pageFile) {
     const { filePath, fileExports } = pageFile;
     assert(fileExports); // assume pageFile.loadFile() was called

package/dist/esm/shared/page-configs/loadConfigValues.js

@@ -1,5 +1,5 @@
 export { loadConfigValues };
-import { objectAssign } from '../utils.js';
+import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
@@ -7,7 +7,11 @@ async function loadConfigValues(pageConfig, isDev) {
         !isDev) {
         return pageConfig;
     }
-    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    const { moduleId, moduleExports } = pageConfig.loadConfigValuesAll();
+    const configValuesLoaded = await moduleExports;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!configValuesLoaded)
+        assert(false, { moduleExports, configValuesLoaded, moduleId });
     const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
     Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -1,7 +1,27 @@
 export { serializeConfigValues };
-import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
-declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
-    configValuesComputed?: undefined;
-}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, { isEager }: {
-    isEager: boolean;
-}, tabspace: string): string[];
+export { getConfigValuesBase };
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
+type ConfigValuesBase = ({
+    configValueBase: {
+        type: 'computed';
+        definedAtData: null;
+    };
+    value: unknown;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'standard';
+        definedAtData: DefinedAtFile;
+    };
+    sourceRelevant: ConfigValueSource;
+    configName: string;
+} | {
+    configValueBase: {
+        type: 'cumulative';
+        definedAtData: DefinedAtFile[];
+    };
+    sourcesRelevant: ConfigValueSource[];
+    configName: string;
+})[];

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

@@ -1,4 +1,5 @@
 export { serializeConfigValues };
+export { getConfigValuesBase };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
@@ -12,77 +13,45 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
 assertIsNotProductionRuntime();
-function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace, isEager) {
     const lines = [];
     tabspace += '  ';
-    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
-        if (!isEnvMatch(configValuesComputed.configEnv))
-            return;
-        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
-        if (pageConfig.configValueSources[configName])
-            return;
-        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
-        const configValueBase = {
-            type: 'computed',
-            definedAtData: null
-        };
-        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-    });
-    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-        const configDef = pageConfig.configDefinitions[configName];
-        assert(configDef);
-        if (isEager !== !!configDef.eager)
-            return;
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            assert(configValueSource);
-            assert(sources.slice(1).every((s) => s.isOverriden === true));
-            if (!isEnvMatch(configValueSource.configEnv))
-                return;
-            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile
-            };
+    getConfigValuesBase(pageConfig, isEnvMatch, isEager).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
-        else {
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
             const valueDataList = [];
-            const definedAtData = [];
-            sources
-                .filter((s) => !s.isOverriden)
-                .forEach((configValueSource) => {
-                if (!isEnvMatch(configValueSource.configEnv))
-                    return;
-                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            sourcesRelevant.forEach((source) => {
+                const valueData = getValueSerializedFromSource(source, configName, importStatements);
                 valueDataList.push(valueData);
-                definedAtData.push(definedAtFile);
             });
-            if (valueDataList.length === 0)
-                return;
-            const configValueBase = {
-                type: 'cumulative',
-                definedAtData
-            };
             serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
         }
     });
     return lines;
 }
-function serializeConfigValueSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements) {
     assert(configValueSource.isOverriden === false);
     let valueData;
     if ('value' in configValueSource) {
-        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
     }
     else {
-        valueData = serializeWithImport(configValueSource, importStatements);
+        valueData = getValueSerializedWithImport(configValueSource, importStatements);
     }
-    const definedAtFile = {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-    return { valueData, definedAtFile };
+    return valueData;
 }
 function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
     lineAdd(`[${JSON.stringify(configName)}]: {`);
@@ -126,7 +95,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function serializeWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
     assert(valueIsImportedAtRuntime);
@@ -139,7 +108,7 @@ function serializeWithImport(configValueSource, importStatements) {
         valueAsJsCode: importName
     };
 }
-function serializeWithJson(value, configName, definedAtData, importStatements) {
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements) {
     const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
     return {
         type: 'js-serialized',
@@ -196,3 +165,59 @@ function logJsonSerializeError(err, configName, definedAtData) {
     assert(configValueFilePathToShowToUser);
     assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
 }
+function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
+    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
+        if (!isEnvMatch(valueInfo.configEnv))
+            return 'SKIP';
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return 'SKIP';
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        return { configValueBase, value: valueInfo.value, configName };
+    });
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        assert(configDef);
+        if (isEager !== null && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const source = sources[0];
+            assert(source);
+            assert(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(source.configEnv))
+                return 'SKIP';
+            const definedAtFile = getDefinedAtFileSource(source);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            return { configValueBase, sourceRelevant: source, configName };
+        }
+        else {
+            const sourcesRelevant = sources.filter((source) => !source.isOverriden && isEnvMatch(source.configEnv));
+            if (sourcesRelevant.length === 0)
+                return 'SKIP';
+            const definedAtData = [];
+            sourcesRelevant.forEach((source) => {
+                const definedAtFile = getDefinedAtFileSource(source);
+                definedAtData.push(definedAtFile);
+            });
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            return { configValueBase, sourcesRelevant, configName };
+        }
+    });
+    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
+}
+function getDefinedAtFileSource(source) {
+    const definedAtFile = {
+        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return definedAtFile;
+}

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,7 +1,7 @@
 export { executeGuardHook };
-import type { PageContextExports, PageFile } from '../getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../getPageFiles.js';
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
-declare function executeGuardHook<T extends PageContextExports & {
+declare function executeGuardHook<T extends PageConfigUserFriendly & {
     pageId: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];