vike 0.4.229-commit-845a4e0 → 0.4.229-commit-7056ef0

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

@@ -28,7 +28,7 @@ async function createPageContextClientSide(urlOriginal) {
     };
     const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
     objectAssign(pageContextCreated, pageContextUrlComputed);
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
     return pageContextCreated;
 }

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

@@ -3,10 +3,12 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
+export { executeHookClient };
 export type { PageContextFromServerHooks };
-export type { PageContextFromClientHooks };
 import type { PageConfigUserFriendlyOld, PageFile } from '../../shared/getPageFiles.js';
+import { type PageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+import type { HookName } from '../../shared/page-configs/Config.js';
 type PageContext = {
     urlOriginal: string;
     _urlRewrite: string | null;
@@ -25,8 +27,6 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     _hasPageContextFromServer: true;
 }): Promise<PageContextSerialized & PageContext & PageConfigUserFriendlyOld & {
     _hasPageContextFromServer: true;
-} & {
-    _hasPageContextFromClient: boolean;
 }>;
 type PageContextFromServerHooks = {
     _hasPageContextFromServer: boolean;
@@ -39,11 +39,19 @@ declare function getPageContextFromServerHooks(pageContext: {
     is404ServerSideRouted?: undefined;
     pageContextFromServerHooks: PageContextFromServerHooks;
 }>;
-type PageContextFromClientHooks = {
-    _hasPageContextFromClient: boolean;
-};
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageConfigUserFriendlyOld, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContext & PageConfigUserFriendlyOld, isErrorPage: boolean): Promise<{
+    pageId: string;
+    _hasPageContextFromServer: boolean;
+} & PageContext & PageConfigUserFriendlyOld>;
+type PageContextExecuteHookClient = PageConfigUserFriendlyOld & PageContextForUserConsumptionClientSide;
+declare function executeHookClient(hookName: HookName, pageContext: PageContextExecuteHookClient): Promise<{
+    hookResult: unknown;
+    hookName: import("../../shared/page-configs/Config.js").HookNameOld;
+    hookFilePath: string;
+    hookFn: (arg: object) => unknown;
+    hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;
+}[]>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;

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

@@ -3,11 +3,11 @@ export { getPageContextFromHooks_serialized };
 export { getPageContextFromServerHooks };
 export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
+export { executeHookClient };
 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';
@@ -18,9 +18,9 @@ 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 { executeHookNew } from '../../shared/hooks/executeHook.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,6 @@ 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
@@ -94,51 +86,51 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
                 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) {
-        const hook = getHookFromPageContext(pageContext, 'onData');
-        if (hook) {
-            const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
-            await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook, pageContext);
-        }
+        await executeHookClient('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 executeHookClient(hookName, pageContext) {
+    return await executeHookNew(hookName, pageContext, (p) => preparePageContextForUserConsumptionClientSide(p, true));
+}
+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 executeHookClient('data', pageContext);
+    const hook = res[0]; // TO-DO/soon: support cumulative
+    if (!hook)
+        return;
+    const { hookResult } = hook;
+    const pageContextAddendum = { data: hookResult };
+    return pageContextAddendum;
+}
+async function executeOnBeforeRenderHook(pageContext) {
+    const res = await executeHookClient('onBeforeRender', pageContext);
+    const hook = res[0]; // TO-DO/soon: support cumulative
+    if (!hook)
+        return;
+    const { hookResult, hookFilePath } = hook;
+    const pageContextFromHook = {};
+    assertOnBeforeRenderHookReturn(hookResult, hookFilePath);
+    // Note: hookResult looks like { pageContext: { ... } }
+    const pageContextFromOnBeforeRender = hookResult?.pageContext;
+    if (pageContextFromOnBeforeRender) {
+        objectAssign(pageContextFromHook, pageContextFromOnBeforeRender);
     }
     return pageContextFromHook;
 }

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

@@ -10,8 +10,17 @@ declare const getGlobalContextClientInternal: () => Promise<{
     _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.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/renderPageClientSide.js

@@ -4,13 +4,13 @@ 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, executeHookClient } 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 { getHookFromPageContext } from '../../shared/hooks/getHook.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';
@@ -60,7 +60,6 @@ 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');
@@ -132,7 +131,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)) {
@@ -201,20 +200,15 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromServerHooks));
             objectAssign(pageContext, pageContextFromServerHooks);
             // Execute +onData
