vike 0.4.229-commit-7056ef0 → 0.4.229-commit-e27d672

package/dist/cjs/shared/createGlobalContextShared.js

@@ -5,7 +5,8 @@ exports.createGlobalContextShared = createGlobalContextShared;
 const utils_js_1 = require("./utils.js");
 const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
 const getUserFriendlyConfigs_js_1 = require("./page-configs/getUserFriendlyConfigs.js");
-const executeHook_js_1 = require("./hooks/executeHook.js");
+const execHook_js_1 = require("./hooks/execHook.js");
+const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextForPublicUsage.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
@@ -25,12 +26,12 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         //      - globalContext._viteDevServer.hot.send()
         //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
         //        - Seems less idiomatic
-        await (0, executeHook_js_1.executeHookGlobalCumulative)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+        await (0, execHook_js_1.execHookGlobal)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage);
     }
     else {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
         // We don't use objectReplace() in order to keep user-land properties.
-        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext);
+        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext, true);
     }
     return globalObject.globalContext;
 }
@@ -43,6 +44,7 @@ function createGlobalContextBase(virtualFileExports) {
          * https://vike.dev/globalContext#typescript
          */
         isGlobalContext: true,
+        _isOriginalObject: true,
         _virtualFileExports: virtualFileExports,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
@@ -52,6 +54,7 @@ function createGlobalContextBase(virtualFileExports) {
         config: userFriendlyConfigsGlobal.config,
         pages: userFriendlyConfigsPageEager
     };
+    (0, utils_js_1.changeEnumerable)(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {

package/dist/cjs/shared/createPageContextShared.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
-const executeHook_js_1 = require("./hooks/executeHook.js");
+exports.createPageContextObject = createPageContextObject;
+const execHook_js_1 = require("./hooks/execHook.js");
+const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    (0, utils_js_1.objectAssign)(pageContextCreated, { isPageContext: true }, true);
     (0, utils_js_1.objectAssign)(pageContextCreated, userFriendlyConfigsGlobal);
-    await (0, executeHook_js_1.executeHookGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
+function createPageContextObject() {
+    const pageContext = {
+        _isOriginalObject: true,
+        isPageContext: true
+    };
+    (0, utils_js_1.changeEnumerable)(pageContext, '_isOriginalObject', false);
+    return pageContext;
+}

package/dist/cjs/shared/getPageContext.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.providePageContext = exports.getPageContext = void 0;
-var executeHook_js_1 = require("./hooks/executeHook.js");
-Object.defineProperty(exports, "getPageContext", { enumerable: true, get: function () { return executeHook_js_1.getPageContext; } });
-Object.defineProperty(exports, "providePageContext", { enumerable: true, get: function () { return executeHook_js_1.providePageContext; } });
+var execHook_js_1 = require("./hooks/execHook.js");
+Object.defineProperty(exports, "getPageContext", { enumerable: true, get: function () { return execHook_js_1.getPageContext; } });
+Object.defineProperty(exports, "providePageContext", { enumerable: true, get: function () { return execHook_js_1.providePageContext; } });

package/dist/cjs/shared/getPageContextUrlComputed.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageContextUrlComputed = getPageContextUrlComputed;
-exports.assertPageContextUrl = assertPageContextUrl;
 // =====================
 // 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 preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
 function getPageContextUrlComputed(pageContext) {
     (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
-    assertPageContextUrlComputed(pageContext);
+    (0, preparePageContextForPublicUsage_js_1.assertPropertyGetters)(pageContext);
     const pageContextUrlComputed = {};
     (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
@@ -130,37 +130,3 @@ function urlParsedGetter() {
     }
     return urlParsedEnhanced;
 }
-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);
-}
-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));
-    }
-}

