vike 0.4.144-commit-de18325 → 0.4.145-commit-2520555

package/dist/esm/client/client-routing-runtime/{getPageContext.js → getPageContextFromHooks.js}

@@ -1,13 +1,11 @@
-export { getPageContext };
-export { getPageContextErrorPage };
-export { checkIf404 };
+export { getPageContextFromHooks_firstRender };
+export { getPageContextFromHooks_uponNavigation };
+export { getPageContextFromHooks_errorPage };
 export { isAlreadyServerSideRouted };
-import { navigationState } from './navigationState.js';
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
-import { route } from '../../shared/route/index.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { getHook } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
@@ -19,85 +17,75 @@ import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRende
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 const globalObject = getGlobalObject('router/getPageContext.ts', {});
-async function getPageContext(pageContext) {
-    if (pageContext._isFirstRenderAttempt && navigationState.isFirstUrl(pageContext.urlOriginal)) {
-        const pageContextAddendum = await getPageContextFirstRender(pageContext);
-        setPageContextInitHasClientData(pageContextAddendum);
-        return pageContextAddendum;
-    }
-    else {
-        const pageContextAddendum = await getPageContextUponNavigation(pageContext);
-        setPageContextInitHasClientData(pageContextAddendum);
-        return pageContextAddendum;
-    }
-}
-async function getPageContextFirstRender(pageContext) {
-    const pageContextAddendum = getPageContextSerializedInHtml();
-    removeBuiltInOverrides(pageContextAddendum);
-    objectAssign(pageContextAddendum, {
+async function getPageContextFromHooks_firstRender(pageContext) {
+    const pageContextFromHooks = getPageContextSerializedInHtml();
+    removeBuiltInOverrides(pageContextFromHooks);
+    objectAssign(pageContextFromHooks, {
         isHydration: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContextAddendum._pageId, pageContext));
+    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
     {
-        const pageContextForHook = { ...pageContext, ...pageContextAddendum };
+        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
         if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
             const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
-            objectAssign(pageContextAddendum, pageContextFromHook);
+            objectAssign(pageContextFromHooks, pageContextFromHook);
         }
     }
-    return pageContextAddendum;
+    setPageContextInitHasClientData(pageContextFromHooks);
+    return pageContextFromHooks;
 }
-async function getPageContextErrorPage(pageContext) {
+async function getPageContextFromHooks_errorPage(pageContext) {
     const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
     if (!errorPageId)
         throw new Error('No error page defined.');
-    const pageContextAddendum = {
+    const pageContextFromHooks = {
         isHydration: false,
         _pageId: errorPageId
     };
-    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, true));
-    return pageContextAddendum;
+    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, true));
+    return pageContextFromHooks;
 }
-async function getPageContextUponNavigation(pageContext) {
-    const pageContextAddendum = {
-        isHydration: false
+async function getPageContextFromHooks_uponNavigation(pageContext) {
+    const pageContextFromHooks = {
+        isHydration: false,
+        _pageId: pageContext._pageId
     };
-    objectAssign(pageContextAddendum, await getPageContextFromRoute(pageContext));
-    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, false));
-    return pageContextAddendum;
+    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, false));
+    setPageContextInitHasClientData(pageContextFromHooks);
+    return pageContextFromHooks;
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
-    let pageContextAddendum = {};
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageId, pageContext));
+    let pageContextFromHooks = {};
+    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
-        (await hasPageContextServer({ ...pageContext, ...pageContextAddendum }))) {
+        (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
         if (!pageContextFromServer['_isError']) {
-            objectAssign(pageContextAddendum, pageContextFromServer);
+            objectAssign(pageContextFromHooks, pageContextFromServer);
         }
         else {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
             assert(errorPageId);
-            pageContextAddendum = {};
-            objectAssign(pageContextAddendum, {
+            pageContextFromHooks = {};
+            objectAssign(pageContextFromHooks, {
                 isHydration: false,
                 _pageId: errorPageId
             });
-            objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContextAddendum._pageId, pageContext));
+            objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
             assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
             assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
             assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
             // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
             assert(!('serverSideError' in pageContextFromServer));
-            objectAssign(pageContextAddendum, pageContextFromServer);
+            objectAssign(pageContextFromHooks, pageContextFromServer);
         }
     }
     else {
-        objectAssign(pageContextAddendum, { _hasPageContextFromServer: false });
+        objectAssign(pageContextFromHooks, { _hasPageContextFromServer: false });
         // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the serve-side.)
         // We cannot call guard() before retrieving pageContext from server, since the server-side may define pageContextInit.user which is paramount for guard() hooks
         if (!isErrorPage) {
@@ -105,41 +93,41 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             await executeGuardHook({
                 _hasPageContextFromClient: false,
                 ...pageContext,
-                ...pageContextAddendum
+                ...pageContextFromHooks
             }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
         }
     }
     {
         // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-        const pageContextFromHook = await executeOnBeforeRenderHookClientSide({ ...pageContext, ...pageContextAddendum });
-        objectAssign(pageContextAddendum, pageContextFromHook);
+        const pageContextFromOnBeforeRender = await executeOnBeforeRenderHookClientSide({
+            ...pageContext,
+            ...pageContextFromHooks
+        });
+        objectAssign(pageContextFromHooks, pageContextFromOnBeforeRender);
     }
-    return pageContextAddendum;
+    return pageContextFromHooks;
 }
 async function executeOnBeforeRenderHookClientSide(pageContext) {
     const hook = getHook(pageContext, 'onBeforeRender');
     if (!hook) {
-        const pageContextAddendum = {
+        const pageContextFromOnBeforeRender = {
             _hasPageContextFromClient: false
         };
-        return pageContextAddendum;
+        return pageContextFromOnBeforeRender;
     }
     const onBeforeRender = hook.hookFn;
-    const pageContextAddendum = {
+    const pageContextFromOnBeforeRender = {
         _hasPageContextFromClient: true
     };
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide({
         ...pageContext,
-        ...pageContextAddendum
+        ...pageContextFromOnBeforeRender
     }, true);
     const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), 'onBeforeRender', hook.hookFilePath);
     assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
-    objectAssign(pageContextAddendum, pageContextFromHook);
-    return pageContextAddendum;
-}
-async function hasPageContextServer(pageContext) {
-    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+    objectAssign(pageContextFromOnBeforeRender, pageContextFromHook);
+    return pageContextFromOnBeforeRender;
 }
 // Workaround for the fact that the client-side cannot known whether a pageContext JSON request is needed in order to fetch pageContextInit data passed to the client.
 //  - The workaround is reliable as long as the user sets additional pageContextInit to undefined instead of not defining the property:
@@ -158,6 +146,9 @@ function setPageContextInitHasClientData(pageContext) {
         globalObject.pageContextInitHasClientData = true;
     }
 }
