vike 0.4.144-commit-f7ab002 → 0.4.144-commit-7f5e99a

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

@@ -1,13 +1,16 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, checkIfClientRouting } from './utils.js';
+import { assert, assertClientRouting, assertUsage, checkIfClientRouting, objectAssign } from './utils.js';
 import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
-import { isClientSideRoutable, skipLink } from './skipLink.js';
+import { skipLink } from './skipLink.js';
 import { getPageId } from './getPageId.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
-import { disableClientRouting } from './useClientRouter.js';
+import { disableClientRouting } from './installClientRouter.js';
 import { isExternalLink } from './isExternalLink.js';
+import { isClientSideRoutable } from './isClientSideRoutable.js';
+import { createPageContext } from './createPageContext.js';
+import { route } from '../../shared/route/index.js';
 assertClientRouting();
 const linkPrefetchHandlerAdded = new Map();
 /**
@@ -79,13 +82,17 @@ function addLinkPrefetchHandlers(pageContext) {
     });
 }
 async function prefetchIfClientSideRoutable(url) {
+    const pageContext = await createPageContext(url);
+    let pageContextFromRoute;
     try {
-        if (!(await isClientSideRoutable(url)))
-            return;
+        pageContextFromRoute = await route(pageContext);
     }
     catch {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
         return;
     }
+    objectAssign(pageContext, pageContextFromRoute);
+    if (!(await isClientSideRoutable(pageContext)))
+        return;
     await prefetch(url);
 }

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

@@ -1,3 +1,2 @@
 export { skipLink };
-export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
 declare function skipLink(linkTag: HTMLElement): boolean;

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

@@ -1,9 +1,8 @@
 export { skipLink };
-export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
 import { getBaseServer } from './getBaseServer.js';
 import { isExternalLink } from './isExternalLink.js';
 import { assert, parseUrl, isBaseServer, isParsable } from './utils.js';
-import { isDisableAutomaticLinkInterception } from './useClientRouter.js';
+import { isDisableAutomaticLinkInterception } from './installClientRouter.js';
 function skipLink(linkTag) {
     const url = linkTag.getAttribute('href');
     if (url === null)

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -19,10 +19,11 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
         }
     }
     if (!hook) {
-        const urlLogical = getUrlLogical(pageContext);
+        const urlToShowToUser = getUrlToShowToUser(pageContext);
+        assert(urlToShowToUser);
         if (pageContext._pageConfigs.length > 0) {
             // V1 design
-            assertUsage(false, `No onRenderClient() hook defined for URL '${urlLogical}', but it's needed, see https://vike.dev/onRenderClient`);
+            assertUsage(false, `No onRenderClient() hook defined for URL '${urlToShowToUser}', but it's needed, see https://vike.dev/onRenderClient`);
         }
         else {
             // TODO/v1-release: remove
@@ -30,11 +31,11 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
             const pageClientsFilesLoaded = pageContext._pageFilesLoaded.filter((p) => p.fileType === '.page.client');
             let errMsg;
             if (pageClientsFilesLoaded.length === 0) {
-                errMsg = 'No file `*.page.client.*` found for URL ' + urlLogical;
+                errMsg = 'No file `*.page.client.*` found for URL ' + urlToShowToUser;
             }
             else {
                 errMsg =
-                    'One of the following files should export a `render()` hook: ' +
+                    'One of the following files should export a render() hook: ' +
                         pageClientsFilesLoaded.map((p) => p.filePath).join(' ');
             }
             assertUsage(false, errMsg);
@@ -47,7 +48,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hookName, hook.hookFilePath);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
-function getUrlLogical(pageContext) {
+function getUrlToShowToUser(pageContext) {
     let url;
     // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForUserConsumption)
     try {

package/dist/esm/client/shared/getPageContextProxyForUser.js

@@ -14,14 +14,14 @@ function getPageContextProxyForUser(pageContext) {
             const val = pageContext[prop];
             const propName = JSON.stringify(prop);
             assertUsage(val !== notSerializable, `pageContext[${propName}] couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
-            assertPassToClient(pageContext, prop, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+            assertIsDefined(pageContext, prop);
             return val;
         }
     });
 }
-function assertPassToClient(pageContext, prop, errMsg) {
-    // We disable assertPassToClient() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
-    //  - Vue tries to read its old value first. This triggers a `assertPassToClient()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
+function assertIsDefined(pageContext, prop) {
+    // We disable assertIsDefined() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
+    //  - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
     //  - Vue seems to read __v_raw before reading the property
     if (globalObject.prev === prop || globalObject.prev === '__v_raw')
         return;
@@ -30,17 +30,23 @@ function assertPassToClient(pageContext, prop, errMsg) {
         return;
     if (isExpected(prop))
         return;
+    const propName = JSON.stringify(prop);
+    /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
+     *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
+     *  - If a pageContext value is set by an optional hook, then it's expected that the value is undefined if the hook doesn't exist.
+    const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
+    assertUsage(false, errMsg)
+    */
     if (pageContext._hasPageContextFromServer && !pageContext._hasPageContextFromClient) {
         // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
         // ```
         // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
         // ```
         // Note how properties have "!undefined" values => we can tell whether an undefined pageContext value exists in passToClient.
-        assertUsage(false, errMsg);
+        assertUsage(false, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
     }
     else {
-        // Do nothing, not even a warning.
-        // Because we don't know whether the user expects the pageContext value to be undefined. (E.g. a client-side onBeforeRender() hook conditionally setting a pageContext value.)
+        // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
     }
 }
 const IGNORE_LIST = [

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -13,9 +13,6 @@ function commonConfig() {
     return [
         {
             name: 'vike-commonConfig-1',
-            config: () => ({
-                appType: 'custom'
-            }),
             configResolved(config) {
                 installRequireShim_setUserRootDir(config.root);
             }

package/dist/esm/node/plugin/plugins/devConfig/index.js

@@ -21,6 +21,7 @@ function devConfig() {
             apply,
             config() {
                 return {
+                    appType: 'custom',
                     optimizeDeps: {
                         exclude: [
                             // We exclude the vike client to be able to use `import.meta.glob()`

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

@@ -113,6 +113,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
             serializationErrMsg = err.messageCore;
         }
         else {
+            // When a property getter throws an error
             console.error('Serialization error:');
             console.error(err);
             serializationErrMsg = 'see serialization error printed above';

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -13,6 +13,7 @@ function previewConfig() {
         apply: 'serve',
         config(config) {
             return {
+                appType: 'custom',
                 build: {
                     outDir: resolveOutDir(config)
                 }
@@ -23,6 +24,10 @@ function previewConfig() {
             configVike = await getConfigVike(config);
         },
         configurePreviewServer(server) {
+            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+            config.appType = 'mpa'
+            */
             markEnvAsPreview();
             return () => {
                 assertDist();

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

@@ -5,7 +5,7 @@ export { prerenderForceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, hasPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -343,7 +343,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             enumerable: false,
             configurable: true
         });
-        assert(hasPropertyGetter(pageContext, 'url'));
+        assert(isPropertyGetter(pageContext, 'url'));
         assert(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
@@ -382,7 +382,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     prerenderContext.pageContexts = result.prerenderContext.pageContexts;
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TODO/v1-release: remove
-        if (!hasPropertyGetter(pageContext, 'url') && pageContext.url) {
+        if (pageContext.url && !isPropertyGetter(pageContext, 'url')) {
             assertWarning(false, msgPrefix +
                 ' provided pageContext.url but it should provide pageContext.urlOriginal instead, see https://vike.dev/migration/0.4.23', { onlyOnce: true });
             pageContext.urlOriginal = pageContext.url;
@@ -407,10 +407,9 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         const { urlOriginal } = pageContext;
         assert(urlOriginal);
-        const routeResult = await route(pageContext);
-        assert(hasProp(routeResult.pageContextAddendum, '_pageId', 'null') ||
-            hasProp(routeResult.pageContextAddendum, '_pageId', 'string'));
-        if (routeResult.pageContextAddendum._pageId === null) {
+        const pageContextFromRoute = await route(pageContext);
+        assert(hasProp(pageContextFromRoute, '_pageId', 'null') || hasProp(pageContextFromRoute, '_pageId', 'string'));
+        if (pageContextFromRoute._pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -427,13 +426,13 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             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.
-                assert(routeResult.pageContextAddendum._routingProvidedByOnBeforeRouteHook);
+                assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
                 // Abort since the URL doesn't correspond to any page
                 return;
             }
         }
-        assert(routeResult.pageContextAddendum._pageId);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        assert(pageContextFromRoute._pageId);
+        objectAssign(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
         objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
         let usesClientRouter;

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

@@ -5,7 +5,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

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

@@ -7,7 +7,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

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.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);

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

@@ -11,7 +11,7 @@ declare function executeOnBeforeRouteHook(onBeforeRouteHook: OnBeforeRouteHook,
     _allPageIds: string[];
 }): Promise<null | {
     urlOriginal?: string;
-    _urlOriginalPristine?: string;
+    urlLogical?: string;
     _pageId?: string | null;
     routeParams?: Record<string, string>;
 }>;

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

@@ -6,6 +6,7 @@ export { executeOnBeforeRouteHook };
 async function executeOnBeforeRouteHook(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 +24,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;
+    _routeMatches: RouteMatches;
+};
 type RouteMatch = {
     pageId: string;
     routeString?: string;
@@ -21,11 +30,4 @@ type RouteMatch = {
     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>;
-}>;
+declare function route(pageContext: PageContextForRoute): Promise<PageContextFromRoute>;

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

@@ -33,7 +33,7 @@ async function route(pageContext) {
                     _routingProvidedByOnBeforeRouteHook: true,
                     _routeMatches: 'CUSTOM_ROUTE'
                 });
-                return { pageContextAddendum };
+                return pageContextAddendum;
             }
             // We already assign so that `pageContext.urlOriginal === pageContextAddendum.urlOriginal`; enabling the `onBeforeRoute()` hook to mutate `pageContext.urlOriginal` before routing.
             objectAssign(pageContext, pageContextAddendum);
@@ -99,7 +99,7 @@ async function route(pageContext) {
             _pageId: null,
             routeParams: {}
         });
-        return { pageContextAddendum };
+        return pageContextAddendum;
     }
     {
         const { routeParams } = winner;
@@ -109,5 +109,5 @@ async function route(pageContext) {
             routeParams: winner.routeParams
         });
     }
-    return { pageContextAddendum };
+    return pageContextAddendum;
 }

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-7f5e99a";
     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-7f5e99a';
 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-7f5e99a",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

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;