vike 0.4.171 → 0.4.172-commit-c1b0884

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

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

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConfigValues = void 0;
+const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
+const utils_js_1 = require("../../../node/plugin/utils.js");
+const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
+const transformFileImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js");
+const helpers_js_1 = require("../helpers.js");
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
+const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
+// - vike/shared/page-configs/serialize/parsePageConfigs.ts
+// - parsePageConfigs() is loaded on both the client- and server-side.
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace) {
+    const lines = [];
+    tabspace += '  ';
+    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
+        if (!isEnvMatch(configValuesComputed.configEnv))
+            return;
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+    });
+    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+        const configDef = pageConfig.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)(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(configValueSource.configEnv))
+                return;
+            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        else {
+            const valueDataList = [];
+            const definedAtData = [];
+            sources
+                .filter((s) => !s.isOverriden)
+                .forEach((configValueSource) => {
+                if (!isEnvMatch(configValueSource.configEnv))
+                    return;
+                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+                valueDataList.push(valueData);
+                definedAtData.push(definedAtFile);
+            });
+            if (valueDataList.length === 0)
+                return;
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
+        }
+    });
+    return lines;
+}
+exports.serializeConfigValues = serializeConfigValues;
+function serializeConfigValueSource(configValueSource, configName, importStatements) {
+    (0, utils_js_1.assert)(configValueSource.isOverriden === false);
+    let valueData;
+    if ('value' in configValueSource) {
+        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+    }
+    else {
+        valueData = serializeWithImport(configValueSource, importStatements);
+    }
+    const definedAtFile = {
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return { valueData, definedAtFile };
+}
+function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
+    lineAdd(`[${JSON.stringify(configName)}]: {`);
+    {
+        tab();
+        lineAdd(`type: "${configValueBase.type}",`);
+        lineAdd(`definedAtData: ${JSON.stringify(configValueBase.definedAtData)},`);
+        lineAdd(`valueSerialized:`);
+        if (!Array.isArray(valueData)) {
+            serializeValueData(valueData);
+        }
+        else {
+            lineAppend(' [');
+            valueData.forEach(serializeValueData);
+            lineAppend(` ],`);
+        }
+        untab();
+    }
+    lineAdd('},');
+    return;
+    function serializeValueData(valueData) {
+        lineAppend(` {`);
+        tab();
+        lineAdd(`type: "${valueData.type}",`);
+        const valueProp = valueData.type !== 'plus-file' ? 'value' : 'exportValues';
+        lineAdd(`${valueProp}: ${valueData.valueAsJsCode},`);
+        untab();
+        lineAdd(`},`);
+    }
+    function lineAppend(str) {
+        const i = lines.length - 1;
+        lines[i] = lines[i] += str;
+    }
+    function lineAdd(str) {
+        lines.push(`${tabspace}${str}`);
+    }
+    function tab() {
+        tabspace += '  ';
+    }
+    function untab() {
+        tabspace = tabspace.slice(2);
+    }
+}
+function serializeWithImport(configValueSource, importStatements) {
+    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
+    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
+    (0, utils_js_1.assert)(valueIsImportedAtRuntime);
+    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
+    if (valueIsDefinedByPlusFile)
+        (0, utils_js_1.assert)(fileExportName === undefined);
+    const { importName } = (0, addImportStatement_js_1.addImportStatement)(importStatements, filePathAbsoluteVite, fileExportName || '*');
+    return {
+        type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
+        valueAsJsCode: importName
+    };
+}
+function serializeWithJson(value, configName, definedAtData, importStatements) {
+    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
+    return {
+        type: 'js-serialized',
+        valueAsJsCode
+    };
+}
+function valueToJson(value, configName, definedAtData, importStatements) {
+    const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = (0, stringify_1.stringify)(value, {
+            valueName,
+            forbidReactElements: true,
+            replacer(_, value) {
+                if (typeof value === 'string') {
+                    const importData = (0, transformFileImports_js_1.parsePointerImportData)(value);
+                    if (importData) {
+                        const { importName } = (0, addImportStatement_js_1.addImportStatement)(importStatements, importData.importPath, importData.exportName);
+                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
+                        return { replacement };
+                    }
+                }
+            }
+        });
+    }
+    catch (err) {
+        logJsonSerializeError(err, configName, definedAtData);
+        (0, utils_js_1.assert)(false);
+    }
+    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
+    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
+    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_BEFORE));
+    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_AFTER));
+    return configValueSerialized;
+}
+function logJsonSerializeError(err, configName, definedAtData) {
+    /*
+    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
+    let serializationErrMsg = ''
+    if (isJsonSerializerError(err)) {
+      serializationErrMsg = err.messageCore
+    } else {
+      // When a property getter throws an error
+      console.error('Serialization error:')
+      console.error(err)
+      serializationErrMsg = 'see serialization error printed above'
+    }
+    //*/
+    const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
+    (0, utils_js_1.assert)(configValueFilePathToShowToUser);
+    (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
+}

package/dist/cjs/shared/route/executeGuardHook.js

@@ -23,7 +23,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await (0, executeHook_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook);
+    const hookResult = await (0, executeHook_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook, pageContext);
     (0, utils_js_1.assertUsage)(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 exports.executeGuardHook = executeGuardHook;

package/dist/cjs/shared/route/executeOnBeforeRouteHook.js

@@ -42,7 +42,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     (0, resolveRouteFunction_js_1.assertSyncRouting)(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await (0, executeHook_js_1.executeHook)(() => hookReturn, onBeforeRouteHook);
+    hookReturn = await (0, executeHook_js_1.executeHook)(() => hookReturn, onBeforeRouteHook, pageContext);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||
         hookReturn === undefined ||

package/dist/cjs/shared/route/index.js

@@ -11,7 +11,7 @@ if ((0, isBrowser_js_1.isBrowser)()) {
     (0, assertRoutingType_js_1.assertClientRouting)();
 }
 const utils_js_1 = require("./utils.js");
-const addUrlComputedProps_js_1 = require("../addUrlComputedProps.js");
+const getPageContextUrlComputed_js_1 = require("../getPageContextUrlComputed.js");
 const resolvePrecedence_js_1 = require("./resolvePrecedence.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
@@ -20,7 +20,7 @@ const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function route(pageContextForRoute) {
     (0, debug_js_1.debug)('Pages routes:', pageContextForRoute._pageRoutes);
-    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContextForRoute);
+    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContextForRoute);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContextForRoute);

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -31,7 +31,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, configName);
+                const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
                     (0, utils_js_1.assert)(configValue.definedAtData);
@@ -47,7 +47,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, getConfigValue_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,

package/dist/cjs/shared/route/resolveRouteFunction.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.warnDeprecatedAllowKey = exports.assertSyncRouting = exports.assertRouteParams = exports.resolveRouteFunction = void 0;
-const addUrlComputedProps_js_1 = require("../addUrlComputedProps.js");
+const getPageContextUrlComputed_js_1 = require("../getPageContextUrlComputed.js");
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
-    (0, addUrlComputedProps_js_1.assertPageContextUrlComputedProps)(pageContext);
+    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     let result = routeFunction(pageContext);
     assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
     // TODO/v1-release: make resolveRouteFunction() and route() sync

package/dist/cjs/shared/sortPageContext.js

@@ -4,14 +4,10 @@ exports.sortPageContext = void 0;
 const utils_js_1 = require("./utils.js");
 // Sort `pageContext` keys alphabetically, in order to make reading `console.log(pageContext)` easier
 function sortPageContext(pageContext) {
-    const entries = Object.entries(pageContext);
-    for (const key in pageContext) {
+    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+    for (const key of Object.keys(pageContext))
         delete pageContext[key];
-    }
-    entries
-        .sort(([key1], [key2]) => (0, utils_js_1.compareString)(key1, key2))
-        .forEach(([key, val]) => {
-        pageContext[key] = val;
-    });
+    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => (0, utils_js_1.compareString)(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
 }
 exports.sortPageContext = sortPageContext;

package/dist/cjs/shared/utils.js

@@ -41,3 +41,5 @@ __exportStar(require("../utils/checkType.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
 __exportStar(require("../utils/escapeRegex.js"), exports);
 __exportStar(require("../utils/isArray.js"), exports);
+__exportStar(require("../utils/changeEnumerable.js"), exports);
+__exportStar(require("../utils/objectDefineProperty.js"), exports);

package/dist/cjs/utils/assert.js

@@ -37,9 +37,9 @@ function assert(condition, debugInfo) {
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
         return picocolors_1.default.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
+    const link = picocolors_1.default.blue('https://github.com/vikejs/vike/issues/new');
     let errMsg = [
-        `You stumbled upon a Vike bug.`,
-        `Go to ${picocolors_1.default.blue('https://github.com/vikejs/vike/issues/new')} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
+        `You stumbled upon a Vike bug. Go to ${link} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
         debugStr
     ]
         .filter(Boolean)
@@ -92,7 +92,7 @@ function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
     }
     globalObject.onBeforeLog?.();
     if (showStackTrace) {
-        const err = new Error(msg);
+        const err = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(msg, numberOfStackTraceLinesToRemove);
         globalObject.showStackTraceList.add(err);
         globalObject.logger(err, 'warn');
     }

package/dist/cjs/utils/assertNodeVersion.js

@@ -8,6 +8,6 @@ function assertNodeVersion() {
     if (!(0, isNodeJS_js_1.isNodeJS)())
         return;
     const version = process.versions.node;
-    (0, assertVersion_js_1.assertVersion)('Node.js', version, '16.0.0');
+    (0, assertVersion_js_1.assertVersion)('Node.js', version, '18.0.0');
 }
 exports.assertNodeVersion = assertNodeVersion;

package/dist/cjs/utils/changeEnumerable.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeEnumerable = void 0;
+/** Change enumerability of an object property. */
+function changeEnumerable(obj, prop, enumerable) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    Object.defineProperty(obj, prop, { ...descriptor, enumerable });
+}
+exports.changeEnumerable = changeEnumerable;

package/dist/cjs/utils/escapeHtml.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = void 0;
+// Copied from https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript/6234804#6234804
+function escapeHtml(unsafeString) {
+    const safe = unsafeString
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+    return safe;
+}
+exports.escapeHtml = escapeHtml;

package/dist/cjs/utils/getPropAccessNotation.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPropAccessNotation = void 0;
 function getPropAccessNotation(key) {
-    return isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+    return typeof key === 'string' && /^[a-z0-9\$_]+$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 }
 exports.getPropAccessNotation = getPropAccessNotation;
-function isKeyDotNotationCompatible(key) {
-    return /^[a-z0-9\$_]+$/i.test(key);
-}