vike 0.4.229-commit-58f7ed0 → 0.4.229-commit-5da80bf

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");
@@ -32,14 +32,9 @@ function getPageContextFromHooks_serialized() {
 }
 // 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 dataHookExists = 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,59 @@ 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 (hookName === 'data')
+                dataHookExists = true;
             if (hookClientOnlyExists(hookName, pageContext) || !pageContext._hasPageContextFromServer) {
                 // 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
+    if (dataHookExists) {
+        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;
 }

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;
 } & {

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

@@ -5,17 +5,12 @@ export { populatePageContextPrefetchCache };
 export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
+import { type PageContextCreated } from './createPageContextClientSide.js';
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { PageConfigUserFriendlyOld, PageFile } from '../../shared/getPageFiles.js';
-import { type PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
-type PageContextForPrefetch = {
-    urlOriginal: string;
-    urlPathname: string;
+type PageContextForPrefetch = PageContextCreated & {
     pageId: string;
-    _urlRewrite: null;
-    _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfigRuntime[];
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;

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

@@ -6,11 +6,11 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign } from './utils.js';
-import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { skipLink } from './skipLink.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
-import { createPageContextClientSide } from './createPageContext.js';
+import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getPageContextFromServerHooks } from './getPageContextFromHooks.js';
@@ -45,7 +45,7 @@ function getPageContextPrefetched(pageContext) {
 }
 async function prefetchAssets(pageContextLink) {
     try {
-        await loadUserFilesClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs, pageContextLink._pageConfigGlobal);
+        await loadPageConfigsLazyClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs, pageContextLink._pageConfigGlobal);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {

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

@@ -0,0 +1,11 @@
+export { preparePageContextForPublicUsageClient };
+export type { PageContextForPublicUsageClient };
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import type { PageContextInternalClient_ClientRouting } from '../../shared/types.js';
+import type { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
+type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ClientRouting & PageConfigUserFriendlyOld & {
+    urlOriginal: string;
+};
+declare function preparePageContextForPublicUsageClient<PageContext extends PageContextForPublicUsageClient>(pageContext: PageContext): PageContext & {
+    Page: unknown;
+};

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

@@ -0,0 +1,5 @@
+export { preparePageContextForPublicUsageClient };
+import { preparePageContextForPublicUsageClientShared } from '../shared/preparePageContextForPublicUsageClientShared.js';
+function preparePageContextForPublicUsageClient(pageContext) {
+    return preparePageContextForPublicUsageClientShared(pageContext);
+}

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

@@ -3,10 +3,17 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
+export type { PageContextBegin };
 import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import type { PageContextClient } from '../../shared/types.js';
 declare const firstRenderStartPromise: Promise<void>;
+type PageContextRouted = {
+    pageId: string;
+    routeParams: Record<string, string>;
+};
+type PageContextBegin = Awaited<ReturnType<typeof getPageContextBegin>>;
 type RenderArgs = {
     scrollTarget: ScrollTarget;
     isBackwardNavigation: boolean | null;
@@ -19,6 +26,134 @@ type RenderArgs = {
     pageContextInitClient?: Record<string, unknown>;
 };
 declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
+declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender }: {
+    urlOriginal: string;
+    isBackwardNavigation: boolean | null;
+    pageContextsFromRewrite: PageContextFromRewrite[];
+    isClientSideNavigation: boolean;
+    pageContextInitClient: Record<string, unknown> | undefined;
+    isFirstRender: boolean;
+}): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: true;
+    isPrerendering: false;
+    urlOriginal: string;
+    _globalContext: {
+        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: {
+            [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("../../shared/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _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 & PageContextRouted & 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: 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;
+}>;
 declare global {
     var _vike: {
         fullyRenderedUrl?: string;

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

@@ -4,13 +4,12 @@ export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
 import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
-import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
-import { createPageContextClientSide } from './createPageContext.js';
+import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient, execHookClient } from './getPageContextFromHooks.js';
+import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook, getHookFromPageContext } from '../../shared/hooks/getHook.js';
-import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -21,7 +20,10 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { executeHook } from '../../shared/hooks/executeHook.js';
+import { execHooksErrorHandling, execHookErrorHandling } from '../../shared/hooks/execHook.js';
+import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
+import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
+import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
 const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -39,6 +41,14 @@ async function renderPageClientSide(renderArgs) {
     addLinkPrefetchHandlers_unwatch();
     const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
+    const pageContextBeginArgs = {
+        urlOriginal,
+        isBackwardNavigation,
+        pageContextsFromRewrite,
+        isClientSideNavigation,
+        pageContextInitClient,
+        isFirstRender
+    };
     if (globalObject.clientRoutingIsDisabled) {
         redirectHard(urlOriginal);
         return;
@@ -52,7 +62,7 @@ async function renderPageClientSide(renderArgs) {
         const onError = async (err) => {
             await renderErrorPage({ err });
         };
-        const pageContext = await getPageContextBegin(false);
+        const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
             return;
         // onPageTransitionStart()
@@ -60,23 +70,16 @@ async function renderPageClientSide(renderArgs) {
             assert(previousPageContext);
             // We use the hook of the previous page in order to be able to call onPageTransitionStart() before fetching the files of the next page.
             // https://github.com/vikejs/vike/issues/1560
-            assertHook(previousPageContext, 'onPageTransitionStart');
             if (!globalObject.isTransitioning) {
                 globalObject.isTransitioning = true;
-                const onPageTransitionStartHook = getHookFromPageContext(previousPageContext, 'onPageTransitionStart');
-                if (onPageTransitionStartHook) {
-                    const hook = onPageTransitionStartHook;
-                    const { hookFn } = hook;
-                    try {
-                        await executeHook(() => hookFn(pageContext), hook, pageContext);
-                    }
-                    catch (err) {
-                        await onError(err);
-                        return;
-                    }
-                    if (isRenderOutdated())
-                        return;
+                const hooks = getHookFromPageContextNew('onPageTransitionStart', previousPageContext);
+                const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClientMinimal);
+                if ('err' in res) {
+                    await onError(res.err);
+                    return;
                 }
+                if (isRenderOutdated())
+                    return;
             }
         }
         // Route
@@ -132,7 +135,7 @@ async function renderPageClientSide(renderArgs) {
             objectAssign(pageContext, pageContextFromRoute);
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -200,6 +203,16 @@ async function renderPageClientSide(renderArgs) {
             // TO-DO/eventually: create helper assertPageContextFromHook()
             assert(!('urlOriginal' in pageContextFromServerHooks));
             objectAssign(pageContext, pageContextFromServerHooks);
+            // Execute +onData
+            try {
+                await execHookClient('onData', pageContext);
+            }
+            catch (err) {
+                await onError(err);
+                return;
+            }
+            if (isRenderOutdated())
+                return;
             // Get pageContext from client-side hooks
             let pageContextFromClientHooks;
             try {
@@ -215,33 +228,6 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    async function getPageContextBegin(isForErrorPage) {
-        const pageContext = await createPageContextClientSide(urlOriginal);
-        objectAssign(pageContext, {
-            isBackwardNavigation,
-            isClientSideNavigation,
-            isHydration: isFirstRender && !isForErrorPage,
-            previousPageContext,
-            ...pageContextInitClient
-        });
-        // TODO/next-major-release: remove
-        Object.defineProperty(pageContext, '_previousPageContext', {
-            get() {
-                assertWarning(false, 'pageContext._previousPageContext has been renamed pageContext.previousPageContext', {
-                    showStackTrace: true,
-                    onlyOnce: true
-                });
-                return previousPageContext;
-            },
-            enumerable: false
-        });
-        {
-            const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-            assert(!('urlOriginal' in pageContextFromAllRewrites));
-            objectAssign(pageContext, pageContextFromAllRewrites);
-        }
-        return pageContext;
-    }
     async function renderErrorPage(args) {
         const onError = (err) => {
             if (!isSameErrorMessage(err, args.err)) {
@@ -267,9 +253,10 @@ async function renderPageClientSide(renderArgs) {
                 // We handle the abort error down below.
             }
         }
-        const pageContext = await getPageContextBegin(true);
+        const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
         if (isRenderOutdated())
             return;
+        objectAssign(pageContext, { routeParams: {} });
         if (args.is404)
             objectAssign(pageContext, { is404: true });
         if (args.pageContextError)
@@ -337,7 +324,7 @@ async function renderPageClientSide(renderArgs) {
             return;
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -379,7 +366,6 @@ async function renderPageClientSide(renderArgs) {
         if (isRenderOutdated())
             return;
         augmentType(pageContext, pageContextFromClientHooks);
-        objectAssign(pageContext, { routeParams: {} });
         await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {
@@ -407,7 +393,7 @@ async function renderPageClientSide(renderArgs) {
         const onRenderClientPromise = (async () => {
             let onRenderClientError;
             try {
-                await executeOnRenderClientHook(pageContext, true);
+                await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
                 onRenderClientError = err;
@@ -429,21 +415,14 @@ async function renderPageClientSide(renderArgs) {
         */
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
-            assertHook(pageContext, 'onHydrationEnd');
-            const hook = getHookFromPageContext(pageContext, 'onHydrationEnd');
-            if (hook) {
-                const { hookFn } = hook;
-                try {
-                    await executeHook(() => hookFn(pageContext), hook, pageContext);
-                }
-                catch (err) {
-                    await onError(err);
-                    if (!isErrorPage)
-                        return;
-                }
-                if (isRenderOutdated(true))
+            const res = await execHookErrorHandling('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
+            if ('err' in res) {
+                await onError(res.err);
+                if (!isErrorPage)
                     return;
             }
+            if (isRenderOutdated(true))
+                return;
         }
         // We purposely abort *after* onHydrationEnd() is called (see comment above).
         if (isRenderOutdated(true))
@@ -452,21 +431,15 @@ async function renderPageClientSide(renderArgs) {
         if (globalObject.isTransitioning) {
             globalObject.isTransitioning = undefined;
             assert(previousPageContext);
-            assertHook(previousPageContext, 'onPageTransitionEnd');
-            const hook = getHookFromPageContext(previousPageContext, 'onPageTransitionEnd');
-            if (hook) {
-                const { hookFn } = hook;
-                try {
-                    await executeHook(() => hookFn(pageContext), hook, pageContext);
-                }
-                catch (err) {
-                    await onError(err);
-                    if (!isErrorPage)
-                        return;
-                }
-                if (isRenderOutdated(true))
+            const hooks = getHookFromPageContextNew('onPageTransitionEnd', previousPageContext);
+            const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClient);
+            if ('err' in res) {
+                await onError(res.err);
+                if (!isErrorPage)
                     return;
             }
+            if (isRenderOutdated(true))
+                return;
         }
         if (!scrollTarget && previousPageContext) {
             const keepScrollPositionPrev = getKeepScrollPositionSetting(previousPageContext);
@@ -489,6 +462,34 @@ async function renderPageClientSide(renderArgs) {
         stampFinished(urlOriginal);
     }
 }
+async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, pageContextsFromRewrite, isClientSideNavigation, pageContextInitClient, isFirstRender }) {
+    const previousPageContext = globalObject.previousPageContext ?? null;
+    const pageContext = await createPageContextClientSide(urlOriginal);
+    objectAssign(pageContext, {
+        isBackwardNavigation,
+        isClientSideNavigation,
+        isHydration: isFirstRender && !isForErrorPage,
+        previousPageContext,
+        ...pageContextInitClient
+    });
+    // TODO/next-major-release: remove
+    Object.defineProperty(pageContext, '_previousPageContext', {
+        get() {
+            assertWarning(false, 'pageContext._previousPageContext has been renamed pageContext.previousPageContext', {
+                showStackTrace: true,
+                onlyOnce: true
+            });
+            return previousPageContext;
+        },
+        enumerable: false
+    });
+    {
+        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+        assert(!('urlOriginal' in pageContextFromAllRewrites));
+        objectAssign(pageContext, pageContextFromAllRewrites);
+    }
+    return pageContext;
+}
 // For Vike tests (but also potentially for Vike users)
 // https://github.com/vikejs/vike/blob/ffbc5cf16407bcc075f414447e50d997c87c0c94/test/playground/pages/nested-layout/e2e-test.ts#L59
 function stampFinished(urlOriginal) {