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

package/dist/cjs/node/runtime/renderPage/analyzePage.js

@@ -6,12 +6,16 @@ const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyze
 const virtualFilePageConfigValuesAll_js_1 = require("../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const analyzeClientSide_js_1 = require("../../../shared/getPageFiles/analyzeClientSide.js");
 const globalContext_js_1 = require("../globalContext.js");
-const getClientEntry_js_1 = require("../../shared/getClientEntry.js");
+const getConfigValue_js_1 = require("../../../shared/page-configs/getConfigValue.js");
 function analyzePage(pageFilesAll, pageConfig, pageId) {
     if (pageConfig) {
         const { isClientSideRenderable, isClientRouting } = (0, analyzeClientSide_js_1.analyzeClientSide)(pageConfig, pageFilesAll, pageId);
-        const clientFilePath = (0, getClientEntry_js_1.getClientEntry)(pageConfig);
-        const clientEntry = !isClientSideRenderable ? clientFilePath : (0, determineClientEntry_js_1.getVikeClientEntry)(isClientRouting);
+        const clientEntries = [];
+        const clientFilePath = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'client', 'string')?.value ?? null;
+        if (clientFilePath)
+            clientEntries.push(clientFilePath);
+        if (isClientSideRenderable)
+            clientEntries.push((0, determineClientEntry_js_1.getVikeClientEntry)(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
             id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, true),
@@ -43,15 +47,13 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
           }
         })
         */
-        const clientEntries = [];
-        if (clientEntry) {
+        clientEntries.forEach((clientEntry) => {
             clientDependencies.push({
                 id: clientEntry,
                 onlyAssets: false,
                 eagerlyImported: false
             });
-            clientEntries.push(clientEntry);
-        }
+        });
         return {
             isHtmlOnly: !isClientSideRenderable,
             isClientRouting,

package/dist/cjs/node/runtime/renderPage/createHttpResponseObject/getCacheControl.js

@@ -9,7 +9,7 @@ function getCacheControl(pageId, pageConfigs) {
     if (pageConfigs.length === 0)
         return defaultValue;
     const pageConfig = (0, helpers_js_1.getPageConfig)(pageId, pageConfigs);
-    const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'cacheControl', 'string');
+    const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'cacheControl', 'string');
     const value = configValue?.value;
     if (value)
         return value;

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -22,7 +22,6 @@ const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js
 const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
