vike 0.4.152-commit-6f928f9 → 0.4.153-commit-159c659

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

@@ -1,71 +1,50 @@
-export { getPageContextFromHooks_firstRender };
-export { getPageContextFromHooks_uponNavigation };
-export { getPageContextFromHooks_errorPage };
-export { isServerSideRouted as isServerSideRouted };
+export { getPageContextFromHooks_isHydration };
+export { getPageContextFromHooks_isNotHydration };
+export { getPageContextFromHooks_serialized };
+export { isServerSideRouted };
 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 { getErrorPageId } from '../../shared/error-page.js';
 import { getHook } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
-import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getConfigValue, getPageConfig } from '../../shared/page-configs/helpers.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
+import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
+import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
 const globalObject = getGlobalObject('router/getPageContext.ts', {});
-async function getPageContextFromHooks_firstRender(pageContext) {
-    const pageContextFromHooks = getPageContextSerializedInHtml();
-    removeBuiltInOverrides(pageContextFromHooks);
-    objectAssign(pageContextFromHooks, {
-        isHydration: true,
-        _hasPageContextFromClient: false
+function getPageContextFromHooks_serialized() {
+    const pageContextSerialized = getPageContextSerializedInHtml();
+    processPageContextFromServer(pageContextSerialized);
+    objectAssign(pageContextSerialized, {
+        _hasPageContextFromServer: true
     });
-    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
+    return pageContextSerialized;
+}
+async function getPageContextFromHooks_isHydration(pageContext) {
+    const pageContextFromHooks = {
+        isHydration: true,
+        _hasPageContextFromClient: false,
+        _hasPageContextFromServer: true
+    };
     for (const hookName of ['data', 'onBeforeRender']) {
         const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
         if (hookClientOnlyExists(hookName, pageContextForHook)) {
             const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
-            objectAssign(pageContextFromHooks, pageContextFromHook);
+            Object.assign(pageContextFromHooks, pageContextFromHook);
         }
     }
-    setPageContextInitHasClientData(pageContextFromHooks);
     return pageContextFromHooks;
 }
-async function getPageContextFromHooks_errorPage(pageContext) {
-    const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
-    if (!errorPageId)
-        throw new Error('No error page defined.');
+async function getPageContextFromHooks_isNotHydration(pageContext, isErrorPage) {
     const pageContextFromHooks = {
         isHydration: false,
-        _pageId: errorPageId
-    };
-    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, true));
-    return pageContextFromHooks;
-}
-async function getPageContextFromHooks_uponNavigation(pageContext) {
-    const pageContextFromHooks = {
-        isHydration: false,
-        _pageId: pageContext._pageId
-    };
-    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, false));
-    setPageContextInitHasClientData(pageContextFromHooks);
-    return pageContextFromHooks;
-}
-async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
-    const getPageContextFromHooksInit = async (pageId) => {
-        const pageContextFromHooks = {
-            _hasPageContextFromClient: false,
-            _pageId: pageId
-        };
-        const pageContextFromPageFiles = await loadPageFilesClientSide(pageId, pageContext);
-        objectAssign(pageContextFromHooks, pageContextFromPageFiles);
-        return pageContextFromHooks;
+        _hasPageContextFromClient: false
     };
-    let pageContextFromHooks = await getPageContextFromHooksInit(pageContext._pageId);
     let hasPageContextFromServer = false;
     // If pageContextInit has some client data or if one of the hooks guard(), data() or onBeforeRender() is server-side
     // only, then we need to fetch pageContext from the server.
@@ -77,19 +56,20 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
         hasPageContextFromServer = true;
-        if (!pageContextFromServer['_isError']) {
+        if (!pageContextFromServer[isRenderFailure] || isErrorPage) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
         else {
-            const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
-            assert(errorPageId);
-            pageContextFromHooks = await getPageContextFromHooksInit(errorPageId);
+            // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
+            assert(!('serverSideError' in pageContextFromServer));
             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(pageContextFromHooks, pageContextFromServer);
+            objectAssign(pageContextFromServer, {
+                _hasPageContextFromServer: true,
+                _hasPageContextFromClient: false
+            });
+            return pageContextFromServer;
         }
     }
     // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
