vike 0.4.228-commit-c2f6e1f → 0.4.228-commit-8d90991

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

@@ -5,30 +5,31 @@ exports.createPageContextServerSideWithoutGlobalContext = createPageContextServe
 const utils_js_1 = require("../utils.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const createPageContextShared_js_1 = require("../../../shared/createPageContextShared.js");
-async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+async function createPageContextServerSide(pageContextInit, globalContext, globalObject_public, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
     urlHandler: null,
     isClientSideNavigation: false
 } }) {
     (0, utils_js_1.assert)(pageContextInit.urlOriginal);
     const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
-    (0, utils_js_1.objectAssign)(pageContextCreated, pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextCreated, {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        // We must use Flatten<T> otherwise TypeScript complains upon assigning types
+        ...(globalContext as Flatten<typeof globalContext>), // least precedence
+        */
+        globalContext: globalObject_public,
+        _globalContext: globalContext,
         // The following is defined on `pageContext` because we can eventually make these non-global
         _baseServer: globalContext.baseServer,
         _baseAssets: globalContext.baseAssets,
         // TODO/now: add meta.default
         _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
         // TODO/soon: use GloablContext instead
-        _pageFilesAll: globalContext.pageFilesAll,
-        _pageConfigs: globalContext.pageConfigs,
-        _pageConfigGlobal: globalContext.pageConfigGlobal,
-        _allPageIds: globalContext.allPageIds,
-        _pageRoutes: globalContext.pageRoutes,
-        _onBeforeRouteHook: globalContext.onBeforeRouteHook,
-        _globalContext: globalContext,
-        // TODO/now: add PageContext['globalContext']
-        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: globalContext.globalContext_public,
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        _pageRoutes: globalContext._pageRoutes,
+        _onBeforeRouteHook: globalContext._onBeforeRouteHook,
         _pageContextInit: pageContextInit,
         _urlRewrite: null,
         _urlHandler: urlHandler,
@@ -54,7 +55,7 @@ async function createPageContextServerSide(pageContextInit, globalContext, { isP
         }
         (0, utils_js_1.objectAssign)(pageContextCreated, { headers });
     }
-    const pageContextAugmented = await (0, createPageContextShared_js_1.createPageContextShared)(pageContextCreated, globalContext.pageConfigGlobal);
+    const pageContextAugmented = await (0, createPageContextShared_js_1.createPageContextShared)(pageContextCreated, globalContext._pageConfigGlobal);
     (0, utils_js_1.augmentType)(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }

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

@@ -13,12 +13,12 @@ const globalObject = (0, utils_js_1.getGlobalObject)('renderPage/getPageAssets.t
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
-    const { isProduction } = globalContext;
+    const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
-        const { viteDevServer } = globalContext;
+        const { _viteDevServer: viteDevServer } = globalContext;
         clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer)));
         assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
     }

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

