vike 0.4.171 → 0.4.172

package/dist/esm/shared/hooks/executeHook.js

@@ -1,18 +1,20 @@
 export { executeHook };
+export { getPageContext };
 export { isUserHookError };
 import { getProjectError, assertWarning } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
 const globalObject = getGlobalObject('utils/executeHook.ts', {
-    userHookErrors: new WeakMap()
+    userHookErrors: new WeakMap(),
+    pageContext: null
 });
 function isUserHookError(err) {
     if (!isObject(err))
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-function executeHook(hookFnCaller, hook) {
+function executeHook(hookFnCaller, hook, pageContext) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
     let resolve;
     let reject;
@@ -43,6 +45,7 @@ function executeHook(hookFnCaller, hook) {
         }, timeoutErr);
     (async () => {
         try {
+            providePageContext(pageContext);
             const ret = await hookFnCaller();
             resolve(ret);
         }
@@ -58,3 +61,19 @@ function executeHook(hookFnCaller, hook) {
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    return globalObject.pageContext;
+}
+function providePageContext(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

package/dist/esm/shared/hooks/getHook.d.ts

@@ -11,7 +11,7 @@ export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
 import type { PageContextExports } from '../getPageFiles.js';
 import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
-import type { PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
     hookTimeout: HookTimeout;
@@ -27,7 +27,7 @@ type HookTimeout = {
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
 declare function getHook(pageContext: PageContextExports, hookName: HookName): null | Hook;
-declare function getHookFromPageConfig(pageConfig: PageConfigRuntime | PageConfigBuildTime, hookName: HookNamePage): null | Hook;
+declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function assertHook<TPageContext extends PageContextExports, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;

package/dist/esm/shared/hooks/getHook.js

@@ -8,7 +8,7 @@ export { setIsPrerenderering };
 export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('getHook.ts', {
@@ -32,8 +32,8 @@ function getHook(pageContext, hookName) {
     return { hookFn, hookName, hookFilePath, hookTimeout };
 }
 function getHookFromPageConfig(pageConfig, hookName) {
-    const configValue = getConfigValue(pageConfig, hookName);
-    const hooksTimeout = getConfigValue(pageConfig, 'hooksTimeout')?.value;
+    const configValue = getConfigValueRuntime(pageConfig, hookName);
+    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
     if (!configValue)
         return null;
     const hookFn = configValue.value;

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

@@ -1,8 +1,8 @@
 export type { PageContextConfig };
 import type { VikePackages } from '../../VikeNamespace.js';
 import type { ConfigBuiltIn } from '../Config.js';
-import type { Combine, IsNotEmpty, XOR5 } from './helpers.ts';
-type PageContextConfig = ConfigBuiltIn & Vike.Config & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+import type { Combine, IsNotEmpty, XOR5 } from './helpers.js';
+type PageContextConfig = ConfigBuiltIn & Vike.ConfigResolved & Omit<Vike.Config, keyof Vike.ConfigResolved> & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
 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>>;

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

@@ -6,7 +6,7 @@ export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
 export type { PageConfigGlobalBuildTime };
 export type { ConfigValue };
-export type { ConfigValueClassic };
+export type { ConfigValueStandard };
 export type { ConfigValueCumulative };
 export type { ConfigValueComputed };
 export type { ConfigValues };
@@ -16,9 +16,10 @@ export type { ConfigValuesComputed };
 export type { DefinedAtData };
 export type { DefinedAtFile };
 export type { DefinedAtFilePath };
-import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
+import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
+import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -26,13 +27,12 @@ type PageConfigBase = {
         routeString: string;
         definedBy: string;
     };
-    configValues: ConfigValues;
 };
 /** Page config data structure available at runtime */
 type PageConfigRuntime = PageConfigBase & {
+    configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
     loadConfigValuesAll: () => Promise<{
-        configValuesImported: ConfigValueImported[];
         configValuesSerialized: Record<string, ConfigValueSerialized>;
     }>;
 };
@@ -43,6 +43,7 @@ type PageConfigRuntimeLoaded = PageConfigRuntime & {
 };
 /** Page config data structure available at build-time */
 type PageConfigBuildTime = PageConfigBase & {
+    configDefinitions: ConfigDefinitions;
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
@@ -52,6 +53,7 @@ type PageConfigGlobalRuntime = {
 };
 type PageConfigGlobalBuildTime = {
     configValueSources: ConfigValueSources;
+    configDefinitions: ConfigDefinitions;
 };
 /** In what environment(s) the config value is loaded.
  *
@@ -65,18 +67,22 @@ type ConfigEnv = {
 /** For Vike internal use */
 type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
     client?: boolean | 'if-client-routing';
+    /** Always load value, not matter what page is loaded. */
     eager?: boolean;
+    /** Load value only in production or only in development. */
+    production?: boolean;
 };
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAtFilePath: DefinedAtFilePath;
     locationId: LocationId;
+    isOverriden: boolean;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
-    valueIsDefinedByValueFile: boolean;
+    valueIsDefinedByPlusFile: boolean;
 };
 type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;
@@ -86,10 +92,10 @@ type ConfigValuesComputed = Record<string, {
     configEnv: ConfigEnvInternal;
     value: unknown;
 }>;
-type ConfigValue = ConfigValueClassic | ConfigValueCumulative | ConfigValueComputed;
+type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComputed;
 /** Defined by a unique source (thus unique file path). */
-type ConfigValueClassic = {
-    type: 'classic';
+type ConfigValueStandard = {
+    type: 'standard';
     value: unknown;
     definedAtData: DefinedAtFile;
 };

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

@@ -1,14 +1,14 @@
-export { getConfigValue };
-import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue } from './PageConfig.js';
+export { getConfigValueRuntime };
+export { getConfigValueTyped };
+export type { TypeAsString };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { PageConfigRuntime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-type PageConfigCommon = PageConfigRuntime | PageConfigBuildTime;
 type ConfigName = ConfigNameBuiltIn;
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | ConfigValue & {
-    value: string;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
-    value: boolean;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
-    value: unknown;
-};
+type TypeAsString = 'string' | 'boolean' | undefined;
+declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});
+declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -1,18 +1,24 @@
-export { getConfigValue };
+export { getConfigValueRuntime };
+export { getConfigValueTyped };
 import { assert, assertUsage, getValuePrintable } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-// prettier-ignore
-// biome-ignore format:
-function getConfigValue(pageConfig, configName, type) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    if (configValue === null)
-        return null;
+function getConfigValueTyped(configValue, configName, type) {
+    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null) return null
+    */
     const { value, definedAtData } = configValue;
     if (type)
         assertConfigValueType(value, type, configName, definedAtData);
     return configValue;
 }
+function getConfigValueRuntime(pageConfig, configName, type) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    return getConfigValueTyped(configValue, configName, type);
+}
 function assertConfigValueType(value, type, configName, definedAtData) {
     assert(value !== null);
     const typeActual = typeof value;
@@ -26,12 +32,3 @@ function assertConfigValueType(value, type, configName, definedAtData) {
     const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
     assertUsage(false, errMsg);
 }
-function getConfigValueEntry(pageConfig, configName) {
-    const configValue = pageConfig.configValues[configName];
-    if (!configValue)
-        return null;
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null)
-        return null;
-    return configValue;
-}

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

@@ -0,0 +1,9 @@
+export { getConfigValueBuildTime };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { PageConfigBuildTime, ConfigValue } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
+import { type TypeAsString } from './getConfigValue.js';
+type ConfigName = ConfigNameBuiltIn;
+declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -0,0 +1,67 @@
+export { getConfigValueBuildTime };
+import { assert } from '../utils.js';
+import { getConfigValueTyped } from './getConfigValue.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+assertIsNotProductionRuntime();
+function getConfigValueBuildTime(pageConfig, configName, type) {
+    const configValue = getConfigValue(pageConfig, configName);
+    if (!configValue)
+        return null;
+    return getConfigValueTyped(configValue, configName, type);
+}
+function getConfigValue(pageConfig, configName) {
+    const { configValueSources, configValuesComputed, configDefinitions } = pageConfig;
+    const configValueComputed = configValuesComputed[configName];
+    if (configValueComputed) {
+        return {
+            type: 'computed',
+            value: configValueComputed.value,
+            definedAtData: null
+        };
+    }
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    assert(sources.every((s) => s.configEnv.config === true));
+    const configDef = configDefinitions[configName];
+    assert(configDef);
+    if (!configDef.cumulative) {
+        const configValueSource = sources[0];
+        assert(configValueSource);
+        assert(configValueSource.isOverriden === false);
+        assert(sources.slice(1).every((s) => s.isOverriden === true));
+        assert('value' in configValueSource);
+        return {
+            type: 'standard',
+            value: configValueSource.value,
+            definedAtData: getDefinedAtFile(configValueSource)
+        };
+    }
+    else {
+        const { value, definedAtData } = mergeCumulative(sources);
+        assert(value.length === definedAtData.length);
+        return {
+            type: 'cumulative',
+            value,
+            definedAtData
+        };
+    }
+}
+function mergeCumulative(configValueSources) {
+    const value = [];
+    const definedAtData = [];
+    configValueSources.forEach((configValueSource) => {
+        assert(configValueSource.isOverriden === false);
+        assert(configValueSource.configEnv.config === true);
+        assert('value' in configValueSource);
+        value.push(configValueSource.value);
+        definedAtData.push(getDefinedAtFile(configValueSource));
+    });
+    return { value, definedAtData };
+}
+function getDefinedAtFile(configValueSource) {
+    return {
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+    };
+}

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

@@ -1,7 +1,6 @@
 export { loadConfigValues };
 import { objectAssign } from '../utils.js';
-import { parseConfigValuesImported } from './serialize/parseConfigValuesImported.js';
-import { parseConfigValuesSerialized } from './serialize/parseConfigValuesSerialized.js';
+import { parseConfigValuesSerialized } from './serialize/parsePageConfigs.js';
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
@@ -9,16 +8,8 @@ async function loadConfigValues(pageConfig, isDev) {
         return pageConfig;
     }
     const configValuesLoaded = await pageConfig.loadConfigValuesAll();
-    {
-        const { configValuesImported } = configValuesLoaded;
-        const configValuesAddendum = parseConfigValuesImported(configValuesImported);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
-    {
-        const { configValuesSerialized } = configValuesLoaded;
-        const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
+    const configValues = parseConfigValuesSerialized(configValuesLoaded.configValuesSerialized);
+    Object.assign(pageConfig.configValues, configValues);
     objectAssign(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

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

@@ -1,35 +1,31 @@
 export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
-export type { ConfigValueImported };
-import type { ConfigValueClassic, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
+export type { ValueSerialized };
+import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
-    /** Config values imported eagerly such as config.route */
-    configValuesImported: ConfigValueImported[];
 };
 type PageConfigGlobalRuntimeSerialized = {
-    configValuesImported: ConfigValueImported[];
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+};
+type ValueSerialized = {
+    type: 'js-serialized';
+    value: unknown;
+} | {
+    type: 'plus-file';
+    exportValues: Record<string, unknown>;
+} | {
+    type: 'pointer-import';
+    value: unknown;
 };
 /** Value is serialized */
-type ConfigValueSerialized = (Omit<ConfigValueClassic, 'value'> & {
-    valueSerialized: string;
+type ConfigValueSerialized = (Omit<ConfigValueStandard, 'value'> & {
+    valueSerialized: ValueSerialized;
 }) | (Omit<ConfigValueCumulative, 'value'> & {
-    valueSerialized: string;
+    valueSerialized: ValueSerialized[];
 }) | (Omit<ConfigValueComputed, 'value'> & {
-    valueSerialized: string;
-});
-/** Value is imported */
-type ConfigValueImported = {
-    configName: string;
-    importPath: string;
-} & ({
-    isValueFile: true;
-    exportValues: Record<string, unknown>;
-} | {
-    isValueFile: false;
-    exportName: string;
-    exportValue: unknown;
+    valueSerialized: ValueSerialized;
 });

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

@@ -1,5 +1 @@
-export { assertPageConfigsSerialized };
-export { assertPageConfigGlobalSerialized };
-import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
-declare function assertPageConfigsSerialized(pageConfigsSerialized: unknown): asserts pageConfigsSerialized is PageConfigRuntimeSerialized[];
-declare function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized: unknown): asserts pageConfigGlobalSerialized is PageConfigGlobalRuntimeSerialized;
+export {};

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

@@ -1,16 +1 @@
-export { assertPageConfigsSerialized };
-export { assertPageConfigGlobalSerialized };
-import { assert, isObject, hasProp, isArray } from '../../utils.js';
-function assertPageConfigsSerialized(pageConfigsSerialized) {
-    assert(isArray(pageConfigsSerialized));
-    pageConfigsSerialized.forEach((pageConfigSerialized) => {
-        assert(isObject(pageConfigSerialized));
-        assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
-        assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
-        assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
-        assert(hasProp(pageConfigSerialized, 'configValuesImported'));
-    });
-}
-function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
-    assert(hasProp(pageConfigGlobalSerialized, 'configValuesImported'));
-}
+export {};

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

@@ -1,6 +1,9 @@
 export { parsePageConfigs };
-import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+export { parseConfigValuesSerialized };
+import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
+import type { ConfigValueSerialized } from './PageConfigSerialized.js';
+declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;

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

@@ -1,21 +1,17 @@
 export { parsePageConfigs };
-import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+export { parseConfigValuesSerialized };
 import { assert, assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
-import { parseConfigValuesSerialized } from './parseConfigValuesSerialized.js';
+import { parseTransform } from '@brillout/json-serializer/parse';
+import { assertPlusFileExport } from '../assertPlusFileExport.js';
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized);
+    return configValues;
+}
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
-        const configValues = {};
-        {
-            const { configValuesSerialized } = pageConfigSerialized;
-            const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
-            Object.assign(configValues, configValuesAddendum);
-        }
-        {
-            const { configValuesImported } = pageConfigSerialized;
-            const configValuesAddendum = parseConfigValuesImported(configValuesImported);
-            Object.assign(configValues, configValuesAddendum);
-        }
+        const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);
         const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
         assertRouteConfigValue(configValues);
         return {
@@ -26,10 +22,11 @@ function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
             loadConfigValuesAll
         };
     });
+    // pageConfigsGlobal
     const pageConfigGlobal = { configValues: {} };
     {
-        const configValuesAddendum = parseConfigValuesImported(pageConfigGlobalSerialized.configValuesImported);
-        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+        const configValues = parseConfigValuesSerialized(pageConfigGlobalSerialized.configValuesSerialized);
+        Object.assign(pageConfigGlobal.configValues, configValues);
     }
     return { pageConfigs, pageConfigGlobal };
 }
@@ -52,3 +49,100 @@ function assertRouteConfigValue(configValues) {
    }
    */
 }
+function parseConfigValuesSerialized_tmp(configValuesSerialized) {
+    const configValues = {};
+    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+        let configValue;
+        if (configValueSeriliazed.type === 'cumulative') {
+            const { valueSerialized, ...common } = configValueSeriliazed;
+            const value = valueSerialized.map((valueSerializedElement, i) => {
+                const { value, sideExports } = parseValueSerialized(valueSerializedElement, configName, () => {
+                    const definedAtFile = configValueSeriliazed.definedAtData[i];
+                    assert(definedAtFile);
+                    return definedAtFile;
+                });
+                addSideExports(sideExports);
+                return value;
+            });
+            configValue = { value, ...common };
+        }
+        else {
+            const { valueSerialized, ...common } = configValueSeriliazed;
+            const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
+                assert(configValueSeriliazed.type !== 'computed');
+                return configValueSeriliazed.definedAtData;
+            });
+            addSideExports(sideExports);
+            configValue = { value, ...common };
+        }
+        configValues[configName] = configValue;
+    });
+    return configValues;
+    function addSideExports(sideExports) {
+        sideExports.forEach((sideExport) => {
+            const { configName, configValue } = sideExport;
+            if (!configValues[configName]) {
+                configValues[configName] = configValue;
+            }
+            else {
+                // Side-exports have lower precedence.
+                // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
+            }
+        });
+    }
+}
+function parseValueSerialized(valueSerialized, configName, getDefinedAtFile) {
+    if (valueSerialized.type === 'js-serialized') {
+        let { value } = valueSerialized;
+        value = parseTransform(value);
+        return { value, sideExports: [] };
+    }
+    if (valueSerialized.type === 'pointer-import') {
+        const { value } = valueSerialized;
+        return { value, sideExports: [] };
+    }
+    if (valueSerialized.type === 'plus-file') {
+        const definedAtFile = getDefinedAtFile();
+        const { exportValues } = valueSerialized;
+        assertPlusFileExport(exportValues, definedAtFile.filePathToShowToUser, configName);
+        let value;
+        let valueWasFound = false;
+        const sideExports = [];
+        Object.entries(exportValues).forEach(([exportName, exportValue]) => {
+            const isSideExport = exportName !== 'default' && exportName !== configName;
+            if (!isSideExport) {
+                value = exportValue;
+                assert(!valueWasFound);
+                valueWasFound = true;
+            }
+            else {
+                sideExports.push({
+                    configName: exportName,
+                    configValue: {
+                        type: 'standard', // We don't support side exports for cumulative values. We could support it but it isn't trivial.
+                        value: exportValue,
+                        definedAtData: {
+                            filePathToShowToUser: definedAtFile.filePathToShowToUser,
+                            fileExportPathToShowToUser: [exportName]
+                        }
+                    }
+                });
+            }
+        });
+        assert(valueWasFound);
+        return { value, sideExports };
+    }
+    assert(false);
+}
+/* [NULL_HANDLING] Do we really need this?
+function assertIsNotNull(configValue: unknown, configName: string, filePathToShowToUser: string) {
+  assert(!filePathToShowToUser.includes('+config.'))
+  // Re-use this for:
+  //  - upcoming config.requestPageContextOnNavigation
+  //  - for cumulative values in the future: we don't need this for now because, currently, cumulative values are never imported.
+  assertUsage(
+    configValue !== null,
+    `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.js file instead of ${filePathToShowToUser}`
+  )
+}
+*/

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

@@ -0,0 +1,5 @@
+export { serializeConfigValues };
+import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
+    configValuesComputed?: undefined;
+}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string): string[];