@@ -172,14 +152,14 @@ async function executeHookClientSide(hookName, pageContext) {
 // - We can show a warning to users when the pageContextInit keys aren't always the same. (We didn't implement the waning yet because it would require a new doc page https://vike.dev/pageContextInit#avoid-conditional-properties
 // - Workaround cannot be made completely reliable because the workaround assumes that passToClient is always the same, but the user may set a different passToClient value for another page
 // - Alternatively, we could define a new config `alwaysFetchPageContextFromServer: boolean`
-function setPageContextInitHasClientData(pageContext) {
-    if (pageContext._pageContextInitHasClientData) {
-        globalObject.pageContextInitHasClientData = true;
+function setPageContextInitIsPassedToClient(pageContext) {
+    if (pageContext[pageContextInitIsPassedToClient]) {
+        globalObject.pageContextInitIsPassedToClient = true;
     }
 }
 // TODO/v1-release: make it sync
 async function hasPageContextServer(pageContext) {
-    return (!!globalObject.pageContextInitHasClientData ||
+    return (!!globalObject.pageContextInitIsPassedToClient ||
         (await hookServerOnlyExists('data', pageContext)) ||
         (await hookServerOnlyExists('onBeforeRender', pageContext)));
 }
@@ -251,9 +231,13 @@ async function fetchPageContextFromServer(pageContext) {
         throw AbortRender(pageContextFromServer);
     }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
-    removeBuiltInOverrides(pageContextFromServer);
+    processPageContextFromServer(pageContextFromServer);
     return pageContextFromServer;
 }
+function processPageContextFromServer(pageContextFromServer) {
+    setPageContextInitIsPassedToClient(pageContextFromServer);
+    removeBuiltInOverrides(pageContextFromServer);
+}
 function isServerSideRouted(err) {
     return isObject(err) && !!err._alreadyServerSideRouted;
 }

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

@@ -1,2 +1,2 @@
 export { installClientRouter };
-declare function installClientRouter(): void;
+declare function installClientRouter(): Promise<void>;

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

@@ -6,17 +6,23 @@ import { onBrowserHistoryNavigation } from './onBrowserHistoryNavigation.js';
 import { onLinkClick } from './onLinkClick.js';
 import { setupNativeScrollRestoration } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
-function installClientRouter() {
+async function installClientRouter() {
     setupNativeScrollRestoration();
     initHistoryState();
     autoSaveScrollPosition();
     monkeyPatchHistoryPushState();
     // First initial render
     assert(getRenderCount() === 0);
-    renderPageClientSide({ scrollTarget: 'preserve-scroll', isBackwardNavigation: null, isClientSideNavigation: false });
+    const promise = renderPageClientSide({
+        scrollTarget: 'preserve-scroll',
+        isBackwardNavigation: null,
+        isClientSideNavigation: false
+    });
     assert(getRenderCount() === 1);
     // Intercept <a> links
     onLinkClick();
     // Handle back-/forward navigation
     onBrowserHistoryNavigation();
+    // Only for full stack straces
+    await promise;
 }

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

@@ -15,7 +15,7 @@ function onBrowserHistoryNavigation() {
     //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
     //     - By JavaScript: `location.hash = 'some-hash'`
     // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
-    window.addEventListener('popstate', (ev) => {
+    window.addEventListener('popstate', async () => {
         const currentState = getState();
         const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
         const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';
@@ -48,7 +48,7 @@ function onBrowserHistoryNavigation() {
             }
         }
         else {
-            renderPageClientSide({ scrollTarget, isBackwardNavigation, isUserLandPushStateNavigation });
+            await renderPageClientSide({ scrollTarget, isBackwardNavigation, isUserLandPushStateNavigation });
         }
     });
 }

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

@@ -6,7 +6,7 @@ import { renderPageClientSide } from './renderPageClientSide.js';
 function onLinkClick() {
     document.addEventListener('click', handler);
 }
-function handler(ev) {
+async function handler(ev) {
     if (!isNormalLeftClick(ev))
         return;
     const linkTag = findLinkTag(ev.target);
@@ -19,7 +19,7 @@ function handler(ev) {
     ev.preventDefault();
     const keepScrollPosition = ![null, 'false'].includes(linkTag.getAttribute('keep-scroll-position'));
     const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
-    renderPageClientSide({
+    await renderPageClientSide({
         scrollTarget,
         urlOriginal: url,
         isBackwardNavigation: false

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

@@ -1,7 +1,7 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
 import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, isExternalLink } from './utils.js';
-import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { skipLink } from './skipLink.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
@@ -14,7 +14,7 @@ assertClientRouting();
 const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new Map() });
 async function prefetchAssets(pageId, pageContext) {
     try {
-        await loadPageFilesClientSide(pageId, pageContext);
+        await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {