vike 0.4.239 → 0.4.240-commit-a80417c

package/dist/esm/client/index.d.ts

@@ -1 +1 @@
-export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync, } from './shared/createGetGlobalContextClient.js';
+export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync, } from './shared/getGlobalContextClientInternalShared.js';

package/dist/esm/client/index.js

@@ -1,4 +1,4 @@
 import { isBrowser } from '../utils/isBrowser.js';
 import { assert } from '../utils/assert.js';
 assert(isBrowser());
-export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync, } from './shared/createGetGlobalContextClient.js';
+export { getGlobalContext, getGlobalContext as getGlobalContextAsync, getGlobalContextSync, } from './shared/getGlobalContextClientInternalShared.js';

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

@@ -58,7 +58,7 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } & Record<string, any>;
+    };
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;

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

@@ -2,7 +2,7 @@ export { createPageContextClientSide };
 import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
 import { getBaseServer } from './getBaseServer.js';
-import { getGlobalContextClientInternal } from './globalContext.js';
+import { getGlobalContextClientInternal } from './getGlobalContextClientInternal.js';
 import { assert, updateType, isBaseServer, objectAssign } from './utils.js';
 async function createPageContextClientSide(urlOriginal) {
     const globalContext = await getGlobalContextClientInternal();

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

@@ -3,9 +3,11 @@ assertClientRouting();
 import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
-// @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
-const isProd = import.meta.env.PROD;
-assertSingleInstance_onClientEntryClientRouting(isProd);
+import { setVirtualFileExportsGlobalEntry } from '../shared/getGlobalContextClientInternalShared.js';
+// @ts-expect-error
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
+assertSingleInstance_onClientEntryClientRouting(import.meta.env.PROD);
+setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
 initClientRouter();
 if (import.meta.env.DEV)
     removeFoucBuster();

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

@@ -1,7 +1,6 @@
 export { getBaseServer };
 import { assert } from '../runtime-server-routing/utils.js';
 function getBaseServer() {
-    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const baseServer = import.meta.env.BASE_SERVER;
     assert(isBaseServer(baseServer));
     return baseServer;

package/dist/esm/client/runtime-client-routing/{globalContext.d.ts → getGlobalContextClientInternal.d.ts}

@@ -4,7 +4,7 @@ export type { GlobalContextClientInternal };
 import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
 type GlobalContextClient = GlobalContextBasePublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
-declare const getGlobalContextClientInternal: () => Promise<{
+declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {
@@ -55,4 +55,4 @@ declare const getGlobalContextClientInternal: () => Promise<{
 } & {
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-} & Record<string, any>>;
+}>;

package/dist/esm/client/runtime-client-routing/{globalContext.js → getGlobalContextClientInternal.js}

@@ -1,9 +1,13 @@
 export { getGlobalContextClientInternal };
-import { createGetGlobalContextClient } from '../shared/createGetGlobalContextClient.js';
+import { getGlobalContextClientInternalShared } from '../shared/getGlobalContextClientInternalShared.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
-// @ts-ignore
-import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:client-routing';
-const getGlobalContextClientInternal = createGetGlobalContextClient(virtualFileExportsGlobalEntry, true, addGlobalContext);
+import { objectAssign } from './utils.js';
+async function getGlobalContextClientInternal() {
+    const globalContext = await getGlobalContextClientInternalShared();
+    objectAssign(globalContext, await addGlobalContext(globalContext));
+    return globalContext;
+}
+// TO-DO/next-major-release make this function sync
 async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {

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

@@ -78,7 +78,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } & Record<string, any>;
+    };
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -145,7 +145,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./globalContext.js").GlobalContextClient;
+        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -210,7 +210,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./globalContext.js").GlobalContextClient;
+    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {
@@ -299,7 +299,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } & Record<string, any>;
+    };
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -366,7 +366,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./globalContext.js").GlobalContextClient;
+        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -429,7 +429,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./globalContext.js").GlobalContextClient;
+    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {

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

@@ -168,7 +168,7 @@ function hasServerOnlyHook(pageContext) {
     if (isOldDesign(pageContext))
         return false;
     const pageConfig = getPageConfig(pageContext.pageId, pageContext._globalContext._pageConfigs);
-    const val = getConfigValueRuntime(pageConfig, `serverOnlyHooks`)?.value;
+    const val = getConfigValueRuntime(pageConfig, `hasServerOnlyHook`)?.value;
     assert(val === true || val === false);
     return val;
 }

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

@@ -1,5 +1,5 @@
 export { isClientSideRoutable };
-import type { GlobalContextClientInternal } from './globalContext.js';
+import type { GlobalContextClientInternal } from './getGlobalContextClientInternal.js';
 import type { PageFile } from '../../shared/getPageFiles.js';
 declare function isClientSideRoutable(pageId: string, pageContext: {
     _globalContext: GlobalContextClientInternal;

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

@@ -7,7 +7,7 @@ export type { PageContextBegin };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
 import type { PageContextConfig } from '../../shared/getPageFiles.js';
-import type { PageContextClient } from '../../types/PageContext.js';
+import type { PageContextClient, PageContextInternalClient } from '../../types/PageContext.js';
 import type { VikeGlobalInternal } from '../../types/VikeGlobalInternal.js';
 declare const firstRenderStartPromise: Promise<void>;
 type PageContextRouted = {
@@ -92,7 +92,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     } & {
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } & Record<string, any>;
+    };
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -107,7 +107,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     isHydration: boolean;
     previousPageContext: ({
         pageId: string;
-    } & PageContextConfig & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../types/PageContext.js").PageContextInternalClient & Omit<Partial<PageContextConfig & {
+    } & PageContextConfig & PageContextRouted & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & PageContextInternalClient & Omit<Partial<PageContextConfig & {
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
         routeParams: Record<string, string>;
@@ -156,7 +156,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: PageContextClient<unknown> | null;
-        globalContext: import("./globalContext.js").GlobalContextClient;
+        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {

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

@@ -16,7 +16,7 @@ import { route } from '../../shared/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
 import { scrollRestoration_initialRenderIsDone } from './scrollRestoration.js';
-import { getErrorPageId } from '../../shared/error-page.js';
+import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
@@ -60,7 +60,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderPageOnError({ err });
+            await handleError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -229,11 +229,43 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // When the normal page threw an error
+    // When the normal page threw an error:
     // - Can be a URL rewrite upon `throw render('/some-url')`
     // - Can be rendering the error page
     // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-    async function renderPageOnError(args) {
+    async function handleError(args) {
+        const { err } = args;
+        assert(err);
+        // Logging
+        if (!isAbortError(err)) {
+            // We don't swallow 404 errors:
+            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+            console.error(err);
+        }
+        else {
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
+            // We handle the abort error down below.
+        }
+        // pageContext
+        const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
+        if (isRenderOutdated())
+            return;
+        objectAssign(pageContext, {
+            errorWhileRendering: err,
+        });
+        // throw redirect()/render()
+        let pageContextAbort;
+        if (isAbortError(err)) {
+            const res = await handleAbortError(err, pageContext);
+            if (res.skip)
+                return;
+            pageContextAbort = res.pageContextAbort;
+        }
+        // Render error page
+        await renderErrorPage(pageContext, args, pageContextAbort);
+    }
+    async function renderErrorPage(pageContext, args, pageContextAbort) {
         const onError = (err) => {
             if (!isSameErrorMessage(err, args.err)) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
@@ -244,81 +276,23 @@ async function renderPageClientSide(renderArgs) {
                 console.error(err);
             }
         };
-        if ('err' in args) {
-            const { err } = args;
-            assert(err);
-            if (!isAbortError(err)) {
-                // We don't swallow 404 errors:
-                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
-                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-                console.error(err);
-            }
-            else {
-                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
-                // We handle the abort error down below.
-            }
-        }
-        const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
-        if (isRenderOutdated())
-            return;
-        objectAssign(pageContext, { routeParams: {} });
-        if (args.pageContextError)
-            objectAssign(pageContext, args.pageContextError);
-        if ('err' in args) {
-            const { err } = args;
-            assert(!('errorWhileRendering' in pageContext));
-            objectAssign(pageContext, { errorWhileRendering: err });
-            if (isAbortError(err)) {
-                const errAbort = err;
-                logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
-                const pageContextAbort = errAbort._pageContextAbort;
-                // throw render('/some-url')
-                if (pageContextAbort._urlRewrite) {
-                    await renderPageClientSide({
-                        ...renderArgs,
-                        scrollTarget: undefined,
-                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
-                    });
-                    return;
-                }
-                // throw redirect('/some-url')
-                if (pageContextAbort._urlRedirect) {
-                    const urlRedirect = pageContextAbort._urlRedirect.url;
-                    if (!urlRedirect.startsWith('/')) {
-                        // External redirection
-                        redirectHard(urlRedirect);
-                        return;
-                    }
-                    else {
-                        await renderPageClientSide({
-                            ...renderArgs,
-                            scrollTarget: undefined,
-                            urlOriginal: urlRedirect,
-                            overwriteLastHistoryEntry: false,
-                            isBackwardNavigation: false,
-                            redirectCount: redirectCount + 1,
-                        });
-                    }
-                    return;
-                }
-                // throw render(statusCode)
-                assert(pageContextAbort.abortStatusCode);
-                assert(!('urlOriginal' in pageContextAbort));
-                objectAssign(pageContext, pageContextAbort);
-                if (pageContextAbort.abortStatusCode === 404) {
-                    objectAssign(pageContext, { is404: true });
-                }
-            }
-            else {
-                objectAssign(pageContext, { is404: false });
-            }
-        }
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
             pageId: errorPageId,
+            routeParams: {},
         });
+        // throw render(statusCode)
+        if (pageContextAbort) {
+            assert(pageContextAbort.abortStatusCode);
+            assert(!('urlOriginal' in pageContextAbort));
+            objectAssign(pageContext, pageContextAbort);
+            objectAssign(pageContext, { is404: pageContextAbort.abortStatusCode === 404 });
+        }
+        else {
+            objectAssign(pageContext, { is404: false });
+        }
         const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
@@ -326,6 +300,9 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
+        if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
+            assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
+        }
         const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
         /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
         if (isRenderOutdated()) return
@@ -367,10 +344,46 @@ async function renderPageClientSide(renderArgs) {
         updateType(pageContext, pageContextFromClientHooks);
         await renderPageView(pageContext, args);
     }
+    async function handleAbortError(err, pageContext) {
+        const errAbort = err;
+        logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
+        const pageContextAbort = errAbort._pageContextAbort;
+        // throw render('/some-url')
+        if (pageContextAbort._urlRewrite) {
+            await renderPageClientSide({
+                ...renderArgs,
+                scrollTarget: undefined,
+                pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
+            });
+            return { skip: true };
+        }
+        // throw redirect('/some-url')
+        if (pageContextAbort._urlRedirect) {
+            const urlRedirect = pageContextAbort._urlRedirect.url;
+            if (!urlRedirect.startsWith('/')) {
+                // External redirection
+                redirectHard(urlRedirect);
+                return { skip: true };
+            }
+            else {
+                await renderPageClientSide({
+                    ...renderArgs,
+                    scrollTarget: undefined,
+                    urlOriginal: urlRedirect,
+                    overwriteLastHistoryEntry: false,
+                    isBackwardNavigation: false,
+                    redirectCount: redirectCount + 1,
+                });
+            }
+            return { skip: true };
+        }
+        // throw render(statusCode)
+        return { pageContextAbort };
+    }
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await handleError({ err });
             }
             else {
                 if (!isSameErrorMessage(err, isErrorPage.err)) {
@@ -395,6 +408,7 @@ async function renderPageClientSide(renderArgs) {
                 await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
+                assert(err);
                 onRenderClientError = err;
             }
             globalObject.onRenderClientPreviousPromise = undefined;
@@ -511,11 +525,9 @@ function disableClientRouting(err, log) {
         // We don't use console.error() to avoid flooding error trackers such as Sentry
         console.log(err);
     }
-    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
-    const isProd = import.meta.env.PROD;
     assertInfo(false, [
         'Failed to fetch static asset.',
-        isProd ? 'This usually happens when a new frontend is deployed.' : null,
+        import.meta.env.PROD ? 'This usually happens when a new frontend is deployed.' : null,
         'Falling back to Server Routing.',
         '(The next page navigation will use Server Routing instead of Client Routing.)',
     ]
@@ -644,3 +656,16 @@ function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
     redirectHard(pageContext.urlOriginal);
     return true;
 }
+// [HMR] If error page is shown => re-render whole page
+if (import.meta.env.DEV && import.meta.hot)
+    import.meta.hot.on('vite:afterUpdate', () => {
+        const pageContext = globalObject.renderedPageContext;
+        if (pageContext?.pageId && isErrorPage(pageContext.pageId, pageContext._globalContext._pageConfigs)) {
+            renderPageClientSide({
+                scrollTarget: { preserveScroll: false },
+                urlOriginal: getCurrentUrl(),
+                overwriteLastHistoryEntry: true,
+                isBackwardNavigation: false,
+            });
+        }
+    });

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

@@ -54,7 +54,7 @@ declare function createPageContextClientSide(): Promise<{
         _allPageIds: string[];
     } & {
         isClientSide: true;
-    } & object & Record<string, any>;
+    };
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;

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

@@ -4,7 +4,7 @@ import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtm
 import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
-import { getGlobalContextClientInternal } from './globalContext.js';
+import { getGlobalContextClientInternal } from './getGlobalContextClientInternal.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { execHook } from '../../shared/hooks/execHook.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });

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

@@ -6,9 +6,11 @@ import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 import { execHook } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
-// @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
-const isProd = import.meta.env.PROD;
-assertSingleInstance_onClientEntryServerRouting(isProd);
+import { setVirtualFileExportsGlobalEntry } from '../shared/getGlobalContextClientInternalShared.js';
+// @ts-expect-error
+import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+assertSingleInstance_onClientEntryServerRouting(import.meta.env.PROD);
+setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
 if (import.meta.env.DEV)
     removeFoucBuster();
 hydrate();

package/dist/esm/client/runtime-server-routing/{globalContext.d.ts → getGlobalContextClientInternal.d.ts}

@@ -4,7 +4,7 @@ export type { GlobalContextClientInternalWithServerRouting };
 import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
 type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
-declare const getGlobalContextClientInternal: () => Promise<{
+declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {
@@ -52,4 +52,4 @@ declare const getGlobalContextClientInternal: () => Promise<{
     _allPageIds: string[];
 } & {
     isClientSide: true;
-} & object & Record<string, any>>;
+}>;

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

@@ -0,0 +1,6 @@
+export { getGlobalContextClientInternal };
+import { getGlobalContextClientInternalShared } from '../shared/getGlobalContextClientInternalShared.js';
+async function getGlobalContextClientInternal() {
+    const globalContext = await getGlobalContextClientInternalShared();
+    return globalContext;
+}

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

@@ -2,7 +2,7 @@ export { execHookOnRenderClient };
 export type { PageContextBeforeRenderClient };
 import type { PageFile, PageContextConfig } from '../../shared/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
-import type { GlobalContextClientInternalShared } from './createGetGlobalContextClient.js';
+import type { GlobalContextClientInternalShared } from './getGlobalContextClientInternalShared.js';
 type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;

package/dist/esm/client/shared/{createGetGlobalContextClient.d.ts → getGlobalContextClientInternalShared.d.ts}

@@ -1,11 +1,11 @@
 export { getGlobalContext };
 export { getGlobalContextSync };
-export { createGetGlobalContextClient };
+export { setVirtualFileExportsGlobalEntry };
+export { getGlobalContextClientInternalShared };
 export type GlobalContextClientInternalShared = GlobalContextClientInternal | GlobalContextClientInternalWithServerRouting;
-import { type GlobalContextBase } from '../../shared/createGlobalContextShared.js';
-import type { GlobalContextClientInternal } from '../runtime-client-routing/globalContext.js';
-import type { GlobalContextClientInternalWithServerRouting } from '../runtime-server-routing/globalContext.js';
-declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExportsGlobalEntry: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): () => Promise<{
+import type { GlobalContextClientInternal } from '../runtime-client-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextClientInternalWithServerRouting } from '../runtime-server-routing/getGlobalContextClientInternal.js';
+declare function getGlobalContextClientInternalShared(): Promise<{
     _globalConfigPublic: {
         pages: {
             [k: string]: {
@@ -53,12 +53,15 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
     _allPageIds: string[];
 } & {
     /**
-     * Whether the environment is client-side or server-side / pre-rendering.
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
      *
-     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
+     * https://vike.dev/globalContext#isClientSide
      */
     isClientSide: true;
-} & Awaited<GlobalContextAddendum> & Record<string, any>>;
+}>;
 type NeverExported = never;
 declare function getGlobalContext(): Promise<NeverExported>;
 declare function getGlobalContextSync(): NeverExported;
+declare function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown): Promise<void>;

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

@@ -0,0 +1,66 @@
+// Public usage
+export { getGlobalContext };
+export { getGlobalContextSync };
+export { setVirtualFileExportsGlobalEntry };
+// Internal usage
+export { getGlobalContextClientInternalShared };
+import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
+import { assert, assertUsage, genPromise, getGlobalObject, objectAssign, checkType } from './utils.js';
+const globalObject = getGlobalObject('getGlobalContextClientInternalShared.ts', (() => {
+    const { promise: globalContextInitialPromise, resolve: globalContextInitialPromiseResolve } = genPromise();
+    return {
+        globalContextInitialPromise,
+        globalContextInitialPromiseResolve,
+    };
+})());
+async function getGlobalContextClientInternalShared() {
+    // Get
+    if (globalObject.globalContextPromise) {
+        const globalContext = await globalObject.globalContextPromise;
+        return globalContext;
+    }
+    // Create
+    const globalContextPromise = createGlobalContextShared(globalObject.virtualFileExportsGlobalEntry, globalObject, () => {
+        const globalContextAddendum = {
+            /**
+             * Whether the environment is the client-side:
+             * - In the browser, the value is `true`.
+             * - Upon SSR and pre-rendering, the value is `false`.
+             *
+             * https://vike.dev/globalContext#isClientSide
+             */
+            isClientSide: true,
+        };
+        objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
+        return globalContextAddendum;
+    });
+    globalObject.globalContextPromise = globalContextPromise;
+    const globalContext = await globalContextPromise;
+    assert(globalObject.globalContext === globalContext);
+    globalObject.globalContextInitialPromiseResolve();
+    // Return
+    return globalContext;
+}
+async function getGlobalContext() {
+    await globalObject.globalContextInitialPromise;
+    const globalContext = await globalObject.globalContextPromise;
+    assert(globalContext);
+    checkType(globalContext);
+    return globalContext;
+}
+function getGlobalContextSync() {
+    const { globalContext } = globalObject;
+    assertUsage(globalContext, getGlobalContextSyncErrMsg);
+    checkType(globalContext);
+    return globalContext;
+}
+async function setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
+    // HMR => virtualFileExportsGlobalEntry differ
+    if (globalObject.virtualFileExportsGlobalEntry !== virtualFileExportsGlobalEntry) {
+        delete globalObject.globalContextPromise;
+        globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
+        // Eagerly call +onCreateGlobalContext() hooks
+        await getGlobalContextClientInternalShared();
+    }
+}

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

@@ -10,13 +10,11 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
-    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
-    const isDev = import.meta.env.DEV;
     try {
         // prettier-ignore
         // biome-ignore format:
         const result = await Promise.all([
-            pageConfig && loadAndParseVirtualFilePageEntry(pageConfig, isDev),
+            pageConfig && loadAndParseVirtualFilePageEntry(pageConfig, import.meta.env.DEV),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),
         ]);
         pageConfigLoaded = result[0];