vike 0.4.229 → 0.4.230

package/dist/cjs/shared/page-configs/{getPageConfigUserFriendly.js → getUserFriendlyConfigs.js}

@@ -3,16 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageConfigUserFriendly = getPageConfigUserFriendly;
-exports.getPageConfigUserFriendly_oldDesign = getPageConfigUserFriendly_oldDesign;
-exports.getPageConfigGlobalUserFriendly = getPageConfigGlobalUserFriendly;
+exports.getUserFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal;
+exports.getUserFriendlyConfigsPageEager = getUserFriendlyConfigsPageEager;
+exports.getUserFriendlyConfigsPageLazy = getUserFriendlyConfigsPageLazy;
 const assert_exports_old_design_js_1 = require("../getPageFiles/assert_exports_old_design.js");
 const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
 const helpers_js_1 = require("./helpers.js");
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
     let page;
     if (!pageConfig.isErrorPage) {
         const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
@@ -29,8 +29,8 @@ function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfi
     }
     return [pageConfig.pageId, page];
 }
-function getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues }) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues }) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues });
     return getPublicCopy(pageConfigUserFriendly);
 }
 function getPublicCopy(pageConfigUserFriendly) {
@@ -42,15 +42,17 @@ function getPublicCopy(pageConfigUserFriendly) {
         _from: p.from
     };
 }
-function getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues }) {
+function getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return getPageConfigUserFriendly_V1Design({ configValues });
+    return getUserFriendlyConfigs_V1Design({ configValues });
 }
-function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }) {
-    const pageConfigGlobalUserFriendly = getPageConfigUserFriendly_V1Design({ configValues: pageConfigGlobalValues });
+function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }) {
+    const pageConfigGlobalUserFriendly = getUserFriendlyConfigs_V1Design({ configValues: pageConfigGlobalValues });
     return getPublicCopy(pageConfigGlobalUserFriendly);
 }