-const assertV1Design_js_1 = require("../../shared/assertV1Design.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -176,7 +175,8 @@ async function getRenderContext() {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    (0, assertV1Design_js_1.assertV1Design)(pageFilesAll.length > 0, pageConfigs, pageFilesAll);
+    // We assume assertV1Design() was already called at build-time
+    (0, utils_js_1.assert)(pageFilesAll.length === 0 || pageConfigs.length === 0);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertV1Design = void 0;
-const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 const utils_js_1 = require("./utils.js");
 function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
     const isV1Design = pageConfigs.length > 0;
@@ -11,10 +10,10 @@ function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
             (0, utils_js_1.assert)(pageFilesAll.length > 0);
             const indent = '- ';
             const filesV1 = (0, utils_js_1.unique)(pageConfigs
-                .map((p) => Object.values(p.configValues)
-                .map((c) => (0, helpers_js_1.getConfigValueFilePathToShowToUser)(c.definedAtData))
+                .map((p) => Object.values(p.configValueSources).map((sources) => sources
+                .map((c) => c.definedAtFilePath.filePathAbsoluteUserRootDir)
                 .filter(utils_js_1.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/cjs/shared/getPageContextUrlComputed.js

@@ -130,22 +130,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) {
         (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
         (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
         (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
-    if ('url' in pageContext)
         (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
+    }
+    else {
+        (0, utils_js_1.assert)(!('urlParsed' in pageContext));
+        (0, utils_js_1.assert)(!('url' in pageContext));
+    }
 }

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

@@ -6,8 +6,8 @@ const analyzePageClientSide_js_1 = require("./analyzePageClientSide.js");
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
     if (pageConfig) {
-        const isClientRouting = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-        const isClientSideRenderable = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
+        const isClientRouting = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
         return { isClientSideRenderable, isClientRouting };
     }
     else {

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

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseGlobResults = void 0;
+// TODO/v1-release: remove old design code, and remove all assertions.
 const utils_js_1 = require("../utils.js");
 const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
-const assertPageConfigsSerialized_js_1 = require("../page-configs/serialize/assertPageConfigsSerialized.js");
 const parsePageConfigs_js_1 = require("../page-configs/serialize/parsePageConfigs.js");
 function parseGlobResults(pageFilesExports) {
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
-    (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
-    (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile === true, `\`isGeneratedFile === ${pageFilesExports.isGeneratedFile}\``);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesLazy', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesEager', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
@@ -21,8 +18,8 @@ function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigsSerialized'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobalSerialized'));
     const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
-    (0, assertPageConfigsSerialized_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
-    (0, assertPageConfigsSerialized_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
+    assertPageConfigsSerialized(pageConfigsSerialized);
+    assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
     const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigs_js_1.parsePageConfigs)(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
@@ -43,8 +40,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
-                (0, utils_js_1.assertUsage)('exportNames' in moduleExports, 'You seem to be using Vite 2 but the latest vike versions only work with Vite 3');
                 (0, utils_js_1.assert)((0, utils_js_1.hasProp)(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
                 pageFile.exportNames = moduleExports.exportNames;
             }
@@ -91,3 +86,15 @@ function parseGlobResult(globObject) {
 function assertLoadModule(globValue) {
     (0, utils_js_1.assert)((0, utils_js_1.isCallable)(globValue));
 }
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    (0, utils_js_1.assert)((0, utils_js_1.isArray)(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfigSerialized));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'pageId', 'string'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'routeFilesystem'));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesSerialized'));
+    });
+}
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobalSerialized, 'configValuesSerialized'));
+}

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

@@ -31,8 +31,8 @@ function getHook(pageContext, hookName) {
 }
 exports.getHook = getHook;
 function getHookFromPageConfig(pageConfig, hookName) {
-    const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, hookName);
-    const hooksTimeout = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'hooksTimeout')?.value;
+    const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, hookName);
+    const hooksTimeout = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'hooksTimeout')?.value;
     if (!configValue)
         return null;
     const hookFn = configValue.value;

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

@@ -3,22 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigValue = void 0;
+exports.getConfigValueTyped = exports.getConfigValueRuntime = void 0;
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getConfigDefinedAt_js_1 = require("./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;
 }
-exports.getConfigValue = getConfigValue;
+exports.getConfigValueTyped = getConfigValueTyped;
+function getConfigValueRuntime(pageConfig, configName, type) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    return getConfigValueTyped(configValue, configName, type);
+}
+exports.getConfigValueRuntime = getConfigValueRuntime;
 function assertConfigValueType(value, type, configName, definedAtData) {
     (0, utils_js_1.assert)(value !== null);
     const typeActual = typeof value;
@@ -32,12 +38,3 @@ function assertConfigValueType(value, type, configName, definedAtData) {
     const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`;
     (0, utils_js_1.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/cjs/shared/page-configs/getConfigValueBuildTime.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValueBuildTime = void 0;
+const utils_js_1 = require("../utils.js");
+const getConfigValue_js_1 = require("./getConfigValue.js");
+const assertIsNotProductionRuntime_js_1 = require("../../utils/assertIsNotProductionRuntime.js");
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function getConfigValueBuildTime(pageConfig, configName, type) {
+    const configValue = getConfigValue(pageConfig, configName);
+    if (!configValue)
+        return null;
+    return (0, getConfigValue_js_1.getConfigValueTyped)(configValue, configName, type);
+}
+exports.getConfigValueBuildTime = getConfigValueBuildTime;
+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;
+    (0, utils_js_1.assert)(sources.every((s) => s.configEnv.config === true));
+    const configDef = configDefinitions[configName];
+    (0, utils_js_1.assert)(configDef);
+    if (!configDef.cumulative) {
+        const configValueSource = sources[0];
+        (0, utils_js_1.assert)(configValueSource);
+        (0, utils_js_1.assert)(configValueSource.isOverriden === false);
+        (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
+        (0, utils_js_1.assert)('value' in configValueSource);
+        return {
+            type: 'standard',
+            value: configValueSource.value,
+            definedAtData: getDefinedAtFile(configValueSource)
+        };
+    }
+    else {
+        const { value, definedAtData } = mergeCumulative(sources);
+        (0, utils_js_1.assert)(value.length === definedAtData.length);
+        return {
+            type: 'cumulative',
+            value,
+            definedAtData
+        };
+    }
+}
+function mergeCumulative(configValueSources) {
+    const value = [];
+    const definedAtData = [];
+    configValueSources.forEach((configValueSource) => {
+        (0, utils_js_1.assert)(configValueSource.isOverriden === false);
+        (0, utils_js_1.assert)(configValueSource.configEnv.config === true);
+        (0, utils_js_1.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/cjs/shared/page-configs/loadConfigValues.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfigValues = void 0;
 const utils_js_1 = require("../utils.js");
-const parseConfigValuesImported_js_1 = require("./serialize/parseConfigValuesImported.js");
-const parseConfigValuesSerialized_js_1 = require("./serialize/parseConfigValuesSerialized.js");
+const parsePageConfigs_js_1 = require("./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
@@ -11,16 +10,8 @@ async function loadConfigValues(pageConfig, isDev) {
         return pageConfig;
     }
     const configValuesLoaded = await pageConfig.loadConfigValuesAll();
-    {
-        const { configValuesImported } = configValuesLoaded;
-        const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
-    {
-        const { configValuesSerialized } = configValuesLoaded;
-        const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
-        Object.assign(pageConfig.configValues, configValuesAddendum);
-    }
+    const configValues = (0, parsePageConfigs_js_1.parseConfigValuesSerialized)(configValuesLoaded.configValuesSerialized);
+    Object.assign(pageConfig.configValues, configValues);
     (0, utils_js_1.objectAssign)(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

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

@@ -1,19 +1 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPageConfigGlobalSerialized = exports.assertPageConfigsSerialized = void 0;
-const utils_js_1 = require("../../utils.js");
-function assertPageConfigsSerialized(pageConfigsSerialized) {
-    (0, utils_js_1.assert)((0, utils_js_1.isArray)(pageConfigsSerialized));
-    pageConfigsSerialized.forEach((pageConfigSerialized) => {
-        (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageConfigSerialized));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'pageId', 'string'));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'routeFilesystem'));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesSerialized'));
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigSerialized, 'configValuesImported'));
-    });
-}
-exports.assertPageConfigsSerialized = assertPageConfigsSerialized;
-function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageConfigGlobalSerialized, 'configValuesImported'));
-}
-exports.assertPageConfigGlobalSerialized = assertPageConfigGlobalSerialized;

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

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePageConfigs = void 0;
-const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
+exports.parseConfigValuesSerialized = exports.parsePageConfigs = void 0;
 const utils_js_1 = require("../../utils.js");
 const getConfigDefinedAt_js_1 = require("../getConfigDefinedAt.js");
-const parseConfigValuesSerialized_js_1 = require("./parseConfigValuesSerialized.js");
+const parse_1 = require("@brillout/json-serializer/parse");
+const assertPlusFileExport_js_1 = require("../assertPlusFileExport.js");
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized);
+    return configValues;
+}
+exports.parseConfigValuesSerialized = parseConfigValuesSerialized;
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
-        const configValues = {};
-        {
-            const { configValuesSerialized } = pageConfigSerialized;
-            const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
-            Object.assign(configValues, configValuesAddendum);
-        }
-        {
-            const { configValuesImported } = pageConfigSerialized;
-            const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
-            Object.assign(configValues, configValuesAddendum);
-        }
+        const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);
         const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
         assertRouteConfigValue(configValues);
         return {
@@ -28,10 +24,11 @@ function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
             loadConfigValuesAll
         };
     });
+    // pageConfigsGlobal
     const pageConfigGlobal = { configValues: {} };
     {
-        const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(pageConfigGlobalSerialized.configValuesImported);
-        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+        const configValues = parseConfigValuesSerialized(pageConfigGlobalSerialized.configValuesSerialized);
+        Object.assign(pageConfigGlobal.configValues, configValues);
     }
     return { pageConfigs, pageConfigGlobal };
 }
@@ -55,3 +52,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];
+                    (0, utils_js_1.assert)(definedAtFile);
+                    return definedAtFile;
+                });
+                addSideExports(sideExports);
+                return value;
+            });
+            configValue = { value, ...common };
+        }
+        else {
+            const { valueSerialized, ...common } = configValueSeriliazed;
+            const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
+                (0, utils_js_1.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 = (0, parse_1.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;
+        (0, assertPlusFileExport_js_1.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;
+                (0, utils_js_1.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]
+                        }
+                    }
+                });
+            }
+        });
+        (0, utils_js_1.assert)(valueWasFound);
+        return { value, sideExports };
+    }
+    (0, utils_js_1.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}`
+  )
+}
+*/