vike 0.4.229 → 0.4.230-commit-dd11364

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

@@ -3,16 +3,14 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
+export { execHookClient };
 export type { PageContextFromServerHooks };
-export type { PageContextFromClientHooks };
 import type { PageConfigUserFriendlyOld, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContext = {
-    urlOriginal: string;
-    _urlRewrite: string | null;
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
-};
+import type { HookName } from '../../shared/page-configs/Config.js';
+import type { PageContextCreated } from './createPageContextClientSide.js';
+import type { PageContextBegin } from './renderPageClientSide.js';
+import { type PageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
 type PageContextSerialized = {
     pageId: string;
     _hasPageContextFromServer: true;
@@ -21,29 +19,416 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendlyOld & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContextBegin & PageConfigUserFriendlyOld & {
     _hasPageContextFromServer: true;
-}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendlyOld & {
+} & PageContextForPublicUsageClient): Promise<PageContextSerialized & {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    urlOriginal: string;
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
+        config: import("../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+    } & {
+        isClientSide: true;
+    } & {
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../__internal/index.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _urlHandler: null;
+    _urlRewrite: null | string;
+    _baseServer: string;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
+    isBackwardNavigation: boolean | null;
+    isClientSideNavigation: boolean;
+    isHydration: boolean;
+    previousPageContext: ({
+        pageId: string;
+    } & PageConfigUserFriendlyOld & {
+        pageId: string;
+        routeParams: Record<string, string>;
+    } & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../shared/types.js").PageContextInternalClient & Omit<Partial<{
+        isPageContext: true;
+        Page: import("../../types/index.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+        configEntries: import("../../types/index.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+        source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+        sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }> & Pick<{
+        isPageContext: true;
+        Page: import("../../types/index.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+        configEntries: import("../../types/index.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+        source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+        sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }, "exports" | "pageId" | "Page" | "data" | "config" | "pageExports" | "routeParams" | "configEntries" | "exportsAll" | "abortReason" | "source" | "sources" | "from"> & {
+        isClientSide: true;
+        isPrerendering: false;
+    } & {
+        isHydration: boolean;
+        isBackwardNavigation: boolean | null;
+        previousPageContext: import("../../shared/types.js").PageContextClient<unknown> | null;
+        globalContext: import("./globalContext.js").GlobalContextClient;
+    } & {
+        urlOriginal: string;
+    } & {
+        urlParsed: import("./utils.js").UrlPublic;
+        urlPathname: string;
+        url: string;
+    }, ("globalContext" | "Page" | "data") | "previousPageContext"> & {
+        previousPageContext: {
+            pageId: string;
+        } | null;
+    } & {
+        urlOriginal: string;
+    }) | null;
+} & PageConfigUserFriendlyOld & {
     _hasPageContextFromServer: true;
+} & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & Omit<Partial<{
+    isPageContext: true;
+    Page: import("../../types/index.js").Config["Page"];
+    routeParams: Record<string, string>;
+    data: unknown;
+    config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+    configEntries: import("../../types/index.js").ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+    urlOriginal: string;
+    headers: Record<string, string> | null;
+    headersOriginal?: unknown;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+    source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+    sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+    url: string;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+}> & Pick<{
+    isPageContext: true;
+    Page: import("../../types/index.js").Config["Page"];
+    routeParams: Record<string, string>;
+    data: unknown;
+    config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+    configEntries: import("../../types/index.js").ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+    urlOriginal: string;
+    headers: Record<string, string> | null;
+    headersOriginal?: unknown;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+    source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+    sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+    url: string;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+}, "exports" | "pageId" | "Page" | "data" | "config" | "pageExports" | "routeParams" | "configEntries" | "exportsAll" | "abortReason" | "source" | "sources" | "from"> & {
+    isClientSide: true;
+    isPrerendering: false;
+} & {
+    isHydration: boolean;
+    isBackwardNavigation: boolean | null;
+    previousPageContext: import("../../shared/types.js").PageContextClient<unknown> | null;
+    globalContext: import("./globalContext.js").GlobalContextClient;
+} & {
+    urlOriginal: string;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+}, ("globalContext" | "Page" | "data") | "previousPageContext"> & {
+    previousPageContext: {
+        pageId: string;
+    } | null;
 } & {
-    _hasPageContextFromClient: boolean;
+    urlOriginal: string;
 }>;
 type PageContextFromServerHooks = {
     _hasPageContextFromServer: boolean;
 };
 declare function getPageContextFromServerHooks(pageContext: {
     pageId: string;
-} & PageContext, isErrorPage: boolean): Promise<{
+} & PageContextCreated, isErrorPage: boolean): Promise<{
     is404ServerSideRouted: true;
 } | {
     is404ServerSideRouted?: undefined;
     pageContextFromServerHooks: PageContextFromServerHooks;
 }>;
-type PageContextFromClientHooks = {
-    _hasPageContextFromClient: boolean;
-};
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageConfigUserFriendlyOld, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContextBegin & PageConfigUserFriendlyOld & PageContextForPublicUsageClient, isErrorPage: boolean): Promise<{
+    pageId: string;
+    _hasPageContextFromServer: boolean;
+} & {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    urlOriginal: string;
+    _globalContext: {
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
+        config: import("../../types/index.js").ConfigResolved;
+        pages: {
+            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+    } & {
+        isClientSide: true;
+    } & {
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../__internal/index.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _urlHandler: null;
+    _urlRewrite: null | string;
+    _baseServer: string;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
+    isBackwardNavigation: boolean | null;
+    isClientSideNavigation: boolean;
+    isHydration: boolean;
+    previousPageContext: ({
+        pageId: string;
+    } & PageConfigUserFriendlyOld & {
+        pageId: string;
+        routeParams: Record<string, string>;
+    } & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & import("../../shared/types.js").PageContextInternalClient & Omit<Partial<{
+        isPageContext: true;
+        Page: import("../../types/index.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+        configEntries: import("../../types/index.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+        source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+        sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }> & Pick<{
+        isPageContext: true;
+        Page: import("../../types/index.js").Config["Page"];
+        routeParams: Record<string, string>;
+        data: unknown;
+        config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+        configEntries: import("../../types/index.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+        urlOriginal: string;
+        headers: Record<string, string> | null;
+        headersOriginal?: unknown;
+        is404: boolean | null;
+        isClientSideNavigation: boolean;
+        abortReason?: unknown;
+        abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+        errorWhileRendering?: unknown;
+        pageId: string | null;
+        from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+        source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+        sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+        url: string;
+        pageExports: Record<string, unknown>;
+        isBaseMissing?: true;
+    }, "exports" | "pageId" | "Page" | "data" | "config" | "pageExports" | "routeParams" | "configEntries" | "exportsAll" | "abortReason" | "source" | "sources" | "from"> & {
+        isClientSide: true;
+        isPrerendering: false;
+    } & {
+        isHydration: boolean;
+        isBackwardNavigation: boolean | null;
+        previousPageContext: import("../../shared/types.js").PageContextClient<unknown> | null;
+        globalContext: import("./globalContext.js").GlobalContextClient;
+    } & {
+        urlOriginal: string;
+    } & {
+        urlParsed: import("./utils.js").UrlPublic;
+        urlPathname: string;
+        url: string;
+    }, ("globalContext" | "Page" | "data") | "previousPageContext"> & {
+        previousPageContext: {
+            pageId: string;
+        } | null;
+    } & {
+        urlOriginal: string;
+    }) | null;
+} & PageConfigUserFriendlyOld & import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum & Omit<Partial<{
+    isPageContext: true;
+    Page: import("../../types/index.js").Config["Page"];
+    routeParams: Record<string, string>;
+    data: unknown;
+    config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+    configEntries: import("../../types/index.js").ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+    urlOriginal: string;
+    headers: Record<string, string> | null;
+    headersOriginal?: unknown;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+    source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+    sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+    url: string;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+}> & Pick<{
+    isPageContext: true;
+    Page: import("../../types/index.js").Config["Page"];
+    routeParams: Record<string, string>;
+    data: unknown;
+    config: import("../../shared/page-configs/Config/PageContextConfig.js").PageContextConfig;
+    configEntries: import("../../types/index.js").ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: import("../../shared/getPageFiles.js").ExportsAll;
+    urlOriginal: string;
+    headers: Record<string, string> | null;
+    headersOriginal?: unknown;
+    is404: boolean | null;
+    isClientSideNavigation: boolean;
+    abortReason?: unknown;
+    abortStatusCode?: import("../../shared/route/abort.js").AbortStatusCode;
+    errorWhileRendering?: unknown;
+    pageId: string | null;
+    from: import("../../shared/page-configs/getUserFriendlyConfigs.js").From;
+    source: import("../../shared/page-configs/getUserFriendlyConfigs.js").Source;
+    sources: import("../../shared/page-configs/getUserFriendlyConfigs.js").Sources;
+    url: string;
+    pageExports: Record<string, unknown>;
+    isBaseMissing?: true;
+}, "exports" | "pageId" | "Page" | "data" | "config" | "pageExports" | "routeParams" | "configEntries" | "exportsAll" | "abortReason" | "source" | "sources" | "from"> & {
+    isClientSide: true;
+    isPrerendering: false;
+} & {
+    isHydration: boolean;
+    isBackwardNavigation: boolean | null;
+    previousPageContext: import("../../shared/types.js").PageContextClient<unknown> | null;
+    globalContext: import("./globalContext.js").GlobalContextClient;
+} & {
+    urlOriginal: string;
+} & {
+    urlParsed: import("./utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+}, ("globalContext" | "Page" | "data") | "previousPageContext"> & {
+    previousPageContext: {
+        pageId: string;
+    } | null;
+} & {
+    urlOriginal: string;
+}>;
+type PageContextExecuteHookClient = PageConfigUserFriendlyOld & PageContextForPublicUsageClient;
+declare function execHookClient(hookName: HookName, pageContext: PageContextExecuteHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
+    hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
+    hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;
+} & {
+    hookReturn: unknown;
+})[]>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;

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

@@ -3,12 +3,11 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
+export { execHookClient };
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 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';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
@@ -18,9 +17,10 @@ import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../shared/misc/isServerSideError.js';
-import { executeHook } from '../../shared/hooks/executeHook.js';
+import { execHook } from '../../shared/hooks/execHook.js';
+import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
 const globalObject = getGlobalObject('client-routing-runtime/getPageContextFromHooks.ts', {});
-// TODO/eventually: rename
+// TO-DO/eventually: rename
 function getPageContextFromHooks_serialized() {
     const pageContextSerialized = getPageContextSerializedInHtml();
     assertUsage(!('urlOriginal' in pageContextSerialized), "Adding 'urlOriginal' to passToClient is forbidden");
@@ -30,16 +30,11 @@ function getPageContextFromHooks_serialized() {
     });
     return pageContextSerialized;
 }
-// TODO/eventually: rename
+// TO-DO/eventually: rename
 async function getPageContextFromHooks_isHydration(pageContext) {
-    objectAssign(pageContext, {
-        _hasPageContextFromClient: false
-    });
     for (const hookName of ['data', 'onBeforeRender']) {
         if (hookClientOnlyExists(hookName, pageContext)) {
-            const pageContextFromHook = await executeHookClientSide(hookName, pageContext);
-            assert(!('urlOriginal' in pageContextFromHook));
-            Object.assign(pageContext, pageContextFromHook);
+            await executeDataLikeHook(hookName, pageContext);
         }
     }
     return pageContext;
@@ -70,9 +65,7 @@ async function getPageContextFromServerHooks(pageContext, isErrorPage) {
     return { pageContextFromServerHooks };
 }
 async function getPageContextFromClientHooks(pageContext, isErrorPage) {
-    objectAssign(pageContext, {
-        _hasPageContextFromClient: false
-    });
+    let dataHookExec = false;
     // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
     // env. However if we have fetched pageContext from the server, some of them might have run already on the
     // server-side, so we run only the client-only ones in this case.
@@ -85,50 +78,60 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
                 !pageContext._hasPageContextFromServer) {
                 // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side
                 // only hook? Or maybe make its env configurable like data() and onBeforeRender()?
-                await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
+                await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageClient(pageContext));
             }
         }
         else {
-            assert(hookName === 'data' || hookName === 'onBeforeRender');
             if (hookClientOnlyExists(hookName, pageContext) || !pageContext._hasPageContextFromServer) {
+                if (hookName === 'data')
+                    dataHookExec = true;
                 // This won't do anything if no hook has been defined or if the hook's env.client is false.
-                const pageContextFromHook = await executeHookClientSide(hookName, pageContext);
-                assert(!('urlOriginal' in pageContextFromHook));
-                Object.assign(pageContext, pageContextFromHook);
+                await executeDataLikeHook(hookName, pageContext);
             }
         }
     }
+    // Execute +onData
+    const dataHookEnv = getHookEnv('data', pageContext);
+    if ((dataHookExec && dataHookEnv.client) || (pageContext._hasPageContextFromServer && dataHookEnv.server)) {
+        await execHookClient('onData', pageContext);
+    }
     const pageContextFromClientHooks = pageContext;
     return pageContextFromClientHooks;
 }
-async function executeHookClientSide(hookName, pageContext) {
-    const hook = getHookFromPageContext(pageContext, hookName);
-    if (!hook) {
-        // No hook defined or hook's env.client is false
-        return {};
-    }
-    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
-    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook, pageContext);
-    const pageContextFromHook = {};
-    if (hookName === 'onBeforeRender') {
-        assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
-        // Note: hookResult looks like { pageContext: { ... } }
-        const pageContextFromOnBeforeRender = hookResult?.pageContext;
-        if (pageContextFromOnBeforeRender) {
-            objectAssign(pageContextFromHook, { _hasPageContextFromClient: true });
-            objectAssign(pageContextFromHook, pageContextFromOnBeforeRender);
-        }
+async function execHookClient(hookName, pageContext) {
+    return await execHook(hookName, pageContext, (p) => preparePageContextForPublicUsageClient(p));
+}
+async function executeDataLikeHook(hookName, pageContext) {
+    let pageContextFromHook;
+    if (hookName === 'data') {
+        pageContextFromHook = await executeDataHook(pageContext);
     }
     else {
-        assert(hookName === 'data');
-        // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
-        const pageContextFromData = {
-            data: hookResult
-        };
-        if (hookResult) {
-            objectAssign(pageContextFromHook, { _hasPageContextFromClient: true });
-        }
-        objectAssign(pageContextFromHook, pageContextFromData);
+        pageContextFromHook = await executeOnBeforeRenderHook(pageContext);
+    }
+    Object.assign(pageContext, pageContextFromHook);
+}
+async function executeDataHook(pageContext) {
+    const res = await execHookClient('data', pageContext);
+    const hook = res[0]; // TO-DO/soon: support cumulative
+    if (!hook)
+        return;
+    const { hookReturn } = hook;
+    const pageContextAddendum = { data: hookReturn };
+    return pageContextAddendum;
+}
+async function executeOnBeforeRenderHook(pageContext) {
+    const res = await execHookClient('onBeforeRender', pageContext);
+    const hook = res[0]; // TO-DO/soon: support cumulative
+    if (!hook)
+        return;
+    const { hookReturn, hookFilePath } = hook;
+    const pageContextFromHook = {};
+    assertOnBeforeRenderHookReturn(hookReturn, hookFilePath);
+    // Note: hookReturn looks like { pageContext: { ... } }
+    const pageContextFromOnBeforeRender = hookReturn?.pageContext;
+    if (pageContextFromOnBeforeRender) {
+        objectAssign(pageContextFromHook, pageContextFromOnBeforeRender);
     }
     return pageContextFromHook;
 }
@@ -186,23 +189,22 @@ async function hookServerOnlyExists(hookName, pageContext) {
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
-/**
- * @param hookName
- * @param pageContext
- * @returns `true` if the given page has a `hookName` hook defined with a client-only env.
- */
 function hookClientOnlyExists(hookName, pageContext) {
+    const hookEnv = getHookEnv(hookName, pageContext);
+    return !!hookEnv.client && !hookEnv.server;
+}
+function getHookEnv(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext.pageId, pageContext._pageConfigs);
-        const hookEnv = getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {};
-        assert(isObject(hookEnv));
-        return !!hookEnv.client && !hookEnv.server;
+        // No runtime validation to save client-side KBs
+        const hookEnv = (getConfigValueRuntime(pageConfig, `${hookName}Env`)?.value ?? {});
+        return hookEnv;
     }
     else {
         // TODO/v1-release: remove
         // Client-only onBeforeRender() or data() hooks were never supported for the V0.4 design
-        return false;
+        return { client: false, server: true };
     }
 }
 async function fetchPageContextFromServer(pageContext) {

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

@@ -5,13 +5,23 @@ type GlobalContextClient = GlobalContextSharedPublic & Pick<GlobalContextClientI
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare const getGlobalContextClientInternal: () => Promise<{
     isGlobalContext: true;
+    _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
+    _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
     config: import("../../types/index.js").ConfigResolved;
-    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    pages: {
+        [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+            route: import("../../shared/page-configs/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
 } & {
     isClientSide: true;
 } & {