-            assertHook(pageContext, 'onData');
-            const hook = getHookFromPageContext(pageContext, 'onData');
-            if (hook) {
-                const { hookFn } = hook;
-                try {
-                    await executeHook(() => hookFn(pageContext), hook, pageContext);
-                }
-                catch (err) {
-                    await onError(err);
-                    return;
-                }
-                if (isRenderOutdated())
-                    return;
+            try {
+                await executeHookClient('onData', pageContext);
+            }
+            catch (err) {
+                await onError(err);
+                return;
             }
+            if (isRenderOutdated())
+                return;
             // Get pageContext from client-side hooks
             let pageContextFromClientHooks;
             try {
@@ -352,7 +346,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)) {
@@ -444,7 +438,6 @@ async function renderPageClientSide(renderArgs) {
         */
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
-            assertHook(pageContext, 'onHydrationEnd');
             const hook = getHookFromPageContext(pageContext, 'onHydrationEnd');
             if (hook) {
                 const { hookFn } = hook;
@@ -467,7 +460,6 @@ 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;

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

@@ -7,8 +7,17 @@ declare function createPageContextClientSide(): Promise<{
         _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;
     } & object;
@@ -21,16 +30,11 @@ declare function createPageContextClientSide(): Promise<{
     isHydration: true;
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;
-    _hasPageContextFromClient: false;
 } & {
     pageId: string;
     routeParams: Record<string, string>;
-} & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
-    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 } & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
     isPageContext: true;
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & import("../../shared/getPageFiles.js").PageConfigUserFriendlyOld & {
+    _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

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

@@ -1,7 +1,7 @@
 export { createPageContextClientSide };
-import { assertUsage, assertWarning, augmentType, objectAssign } from './utils.js';
+import { assertUsage, augmentType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
+import { loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './globalContext.js';
@@ -21,13 +21,14 @@ async function createPageContextClientSide() {
         isClientSide: true,
         isHydration: true,
         isBackwardNavigation: null,
-        _hasPageContextFromServer: true,
-        _hasPageContextFromClient: false
+        _hasPageContextFromServer: true
     };
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
-    objectAssign(pageContextCreated, await loadPageUserFiles(pageContextCreated.pageId, pageContextCreated));
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    // Sets pageContext.config to global configs
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._userFriendlyConfigsGlobal);
     augmentType(pageContextCreated, pageContextAugmented);
+    // Sets pageContext.config to local configs (overrides the pageContext.config set above)
+    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, pageContextCreated._pageFilesAll, pageContextCreated._pageConfigs, pageContextCreated._pageConfigGlobal));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -35,13 +36,3 @@ function assertPristineUrl() {
     const urlCurrent = getCurrentUrl({ withoutHash: true });
     assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
 }
-async function loadPageUserFiles(pageId, pageContext) {
-    const pageContextAddendum = {};
-    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageConfigGlobal));
-    pageContext._pageFilesAll
-        .filter((p) => p.fileType !== '.page.server')
-        .forEach((p) => {
-        assertWarning(!p.fileExports?.onBeforeRender, `export { onBeforeRender } of ${p.filePath} is loaded in the browser but never executed (because you are using Server-side Routing). In order to reduce the size of you browser-side JavaScript, define onBeforeRender() in a .page.server.js file instead, see https://vike.dev/onBeforeRender-isomorphic#server-routing`, { onlyOnce: true });
-    });
-    return pageContextAddendum;
-}

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

@@ -2,9 +2,10 @@ import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook } from '../../shared/hooks/getHook.js';
+import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
 const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryServerRouting(isProd);
@@ -14,6 +15,7 @@ hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClientSide();
     await executeOnRenderClientHook(pageContext, false);
-    assertHook(pageContext, 'onHydrationEnd');
-    await pageContext.exports.onHydrationEnd?.(pageContext);
+    const hook = getHookFromPageContext(pageContext, 'onHydrationEnd');
+    if (hook)
+        await executeHook(() => hook.hookFn(pageContext), hook, pageContext);
 }

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

@@ -10,8 +10,17 @@ declare const getGlobalContextClientInternal: () => Promise<{
     _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;
 } & object>;

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

@@ -9,8 +9,17 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
     _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;
+        });
+    };
 } & Awaited<{
     /**
      * Whether the environment is client-side or server-side / pre-rendering.

package/dist/esm/client/shared/{loadUserFilesClientSide.d.ts → loadPageConfigsLazyClientSide.d.ts}

@@ -1,4 +1,4 @@
-export { loadUserFilesClientSide };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 export type { PageContextUserFiles };
 import { type PageFile, type PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
@@ -11,5 +11,5 @@ type PageContextUserFiles = {
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: PageConfigGlobalRuntime;
 };
-declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/{loadUserFilesClientSide.js → loadPageConfigsLazyClientSide.js}

@@ -1,12 +1,12 @@
-export { loadUserFilesClientSide };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { getPageConfigUserFriendly_oldDesign } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getUserFriendlyConfigsPageLazy } from '../../shared/page-configs/getUserFriendlyConfigs.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
-async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
@@ -30,7 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageCo
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendly_oldDesign(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = getUserFriendlyConfigsPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -57,10 +57,8 @@ const configDefinitionsBuiltIn = {
         env: { server: true }
     },
     onData: {
-        env: { server: true, client: true }
-        /* TODO/now
+        env: { server: true, client: true },
         cumulative: true
-        */
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
         env: { server: true, client: 'if-client-routing' },

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -11,7 +11,7 @@ export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
-import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getUserFriendlyConfigs.js';
 import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -21,7 +21,7 @@ import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
-import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from '../../../../../shared/page-configs/getUserFriendlyConfigs.js';
 import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 import { getEnvVarObject } from '../../../shared/getEnvVarObject.js';
@@ -137,7 +137,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: {} }),
+                global: getUserFriendlyConfigsGlobal({ pageConfigGlobalValues: {} }),
                 pages: {},
                 vikeConfigDependencies: new Set()
             };
@@ -158,13 +158,19 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
+    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({ pageConfigGlobalValues });
     // pages
-    const pages = objectFromEntries(pageConfigs.map((pageConfig) => {
+    const userFriendlyConfigsPageEager = objectFromEntries(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return { pageConfigs, pageConfigGlobal, global, pages, vikeConfigDependencies: esbuildCache.vikeConfigDependencies };
+    return {
+        pageConfigs,
+        pageConfigGlobal,
+        global: userFriendlyConfigsGlobal,
+        pages: userFriendlyConfigsPageEager,
+        vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)