-function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGlobal) {
+function getUserFriendlyConfigsPageLazy(pageFiles, // V0.4 design
+pageConfig, // V1 design
+pageConfigGlobal) {
     const config = {};
     const configEntries = {}; // TODO/v1-release: remove
     const exportsAll = {}; // TODO/v1-release: remove
@@ -75,7 +77,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
     let sources;
     let from;
     if (pageConfig) {
-        const res = getPageConfigUserFriendly_base({
+        const res = getUserFriendlyConfigs_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues
         });
@@ -95,7 +97,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
             configsComputed: {}
         };
     }
-    const pageExports = createObjectWithDeprecationWarning();
+    const pageExports = {};
     const exports = {};
     Object.entries(exportsAll).forEach(([exportName, values]) => {
         values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
@@ -118,13 +120,27 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
         // TODO/eventually: deprecate/remove every prop below
         configEntries,
         exports,
-        exportsAll,
-        pageExports
+        exportsAll
     };
+    // TODO/v1-release: remove
+    (0, utils_js_1.objectDefineProperty)(pageContextExports, 'pageExports', {
+        get: () => {
+            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
+            if (!(0, utils_js_1.isBrowser)()) {
+                (0, utils_js_1.assertWarning)(false, 'pageContext.pageExports is outdated, use pageContext.exports instead', {
+                    onlyOnce: true,
+                    showStackTrace: true
+                });
+            }
+            return pageExports;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendly_V1Design(pageConfig) {
+function getUserFriendlyConfigs_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -140,19 +156,30 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
         sources[configName] ?? (sources[configName] = []);
         sources[configName].push(src);
     };
-    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-        const { value } = configValue;
-        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue.definedAtData);
-        const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, configValue.definedAtData);
-        config[configName] = config[configName] ?? value;
+    const addLegacy = (configName, value, definedAtData) => {
+        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
+        const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, definedAtData);
         configEntries[configName] = configEntries[configName] ?? [];
-        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
-        (0, utils_js_1.assert)(configEntries[configName].length === 0);
         configEntries[configName].push({
             configValue: value,
             configDefinedAt,
             configDefinedByFile: configValueFilePathToShowToUser
         });
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        config[configName] = config[configName] ?? value;
         if (configValue.type === 'standard') {
             const src = {
                 type: 'configsStandard',
@@ -161,6 +188,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsStandard[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
         if (configValue.type === 'cumulative') {
             const src = {
@@ -169,6 +197,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
                     const definedAtFile = configValue.definedAtData[i];
                     (0, utils_js_1.assert)(definedAtFile);
                     const definedAt = (0, getConfigDefinedAt_js_1.getDefinedAtString)(definedAtFile, configName);
+                    addLegacy(configName, value, definedAtFile);
                     return {
                         value,
                         definedAt
@@ -185,18 +214,8 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsComputed[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
-        // TODO/v1-release: remove
-        const exportName = configName;
-        exportsAll[exportName] = exportsAll[exportName] ?? [];
-        exportsAll[exportName].push({
-            exportValue: value,
-            exportSource: configDefinedAt,
-            filePath: configValueFilePathToShowToUser,
-            _filePath: configValueFilePathToShowToUser,
-            _fileType: null,
-            _isFromDefaultExport: null
-        });
     });
     return {
         config: config,
@@ -244,15 +263,3 @@ function getExportValues(pageFile) {
     });
     return exportValues;
 }
-// TODO/v1-release: remove
-function createObjectWithDeprecationWarning() {
-    return new Proxy({}, {
-        get(...args) {
-            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
-            if (!(0, utils_js_1.isBrowser)()) {
-                (0, utils_js_1.assertWarning)(false, '`pageContext.pageExports` is outdated. Use `pageContext.exports` instead, see https://vike.dev/exports', { onlyOnce: true, showStackTrace: true });
-            }
-            return Reflect.get(...args);
-        }
-    });
-}

package/dist/cjs/shared/prepareGlobalContextForPublicUsage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareGlobalContextForPublicUsage = prepareGlobalContextForPublicUsage;
+const getProxyForPublicUsage_js_1 = require("./getProxyForPublicUsage.js");
+const utils_js_1 = require("./utils.js");
+function prepareGlobalContextForPublicUsage(globalContext) {
+    (0, utils_js_1.assert)(globalContext._isOriginalObject); // ensure we preserve the original object reference
+    const globalContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(globalContext, 'globalContext');
+    return globalContextPublic;
+}

package/dist/cjs/shared/preparePageContextForPublicUsage.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForPublicUsage = preparePageContextForPublicUsage;
+exports.assertPropertyGetters = assertPropertyGetters;
+const utils_js_1 = require("./utils.js");
+const addIs404ToPageProps_js_1 = require("./addIs404ToPageProps.js");
+const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextForPublicUsage.js");
+const getProxyForPublicUsage_js_1 = require("./getProxyForPublicUsage.js");
+function preparePageContextForPublicUsage(pageContext) {
+    (0, utils_js_1.assert)(!pageContext._isProxyObject);
+    (0, utils_js_1.assert)(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
+    (0, utils_js_1.assert)(pageContext._isOriginalObject); // ensure we preserve the original object reference
+    (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
+    // TODO/next-major-release: remove
+    if (!('_pageId' in pageContext)) {
+        Object.defineProperty(pageContext, '_pageId', {
+            get() {
+                (0, utils_js_1.assertWarning)(false, 'pageContext._pageId has been renamed to pageContext.pageId', {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return pageContext.pageId;
+            },
+            enumerable: false
+        });
+    }
+    // For a more readable `console.log(pageContext)` output
+    sortPageContext(pageContext);
+    const globalContextPublic = (0, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage)(pageContext._globalContext);
+    const pageContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(pageContext, 'pageContext', 
+    // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TODO/now: double check whether that's true
+    true, (prop) => {
+        if (prop === 'globalContext') {
+            return globalContextPublic;
+        }
+        if (prop in globalContextPublic) {
+            return globalContextPublic[prop];
+        }
+    });
+    return pageContextPublic;
+}
+// Sort `pageContext` keys alphabetically, in order to make reading the `console.log(pageContext)` output easier
+function sortPageContext(pageContext) {
+    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+    for (const key of Object.keys(pageContext))
+        delete pageContext[key];
+    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => (0, utils_js_1.compareString)(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
+}
+function assertPropertyGetters(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)
+    ```
+    */
+    ;
+    [
+        'urlPathname',
+        // TODO/v1-release: remove
+        'urlParsed',
+        // TODO/v1-release: remove
+        'url',
+        // TODO/v1-release: remove
+        'pageExports'
+    ].forEach((prop) => {
+        if (pageContext.prop)
+            (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, prop));
+    });
+}

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

@@ -12,7 +12,7 @@ exports.logAbortErrorHandled = logAbortErrorHandled;
 exports.getPageContextFromAllRewrites = getPageContextFromAllRewrites;
 exports.AbortRender = AbortRender;
 exports.assertNoInfiniteAbortLoop = assertNoInfiniteAbortLoop;
-const executeHook_js_1 = require("../hooks/executeHook.js");
+const execHook_js_1 = require("../hooks/execHook.js");
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 /**
@@ -124,7 +124,7 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
     (0, utils_js_1.assert)(urlCurrent);
     const abortCall = err._pageContextAbort._abortCall;
     (0, utils_js_1.assert)(abortCall);
-    const hookLoc = (0, executeHook_js_1.isUserHookError)(err);
+    const hookLoc = (0, execHook_js_1.isUserHookError)(err);
     let thrownBy = '';
     if (hookLoc) {
         thrownBy = ` by ${picocolors_1.default.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;

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

@@ -1,13 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debug = debug;
-var _debug;
+exports.setCreateDebugger = setCreateDebugger;
+// Using createDebugger() for isomorphic code without bloating the client-side.
+// On the server-side, this is just a transparent proxy.
+// On the client-side, this is an emtpy shell.
+const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('route/debug.ts', {});
 function debug(...args) {
-    if (!_debug) {
-        // We use this trick instead of `import { createDebugger } from '../../utils/debug` in order to ensure that the `debug` mechanism is only loaded on the server-side
-        _debug = globalThis.__brillout_debug_createDebugger?.('vike:routing');
-    }
-    if (_debug) {
-        _debug(...args);
+    // Client-side => does nothing
+    if (!globalObject.createDebugger)
+        return;
+    // Server-side => just a proxy
+    if (!globalObject.debug) {
+        globalObject.debug = globalObject.createDebugger('vike:routing');
     }
+    globalObject.debug(...args);
+}
+// Called only on the server-side
+function setCreateDebugger(createDebugger) {
+    globalObject.createDebugger = createDebugger;
 }

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

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeGuardHook = executeGuardHook;
 const getHook_js_1 = require("../hooks/getHook.js");
 const utils_js_1 = require("./utils.js");
-const executeHook_js_1 = require("../hooks/executeHook.js");
+const execHook_js_1 = require("../hooks/execHook.js");
 const errIntro = 'The guard() hook defined by';
-async function executeGuardHook(pageContext, prepareForUserConsumption) {
+async function executeGuardHook(pageContext, prepareForPublicUsage) {
     let hook;
     if (pageContext._pageFilesAll.length > 0) {
+        // TODO/v1-release: remove
         // V0.4 design
         (0, utils_js_1.assert)(pageContext._pageConfigs.length === 0);
         hook = findPageGuard(pageContext.pageId, pageContext._pageFilesAll);
@@ -18,13 +19,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     if (!hook)
         return;
-    const guard = hook.hookFn;
-    let pageContextForUserConsumption = pageContext;
-    const res = prepareForUserConsumption(pageContext);
-    if (res)
-        pageContextForUserConsumption = res;
-    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`);
+    await (0, execHook_js_1.execHookSingle)(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

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

@@ -8,7 +8,8 @@ const assertPageContextProvidedByUser_js_1 = require("../assertPageContextProvid
 const utils_js_1 = require("./utils.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const executeHook_js_1 = require("../hooks/executeHook.js");
+const execHook_js_1 = require("../hooks/execHook.js");
+const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._onBeforeRouteHook)
@@ -38,10 +39,10 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let hookReturn = onBeforeRouteHook.hookFn(pageContext);
+    let { hookReturn } = (0, execHook_js_1.execHookSync)(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     (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, pageContext);
+    hookReturn = await hookReturn;
     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,6 @@ if ((0, isBrowser_js_1.isBrowser)()) {
     (0, assertRoutingType_js_1.assertClientRouting)();
 }
 const utils_js_1 = require("./utils.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 +19,6 @@ const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
-    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
@@ -74,8 +72,8 @@ async function route(pageContext, skipOnBeforeRouteHook) {
         }
         // Route Function defined in `.page.route.js`
         if (pageRoute.routeType === 'FUNCTION') {
-            const { routeFunction, routeDefinedAtString } = pageRoute;
-            const match = await (0, resolveRouteFunction_js_1.resolveRouteFunction)(routeFunction, pageContext, routeDefinedAtString);
+            const { routeFunction, routeFunctionFilePath } = pageRoute;
+            const match = await (0, resolveRouteFunction_js_1.resolveRouteFunction)(routeFunction, pageContext, routeFunctionFilePath);
             if (match) {
                 const { routeParams, precedence } = match;
                 routeMatches.push({ pageId, precedence, routeParams, routeType });

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

@@ -46,6 +46,10 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         };
                     }
                     else {
+                        const { definedAtData } = configValue;
+                        (0, utils_js_1.assert)(!(0, utils_js_2.isArray)(definedAtData) && !definedAtData.definedBy);
+                        const { filePathToShowToUser } = definedAtData;
+                        (0, utils_js_1.assert)(filePathToShowToUser);
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
                         // TODO/next-major: remove
                         if ((0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
@@ -54,6 +58,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                             pageId,
                             comesFromV1PageConfig,
                             routeFunction: route,
+                            routeFunctionFilePath: filePathToShowToUser,
                             routeDefinedAtString: definedAtString,
                             routeType: 'FUNCTION'
                         };
@@ -127,6 +132,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeFunction,
+                        routeFunctionFilePath: filePath,
                         routeDefinedAtString: filePath,
                         routeType: 'FUNCTION'
                     });

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

@@ -7,13 +7,17 @@ exports.resolveRouteFunction = resolveRouteFunction;
 exports.assertRouteParams = assertRouteParams;
 exports.assertSyncRouting = assertSyncRouting;
 exports.warnDeprecatedAllowKey = warnDeprecatedAllowKey;
-const getPageContextUrlComputed_js_1 = require("../getPageContextUrlComputed.js");
+const execHook_js_1 = require("../hooks/execHook.js");
+const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
-    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
-    let result = routeFunction(pageContext);
-    assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
+async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
+    let { hookReturn: result } = (0, execHook_js_1.execHookSync)({
+        hookFn: routeFunction,
+        hookFilePath: routeFunctionFilePath,
+        hookName: 'route'
+    }, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
+    assertSyncRouting(result, `The Route Function ${routeFunctionFilePath}`);
     // TODO/v1-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener
     result = await result;
@@ -24,11 +28,11 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtSt
     if (result === true) {
         result = {};
     }
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeDefinedAtString} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainObject)(result), `The Route Function ${routeFunctionFilePath} should return a boolean or a plain JavaScript object (but it's ${picocolors_1.default.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
     // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
-        (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeDefinedAtString} should be a boolean.`);
+        (0, utils_js_1.assertUsage)(typeof match === 'boolean', `The ${picocolors_1.default.cyan('match')} value returned by the Route Function ${routeFunctionFilePath} should be a boolean.`);
         if (!match) {
             return null;
         }
@@ -36,14 +40,14 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtSt
     let precedence = null;
     if ('precedence' in result) {
         precedence = result.precedence;
-        (0, utils_js_1.assertUsage)(typeof precedence === 'number', `The ${picocolors_1.default.cyan('precedence')} value returned by the Route Function ${routeDefinedAtString} should be a number.`);
+        (0, utils_js_1.assertUsage)(typeof precedence === 'number', `The ${picocolors_1.default.cyan('precedence')} value returned by the Route Function ${routeFunctionFilePath} should be a number.`);
     }
-    assertRouteParams(result, `The ${picocolors_1.default.cyan('routeParams')} object returned by the Route Function ${routeDefinedAtString} should`);
+    assertRouteParams(result, `The ${picocolors_1.default.cyan('routeParams')} object returned by the Route Function ${routeFunctionFilePath} should`);
     const routeParams = result.routeParams || {};
     (0, utils_js_1.assertUsage)(!('pageContext' in result), `Providing ${picocolors_1.default.cyan('pageContext')} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`);
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(routeParams));
     Object.keys(result).forEach((key) => {
-        (0, utils_js_1.assertUsage)(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAtString} returned an object with an unknown property ${picocolors_1.default.cyan(key)} (the known properties are ${picocolors_1.default.cyan('match')}, ${picocolors_1.default.cyan('routeParams')}, and ${picocolors_1.default.cyan('precedence')})`);
+        (0, utils_js_1.assertUsage)(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeFunctionFilePath} returned an object with an unknown property ${picocolors_1.default.cyan(key)} (the known properties are ${picocolors_1.default.cyan('match')}, ${picocolors_1.default.cyan('routeParams')}, and ${picocolors_1.default.cyan('precedence')})`);
     });
     return {
         precedence,

package/dist/cjs/shared/utils.js

@@ -43,3 +43,4 @@ __exportStar(require("../utils/changeEnumerable.js"), exports);
 __exportStar(require("../utils/objectDefineProperty.js"), exports);
 __exportStar(require("../utils/isScriptFile.js"), exports);
 __exportStar(require("../utils/objectFilter.js"), exports);
+__exportStar(require("../utils/getPropAccessNotation.js"), exports);

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.229';
+exports.PROJECT_VERSION = '0.4.230';

package/dist/cjs/utils/debug.js

@@ -13,11 +13,10 @@ const checkType_js_1 = require("./checkType.js");
 const getTerminWidth_js_1 = require("./getTerminWidth.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isArray_js_1 = require("./isArray.js");
-// Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
+const isObject_js_1 = require("./isObject.js");
+const debug_js_1 = require("../shared/route/debug.js");
 (0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
-globalThis.__brillout_debug_createDebugger = createDebugger;
-// We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies: for example https://github.com/vikejs/vike/issues/2239
-const DEBUG = getDEBUG() ?? '';
+(0, debug_js_1.setCreateDebugger)(createDebugger); // for isomorphic code
 const flags = [
     'vike:crawl',
     'vike:error',
@@ -31,6 +30,7 @@ const flags = [
     'vike:outDir',
     'vike:pageFiles',
     'vike:pointer-imports',
+    'vike:resolve',
     'vike:routing',
     'vike:setup',
     'vike:stream',
@@ -38,6 +38,10 @@ const flags = [
 ];
 const flagsSkipWildcard = ['vike:log'];
 const flagRegex = /\bvike:[a-zA-Z-]+/g;
+// We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
+const DEBUG = getDEBUG() ?? '';
+if (isDebug())
+    Error.stackTraceLimit = Infinity;
 assertFlagsActivated();
 function createDebugger(flag, optionsGlobal) {
     (0, checkType_js_1.checkType)(flag);
@@ -64,9 +68,10 @@ function debug_(flag, options, ...msgs) {
     });
     let logFirst;
     let logsRest;
-    const noNewLine = msgsRest.length <= 1 && [msgFirst, ...msgsRest].every((m) => typeof m === 'string' && !m.includes('\n'));
+    const noNewLine = msgsRest.length <= 1 &&
+        [msgFirst, ...msgsRest].every((m) => (typeof m === 'string' ? !m.includes('\n') : !(0, isObject_js_1.isObject)(m)));
     if (noNewLine) {
-        logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+        logFirst = [msgFirst, ...msgsRest].map((m) => (typeof m !== 'string' ? m : m.trim()));
         logsRest = [];
     }
     else {
@@ -156,6 +161,10 @@ function getFlagsActivated() {
     const all = DEBUG.includes('vike:*');
     return { flagsActivated, all };
 }
+function isDebug() {
+    const { flagsActivated, all } = getFlagsActivated();
+    return all || flagsActivated.length > 0;
+}
 function getDEBUG() {
     let DEBUG;
     // - `process` can be undefined in edge workers