vike 0.4.144-commit-de18325 → 0.4.145

package/dist/cjs/node/prerender/runPrerender.js

@@ -49,6 +49,7 @@ const assertPathIsFilesystemAbsolute_js_1 = require("../../utils/assertPathIsFil
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadPageFilesServerSide_js_1 = require("../runtime/renderPage/loadPageFilesServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
+const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
 async function prerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
 }
@@ -450,7 +451,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             if (hookName) {
                 (0, utils_js_1.assert)(hookFilePath);
-                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that doesn't match the route of any of your pages. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
+                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that ${noRouteMatch_js_1.noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
             }
             else {
                 // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
@@ -514,15 +515,18 @@ function warnContradictoryNoPrerenderList(prerenderPageIds, doNotPrerenderList)
 }
 function warnMissingPages(prerenderPageIds, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
-    const hookName = isV1 ? 'prerender' : 'onBeforePrerenderStart';
-    const getPageAt = isV1 ? (pageId) => `defined at ${pageId}` : (pageId) => `\`${pageId}.page.*\``;
+    const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
+    /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
+    const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
+    const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
+    */
     renderContext.allPageIds
         .filter((pageId) => !prerenderPageIds[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
-        const pageAt = getPageAt(pageId);
-        (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, and no ${hookName}() hook returned (an) URL(s) matching the page's route. Either use a ${hookName}() hook to pre-render the page, or use the option ${picocolors_1.default.cyan('prerender.partial')} to suppress this warning, see https://vike.dev/prerender-config`, { onlyOnce: true });
+        const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
+        (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
 async function prerender404(htmlFiles, renderContext, prerenderContext) {

package/dist/cjs/node/runtime/renderPage/log404/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRoutesInfo = exports.log404 = void 0;
+const noRouteMatch_js_1 = require("../../../../shared/route/noRouteMatch.js");
 const globalContext_js_1 = require("../../globalContext.js");
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -18,7 +19,7 @@ async function log404(pageContext) {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
         const routesInfo = getRoutesInfo(pageRoutes);
-        let msg = `URL ${picocolors_1.default.cyan(urlPathname)} doesn't match the route of any of your pages`;
+        let msg = `URL ${picocolors_1.default.cyan(urlPathname)} ${noRouteMatch_js_1.noRouteMatch}`;
         const outro = 'See https://vike.dev/routing for more information about routing.';
         if (!routesInfo) {
             msg = `${msg}. ${picocolors_1.default.dim(outro)}`;

package/dist/cjs/shared/route/noRouteMatch.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRouteMatch = void 0;
+exports.noRouteMatch = "doesn't match the route of any of your pages";

package/dist/cjs/utils/isExternalLink.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalLink = void 0;
+function isExternalLink(url) {
+    return !url.startsWith('/') && !url.startsWith('.') && !url.startsWith('?') && url !== '';
+}
+exports.isExternalLink = isExternalLink;

package/dist/cjs/utils/onPageVisibilityChange.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPageShow = exports.onPageHide = void 0;
+function onPageHide(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            listener();
+        }
+    });
+}
+exports.onPageHide = onPageHide;
+function onPageShow(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') {
+            listener();
+        }
+    });
+}
+exports.onPageShow = onPageShow;

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.144-commit-de18325';
+const PROJECT_VERSION = '0.4.145';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

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

@@ -22,7 +22,6 @@ async function createPageContext(urlOriginal) {
         _urlRewrite: null,
         _baseServer: baseServer,
         _isProduction: isProd,
-        // TODO: use GlobalContext instead
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,

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

@@ -1 +1,2 @@
-export declare function getBaseServer(): string;
+export { getBaseServer };
+declare function getBaseServer(): string;

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

@@ -1,5 +1,6 @@
+export { getBaseServer };
 import { assert } from '../server-routing-runtime/utils.js';
-export function getBaseServer() {
+function getBaseServer() {
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const baseServer = import.meta.env.BASE_SERVER;
     assert(isBaseServer(baseServer));

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

@@ -0,0 +1,39 @@
+export { getPageContextFromHooks_firstRender };
+export { getPageContextFromHooks_uponNavigation };
+export { getPageContextFromHooks_errorPage };
+export { isAlreadyServerSideRouted };
+export type { PageContextFromHooks };
+import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageContextUrlComputedPropsInternal } from '../../shared/addUrlComputedProps.js';
+import type { PageContextForRoute } from '../../shared/route/index.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+import type { PageContextForPassToClientWarning } from '../shared/getPageContextProxyForUser.js';
+/** - pageContext set by user hooks
+ *  - pageContext set by loadPageFilesClientSide()
+ *  - misc:
+ *    - pageContext.isHydration
+ *    - pageContext._pageId
+ *    - pageContext._hasPageContextFromClient
+ *    - pageContext._hasPageContextFromServer
+ */
+type PageContextFromHooks = {
+    _pageId: string;
+    isHydration: boolean;
+    _pageFilesLoaded: PageFile[];
+} & PageContextExports & PageContextForPassToClientWarning;
+type PageContext = PageContextUrlComputedPropsInternal & PageContextForRoute & {
+    _allPageIds: string[];
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    isBackwardNavigation: boolean | null;
+};
+declare function getPageContextFromHooks_firstRender(pageContext: {
+    urlOriginal: string;
+} & PageContext): Promise<PageContextFromHooks>;
+declare function getPageContextFromHooks_errorPage(pageContext: {
+    urlOriginal: string;
+} & PageContext): Promise<PageContextFromHooks>;
+declare function getPageContextFromHooks_uponNavigation(pageContext: {
+    _pageId: string;
+} & PageContext): Promise<PageContextFromHooks>;
+declare function isAlreadyServerSideRouted(err: unknown): boolean;

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/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;