vike 0.4.171-commit-bb72501 → 0.4.171-commit-f9548df

package/dist/cjs/node/plugin/shared/addSsrMiddleware.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addSsrMiddleware = void 0;
 const renderPage_js_1 = require("../../runtime/renderPage.js");
 const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function addSsrMiddleware(middlewares) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
@@ -13,15 +17,19 @@ function addSsrMiddleware(middlewares) {
         const { headers } = req;
         const pageContextInit = {
             urlOriginal: url,
-            get userAgent() {
-                (0, utils_js_1.assertWarning)(false, "pageContext.userAgent is deprecated in favor of pageContext.headers['user-agent']", {
+            headersOriginal: headers
+        };
+        Object.defineProperty(pageContextInit, 'userAgent', {
+            get() {
+                // TODO/next-major-release: assertUsage() instead of assertWarning()
+                (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('pageContext.userAgent')} is deprecated: use ${picocolors_1.default.cyan("pageContext.headers['user-agent']")} instead.`, {
                     showStackTrace: true,
                     onlyOnce: true
                 });
                 return headers['user-agent'];
             },
-            headers
-        };
+            enumerable: false
+        });
         let pageContext;
         try {
             pageContext = await (0, renderPage_js_1.renderPage)(pageContextInit);

package/dist/cjs/node/prerender/runPrerender.js

@@ -44,7 +44,7 @@ const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 const getConfigValue_js_1 = require("../../shared/page-configs/getConfigValue.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
-const addUrlComputedProps_js_1 = require("../../shared/addUrlComputedProps.js");
+const getPageContextUrlComputed_js_1 = require("../../shared/getPageContextUrlComputed.js");
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadUserFilesServerSide_js_1 = require("../runtime/renderPage/loadUserFilesServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
@@ -268,9 +268,9 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 (0, utils_js_1.objectAssign)(pageContextNew, {
-                    _pageContextAlreadyProvidedByOnPrerenderHook: true,
-                    ...pageContext
+                    _pageContextAlreadyProvidedByOnPrerenderHook: true
                 });
+                (0, utils_js_1.objectAssign)(pageContextNew, pageContext);
             }
         });
     })));
@@ -328,14 +328,11 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
-        urlOriginal,
-        ...prerenderContext.pageContextInit
+        urlOriginal
     };
+    (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext, {
-            // We set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in a onPrerenderStart() hook, e.g. /examples/i18n/
-            urlComputedPropsNonEnumerable: true
-        });
+        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext);
         (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
@@ -410,6 +407,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
     const docLink = 'https://vike.dev/i18n#pre-rendering';
+    // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
+    const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
     let result = await (0, executeHook_js_1.executeHook)(() => hookFn({
         pageContexts: prerenderContext.pageContexts,
         // TODO/v1-release: remove warning
@@ -421,6 +420,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             return prerenderContext.pageContexts;
         }
     }), onPrerenderStartHook, null);
+    restoreEnumerable();
     if (result === null || result === undefined) {
         return;
     }
@@ -458,9 +458,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
                 hookName
             };
         }
-        // Restore as URL computed props are lost when user makes a pageContext copy
-        (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContext);
     });
+    addPageContextComputedUrl(prerenderContext.pageContexts);
 }
 async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
@@ -743,3 +742,23 @@ function assertIsNotAbort(err, urlOr404) {
     (0, utils_js_1.assert)(abortCall);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${picocolors_1.default.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
+function makePageContextComputedUrlNonEnumerable(pageContexts) {
+    change(false);
+    return { restoreEnumerable, addPageContextComputedUrl };
+    function restoreEnumerable() {
+        change(true);
+    }
+    function addPageContextComputedUrl(pageContexts) {
+        // Add URL computed props to the user-generated pageContext copies
+        pageContexts.forEach((pageContext) => {
+            const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContext);
+            (0, utils_js_1.objectAssign)(pageContext, pageContextUrlComputed);
+        });
+    }
+    function change(enumerable) {
+        pageContexts.forEach((pageContext) => {
+            (0, utils_js_1.changeEnumerable)(pageContext, 'urlPathname', enumerable);
+            (0, utils_js_1.changeEnumerable)(pageContext, 'urlParsed', enumerable);
+        });
+    }
+}

package/dist/cjs/node/prerender/utils.js

@@ -31,3 +31,4 @@ __exportStar(require("../../utils/assertNodeEnv.js"), exports);
 __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/assertPathFilesystemAbsolute.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
+__exportStar(require("../../utils/changeEnumerable.js"), exports);

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

@@ -69,13 +69,13 @@ function getRenderHook(pageContext) {
         (0, utils_js_1.assertUsage)(false, [
             `No ${hookName}() hook found, see https://vike.dev/${hookName}`
             /*
-          'See https://vike.dev/render-modes for more information.',
-          [
-            // 'Loaded config files (none of them define the onRenderHtml() hook):',
-            'Loaded server-side page files (none of them `export { render }`):',
-            ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
-          ].join('\n')
-          */
+            'See https://vike.dev/render-modes for more information.',
+            [
+              // 'Loaded config files (none of them define the onRenderHtml() hook):',
+              'Loaded server-side page files (none of them `export { render }`):',
+              ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
+            ].join('\n')
+            */
         ].join(' '));
     }
     return hookFound;

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

@@ -12,7 +12,7 @@ const globalContext_js_1 = require("../globalContext.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
 async function loadUserFilesServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
-    const [{ pageFilesLoaded, pageConfigLoaded, ...pageContextExports }] = await Promise.all([
+    const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
         loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !(0, globalContext_js_1.getGlobalContext)().isProduction),
         (0, analyzePageClientSide_js_1.analyzePageClientSideInit)(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
@@ -37,8 +37,8 @@ async function loadUserFilesServerSide(pageContext) {
         });
     }
     const pageContextAddendum = {};
+    (0, utils_js_1.objectAssign)(pageContextAddendum, pageContextExports);
     (0, utils_js_1.objectAssign)(pageContextAddendum, {
-        ...pageContextExports,
         Page: pageContextExports.exports.Page,
         _isHtmlOnly: isHtmlOnly,
         _passToClient: passToClient,
@@ -104,8 +104,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
     const pageContextExports = (0, getPageFiles_js_1.getPageContextExports)(pageFilesServerSide, pageConfigLoaded);
     return {
-        ...pageContextExports,
-        pageFilesLoaded: pageFilesServerSide,
-        pageConfigLoaded
+        pageContextExports,
+        pageFilesLoaded: pageFilesServerSide
     };
 }

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preparePageContextForUserConsumptionServerSide = void 0;
 const utils_js_1 = require("../utils.js");
 const sortPageContext_js_1 = require("../../../shared/sortPageContext.js");
-const addUrlComputedProps_js_1 = require("../../../shared/addUrlComputedProps.js");
+const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
 function preparePageContextForUserConsumptionServerSide(pageContext) {
-    (0, addUrlComputedProps_js_1.assertPageContextUrlComputedProps)(pageContext);
+    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.routeParams));
     (0, utils_js_1.assert)('Page' in pageContext);
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.pageExports));

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

@@ -9,7 +9,7 @@ const renderHtml_js_1 = require("../html/renderHtml.js");
 const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
 const utils_js_1 = require("../utils.js");
 const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
-const addUrlComputedProps_js_1 = require("../../../shared/addUrlComputedProps.js");
+const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const globalContext_js_1 = require("../globalContext.js");
 const createHttpResponseObject_js_1 = require("./createHttpResponseObject.js");
 const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
@@ -120,7 +120,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
     return prerenderPage(pageContext);
 }
 exports.prerender404Page = prerender404Page;
-function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
@@ -147,7 +147,26 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { urlCompute
         _urlHandler: urlHandler,
         isClientSideNavigation
     });
-    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContextInitEnhanced, !urlComputedPropsNonEnumerable);
+    // pageContext.urlParsed
+    const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContextInitEnhanced);
+    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = (0, utils_js_1.normalizeHeaders)(pageContextInit.headersOriginal);
+            (0, utils_js_1.assertUsage)(!('headers' in pageContextInit), "You're defining pageContextInit.headersOriginal as well as pageContextInit.headers but you should only define pageContextInit.headersOriginal instead, see https://vike.dev/headers");
+        }
+        else if (pageContextInit.headers) {
+            headers = pageContextInit.headers;
+            // TODO/next-major-release: assertUsage() instead of assertWarning()
+            (0, utils_js_1.assertWarning)(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { headers });
+    }
     return pageContextInitEnhanced;
 }
 exports.getPageContextInitEnhanced = getPageContextInitEnhanced;