package/dist/cjs/shared/getProxyForPublicUsage.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxyForPublicUsage = getProxyForPublicUsage;
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+// Show warning when user is accessing internal `_` properties.
+const NOT_SERIALIZABLE_js_1 = require("./NOT_SERIALIZABLE.js");
+const utils_js_1 = require("./utils.js");
+function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp, fallback)
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        if (fallback) {
+            // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
+            // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
+            if (!(prop in obj) && prop in fallback)
+                return fallback[prop];
+        }
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function onNotSerializable(propStr, val, objName) {
+    if (val !== NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE)
+        return;
+    const propName = (0, utils_js_1.getPropAccessNotation)(propStr);
+    (0, utils_js_1.assert)((0, utils_js_1.isBrowser)());
+    (0, utils_js_1.assertUsage)(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
+}
+function onInternalProp(propStr, objName) {
+    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
+    //   - Where import.meta.CLIENT is defined by Vike
+    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
+    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
+    if ((0, utils_js_1.isBrowser)())
+        return;
+    // TODO/now remove this and only warn on built-in access instead
+    if (propStr === '_configFromHook')
+        return;
+    if (propStr.startsWith('_')) {
+        (0, utils_js_1.assertWarning)(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+    }
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHook = execHook;
+exports.execHookSingle = execHookSingle;
+exports.execHookSingleWithReturn = execHookSingleWithReturn;
+exports.execHookErrorHandling = execHookErrorHandling;
+exports.execHooksErrorHandling = execHooksErrorHandling;
+exports.execHookWithoutPageContext = execHookWithoutPageContext;
+exports.execHookGlobal = execHookGlobal;
+exports.execHookSync = execHookSync;
+exports.getPageContext = getPageContext;
+exports.providePageContext = providePageContext;
+exports.isUserHookError = isUserHookError;
+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 getHook_js_1 = require("./getHook.js");
+const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/execHook.ts', {
+    userHookErrors: new WeakMap(),
+    pageContext: null
+});
+async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    (0, assert_js_1.assertUsage)(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    return { hookReturn };
+}
+async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    return res.hooks;
+}
+async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
+    const hooks = (0, getHook_js_1.getHookFromPageContextNew)(hookName, pageContext);
+    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
+}
+async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return { hooks: [] };
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    let hooksWithResult;
+    let err;
+    try {
+        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+            return { ...hook, hookReturn };
+        }));
+    }
+    catch (err_) {
+        err = err_;
+    }
+    if (hooksWithResult) {
+        return { hooks: hooksWithResult };
+    }
+    else {
+        return { hooks, err };
+    }
+}
+async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
+    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+    await Promise.all(hooks.map(async (hook) => {
+        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+    }));
+}
+function isUserHookError(err) {
+    if (!(0, isObject_js_1.isObject)(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+async function execHookWithoutPageContext(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout } = hook;
+    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    return hookReturn;
+}
+function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
+    };
+    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
+        setTimeout(() => {
+            (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
+        }, timeoutWarn);
+    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
+        setTimeout(() => {
+            const err = (0, assert_js_1.getProjectError)(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)} (https://vike.dev/hooksTimeout)`);
+            reject(err);
+        }, timeoutErr);
+    (async () => {
+        try {
+            providePageContext(pageContextForPublicUsage);
+            const ret = await hookFnCaller();
+            resolve(ret);
+        }
+        catch (err) {
+            if ((0, isObject_js_1.isObject)(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    providePageContext(pageContextForPublicUsage);
+    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    return { hookReturn };
+}
+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() {
+    const { pageContext } = globalObject;
+    if (!pageContext)
+        return pageContext;
+    const pageContextForPublicUsage = (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
+    return pageContextForPublicUsage;
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/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/page-configs/getUserFriendlyConfigs.js

@@ -97,7 +97,7 @@ pageConfigGlobal) {
             configsComputed: {}
         };
     }
-    const pageExports = createObjectWithDeprecationWarning();
+    const pageExports = {};
     const exports = {};
     Object.entries(exportsAll).forEach(([exportName, values]) => {
         values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
@@ -120,9 +120,23 @@ pageConfigGlobal) {
         // 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
@@ -249,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,75 @@
+"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.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
+    const globalContextPublic = (0, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage)(pageContext._globalContext);
+    (0, utils_js_1.objectAssign)(pageContext, {
+        globalContext: globalContextPublic
+    });
+    (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 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, pageContext.globalContext);
+    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/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'
                     });