vike 0.4.171-commit-f9548df → 0.4.171-commit-3b2cb88

package/dist/esm/node/shared/assertV1Design.d.ts

@@ -1,4 +1,4 @@
 export { assertV1Design };
 import { PageFile } from '../../shared/getPageFiles.js';
-import type { PageConfigBuildTime, PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-declare function assertV1Design(isOldDesign: boolean, pageConfigs: (PageConfigRuntime | PageConfigBuildTime)[], pageFilesAll?: PageFile[]): void;
+import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function assertV1Design(isOldDesign: boolean, pageConfigs: PageConfigBuildTime[], pageFilesAll?: PageFile[]): void;

package/dist/esm/node/shared/assertV1Design.js

@@ -1,5 +1,4 @@
 export { assertV1Design };
-import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { assert, assertUsage, assertWarning, isNotNullish, unique } from './utils.js';
 function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
     const isV1Design = pageConfigs.length > 0;
@@ -9,10 +8,10 @@ function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
             assert(pageFilesAll.length > 0);
             const indent = '- ';
             const filesV1 = unique(pageConfigs
-                .map((p) => Object.values(p.configValues)
-                .map((c) => getConfigValueFilePathToShowToUser(c.definedAtData))
+                .map((p) => Object.values(p.configValueSources).map((sources) => sources
+                .map((c) => c.definedAtFilePath.filePathAbsoluteUserRootDir)
                 .filter(isNotNullish)
-                .map((filePathToShowToUser) => indent + filePathToShowToUser))
+                .map((filePathToShowToUser) => indent + filePathToShowToUser)))
                 .flat(2));
             const filesOld = pageFilesAll.map((p) => indent + p.filePath);
             lines.push(...['V1 design files:', ...filesV1, 'Old design files:', ...filesOld]);

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -127,22 +127,24 @@ function assertPageContextUrlComputed(pageContext) {
     ```js
     const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
   
-    // ❌ Breaks the property getters of pageContext set by getPageContextUrlComputed() such as pageContext.urlPathname
+    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
     Object.assign(pageContext, pageContextUrlComputed)
   
-    // ❌ Also breaks property getters
+    // ❌ Also breaks property descriptors/getters
     const pageContext = { ...pageContextUrlComputed }
   
-    // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
     objectAssign(pageContext, pageContextUrlComputed)
     ```
     */
     if ('urlPathname' in pageContext) {
         assert(typeof pageContext.urlPathname === 'string');
         assert(isPropertyGetter(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
         assert(isPropertyGetter(pageContext, 'urlParsed'));
-    if ('url' in pageContext)
         assert(isPropertyGetter(pageContext, 'url'));
+    }
+    else {
+        assert(!('urlParsed' in pageContext));
+        assert(!('url' in pageContext));
+    }
 }

package/dist/esm/shared/getPageFiles/analyzeClientSide.js

@@ -1,11 +1,11 @@
 export { analyzeClientSide };
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { analyzePageClientSide } from './analyzePageClientSide.js';
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
     if (pageConfig) {
-        const isClientRouting = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-        const isClientSideRenderable = getConfigValue(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
+        const isClientRouting = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = getConfigValueRuntime(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
         return { isClientSideRenderable, isClientRouting };
     }
     else {

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -1,14 +1,11 @@
 export { parseGlobResults };
-import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../utils.js';
+// TODO/v1-release: remove old design code, and remove all assertions.
+import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigsSerialized.js';
 import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
 function parseGlobResults(pageFilesExports) {
-    assert(hasProp(pageFilesExports, 'isGeneratedFile'));
-    assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
-    assert(pageFilesExports.isGeneratedFile === true, `\`isGeneratedFile === ${pageFilesExports.isGeneratedFile}\``);
     assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
     assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
     assert(hasProp(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
@@ -41,8 +38,6 @@ function parseGlobResults(pageFilesExports) {
         pageFile.loadExportNames = async () => {
             if (!('exportNames' in pageFile)) {
                 const moduleExports = await loadModule();
-                // Vite 2 seems to choke following assertion: https://github.com/vikejs/vike/issues/455
-                assertUsage('exportNames' in moduleExports, 'You seem to be using Vite 2 but the latest vike versions only work with Vite 3');
                 assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
                 pageFile.exportNames = moduleExports.exportNames;
             }
@@ -88,3 +83,15 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     assert(isCallable(globValue));
 }
+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'));
+    });
+}
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesSerialized'));
+}

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/PageConfig.d.ts

@@ -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;

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 };
+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<ConfigValueStandard, 'value'> & {
-    valueSerialized: string;
+    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[];