vike 0.4.144-commit-f7ab002 → 0.4.144-commit-de18325

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -54,6 +54,7 @@ function serializePageContextClientSide(pageContext) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
                 }
                 else {
+                    // When a property getter throws an error
                     console.warn('Serialization error:');
                     console.warn(err);
                     msg = `${msg} The serialization failed because of the error printed above.`;

package/dist/esm/node/runtime/renderPage/debugPageFiles.d.ts

@@ -1,11 +1,11 @@
 export { debugPageFiles };
-export type { PageContextDebug };
-import { RouteMatches } from '../../../shared/route/index.js';
+export type { PageContextDebugRouteMatches };
+import type { RouteMatches } from '../../../shared/route/index.js';
 import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContextDebug = {
-    _routeMatches: 'ROUTE_ERROR' | RouteMatches;
+type PageContextDebugRouteMatches = {
+    _debugRouteMatches: 'ROUTING_ERROR' | RouteMatches;
 };
 declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }: {
     pageContext: {
@@ -13,7 +13,7 @@ declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, page
         _pageId: string;
         _pageFilesAll: PageFile[];
         _pageConfigs: PageConfigRuntime[];
-    } & PageContextDebug;
+    } & PageContextDebugRouteMatches;
     isHtmlOnly: boolean;
     isClientRouting: boolean;
     pageFilesLoaded: PageFile[];

package/dist/esm/node/runtime/renderPage/debugPageFiles.js

@@ -6,7 +6,7 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     const padding = '   - ';
     debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
     debug(`URL:`, pageContext.urlOriginal);
-    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._routeMatches));
+    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
     debug(`pageId:`, pageContext._pageId);
     debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
     debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
@@ -16,14 +16,14 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     debug('Client-side entries:', clientEntries);
     debug('Client-side dependencies:', clientDependencies);
     return;