package/dist/cjs/node/runtime/utils.js

@@ -69,3 +69,4 @@ __exportStar(require("../../utils/formatHintLog.js"), exports);
 __exportStar(require("../../utils/joinEnglish.js"), exports);
 __exportStar(require("../../utils/isArrayOfStrings.js"), exports);
 __exportStar(require("../../utils/escapeHtml.js"), exports);
+__exportStar(require("../../utils/normalizeHeaders.js"), exports);

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

@@ -1,48 +1,34 @@
 "use strict";
-// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPageContextUrlComputedProps = exports.addUrlComputedProps = void 0;
+exports.assertPageContextUrl = exports.getPageContextUrlComputed = void 0;
+// =====================
+// File determining the URL logic.
+// URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// =====================
+const objectDefineProperty_js_1 = require("../utils/objectDefineProperty.js");
 const utils_js_1 = require("./utils.js");
-function addUrlComputedProps(pageContext, enumerable = true) {
-    (0, utils_js_1.assert)(pageContext.urlOriginal);
-    if ('urlPathname' in pageContext) {
-        (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
-        /* If the following assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
-           ```js
-           // Add property getters such as pageContext.urlPathname to pageContext
-           addUrlComputedProps(pageContext)
-           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
-           Object.assign(pageContext2, pageContext)
-           // ❌ Also breaks the property getters
-           const pageContext3 = { ...pageContext }
-           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
-           objectAssign(pageContext2, pageContext)
-           ```
-        */
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
-    }
-    if ('urlParsed' in pageContext)
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
-    Object.defineProperty(pageContext, 'urlPathname', {
+function getPageContextUrlComputed(pageContext) {
+    (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
+    assertPageContextUrlComputed(pageContext);
+    const pageContextUrlComputed = {};
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'url', {
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(pageContext, 'urlParsed', {
+    (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlParsed', {
         get: urlParsedGetter,
-        enumerable,
+        enumerable: true,
         configurable: true
     });
+    return pageContextUrlComputed;
 }
-exports.addUrlComputedProps = addUrlComputedProps;
+exports.getPageContextUrlComputed = getPageContextUrlComputed;
 function getUrlParsed(pageContext) {
     // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
     let urlHandler = pageContext._urlHandler;
@@ -92,7 +78,7 @@ function urlParsedGetter() {
     const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
     const hashIsAvailable = (0, utils_js_1.isBrowser)();
     const warnHashNotAvailable = (prop) => {
-        (0, utils_js_1.assertWarning)(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash by design)`, { onlyOnce: true, showStackTrace: true });
+        (0, utils_js_1.assertWarning)(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });
     };
     const urlParsed = {
         origin,
@@ -122,22 +108,44 @@ function urlParsedGetter() {
             return searchOriginal;
         }
     };
-    makeNonEnumerable(urlParsed, 'hashString');
-    makeNonEnumerable(urlParsed, 'searchString');
+    (0, utils_js_1.changeEnumerable)(urlParsed, 'hashString', false);
+    (0, utils_js_1.changeEnumerable)(urlParsed, 'searchString', false);
     if (!hashIsAvailable) {
-        makeNonEnumerable(urlParsed, 'hash');
-        makeNonEnumerable(urlParsed, 'hashOriginal');
+        (0, utils_js_1.changeEnumerable)(urlParsed, 'hash', false);
+        (0, utils_js_1.changeEnumerable)(urlParsed, 'hashOriginal', false);
     }
     return urlParsed;
 }
-function makeNonEnumerable(obj, prop) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
-    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
-}
-function assertPageContextUrlComputedProps(pageContext) {
+function assertPageContextUrl(pageContext) {
     (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
     (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.urlParsed));
     (0, utils_js_1.assert)(pageContext.urlPathname === pageContext.urlParsed.pathname);
+    assertPageContextUrlComputed(pageContext);
+}
+exports.assertPageContextUrl = assertPageContextUrl;
+function assertPageContextUrlComputed(pageContext) {
+    /*
+    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
+    ```js
+    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
+  
+    // ❌ Breaks the property getters of pageContext set by getPageContextUrlComputed() such as pageContext.urlPathname
+    Object.assign(pageContext, pageContextUrlComputed)
+  
+    // ❌ Also breaks property getters
+    const pageContext = { ...pageContextUrlComputed }
+  
+    // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+    objectAssign(pageContext, pageContextUrlComputed)
+    ```
+    */
+    if ('urlPathname' in pageContext) {
+        (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
+    }
+    if ('urlParsed' in pageContext)
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
+    if ('url' in pageContext)
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
 }
-exports.assertPageContextUrlComputedProps = assertPageContextUrlComputedProps;

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/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/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

@@ -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/normalizeHeaders.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaders = void 0;
+function normalizeHeaders(
+/* This type is precise, too precise which can be annoying: e.g. cannot pass a string[][] argument because it doesn't match the more precise [string,string][] type.
+headersOriginal ConstructorParameters<typeof Headers>[0]
+*/
+headersOriginal) {
+    const headersStandard = new Headers(headersOriginal);
+    const headers = Object.fromEntries(headersStandard.entries());
+    return headers;
+}
+exports.normalizeHeaders = normalizeHeaders;

package/dist/cjs/utils/objectAssign.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectAssign = void 0;
 // Same as Object.assign() but:
 //  - With type inference
-//  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
+//  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
 function objectAssign(obj, objAddendum) {
     if (objAddendum) {
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));

package/dist/cjs/utils/objectDefineProperty.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectDefineProperty = void 0;
+/** Like Object.defineProperty() but with type inference */
+function objectDefineProperty(obj, prop, { get, ...args }) {
+    Object.defineProperty(obj, prop, { ...args, get });
+}
+exports.objectDefineProperty = objectDefineProperty;

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.171-commit-bb72501';
+const PROJECT_VERSION = '0.4.171-commit-f9548df';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -11,6 +11,8 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-} & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
-    _urlRewrite: string | null;
+} & {
+    urlParsed: import("../../shared/getPageContextUrlComputed.js").Url;
+    urlPathname: string;
+    url: string;
 }>;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -1,9 +1,9 @@
 export { createPageContext };
-import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
+import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, getGlobalObject } from './utils.js';
+import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
 const globalObject = getGlobalObject('createPageContext.ts', {});
 async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
@@ -26,6 +26,7 @@ async function createPageContext(urlOriginal) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook
     };
-    addUrlComputedProps(pageContext);
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
+    objectAssign(pageContext, pageContextUrlComputed);
     return pageContext;
 }

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -32,7 +32,9 @@ async function getPageContextFromHooks_isHydration(pageContext) {
         _hasPageContextFromServer: true
     };
     for (const hookName of ['data', 'onBeforeRender']) {
-        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookClientOnlyExists(hookName, pageContextForHook)) {
             const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
             Object.assign(pageContextFromHooks, pageContextFromHook);
@@ -45,6 +47,9 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
         isHydration: false,
         _hasPageContextFromClient: false
     };
+    const pageContextForCondition = {};
+    objectAssign(pageContextForCondition, pageContext);
+    objectAssign(pageContextForCondition, pageContextFromHooks);
     let hasPageContextFromServer = false;
     // If pageContextInit has some client data or if one of the hooks guard(), data() or onBeforeRender() is server-side
     // only, then we need to fetch pageContext from the server.
@@ -53,7 +58,7 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
         // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
-        (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
+        (await hasPageContextServer(pageContextForCondition))) {
         const res = await fetchPageContextFromServer(pageContext);
         if ('is404ServerSideRouted' in res)
             return { is404ServerSideRouted: true };
@@ -70,11 +75,10 @@ async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage)
     // Note: for the error page, we also execute the client-side data() and onBeforeRender() hooks, but maybe we
     // shouldn't? The server-side does it as well (but maybe it shouldn't).
     for (const hookName of ['guard', 'data', 'onBeforeRender']) {
-        const pageContextForHook = {
-            _hasPageContextFromServer: hasPageContextFromServer,
-            ...pageContext,
-            ...pageContextFromHooks
-        };
+        const pageContextForHook = {};
+        objectAssign(pageContextForHook, { _hasPageContextFromServer: hasPageContextFromServer });
+        objectAssign(pageContextForHook, pageContext);
+        objectAssign(pageContextForHook, pageContextFromHooks);
         if (hookName === 'guard') {
             if (!isErrorPage &&
                 // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the server-side.)

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -3,6 +3,7 @@ export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
+import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
 async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
@@ -29,10 +30,9 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         throw err;
     }
     const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
-    const pageContextAddendum = {
-        ...pageContextExports,
-        _pageFilesLoaded: pageFilesClientSide
-    };
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, pageContextExports);
+    objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });
     return pageContextAddendum;
 }
 function isErrorFetchingStaticAssets(err) {

package/dist/esm/node/plugin/shared/addSsrMiddleware.js

@@ -1,6 +1,7 @@
 export { addSsrMiddleware };
 import { renderPage } from '../../runtime/renderPage.js';
 import { assertWarning } from '../utils.js';
+import pc from '@brillout/picocolors';
 function addSsrMiddleware(middlewares) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
@@ -11,15 +12,19 @@ function addSsrMiddleware(middlewares) {
         const { headers } = req;
         const pageContextInit = {
             urlOriginal: url,
-            get userAgent() {
-                assertWarning(false, "pageContext.userAgent is deprecated in favor of pageContext.headers['user-agent']", {
+            headersOriginal: headers
+        };
+        Object.defineProperty(pageContextInit, 'userAgent', {
+            get() {
+                // TODO/next-major-release: assertUsage() instead of assertWarning()
+                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
                     showStackTrace: true,
                     onlyOnce: true
                 });
                 return headers['user-agent'];
             },
-            headers
-        };
+            enumerable: false
+        });
         let pageContext;
         try {
             pageContext = await renderPage(pageContextInit);