+async function hasPageContextServer(pageContext) {
+    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+}
 async function onBeforeRenderServerOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
@@ -182,23 +173,6 @@ async function onBeforeRenderClientOnlyExists(pageContext) {
         return false;
     }
 }
-async function getPageContextFromRoute(pageContext) {
-    const pageContextFromRoute = await route(pageContext);
-    // We'll be able to remove this once async route functions are deprecated (because we'll be able to skip link hijacking if a link doesn't match a route (because whether to call event.preventDefault() needs to be determined synchronously))
-    if (!pageContextFromRoute._pageId) {
-        const err = new Error('No routing match');
-        markIs404(err);
-        throw err;
-    }
-    assert(hasProp(pageContextFromRoute, '_pageId', 'string'));
-    return pageContextFromRoute;
-}
-function markIs404(err) {
-    objectAssign(err, { _is404: true });
-}
-function checkIf404(err) {
-    return isObject(err) && err._is404 === true;
-}
 async function fetchPageContextFromServer(pageContext) {
     const pageContextUrl = getPageContextRequestUrl(pageContext._urlRewrite ?? pageContext.urlOriginal);
     const response = await fetch(pageContextUrl);

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

@@ -1,5 +1,6 @@
 export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition, monkeyPatchHistoryPushState };
-import { assert, assertUsage, hasProp, isObject } from './utils.js';
+import { assert, assertUsage, getGlobalObject, hasProp, isObject } from './utils.js';
+const globalObject = getGlobalObject('history.ts', {});
 // Fill missing state information:
 //  - `history.state` can uninitialized (i.e. `null`):
 //    - The very first render
@@ -71,11 +72,11 @@ function replaceHistoryState(state, url) {
     window.history.replaceState(state, '', url ?? /* Passing `undefined` chokes older Edge versions */ null);
 }
 function pushHistoryState(state, url) {
-    window.history.pushState(state, '', url);
+    pushStateOriginal(state, '', url);
 }
 function monkeyPatchHistoryPushState() {
-    const pushStateOriginal = history.pushState;
-    history.pushState = (stateFromUser = {}, ...rest) => {
+    globalObject.pushStateOriginal = globalObject.pushStateOriginal ?? window.history.pushState;
+    window.history.pushState = (stateFromUser = {}, ...rest) => {
         assertUsage(null === stateFromUser || undefined === stateFromUser || isObject(stateFromUser), 'history.pushState(state) argument state must be an object');
         const state = {
             scrollPosition: getScrollPosition(),
@@ -84,6 +85,9 @@ function monkeyPatchHistoryPushState() {
             // Don't allow user to overwrite triggedBy as it would break Vike's handling of the 'popstate' event
             triggedBy: 'user'
         };
-        return pushStateOriginal.apply(history, [state, ...rest]);
+        return pushStateOriginal(state, ...rest);
     };
 }
+function pushStateOriginal(...args) {
+    globalObject.pushStateOriginal.apply(history, args);
+}

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

@@ -1,21 +1,2 @@
 export { installClientRouter };
-export { disableClientRouting };
-export { isDisableAutomaticLinkInterception };
-export { renderPageClientSide };
-import { ScrollPosition } from './history.js';
-import { PageContextFromRewrite } from '../../shared/route/abort.js';
 declare function installClientRouter(): void;
-type RenderArgs = {
-    scrollTarget: ScrollTarget;
-    isBackwardNavigation: boolean | null;
-    urlOriginal?: string;
-    overwriteLastHistoryEntry?: boolean;
-    checkIfClientSideRenderable?: boolean;
-    pageContextsFromRewrite?: PageContextFromRewrite[];
-    redirectCount?: number;
-    isUserLandNavigation?: boolean;
-};
-declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
-type ScrollTarget = ScrollPosition | 'scroll-to-top-or-hash' | 'preserve-scroll';
-declare function isDisableAutomaticLinkInterception(): boolean;
-declare function disableClientRouting(err: unknown, log: boolean): void;