-    function printRouteMatches(routeMatches) {
-        if (routeMatches === 'ROUTE_ERROR') {
+    function printRouteMatches(debugRouteMatches) {
+        if (debugRouteMatches === 'ROUTING_ERROR') {
             return 'Routing Failed';
         }
-        if (routeMatches === 'CUSTOM_ROUTE') {
+        if (debugRouteMatches === 'CUSTOM_ROUTING') {
             return 'Custom Routing';
         }
-        return routeMatches;
+        return debugRouteMatches;
     }
     function printPageFiles(pageFiles, genericPageFilesLast = false) {
         if (pageFiles.length === 0) {

package/dist/esm/node/runtime/renderPage/loadPageFilesServerSide.d.ts

@@ -4,9 +4,9 @@ export type { PageContext_loadPageFilesServerSide };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
-import { type PageContextDebug } from './debugPageFiles.js';
+import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebug & {
+type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -102,7 +102,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         routeParams: {},
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
-        _routeMatches: []
+        _debugRouteMatches: []
     };
     const pageContextInit = {
         urlOriginal: '/fake-404-url',

package/dist/esm/node/runtime/renderPage.js

@@ -240,8 +240,8 @@ async function renderPageNominal(pageContext) {
     }
     // Route
     {
-        const routeResult = await route(pageContext);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        const pageContextFromRoute = await route(pageContext);
+        objectAssign(pageContext, pageContextFromRoute);
         objectAssign(pageContext, { is404: pageContext._pageId ? null : true });
         if (pageContext._pageId === null) {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
@@ -268,7 +268,7 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
         routeParams: {}
     };
     objectAssign(pageContext, {
-        _routeMatches: pageContextNominalPagePartial._routeMatches || 'ROUTE_ERROR'
+        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
     });
     assert(pageContext.errorWhileRendering);
     return pageContext;

package/dist/esm/node/runtime/utils.d.ts

@@ -25,7 +25,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/runtime/utils.js

@@ -28,7 +28,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

package/dist/esm/shared/addUrlComputedProps.d.ts

@@ -55,6 +55,7 @@ type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
 declare function addUrlComputedProps<PageContext extends Record<string, unknown> & PageContextUrlSources>(pageContext: PageContext, enumerable?: boolean): asserts pageContext is PageContext & PageContextUrlComputedPropsInternal;
 type PageContextUrlSources = {
     urlOriginal: string;
+    urlLogical?: string;
     _urlRewrite: string | null;
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);

package/dist/esm/shared/addUrlComputedProps.js

@@ -1,28 +1,40 @@
 // URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
 export { addUrlComputedProps };
 export { assertPageContextUrlComputedProps };
-import { assert, parseUrl, assertWarning, isPlainObject, hasPropertyGetter, isBrowser } from './utils.js';
+import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser } from './utils.js';
 function addUrlComputedProps(pageContext, enumerable = true) {
     assert(pageContext.urlOriginal);
     if ('urlPathname' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlPathname'));
+        assert(typeof pageContext.urlPathname === 'string');
+        /* If this assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
+           ```js
+           // Add property getters such as pageContext.urlPathname to pageContext
+           addUrlComputedProps(pageContext)
+           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
+           Object.assign(pageContext2, pageContext)
+           // ❌ Also breaks the property getters
+           const pageContext3 = { ...pageContext }
+           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+           objectAssign(pageContext2, pageContext)
+           ```
+        */
+        assert(isPropertyGetter(pageContext, 'urlPathname'));
     }
+    if ('urlParsed' in pageContext)
+        assert(isPropertyGetter(pageContext, 'urlParsed'));
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        assert(isPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'urlPathname', {
         get: urlPathnameGetter,
         enumerable,
         configurable: true
     });
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        assert(hasPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    if ('urlParsed' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlParsed'));
-    }
     Object.defineProperty(pageContext, 'urlParsed', {
         get: urlParsedGetter,
         enumerable,
@@ -30,17 +42,17 @@ function addUrlComputedProps(pageContext, enumerable = true) {
     });
 }
 function getUrlParsed(pageContext) {
-    // We use a url handler function because the onBeforeRoute() hook may modify pageContext.urlOriginal (e.g. for i18n)
+    // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
     let urlHandler = pageContext._urlHandler;
     if (!urlHandler) {
         urlHandler = (url) => url;
     }
-    const url = pageContext._urlRewrite ?? pageContext.urlOriginal;
-    assert(url && typeof url === 'string');
-    const urlLogical = urlHandler(url);
+    let urlResolved = pageContext._urlRewrite ?? pageContext.urlLogical ?? pageContext.urlOriginal;
+    urlResolved = urlHandler(urlResolved);
     const baseServer = pageContext._baseServer;
+    assert(urlResolved && typeof urlResolved === 'string');
     assert(baseServer.startsWith('/'));
-    return parseUrl(urlLogical, baseServer);
+    return parseUrl(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
     const { pathname } = getUrlParsed(this);

package/dist/esm/shared/route/executeOnBeforeRouteHook.d.ts

@@ -1,3 +1,4 @@
+import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 export { executeOnBeforeRouteHook };
 export type { OnBeforeRouteHook };
 type OnBeforeRouteHook = {
@@ -6,12 +7,8 @@ type OnBeforeRouteHook = {
         urlOriginal: string;
     } & Record<string, unknown>) => unknown;
 };
-declare function executeOnBeforeRouteHook(onBeforeRouteHook: OnBeforeRouteHook, pageContext: {
-    urlOriginal: string;
-    _allPageIds: string[];
-}): Promise<null | {
-    urlOriginal?: string;
-    _urlOriginalPristine?: string;
-    _pageId?: string | null;
-    routeParams?: Record<string, string>;
+declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
+    _routingProvidedByOnBeforeRouteHook: true;
+} & PageContextFromRoute) | {
+    _routingProvidedByOnBeforeRouteHook: false;
 }>;

package/dist/esm/shared/route/executeOnBeforeRouteHook.js

@@ -1,11 +1,40 @@
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 export { executeOnBeforeRouteHook };
-async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+async function executeOnBeforeRouteHook(pageContext) {
+    const pageContextFromOnBeforeRouteHook = {};
+    if (!pageContext._onBeforeRouteHook)
+        return null;
+    const pageContextFromHook = await executeHook(pageContext._onBeforeRouteHook, pageContext);
+    if (pageContextFromHook) {
+        objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
+        if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
+            hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'null')) {
+            // We bypass Vike's routing
+            if (!hasProp(pageContextFromOnBeforeRouteHook, 'routeParams')) {
+                objectAssign(pageContextFromOnBeforeRouteHook, { routeParams: {} });
+            }
+            else {
+                assert(hasProp(pageContextFromOnBeforeRouteHook, 'routeParams', 'object'));
+            }
+            objectAssign(pageContextFromOnBeforeRouteHook, {
+                _routingProvidedByOnBeforeRouteHook: true,
+                _debugRouteMatches: 'CUSTOM_ROUTING'
+            });
+            return pageContextFromOnBeforeRouteHook;
+        }
+    }
+    objectAssign(pageContextFromOnBeforeRouteHook, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    return pageContextFromOnBeforeRouteHook;
+}
+async function executeHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
+    // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
     hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
@@ -23,28 +52,25 @@ async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
     }
-    const pageContextAddendumHook = {};
+    const deprecatedReturn = (prop) => `${errPrefix} returned ${pc.cyan(`{ pageContext: { ${prop} } }`)} which is deprecated. Return ${pc.cyan('{ pageContext: { urlLogical } }')} instead.`;
     if (hasProp(hookReturn.pageContext, 'url')) {
-        assertWarning(false, `${errPrefix} returned ${pc.cyan('{ pageContext: { url } }')} but ${pc.cyan('pageContext.url')} has been renamed to ${pc.cyan('pageContext.urlOriginal')}. Return ${pc.cyan('{ pageContext: { urlOriginal } }')} instead. (See https://vike.dev/migration/0.4.23 for more information.)`, { onlyOnce: true });
-        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        assertWarning(false, deprecatedReturn('url'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.url;
         delete hookReturn.pageContext.url;
     }
     if (hasProp(hookReturn.pageContext, 'urlOriginal')) {
-        assertUsageUrl(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlOriginal } }')} but ${pc.cyan('urlOriginal')}`);
-        // Ugly workaround: ideally urlOriginal should be immutable.
-        //  - Instead of using pageContext._urlOriginalPristine, maybe we can keep pageContext.urlOriginal immutable while re-using `pageContext._urlRewrite`.
-        //  - Or better yet we rename pageContext._urlRewrite to pageContext.urlLogical and we allow the user to override pageContext.urlLogical, and we rename pageContext.urlOriginal => `pageContext.urlReal`.
-        //    - pageContext.urlReal / pageContext.urlLogical
-        //                         VS
-        //      pageContext.urlReal / pageContext.urlModified
-        //                         VS
-        //      pageContext.urlOriginal / pageContext.urlModified
-        objectAssign(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+        assertWarning(false, deprecatedReturn('urlOriginal'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.urlOriginal;
+        delete hookReturn.pageContext.urlOriginal;
+    }
+    if (hasProp(hookReturn.pageContext, 'urlLogical')) {
+        assertUsageUrl(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} but ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,
         hookName: 'onBeforeRoute'
     });
+    const pageContextAddendumHook = {};
     objectAssign(pageContextAddendumHook, hookReturn.pageContext);
     return pageContextAddendumHook;
 }

package/dist/esm/shared/route/index.d.ts

@@ -1,5 +1,8 @@
 export { route };
-export type { PageRoutes, PageContextForRoute, RouteMatches };
+export type { PageContextForRoute };
+export type { PageContextFromRoute };
+export type { PageRoutes };
+export type { RouteMatches };
 import type { PageFile } from '../getPageFiles.js';
 import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
 import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
@@ -13,6 +16,12 @@ type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: OnBeforeRouteHook | null;
 } & PageContextUrlSources;
+type PageContextFromRoute = {
+    _pageId: string | null;
+    routeParams: Record<string, string>;
+    _routingProvidedByOnBeforeRouteHook?: boolean;
+    _debugRouteMatches: RouteMatches;
+};
 type RouteMatch = {
     pageId: string;
     routeString?: string;
@@ -20,12 +29,5 @@ type RouteMatch = {
     routeType: RouteType;
     routeParams: Record<string, string>;
 };
-type RouteMatches = 'CUSTOM_ROUTE' | RouteMatch[];
-declare function route(pageContext: PageContextForRoute): Promise<{
-    pageContextAddendum: {
-        _pageId: string | null;
-        routeParams: Record<string, string>;
-        _routingProvidedByOnBeforeRouteHook: boolean;
-        _routeMatches: RouteMatches;
-    } & Record<string, unknown>;
-}>;
+type RouteMatches = 'CUSTOM_ROUTING' | RouteMatch[];
+declare function route(pageContextForRoute: PageContextForRoute): Promise<PageContextFromRoute>;

package/dist/esm/shared/route/index.js

@@ -5,7 +5,7 @@ import { isBrowser } from '../../utils/isBrowser.js';
 if (isBrowser()) {
     assertClientRouting();
 }
-import { assert, assertUsage, hasProp, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
 import { addUrlComputedProps } from '../addUrlComputedProps.js';
 import { resolvePrecendence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
@@ -13,35 +13,25 @@ import { resolveRouteFunction } from './resolveRouteFunction.js';
 import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
-async function route(pageContext) {
-    addUrlComputedProps(pageContext);
-    debug('Pages routes:', pageContext._pageRoutes);
-    const pageContextAddendum = {};
-    if (pageContext._onBeforeRouteHook) {
-        const pageContextAddendumHook = await executeOnBeforeRouteHook(pageContext._onBeforeRouteHook, pageContext);
-        if (pageContextAddendumHook) {
-            objectAssign(pageContextAddendum, pageContextAddendumHook);
-            if (hasProp(pageContextAddendum, '_pageId', 'string') || hasProp(pageContextAddendum, '_pageId', 'null')) {
-                // We bypass Vike's routing
-                if (!hasProp(pageContextAddendum, 'routeParams')) {
-                    objectAssign(pageContextAddendum, { routeParams: {} });
-                }
-                else {
-                    assert(hasProp(pageContextAddendum, 'routeParams', 'object'));
-                }
-                objectAssign(pageContextAddendum, {
-                    _routingProvidedByOnBeforeRouteHook: true,
-                    _routeMatches: 'CUSTOM_ROUTE'
-                });
-                return { pageContextAddendum };
-            }
-            // We already assign so that `pageContext.urlOriginal === pageContextAddendum.urlOriginal`; enabling the `onBeforeRoute()` hook to mutate `pageContext.urlOriginal` before routing.
-            objectAssign(pageContext, pageContextAddendum);
+async function route(pageContextForRoute) {
+    debug('Pages routes:', pageContextForRoute._pageRoutes);
+    addUrlComputedProps(pageContextForRoute);
+    const pageContextFromRoute = {};
+    // onBeforeRoute()
+    const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContextForRoute);
+    if (pageContextFromOnBeforeRouteHook) {
+        if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
+            assert(pageContextFromOnBeforeRouteHook._pageId);
+            return pageContextFromOnBeforeRouteHook;
+        }
+        else {
+            objectAssign(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
         }
     }
-    objectAssign(pageContextAddendum, {
-        _routingProvidedByOnBeforeRouteHook: false
-    });
+    // We take into account pageContext.urlLogical set by onBeforeRoute()
+    const pageContext = {};
+    objectAssign(pageContext, pageContextForRoute);
+    objectAssign(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
     assert(allPageIds.length >= 0);
@@ -93,21 +83,21 @@ async function route(pageContext) {
     resolvePrecendence(routeMatches);
     const winner = routeMatches[0];
     debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
-    objectAssign(pageContextAddendum, { _routeMatches: routeMatches });
+    objectAssign(pageContextFromRoute, { _debugRouteMatches: routeMatches });
     if (!winner) {
-        objectAssign(pageContextAddendum, {
+        objectAssign(pageContextFromRoute, {
             _pageId: null,
             routeParams: {}
         });
-        return { pageContextAddendum };
+        return pageContextFromRoute;
     }
     {
         const { routeParams } = winner;
         assert(isPlainObject(routeParams));
-        objectAssign(pageContextAddendum, {
+        objectAssign(pageContextFromRoute, {
             _pageId: winner.pageId,
             routeParams: winner.routeParams
         });
     }
-    return { pageContextAddendum };
+    return pageContextFromRoute;
 }

package/dist/esm/shared/route/resolveRouteFunction.js

@@ -9,7 +9,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     assertPageContextUrlComputedProps(pageContext);
     let result = routeFunction(pageContext);
     assertSyncRouting(result, `The Route Function ${routeDefinedAt}`);
-    // TODO/v1-release
+    // TODO/v1-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener
     result = await result;
     //*/

package/dist/esm/shared/utils.d.ts

@@ -15,7 +15,7 @@ export * from '../utils/stringifyStringArray.js';
 export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/projectInfo.js';
-export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/objectEntries.js';

package/dist/esm/shared/utils.js

@@ -19,7 +19,7 @@ export * from '../utils/stringifyStringArray.js';
 export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/projectInfo.js';
-export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/objectEntries.js';

package/dist/esm/utils/isPropertyGetter.d.ts

@@ -0,0 +1 @@
+export declare function isPropertyGetter(obj: Object, prop: string): boolean;

package/dist/esm/utils/{hasPropertyGetter.js → isPropertyGetter.js}

@@ -1,4 +1,4 @@
-export function hasPropertyGetter(obj, prop) {
+export function isPropertyGetter(obj, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
     return !!descriptor && !('value' in descriptor) && !!descriptor.get;
 }

package/dist/esm/utils/projectInfo.d.ts

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.144-commit-f7ab002";
+    projectVersion: "0.4.144-commit-de18325";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.144-commit-f7ab002';
+const PROJECT_VERSION = '0.4.144-commit-de18325';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.144-commit-f7ab002",
+  "version": "0.4.144-commit-de18325",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

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

@@ -1,10 +0,0 @@
-export { getPageId };
-declare function getPageId(url: string): Promise<{
-    pageId: null;
-    pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-} | {
-    pageId: string;
-    pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
-    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-}>;

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

@@ -1,17 +0,0 @@
-export { getPageId };
-import { route } from '../../shared/route/index.js';
-import { createPageContext } from './createPageContext.js';
-async function getPageId(url) {
-    const pageContext = await createPageContext({ urlOriginal: url });
-    const routeContext = await route(pageContext);
-    const pageFilesAll = pageContext._pageFilesAll;
-    const pageConfigs = pageContext._pageConfigs;
-    if (!('pageContextAddendum' in routeContext)) {
-        return { pageId: null, pageFilesAll, pageConfigs };
-    }
-    const pageId = routeContext.pageContextAddendum._pageId;
-    if (!pageId) {
-        return { pageId: null, pageFilesAll, pageConfigs };
-    }
-    return { pageId, pageFilesAll, pageConfigs };
-}

package/dist/esm/client/client-routing-runtime/skipLink/isClientSideRoutable.d.ts

@@ -1,2 +0,0 @@
-export { isClientSideRoutable };
-declare function isClientSideRoutable(url: string): Promise<boolean>;

package/dist/esm/client/client-routing-runtime/skipLink/isClientSideRoutable.js

@@ -1,15 +0,0 @@
-export { isClientSideRoutable };
-import { getPageId } from '../getPageId.js';
-import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
-import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
-async function isClientSideRoutable(url) {
-    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
-    if (!pageId) {
-        return false;
-    }
-    await analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded: false });
-    const pageConfig = findPageConfig(pageConfigs, pageId);
-    const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
-    return isClientSideRenderable && isClientRouting;
-}

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

@@ -1,6 +0,0 @@
-export { useClientRouter };
-export { disableClientRouting };
-export { isDisableAutomaticLinkInterception };
-declare function disableClientRouting(err: unknown, log: boolean): void;
-declare function useClientRouter(): void;
-declare function isDisableAutomaticLinkInterception(): boolean;

package/dist/esm/utils/hasPropertyGetter.d.ts

@@ -1 +0,0 @@
-export declare function hasPropertyGetter(obj: Object, prop: string): boolean;