vike 0.4.171-commit-75e1588 → 0.4.171-commit-6e37128

package/dist/esm/shared/{addUrlComputedProps.js → getPageContextUrlComputed.js}

@@ -1,45 +1,31 @@
-// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
-export { addUrlComputedProps };
-export { assertPageContextUrlComputedProps };
-import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser } from './utils.js';
-function addUrlComputedProps(pageContext, enumerable = true) {
-    assert(pageContext.urlOriginal);
-    if ('urlPathname' in pageContext) {
-        assert(typeof pageContext.urlPathname === 'string');
-        /* If the following assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
-           ```js
-           // Add property getters such as pageContext.urlPathname to pageContext
-           addUrlComputedProps(pageContext)
-           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
-           Object.assign(pageContext2, pageContext)
-           // ❌ Also breaks the property getters
-           const pageContext3 = { ...pageContext }
-           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
-           objectAssign(pageContext2, pageContext)
-           ```
-        */
-        assert(isPropertyGetter(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
-        assert(isPropertyGetter(pageContext, 'urlParsed'));
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        assert(isPropertyGetter(pageContext, 'url'));
-    Object.defineProperty(pageContext, 'urlPathname', {
+export { getPageContextUrlComputed };
+export { assertPageContextUrl };
+// =====================
+// File determining the URL logic.
+// URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// =====================
+import { objectDefineProperty } from '../utils/objectDefineProperty.js';
+import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser, changeEnumerable } from './utils.js';
+function getPageContextUrlComputed(pageContext) {
+    assert(typeof pageContext.urlOriginal === 'string');
+    assertPageContextUrlComputed(pageContext);
+    const pageContextUrlComputed = {};
+    objectDefineProperty(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'url', {
+    objectDefineProperty(pageContextUrlComputed, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'urlParsed', {
+    objectDefineProperty(pageContextUrlComputed, 'urlParsed', {
         get: urlParsedGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
+    return pageContextUrlComputed;
 }
 function getUrlParsed(pageContext) {
     // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
@@ -90,7 +76,7 @@ function urlParsedGetter() {
     const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
     const hashIsAvailable = isBrowser();
     const warnHashNotAvailable = (prop) => {
-        assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash by design)`, { onlyOnce: true, showStackTrace: true });
+        assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });
     };
     const urlParsed = {
         origin,
@@ -120,21 +106,45 @@ function urlParsedGetter() {
             return searchOriginal;
         }
     };
-    makeNonEnumerable(urlParsed, 'hashString');
-    makeNonEnumerable(urlParsed, 'searchString');
+    changeEnumerable(urlParsed, 'hashString', false);
+    changeEnumerable(urlParsed, 'searchString', false);
     if (!hashIsAvailable) {
-        makeNonEnumerable(urlParsed, 'hash');
-        makeNonEnumerable(urlParsed, 'hashOriginal');
+        changeEnumerable(urlParsed, 'hash', false);
+        changeEnumerable(urlParsed, 'hashOriginal', false);
     }
     return urlParsed;
 }
-function makeNonEnumerable(obj, prop) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
-    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
-}
-function assertPageContextUrlComputedProps(pageContext) {
+function assertPageContextUrl(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
     assert(typeof pageContext.urlPathname === 'string');
     assert(isPlainObject(pageContext.urlParsed));
     assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
+    assertPageContextUrlComputed(pageContext);
+}
+function assertPageContextUrlComputed(pageContext) {
+    /*
+    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
+    ```js
+    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
+  
+    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
+    Object.assign(pageContext, pageContextUrlComputed)
+  
+    // ❌ Also breaks property descriptors/getters
+    const pageContext = { ...pageContextUrlComputed }
+  
+    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
+    objectAssign(pageContext, pageContextUrlComputed)
+    ```
+    */
+    if ('urlPathname' in pageContext) {
+        assert(typeof pageContext.urlPathname === 'string');
+        assert(isPropertyGetter(pageContext, 'urlPathname'));
+        assert(isPropertyGetter(pageContext, 'urlParsed'));
+        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/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.js

@@ -8,9 +8,8 @@ function assertPageConfigsSerialized(pageConfigsSerialized) {
         assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
         assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
         assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
-        assert(hasProp(pageConfigSerialized, 'configValuesImported'));
     });
 }
 function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
-    assert(hasProp(pageConfigGlobalSerialized, 'configValuesImported'));
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesSerialized'));
 }

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}`
+  )
+}
+*/