@@ -14,7 +14,7 @@ async function handleErrorWithoutErrorPage(pageContext) {
     (0, utils_js_1.assert)(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;
-        await warnMissingErrorPage(isV1, pageContext._globalContext.isProduction);
+        await warnMissingErrorPage(isV1, pageContext._globalContext._isProduction);
     }
     if (!pageContext.isClientSideNavigation) {
         const httpResponse = (0, createHttpResponse_js_1.createHttpResponseError)(pageContext);

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

@@ -14,7 +14,7 @@ async function loadUserFilesServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, globalContext.pageConfigGlobal, pageContext.pageId, !globalContext.isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, globalContext._pageConfigGlobal, pageContext.pageId, !globalContext._isProduction),
         (0, analyzePageClientSide_js_1.analyzePageClientSideInit)(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await (0, analyzePage_js_1.analyzePage)(pageContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);

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

@@ -17,7 +17,7 @@ async function log404(pageContext) {
     */
     );
     const globalContext = pageContext._globalContext;
-    if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
+    if (!globalContext._isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
         const routesInfo = getRoutesInfo(pageRoutes);
         let msg = `URL ${picocolors_1.default.cyan(urlPathname)} ${noRouteMatch_js_1.noRouteMatch}`;
         const outro = 'See https://vike.dev/routing for more information about routing.';

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

@@ -8,7 +8,7 @@ exports.prerenderPage = prerenderPage;
 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");
-const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
+const serializeContext_js_1 = require("../html/serializeContext.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
 const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
@@ -47,7 +47,7 @@ async function renderPageAlreadyRouted(pageContext) {
         if (isError) {
             (0, utils_js_1.objectAssign)(pageContext, { [isServerSideError_js_1.isServerSideError]: true });
         }
-        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
@@ -77,7 +77,7 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }

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

@@ -19,7 +19,7 @@ const assertArguments_js_1 = require("./renderPage/assertArguments.js");
 const index_js_2 = require("./renderPage/log404/index.js");
 const isVikeConfigInvalid_js_1 = require("./renderPage/isVikeConfigInvalid.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const serializePageContextClientSide_js_1 = require("./html/serializePageContextClientSide.js");
+const serializeContext_js_1 = require("./html/serializeContext.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
 const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
@@ -81,8 +81,8 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
-    const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
-    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
+    const { globalContext, globalContext_public } = await (0, globalContext_js_1.getGlobalContextInternal)();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -159,7 +159,7 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
             if (!errorPageId) {
                 (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
                 return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
@@ -304,9 +304,9 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     (0, utils_js_1.assert)(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
+    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
@@ -402,12 +402,12 @@ function normalize(url) {
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextBegin, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageBegin to it: we only use some pageContextNominalPageBegin information.
 pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext) {
-    (0, abort_js_1.logAbortErrorHandled)(errAbort, globalContext.isProduction, pageContextNominalPageBegin);
+    (0, abort_js_1.logAbortErrorHandled)(errAbort, globalContext._isProduction, pageContextNominalPageBegin);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
     if (pageContextNominalPageBegin.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
             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`);
@@ -417,10 +417,10 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (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);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }
         else {
-            pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextAbort)(pageContextAbort);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerializedAbort)(pageContextAbort);
         }
         const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         const pageContextReturn = { httpResponse };

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

@@ -74,5 +74,5 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
-__exportStar(require("../../utils/makePublicCopy.js"), exports);
+__exportStar(require("../../utils/getPublicProxy.js"), exports);
 __exportStar(require("../../utils/augmentType.js"), exports);

package/dist/cjs/shared/createGlobalContextShared.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobalContextShared = createGlobalContextShared;
+const getPageConfigsRuntime_js_1 = require("./getPageConfigsRuntime.js");
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
+const utils_js_1 = require("./utils.js");
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+    const globalContext = createGlobalContextBase(virtualFileExports);
+    const globalContextAddendum = await addGlobalContext?.(globalContext);
+    (0, utils_js_1.objectAssign)(globalContext, globalContextAddendum);
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
+        // - TO-DO/eventually: HMR
+        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
+        //    - Either use:
+        //      - import.meta.hot
+        //        - https://vite.dev/guide/api-hmr.html
+        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
+        //        - Seems more idiomatic
+        //      - 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, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+    }
+    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);
+    }
+    return globalObject.globalContext;
+}
+function createGlobalContextBase(virtualFileExports) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
+    const globalContext = {
+        _virtualFileExports: virtualFileExports,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        config: globalConfig.config,
+        pages: pageConfigsUserFriendly
+    };
+    return globalContext;
+}

package/dist/cjs/shared/createPageContextShared.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
-const executeHookGeneric_js_1 = require("../node/runtime/renderPage/executeHookGeneric.js");
+const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
 const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
 const utils_js_1 = require("./utils.js");
 async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
@@ -12,6 +12,6 @@ async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
         _isPageContextObject: true,
         ...pageConfigGlobalUserFriendly
     }, true);
-    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated);
+    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
     return pageContextCreated;
 }

package/dist/cjs/{node/runtime/renderPage → shared/hooks}/executeHookGeneric.js

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeHookGeneric = executeHookGeneric;
 exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
-const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
-const getHook_js_1 = require("../../../shared/hooks/getHook.js");
+const executeHook_js_1 = require("./executeHook.js");
+const getHook_js_1 = require("./getHook.js");
 async function executeHookGeneric(hookName, pageContext) {
     const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
     if (!hook)
         return;
     await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
 }
-async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext) {
+async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
     const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
     await Promise.all(hooks.map(async (hook) => {
-        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, null);
+        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(arg), hook, pageContext);
     }));
 }

package/dist/cjs/shared/htmlElementIds.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlElementId_globalContext = exports.htmlElementId_pageContext = void 0;
+exports.htmlElementId_pageContext = 'vike_pageContext';
+exports.htmlElementId_globalContext = 'vike_globalContext';

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.228-commit-c2f6e1f';
+exports.PROJECT_VERSION = '0.4.228-commit-8d90991';

package/dist/cjs/utils/catchInfiniteLoop.js

@@ -14,14 +14,14 @@ function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds =
     // Count
     tracker.count++;
     // Error
-    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    const msg = `[Infinite Loop] Rendering ${tracker.count} times within ${withinSeconds} seconds [${functionName}]`;
     if (tracker.count > maxNumberOfCalls) {
-        (0, assert_js_1.assert)(false, msg);
+        (0, assert_js_1.assertUsage)(false, msg);
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
         // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
-        (0, assert_js_1.assertWarning)(false, msg, { onlyOnce: false });
+        (0, assert_js_1.assertWarning)(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }

package/dist/cjs/utils/getPublicProxy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicProxy = getPublicProxy;
+// 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
+const assert_js_1 = require("./assert.js");
+// Show warning when user is accessing internal `_` properties.
+function getPublicProxy(obj, objName, propsPublic, expectCustomUserLandProps) {
+    if (!expectCustomUserLandProps) {
+        Object.keys(obj).forEach((key) => (0, assert_js_1.assert)(key.startsWith('_') || propsPublic.includes(key)));
+        propsPublic.forEach((prop) => prop in obj);
+    }
+    return new Proxy(obj, {
+        get(_, prop) {
+            const propStr = String(prop);
+            if (propStr.startsWith('_')) {
+                (0, assert_js_1.assertWarning)(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+            }
+            // @ts-ignore Seems to be TypeScript bug
+            return Reflect.get(...arguments);
+        }
+    });
+}

package/dist/cjs/utils/objectAssign.js

@@ -6,9 +6,9 @@ const assert_js_1 = require("./assert.js");
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters of getPageContextUrlComputed()
 function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
-    if (objAddendum) {
-        if (!objAddendumCanBePageContextObject)
-            (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
-        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
-    }
+    if (!objAddendum)
+        return;
+    if (!objAddendumCanBePageContextObject)
+        (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
+    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

package/dist/cjs/utils/objectReplace.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectReplace = objectReplace;
-function objectReplace(obj, objNew, except) {
-    Object.keys(obj)
+function objectReplace(objOld, objNew, except) {
+    Object.keys(objOld)
         .filter((key) => !except?.includes(key))
-        .forEach((key) => delete obj[key]);
-    Object.assign(obj, objNew);
+        .forEach((key) => delete objOld[key]);
+    Object.defineProperties(objOld, Object.getOwnPropertyDescriptors(objNew));
 }

package/dist/esm/__internal/index.js

@@ -13,10 +13,10 @@ import { setNodeEnvProduction } from '../utils/assertSetup.js';
 async function getPagesAndRoutes() {
     setNodeEnvProduction();
     await initGlobalContext_getPagesAndRoutes();
-    const globalContext = await getGlobalContextInternal();
+    const { globalContext } = await getGlobalContextInternal();
     const { 
     //
-    pageRoutes, pageFilesAll, pageConfigs, allPageIds } = globalContext;
+    _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds } = globalContext;
     return {
         pageRoutes,
         pageFilesAll,

package/dist/esm/client/client-routing-runtime/{createPageContextClientSide.d.ts → createPageContext.d.ts}

@@ -1,20 +1,29 @@
 export { createPageContextClientSide };
 declare function createPageContextClientSide(urlOriginal: string): Promise<{
-    isClientSide: boolean;
-    isPrerendering: boolean;
-    urlOriginal: string;
     globalContext: {
-        [x: string]: unknown;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & object & {
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     };
-    _urlHandler: null;
-    _urlRewrite: null;
-    _baseServer: string;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _pageRoutes: import("../../__internal/index.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+    urlOriginal: string;
+    _urlHandler: null;
+    _urlRewrite: null;
+    _baseServer: string;
 } & {
     urlParsed: import("./utils.js").UrlPublic;
     urlPathname: string;

package/dist/esm/client/client-routing-runtime/{createPageContextClientSide.js → createPageContext.js}

@@ -1,36 +1,34 @@
 export { createPageContextClientSide };
 import { createPageContextShared } from '../../shared/createPageContextShared.js';
-import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
-import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { getGlobalContext } from './globalContextClientSide.js';
+import { getGlobalContext } from './globalContext.js';
 import { assert, augmentType, isBaseServer, objectAssign } from './utils.js';
-// @ts-ignore
-import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
-const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 async function createPageContextClientSide(urlOriginal) {
-    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    const globalContext = await getGlobalContext();
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
     const pageContextCreated = {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        ...globalContext, // least precedence
+        */
+        globalContext,
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        _pageRoutes: globalContext._pageRoutes,
+        _onBeforeRouteHook: globalContext._onBeforeRouteHook,
         isClientSide: true,
         isPrerendering: false,
         urlOriginal,
-        globalContext: getGlobalContext(),
         _urlHandler: null,
         _urlRewrite: null,
-        _baseServer: baseServer,
-        _pageFilesAll: pageFilesAll,
-        _pageConfigs: pageConfigs,
-        _pageConfigGlobal: pageConfigGlobal,
-        _allPageIds: allPageIds,
-        _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _baseServer: baseServer
     };
     const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
     objectAssign(pageContextCreated, pageContextUrlComputed);
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, pageConfigGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }

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

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
-import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
 import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';

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

@@ -0,0 +1,16 @@
+export { getGlobalContext };
+export type { GlobalContextClient };
+import type { GlobalContextSharedPublic } from '../../shared/createGlobalContextShared.js';
+type GlobalContextClient = GlobalContextSharedPublic & Vike.GlobalContext & {};
+declare const getGlobalContext: () => Promise<{
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("../../types/index.js").ConfigResolved;
+    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & object & {
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+}>;

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

@@ -0,0 +1,13 @@
+export { getGlobalContext };
+import { createGetGlobalContext } from '../shared/createGetGlobalContext.js';
+import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+// @ts-ignore
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:client-routing';
+const getGlobalContext = createGetGlobalContext(virtualFileExports, true, addGlobalContext);
+async function addGlobalContext(globalContext) {
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    return {
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+}

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

@@ -10,7 +10,7 @@ import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/
 import { skipLink } from './skipLink.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
-import { createPageContextClientSide } from './createPageContextClientSide.js';
+import { createPageContextClientSide } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getPageContextFromServerHooks } from './getPageContextFromHooks.js';

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

@@ -5,7 +5,7 @@ export { firstRenderStartPromise };
 export { getPageContextClient };
 import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
-import { createPageContextClientSide } from './createPageContextClientSide.js';
+import { createPageContextClientSide } from './createPageContext.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
@@ -27,8 +27,7 @@ const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSid
     return {
         renderCounter: 0,
         firstRenderStartPromise,
-        firstRenderStartPromiseResolve,
-        globalContext: {}
+        firstRenderStartPromiseResolve
     };
 })());
 const { firstRenderStartPromise } = globalObject;

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

@@ -1,5 +1,18 @@
 export { createPageContextClientSide };
 declare function createPageContextClientSide(): Promise<{
+    globalContext: {
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../types/index.js").ConfigResolved;
+        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & object;
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
     isPrerendering: boolean;
     isClientSide: boolean;
     isHydration: true;
@@ -9,10 +22,6 @@ declare function createPageContextClientSide(): Promise<{
 } & {
     pageId: string;
     routeParams: Record<string, string>;
-} & {
-    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-    _pageConfigs: import("../../__internal/index.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
 } & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
     _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 } & {