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

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

@@ -21,32 +21,36 @@ exports.clearGlobalContext = clearGlobalContext;
 exports.assertBuildInfo = assertBuildInfo;
 exports.updateUserFiles = updateUserFiles;
 // The core logic revolves around:
-// - globalObject.userFiles which is the main requirement for resolveGlobalContext()
+// - virtualFileExports is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
-//   - loadBuildEntry() sets globalObject.buildEntry and then sets globalObject.userFiles
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
-//   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
 const virtualFileImportUserCode_js_1 = require("../shared/virtual-files/virtualFileImportUserCode.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
-const getPageConfigsRuntime_js_1 = require("../../shared/getPageConfigsRuntime.js");
 const resolveBase_js_1 = require("../shared/resolveBase.js");
+const createGlobalContextShared_js_1 = require("../../shared/createGlobalContextShared.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/globalContext.ts', getInitialGlobalContext());
+// Trick to break down TypeScript circular dependency
+// https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
+const globalObjectTyped = globalObject;
 async function getGlobalContextInternal() {
     // getGlobalContextInternal() should always be called after initGlobalContext()
     (0, utils_js_1.assert)(globalObject.isInitialized);
     assertGlobalContextIsDefined();
     if (globalObject.isProduction !== true)
         await globalObject.waitForUserFilesUpdate;
-    const { globalContext } = globalObject;
+    const { globalContext, globalContext_public } = globalObjectTyped;
     assertIsDefined(globalContext);
-    return globalContext;
+    (0, utils_js_1.assert)(globalContext_public);
+    return { globalContext, globalContext_public };
 }
 function assertIsDefined(globalContext) {
     if (!globalContext) {
@@ -56,7 +60,8 @@ function assertIsDefined(globalContext) {
     }
 }
 function assertGlobalContextIsDefined() {
-    assertIsDefined(globalObject.globalContext);
+    assertIsDefined(globalObjectTyped.globalContext);
+    (0, utils_js_1.assert)(globalObject.globalContext);
     (0, utils_js_1.assert)(globalObject.globalContext_public);
 }
 /**
@@ -86,7 +91,7 @@ async function getGlobalContextAsync(isProduction) {
     if (!isProduction)
         await globalObject.waitForUserFilesUpdate;
     assertGlobalContextIsDefined();
-    const { globalContext_public } = globalObject;
+    const { globalContext_public } = globalObjectTyped;
     (0, utils_js_1.assert)(globalContext_public);
     return globalContext_public;
 }
@@ -99,7 +104,7 @@ async function getGlobalContextAsync(isProduction) {
  */
 function getGlobalContextSync() {
     debug('getGlobalContextSync()');
-    const { globalContext_public } = globalObject;
+    const { globalContext_public } = globalObjectTyped;
     (0, utils_js_1.assertUsage)(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.");
     (0, utils_js_1.assertWarning)(false, 
     // We discourage users from using it because using `pageContext.globalContext` is better: it doesn't have the race condition issue that `getGlobalContextSync()` would have when called inside React/Vue components.
@@ -108,15 +113,7 @@ function getGlobalContextSync() {
     return globalContext_public;
 }
 function makePublic(globalContext) {
-    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', [
-        'assetsManifest',
-        'config',
-        'viteConfig',
-        'viteConfigRuntime',
-        'pages',
-        'baseServer',
-        'baseAssets'
-    ]);
+    const globalContextPublic = (0, utils_js_1.getPublicProxy)(globalContext, 'globalContext', ['assetsManifest', 'config', 'viteConfig', 'viteConfigRuntime', 'pages', 'baseServer', 'baseAssets'], true);
     return globalContextPublic;
 }
 async function setGlobalContext_viteDevServer(viteDevServer) {
@@ -224,96 +221,6 @@ function setIsProduction(isProduction) {
         (0, utils_js_1.assert)(globalObject.isProduction === isProduction);
     globalObject.isProduction = isProduction;
 }
-function defineGlobalContext() {
-    const globalContext = resolveGlobalContext();
-    assertIsDefined(globalContext);
-    const globalContext_public = makePublic(globalContext);
-    (0, utils_js_1.objectAssign)(globalContext, { globalContext_public });
-    globalObject.globalContext = globalContext;
-    globalObject.globalContext_public = globalContext_public;
-    assertGlobalContextIsDefined();
-    (0, utils_js_1.onSetupRuntime)();
-}
-function resolveGlobalContext() {
-    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction, userFiles } = globalObject;
-    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
-    let globalContext;
-    if (!isProduction) {
-        // Requires globalObject.viteDevServer
-        if (!viteDevServer)
-            return null;
-        (0, utils_js_1.assert)(userFiles); // main common requiement
-        (0, utils_js_1.assert)(viteConfig);
-        (0, utils_js_1.assert)(viteConfigRuntime);
-        (0, utils_js_1.assert)(!isPrerendering);
-        globalContext = {
-            isProduction: false,
-            isPrerendering: false,
-            assetsManifest: null,
-            viteDevServer,
-            viteConfig,
-            ...userFiles,
-            viteConfigRuntime,
-            ...resolveBaseRuntime(viteConfigRuntime, userFiles.config)
-        };
-    }
-    else {
-        // Requires globalObject.buildEntry
-        if (!globalObject.buildEntry)
-            return null;
-        (0, utils_js_1.assert)(userFiles); // main common requiement
-        const { buildInfo, assetsManifest } = globalObject;
-        (0, utils_js_1.assert)(buildInfo);
-        (0, utils_js_1.assert)(assetsManifest);
-        const globalContext_ = {
-            isProduction: true,
-            assetsManifest,
-            ...userFiles,
-            viteDevServer: null,
-            viteConfigRuntime: buildInfo.viteConfigRuntime,
-            usesClientRouter: buildInfo.usesClientRouter,
-            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, userFiles.config)
-        };
-        if (isPrerendering) {
-            (0, utils_js_1.assert)(viteConfig);
-            (0, utils_js_1.objectAssign)(globalContext_, {
-                isPrerendering: true,
-                viteConfig
-            });
-            globalContext = globalContext_;
-        }
-        else {
-            (0, utils_js_1.objectAssign)(globalContext_, {
-                isPrerendering: false,
-                viteConfig: null
-            });
-            globalContext = globalContext_;
-        }
-    }
-    return globalContext;
-}
-async function getUserFiles() {
-    // Help TypeScript resolve what TypeScript (wrongfully) believes to be cyclic dependency
-    const globalObject_ = globalObject;
-    const { pageConfigsRuntime } = globalObject_;
-    (0, utils_js_1.assert)(pageConfigsRuntime);
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = pageConfigsRuntime;
-    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    const userFiles = {
-        pageFilesAll,
-        pageConfigs,
-        pageConfigGlobal,
-        allPageIds,
-        pageRoutes,
-        onBeforeRouteHook,
-        pages: pageConfigsUserFriendly,
-        config: globalConfig.config
-    };
-    (0, assertV1Design_js_1.assertV1Design)(
-    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
-    pageConfigs.length > 0, pageFilesAll);
-    return userFiles;
-}
 function assertViteManifest(manifest) {
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -329,10 +236,7 @@ function assertViteManifest(manifest) {
 }
 async function loadBuildEntry(outDir) {
     debug('loadBuildEntry()');
-    if (globalObject.userFiles) {
-        (0, utils_js_1.assert)(globalObject.buildInfo);
-        (0, utils_js_1.assert)(globalObject.assetsManifest);
-        (0, utils_js_1.assert)(globalObject.buildEntry);
+    if (globalObject.globalContext) {
         return;
     }
     if (!globalObject.buildEntry) {
@@ -356,7 +260,7 @@ async function loadBuildEntry(outDir) {
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setUserFiles(buildEntry.virtualFileExports);
+    await setGlobalContext(buildEntry.virtualFileExports);
 }
 async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
@@ -416,15 +320,79 @@ async function updateUserFiles() {
     // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
     if (viteDevServer !== globalObject.viteDevServer)
         return;
-    await setUserFiles(virtualFileExports);
+    await setGlobalContext(virtualFileExports);
     resolve();
 }
-async function setUserFiles(virtualFileExports) {
-    globalObject.pageConfigsRuntime = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
-    const userFiles = await getUserFiles();
-    globalObject.userFiles = userFiles;
-    defineGlobalContext();
+async function setGlobalContext(virtualFileExports) {
+    const globalContext = await (0, createGlobalContextShared_js_1.createGlobalContextShared)(virtualFileExports, globalObject, addGlobalContext);
+    (0, assertV1Design_js_1.assertV1Design)(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
+    // Public usage
+    globalObject.globalContext_public = makePublic(globalContext);
     assertGlobalContextIsDefined();
+    (0, utils_js_1.onSetupRuntime)();
+    // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
+    return globalContext;
+}
+async function addGlobalContext(globalContext) {
+    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
+    const globalContextBase = {
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
+    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
+    if (!isProduction) {
+        (0, utils_js_1.assert)(viteDevServer);
+        (0, utils_js_1.assert)(globalContext); // main common requirement
+        (0, utils_js_1.assert)(viteConfig);
+        (0, utils_js_1.assert)(viteConfigRuntime);
+        (0, utils_js_1.assert)(!isPrerendering);
+        return {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+            _isProduction: false,
+            _isPrerendering: false,
+            assetsManifest: null,
+            _viteDevServer: viteDevServer,
+            viteConfig,
+            viteConfigRuntime
+        };
+    }
+    else {
+        (0, utils_js_1.assert)(globalObject.buildEntry);
+        (0, utils_js_1.assert)(globalContext); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        (0, utils_js_1.assert)(buildInfo);
+        (0, utils_js_1.assert)(assetsManifest);
+        const globalContextBase2 = {
+            ...globalContext,
+            ...globalContextBase,
+            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
+            _isProduction: true,
+            assetsManifest,
+            _viteDevServer: null,
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            _usesClientRouter: buildInfo.usesClientRouter
+        };
+        if (isPrerendering) {
+            (0, utils_js_1.assert)(viteConfig);
+            return {
+                ...globalContextBase2,
+                _isPrerendering: true,
+                viteConfig
+            };
+        }
+        else {
+            return {
+                ...globalContextBase2,
+                _isPrerendering: false,
+                viteConfig: null
+            };
+        }
+    }
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHtmlTags = getHtmlTags;
 const isFontFallback_js_1 = require("../../renderPage/isFontFallback.js");
 const utils_js_1 = require("../../utils.js");
-const serializePageContextClientSide_js_1 = require("../serializePageContextClientSide.js");
+const serializeContext_js_1 = require("../serializeContext.js");
 const sanitizeJson_js_1 = require("./sanitizeJson.js");
 const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
 const mergeScriptTags_js_1 = require("./mergeScriptTags.js");
@@ -14,11 +14,12 @@ const helpers_js_1 = require("../../../../shared/page-configs/helpers.js");
 const getConfigValueRuntime_js_1 = require("../../../../shared/page-configs/getConfigValueRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getConfigDefinedAt_js_1 = require("../../../../shared/page-configs/getConfigDefinedAt.js");
+const htmlElementIds_js_1 = require("../../../../shared/htmlElementIds.js");
 const stamp = '__injectFilterEntry';
 async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = pageContext._globalContext;
+    const { _isProduction: isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets
@@ -124,14 +125,21 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         //   - https://github.com/vikejs/vike-vue/issues/85
         (0, utils_js_1.assertWarning)(false, "We recommend against using HTML streaming and a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://vike.dev/streaming#progressive-rendering) won't work.", { onlyOnce: true });
     }
-    // <script id="vike_pageContext" type="application/json">
     if (!isHtmlOnly) {
+        // <script id="vike_pageContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
             position: positionJavaScriptEntry
         });
+        // <script id="vike_globalContext" type="application/json">
+        htmlTags.push({
+            htmlTag: () => 
+            // Needs to be called after resolvePageContextPromise()
+            getGlobalContextJsonScriptTag(pageContext),
+            position: positionJavaScriptEntry
+        });
     }
     // The JavaScript entry <script> tag
     const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript);
@@ -162,13 +170,18 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     return scriptTag;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext));
-    const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    const pageContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getPageContextClientSerialized)(pageContext));
+    const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
     return htmlTag;
 }
+function getGlobalContextJsonScriptTag(pageContext) {
+    const globalContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getGlobalContextClientSerialized)(pageContext));
+    const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
+    return htmlTag;
+}
 function assertInjectFilterEntries(injectFilterEntries) {
     try {
         checkForWrongUsage(injectFilterEntries);

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -9,10 +9,10 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
-    if (globalContext.isProduction) {
+    if (globalContext._isProduction) {
         return '';
     }
-    const { viteDevServer } = globalContext;
+    const { _viteDevServer: viteDevServer } = globalContext;
     const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
     const fakeHtmlEnd = '</head><body></body></html>';
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropVal = getPropVal;
+exports.setPropVal = setPropVal;
+exports.getPropKeys = getPropKeys;
+const utils_js_1 = require("../utils.js");
+// 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 getPageContextClientSerialized.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/html/renderHtml.js

@@ -197,7 +197,7 @@ function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = pageContext._globalContext;
+            const { _isProduction: isProduction } = pageContext._globalContext;
             if ((0, utils_js_1.isHtml)(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {

package/dist/cjs/node/runtime/html/{serializePageContextClientSide.js → serializeContext.js}

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializePageContextClientSide = serializePageContextClientSide;
-exports.serializePageContextAbort = serializePageContextAbort;
-exports.getPropKeys = getPropKeys;
+exports.getPageContextClientSerialized = getPageContextClientSerialized;
+exports.getPageContextClientSerializedAbort = getPageContextClientSerializedAbort;
+exports.getGlobalContextClientSerialized = getGlobalContextClientSerialized;
 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");
@@ -14,7 +14,8 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 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 = [
+const propKeys_js_1 = require("./propKeys.js");
+const passToClientBuiltInPageContext = [
     'abortReason',
     '_urlRewrite',
     '_urlRedirect',
@@ -28,29 +29,39 @@ const PASS_TO_CLIENT = [
     'routeParams',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
-function serializePageContextClientSide(pageContext) {
-    const passToClient = getPassToClient(pageContext);
-    const pageContextClient = applyPassToClient(passToClient, pageContext);
-    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
+const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
+function getPageContextClientSerialized(pageContext) {
+    const passToClientPageContext = getPassToClientPageContext(pageContext);
+    const pageContextClient = applyPassToClient(passToClientPageContext, pageContext);
+    if (passToClientPageContext.some((prop) => (0, propKeys_js_1.getPropVal)(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient] = true;
     }
-    let pageContextSerialized;
+    const pageContextClientSerialized = serializeObject(pageContextClient, 'pageContext', passToClientPageContext);
+    return pageContextClientSerialized;
+}
+function getGlobalContextClientSerialized(pageContext) {
+    const passToClient = pageContext._passToClient;
+    const globalContextClient = applyPassToClient(passToClient, pageContext.globalContext);
+    const globalContextClientSerialized = serializeObject(globalContextClient, 'globalContext', passToClient);
+    return globalContextClientSerialized;
+}
+function serializeObject(obj, objName, passToClient) {
+    let serialized;
     try {
-        pageContextSerialized = serialize(pageContextClient);
+        serialized = serializeValue(obj);
     }
     catch (err) {
         const h = (s) => picocolors_1.default.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const res = getPropVal(pageContext, prop);
+            const res = (0, propKeys_js_1.getPropVal)(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const varName = `pageContext${getPropKeys(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
+            const varName = `${objName}${(0, propKeys_js_1.getPropKeys)(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
-                serialize(value, varName);
+                serializeValue(value, varName);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -62,7 +73,7 @@ function serializePageContextClientSide(pageContext) {
                     }
                     (0, utils_js_1.assertUsage)(false, `Cannot serialize config ${h(pathString)} set by useConfig(), see https://vike.dev/useConfig#serialization-error`);
                 }
-                // Non-serializable pageContext set by the user
+                // Non-serializable property 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(JSON.stringify(prop))} from ${h('passToClient')}.`
@@ -83,31 +94,31 @@ function serializePageContextClientSide(pageContext) {
         });
         (0, utils_js_1.assert)(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
+            obj[(0, propKeys_js_1.getPropKeys)(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
         });
         try {
-            pageContextSerialized = serialize(pageContextClient);
+            serialized = serializeValue(obj);
         }
         catch (err) {
             (0, utils_js_1.assert)(false);
         }
     }
-    return pageContextSerialized;
+    return serialized;
 }
-function serialize(value, varName) {
+function serializeValue(value, varName) {
     return (0, stringify_1.stringify)(value, { forbidReactElements: true, valueName: varName });
 }
-function getPassToClient(pageContext) {
-    let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
+function getPassToClientPageContext(pageContext) {
+    let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
     if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
         (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
-        passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);
+        passToClient.push(...pageToClientBuiltInPageContextError);
     }
     passToClient = (0, utils_js_1.unique)(passToClient);
     return passToClient;
 }
-function serializePageContextAbort(pageContext) {
+function getPageContextClientSerializedAbort(pageContext) {
     (0, utils_js_1.assert)(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
     (0, utils_js_1.assert)(pageContext._abortCall);
     (0, utils_js_1.assert)(pageContext._abortCaller);
@@ -140,59 +151,18 @@ function serializePageContextAbort(pageContext) {
             onlyOnce: false
         });
     }
-    return serialize(pageContext);
+    return serializeValue(pageContext);
 }
 function applyPassToClient(passToClient, pageContext) {
     const pageContextClient = {};
     passToClient.forEach((prop) => {
         // Get value from pageContext
-        const res = getPropVal(pageContext, prop);
+        const res = (0, propKeys_js_1.getPropVal)(pageContext, prop);
         if (!res)
             return;
         const { value } = res;
         // Set value to pageContextClient
-        setPropVal(pageContextClient, prop, value);
+        (0, propKeys_js_1.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/analyzePage.js

@@ -22,7 +22,7 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!globalContext.isProduction) {
+        if (!globalContext._isProduction) {
             clientDependencies.push({
                 id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, false),
                 onlyAssets: true,