vike 0.4.225-commit-37a36a5 → 0.4.225-commit-b8fc36e

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -5,12 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializePageContextClientSide = serializePageContextClientSide;
 exports.serializePageContextAbort = serializePageContextAbort;
+exports.getPropKeys = getPropKeys;
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
 const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const notSerializable_js_1 = require("../../../shared/notSerializable.js");
+const NOT_SERIALIZABLE_js_1 = require("../../../shared/NOT_SERIALIZABLE.js");
 const pageContextInitIsPassedToClient_js_1 = require("../../../shared/misc/pageContextInitIsPassedToClient.js");
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 const PASS_TO_CLIENT = [
@@ -30,12 +31,8 @@ const PASS_TO_CLIENT = [
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
-    const pageContextClient = {};
-    passToClient.forEach((prop) => {
-        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
-        pageContextClient[prop] = pageContext[prop];
-    });
-    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+    const pageContextClient = applyPassToClient(passToClient, pageContext);
+    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient] = true;
     }
     let pageContextSerialized;
@@ -47,14 +44,15 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName1 = (0, utils_js_1.getPropAccessNotation)(prop);
-            const propName2 = JSON.stringify(prop);
-            const varName = `pageContext${propName1}`;
+            const res = getPropVal(pageContext, prop);
+            if (!res)
+                return;
+            const { value } = res;
+            const varName = `pageContext${getPropKeys(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
-                serialize(pageContext[prop], varName);
+                serialize(value, varName);
             }
             catch (err) {
-                hasWarned = true;
                 propsNonSerializable.push(prop);
                 // useConfig() wrong usage
                 if (prop === '_configFromHook') {
@@ -67,7 +65,7 @@ function serializePageContextClientSide(pageContext) {
                 // Non-serializable pageContext set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(propName2)} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
                 ].join(' ');
                 if ((0, stringify_1.isJsonSerializerError)(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -80,11 +78,12 @@ function serializePageContextClientSide(pageContext) {
                 }
                 // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
                 (0, utils_js_1.assertWarning)(false, msg, { onlyOnce: false });
+                hasWarned = true;
             }
         });
         (0, utils_js_1.assert)(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[prop] = notSerializable_js_1.notSerializable;
+            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
         });
         try {
             pageContextSerialized = serialize(pageContextClient);
@@ -143,3 +142,57 @@ function serializePageContextAbort(pageContext) {
     }
     return serialize(pageContext);
 }
+function applyPassToClient(passToClient, pageContext) {
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // Get value from pageContext
+        const res = getPropVal(pageContext, prop);
+        if (!res)
+            return;
+        const { value } = res;
+        // Set value to pageContextClient
+        setPropVal(pageContextClient, prop, value);
+    });
+    return pageContextClient;
+}
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if ((0, utils_js_1.isObject)(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!(0, utils_js_1.isObject)(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see serializePageContextClientSide.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

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

@@ -9,5 +9,8 @@ function preparePageContextForUserConsumptionServerSide(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)(typeof pageContext.isClientSideNavigation === 'boolean');
+    (0, utils_js_1.assert)(pageContext._isPageContextObject);
+    (0, utils_js_1.assert)(pageContext.isClientSide === false);
+    (0, utils_js_1.assert)(typeof pageContext.isPrerendering === 'boolean');
     (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
 }

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

@@ -7,6 +7,7 @@ exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
 exports.prerender404Page = prerender404Page;
 exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
+exports.createPageContext = createPageContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const utils_js_1 = require("../utils.js");
@@ -89,7 +90,11 @@ async function prerender404Page(pageContextInit_, globalContext) {
     if (!errorPageId) {
         return null;
     }
-    const pageContext = {
+    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
+    const pageContextInit = { urlOriginal: '/fake-404-url' };
+    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    (0, utils_js_1.objectAssign)(pageContext, {
         pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
@@ -98,25 +103,17 @@ async function prerender404Page(pageContextInit_, globalContext) {
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
         _debugRouteMatches: []
-    };
-    const pageContextInit = {
-        urlOriginal: '/fake-404-url' // A URL is needed for `applyViteHtmlTransform`
-    };
-    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
-    }
+    });
     (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
     return prerenderPage(pageContext);
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
 } } = {}) {
     (0, utils_js_1.assert)(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = {};
+    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
@@ -163,3 +160,12 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     }
     return pageContextInitEnhanced;
 }
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: false,
+        isPrerendering
+    };
+    (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -108,15 +108,9 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
     0);
     let pageContextNominalPageSuccess;
-    let pageContextNominalPageInit = {};
-    {
-        const pageContextFromAllRewrites = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
-        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
-    }
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
-        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextInitEnhanced);
-    }
+    const pageContextFromAllRewrites = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
+    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
+    (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
@@ -247,7 +241,7 @@ function prettyUrl(url) {
     return picocolors_1.default.bold(decodeURI(url));
 }
 function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit);
+    const pageContextWithError = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);
     (0, utils_js_1.objectAssign)(pageContextWithError, {
         httpResponse,
@@ -255,13 +249,6 @@ function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     });
     return pageContextWithError;
 }
-function createPageContext(pageContextInit) {
-    const pageContext = {
-        _isPageContextObject: true
-    };
-    Object.assign(pageContext, pageContextInit);
-    return pageContext;
-}
 async function renderPageNominal(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
     // Route
@@ -286,10 +273,8 @@ async function renderPageNominal(pageContext) {
     return pageContextAfterRender;
 }
 async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
+    const pageContext = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
     (0, utils_js_1.assert)(errNominalPage);
-    const pageContext = {};
-    (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     (0, utils_js_1.objectAssign)(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
@@ -303,7 +288,7 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
 }
 async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, {
+    const pageContextInitEnhanced = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, false, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -347,7 +332,7 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -389,7 +374,7 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, pageContextInit);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const pageContextHttpResponse = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -410,10 +395,10 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
             const abortCall = pageContextAbort._abortCall;
             (0, utils_js_1.assert)(abortCall);
             (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = createPageContext({});
+            const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)({}, false);
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
-            (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit);
+            (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
             (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
@@ -434,7 +419,7 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit);
+        const pageContextReturn = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
         const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)(pageContextAbort._urlRedirect, pageContextInit);
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
@@ -449,7 +434,7 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     const { isBaseMissing } = (0, utils_js_1.parseUrl)(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit);
+    const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseBaseIsMissing)(urlOriginal, baseServer);
     (0, utils_js_1.objectAssign)(pageContext, {
         httpResponse,
@@ -462,7 +447,7 @@ function renderInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
     if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit);
+        const pageContext = (0, renderPageAlreadyRouted_js_1.createPageContext)(pageContextInit, false);
         const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         (0, utils_js_1.checkType)(pageContext);

package/dist/cjs/node/runtime-dev/createDevMiddleware.js

@@ -22,8 +22,8 @@ async function createDevMiddleware(options = {}) {
             }
         }
     };
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
-    const server = await (0, vite_1.createServer)(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
+    const server = await (0, vite_1.createServer)(viteConfigFromUserEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

package/dist/cjs/shared/NOT_SERIALIZABLE.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOT_SERIALIZABLE = void 0;
+// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
+exports.NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';

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.225-commit-37a36a5';
+exports.PROJECT_VERSION = '0.4.225-commit-b8fc36e';

package/dist/cjs/utils/assert.js

@@ -47,7 +47,7 @@ function assert(condition, debugInfo) {
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
         return picocolors_1.default.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = picocolors_1.default.blue('https://github.com/vikejs/vike/issues/new?template=bug.yml');
+    const link = picocolors_1.default.underline('https://github.com/vikejs/vike/issues/new?template=bug.yml');
     let errMsg = [
         `You stumbled upon a Vike bug. Go to ${link} and copy-paste this error. A maintainer will fix the bug (usually within 24 hours).`,
         debugStr

package/dist/cjs/utils/objectAssign.js

@@ -5,9 +5,14 @@ const assert_js_1 = require("./assert.js");
 // Same as Object.assign() but:
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
-function objectAssign(obj, objAddendum) {
+function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
     if (objAddendum) {
-        (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+        if (!objAddendumCanBePageContextObject) {
+            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
+            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
+            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
+            (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+        }
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }

package/dist/cjs/utils/pick.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pick = pick;
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}

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

@@ -1,6 +1,8 @@
 export { createPageContext };
 declare function createPageContext(urlOriginal: string): Promise<{
     _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
     urlOriginal: string;
     _objectCreatedByVike: boolean;
     _urlHandler: null;

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

@@ -4,7 +4,6 @@ import { getPageContextUrlComputed } from '../../shared/getPageContextUrlCompute
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, isBaseServer, objectAssign } from './utils.js';
-// TODO/now: can we avoid optimizeDeps.exclude of client runtime?
 // @ts-ignore
 import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
 const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
@@ -14,6 +13,8 @@ async function createPageContext(urlOriginal) {
     assert(isBaseServer(baseServer));
     const pageContext = {
         _isPageContextObject: true,
+        isClientSide: true,
+        isPrerendering: false,
         urlOriginal,
         _objectCreatedByVike: true,
         _urlHandler: null,

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

@@ -276,7 +276,7 @@ async function renderPageClientSide(renderArgs) {
         if ('err' in args) {
             const { err } = args;
             assert(!('errorWhileRendering' in pageContext));
-            pageContext.errorWhileRendering = err;
+            objectAssign(pageContext, { errorWhileRendering: err });
             if (isAbortError(err)) {
                 const errAbort = err;
                 logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,12 +1,15 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
-    pageId: string;
-    routeParams: Record<string, string>;
-} & {
+    _isPageContextObject: boolean;
+    isPrerendering: boolean;
+    isClientSide: boolean;
     isHydration: true;
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;
     _hasPageContextFromClient: false;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -9,13 +9,16 @@ import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-r
 const { pageFilesAll, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
-    const pageContext = getPageContextSerializedInHtml();
-    objectAssign(pageContext, {
+    const pageContext = {
+        _isPageContextObject: true,
+        isPrerendering: false,
+        isClientSide: true,
         isHydration: true,
         isBackwardNavigation: null,
         _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
-    });
+    };
+    objectAssign(pageContext, getPageContextSerializedInHtml());
     objectAssign(pageContext, await loadPageUserFiles(pageContext.pageId));
     assertPristineUrl();
     return pageContext;

package/dist/esm/client/shared/getPageContextProxyForUser.d.ts

@@ -1,12 +1,2 @@
 export { getPageContextProxyForUser };
-export { PageContextForPassToClientWarning };
-type PageContextForPassToClientWarning = {
-    _hasPageContextFromServer: boolean;
-    _hasPageContextFromClient: boolean;
-};
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
-declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;
+declare function getPageContextProxyForUser<PageContext extends Record<string, unknown>>(pageContext: PageContext): PageContext;

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

@@ -1,77 +1,14 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
-import { notSerializable } from '../../shared/notSerializable.js';
-const globalObject = getGlobalObject('shared/getPageContextProxyForUser.ts', {});
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
+import { assertUsage, getPropAccessNotation } from '../server-routing-runtime/utils.js';
+import { NOT_SERIALIZABLE } from '../../shared/NOT_SERIALIZABLE.js';
+// Throw error when pageContext value isn't serializable
 function getPageContextProxyForUser(pageContext) {
-    assert([true, false].includes(pageContext._hasPageContextFromServer));
-    assert([true, false].includes(pageContext._hasPageContextFromClient));
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
             const propName = getPropAccessNotation(prop);
-            assertUsage(val !== notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            passToClientHint(pageContext, prop, propName);
+            assertUsage(val !== NOT_SERIALIZABLE, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
             return val;
         }
     });
 }
-function passToClientHint(pageContext, prop, propName) {
-    if (handleVueReactivity(prop))
-        return;
-    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
-    // ```html
-    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
-    // ```
-    if (prop in pageContext)
-        return;
-    if (isWhitelisted(prop))
-        return;
-    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
-    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
-    if (!pageContext._hasPageContextFromServer)
-        return;
-    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
-    if (
-    // TODO/next-major-release always make it an error.
-    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
-    pageContext._hasPageContextFromClient) {
-        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
-    }
-    else {
-        assertUsage(false, errMsg);
-    }
-}
-const WHITELIST = [
-    'then',
-    // Vue calls toJSON()
-    'toJSON'
-];
-function isWhitelisted(prop) {
-    if (WHITELIST.includes(prop))
-        return true;
-    if (typeof prop === 'symbol')
-        return true; // Vue tries to access some symbols
-    if (typeof prop !== 'string')
-        return true;
-    if (prop.startsWith('__v_'))
-        return true; // Vue internals upon `reactive(pageContext)`
-    return false;
-}
-// Handle Vue's reactivity.
-// When changing a reactive object:
-// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
-// - Vue seems to read __v_raw before reading the property.
-function handleVueReactivity(prop) {
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
-        return true;
-    globalObject.prev = prop;
-    window.setTimeout(() => {
-        globalObject.prev = undefined;
-    }, 0);
-    return false;
-}

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -2,9 +2,9 @@ export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
 import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & {
     pageId: string;
+    _hasPageContextFromServer: boolean;
     _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {

package/dist/esm/node/api/build.js

@@ -11,13 +11,13 @@ import { assertVersion } from './utils.js';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
+    const { viteConfigFromUserEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
     // Pass it to pluginAutoFullBuild()
-    if (viteConfigEnhanced)
-        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (viteConfigFromUserEnhanced)
+        viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
     if (vikeConfig.global.config.vite6BuilderApp) {
         assertVersion('Vite', version, '6.0.0');
-        const builder = await createBuilder(viteConfigEnhanced);
+        const builder = await createBuilder(viteConfigFromUserEnhanced);
         // See Vite plugin vike:build:pluginBuildApp
         await builder.buildApp();
     }
@@ -30,14 +30,14 @@ async function build(options = {}) {
         //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
         //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
-        await buildVite(viteConfigEnhanced);
+        await buildVite(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
         if (isVikeCli() && isPrerendering())
             assert(false);
     }
     return {
-    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigEnhanced,
+    /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigFromUserEnhanced,
     */
     };
 }

package/dist/esm/node/api/dev.js

@@ -7,8 +7,8 @@ import { createServer } from 'vite';
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
         viteConfig: server.config

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -7,7 +7,7 @@ import type { APIOptions, Operation } from './types.js';
 import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
     vikeConfig: VikeConfigObject;
-    viteConfigEnhanced: InlineConfig | undefined;
+    viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;
 declare function getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;