vike 0.4.171 → 0.4.172

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

@@ -1,48 +1,34 @@
 "use strict";
-// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPageContextUrlComputedProps = exports.addUrlComputedProps = void 0;
+exports.assertPageContextUrl = exports.getPageContextUrlComputed = void 0;
+// =====================
+// File determining the URL logic.
+// URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// =====================
+const objectDefineProperty_js_1 = require("../utils/objectDefineProperty.js");
 const utils_js_1 = require("./utils.js");
-function addUrlComputedProps(pageContext, enumerable = true) {
-    (0, utils_js_1.assert)(pageContext.urlOriginal);
-    if ('urlPathname' in pageContext) {
-        (0, utils_js_1.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)
-           ```
-        */
-        (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'));
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
-    Object.defineProperty(pageContext, 'urlPathname', {
+function getPageContextUrlComputed(pageContext) {
+    (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
+    assertPageContextUrlComputed(pageContext);
+    const pageContextUrlComputed = {};
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'url', {
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'urlParsed', {
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlParsed', {
         get: urlParsedGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
+    return pageContextUrlComputed;
 }
-exports.addUrlComputedProps = addUrlComputedProps;
+exports.getPageContextUrlComputed = getPageContextUrlComputed;
 function getUrlParsed(pageContext) {
     // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
     let urlHandler = pageContext._urlHandler;
@@ -92,7 +78,7 @@ function urlParsedGetter() {
     const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
     const hashIsAvailable = (0, utils_js_1.isBrowser)();
     const warnHashNotAvailable = (prop) => {
-        (0, utils_js_1.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 });
+        (0, utils_js_1.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,
@@ -122,22 +108,46 @@ function urlParsedGetter() {
             return searchOriginal;
         }
     };
-    makeNonEnumerable(urlParsed, 'hashString');
-    makeNonEnumerable(urlParsed, 'searchString');
+    (0, utils_js_1.changeEnumerable)(urlParsed, 'hashString', false);
+    (0, utils_js_1.changeEnumerable)(urlParsed, 'searchString', false);
     if (!hashIsAvailable) {
-        makeNonEnumerable(urlParsed, 'hash');
-        makeNonEnumerable(urlParsed, 'hashOriginal');
+        (0, utils_js_1.changeEnumerable)(urlParsed, 'hash', false);
+        (0, utils_js_1.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) {
     (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
     (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.urlParsed));
     (0, utils_js_1.assert)(pageContext.urlPathname === pageContext.urlParsed.pathname);
+    assertPageContextUrlComputed(pageContext);
+}
+exports.assertPageContextUrl = assertPageContextUrl;
+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) {
+        (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
+        (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));
+    }
 }
-exports.assertPageContextUrlComputedProps = assertPageContextUrlComputedProps;

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/getExports.js

@@ -32,6 +32,18 @@ function getPageContextExports(pageFiles, pageConfig) {
         });
     });
     // V1 design
+    const source = {};
+    const sources = {};
+    const addSrc = (src, configName) => {
+        source[configName] = src;
+        sources[configName] ?? (sources[configName] = []);
+        sources[configName].push(src);
+    };
+    const from = {
+        configsStandard: {},
+        configsCumulative: {},
+        configsComputed: {}
+    };
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
@@ -46,6 +58,39 @@ function getPageContextExports(pageFiles, pageConfig) {
                 configDefinedAt,
                 configDefinedByFile: configValueFilePathToShowToUser
             });
+            if (configValue.type === 'standard') {
+                const src = {
+                    type: 'configsStandard',
+                    value: configValue.value,
+                    definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName)
+                };
+                addSrc(src, configName);
+                from.configsStandard[configName] = src;
+            }
+            if (configValue.type === 'cumulative') {
+                const src = {
+                    type: 'configsCumulative',
+                    values: configValue.value.map((value, i) => {
+                        const definedAtFile = configValue.definedAtData[i];
+                        (0, utils_js_1.assert)(definedAtFile);
+                        const definedAt = (0, getConfigDefinedAt_js_1.getDefinedAtString)(definedAtFile, configName);
+                        return {
+                            value,
+                            definedAt
+                        };
+                    })
+                };
+                addSrc(src, configName);
+                from.configsCumulative[configName] = src;
+            }
+            if (configValue.type === 'computed') {
+                const src = {
+                    type: 'configsComputed',
+                    value: configValue.value
+                };
+                addSrc(src, configName);
+                from.configsComputed[configName] = src;
+            }
             // TODO/v1-release: remove
             const exportName = configName;
             exportsAll[exportName] = exportsAll[exportName] ?? [];
@@ -75,9 +120,12 @@ function getPageContextExports(pageFiles, pageConfig) {
     (0, utils_js_1.assert)(!('default' in exports));
     (0, utils_js_1.assert)(!('default' in exportsAll));
     const pageContextExports = {
+        from,
+        source,
+        sources,
+        // TODO/eventually: deprecate/remove every prop below
         config,
         configEntries,
-        // TODO/v1-release: remove
         exports,
         exportsAll,
         pageExports

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/executeHook.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUserHookError = exports.executeHook = void 0;
+exports.isUserHookError = exports.getPageContext = exports.executeHook = void 0;
 const assert_js_1 = require("../../utils/assert.js");
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const humanizeTime_js_1 = require("../../utils/humanizeTime.js");
 const isObject_js_1 = require("../../utils/isObject.js");
 const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/executeHook.ts', {
-    userHookErrors: new WeakMap()
+    userHookErrors: new WeakMap(),
+    pageContext: null
 });
 function isUserHookError(err) {
     if (!(0, isObject_js_1.isObject)(err))
@@ -14,7 +15,7 @@ function isUserHookError(err) {
     return globalObject.userHookErrors.get(err) ?? false;
 }
 exports.isUserHookError = isUserHookError;
-function executeHook(hookFnCaller, hook) {
+function executeHook(hookFnCaller, hook, pageContext) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
     let resolve;
     let reject;
@@ -45,6 +46,7 @@ function executeHook(hookFnCaller, hook) {
         }, timeoutErr);
     (async () => {
         try {
+            providePageContext(pageContext);
             const ret = await hookFnCaller();
             resolve(ret);
         }
@@ -61,3 +63,20 @@ exports.executeHook = executeHook;
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    return globalObject.pageContext;
+}
+exports.getPageContext = getPageContext;
+function providePageContext(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

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