vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -8,9 +8,39 @@ const assertPageContextProvidedByUser_js_1 = require("../assertPageContextProvid
 const utils_js_1 = require("./utils.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-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) {
+        (0, utils_js_1.objectAssign)(pageContextFromOnBeforeRouteHook, pageContextFromHook);
+        if ((0, utils_js_1.hasProp)(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
+            (0, utils_js_1.hasProp)(pageContextFromOnBeforeRouteHook, '_pageId', 'null')) {
+            // We bypass Vike's routing
+            if (!(0, utils_js_1.hasProp)(pageContextFromOnBeforeRouteHook, 'routeParams')) {
+                (0, utils_js_1.objectAssign)(pageContextFromOnBeforeRouteHook, { routeParams: {} });
+            }
+            else {
+                (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromOnBeforeRouteHook, 'routeParams', 'object'));
+            }
+            (0, utils_js_1.objectAssign)(pageContextFromOnBeforeRouteHook, {
+                _routingProvidedByOnBeforeRouteHook: true,
+                _debugRouteMatches: 'CUSTOM_ROUTING'
+            });
+            return pageContextFromOnBeforeRouteHook;
+        }
+    }
+    (0, utils_js_1.objectAssign)(pageContextFromOnBeforeRouteHook, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    return pageContextFromOnBeforeRouteHook;
+}
+exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;
+async function executeHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
     (0, resolveRouteFunction_js_1.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}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||
@@ -28,29 +58,25 @@ async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'routeParams')) {
         (0, resolveRouteFunction_js_1.assertRouteParams)(hookReturn.pageContext, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
     }
-    const pageContextAddendumHook = {};
+    const deprecatedReturn = (prop) => `${errPrefix} returned ${picocolors_1.default.cyan(`{ pageContext: { ${prop} } }`)} which is deprecated. Return ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} instead.`;
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'url')) {
-        (0, utils_js_1.assertWarning)(false, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { url } }')} but ${picocolors_1.default.cyan('pageContext.url')} has been renamed to ${picocolors_1.default.cyan('pageContext.urlOriginal')}. Return ${picocolors_1.default.cyan('{ pageContext: { urlOriginal } }')} instead. (See https://vike.dev/migration/0.4.23 for more information.)`, { onlyOnce: true });
-        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        (0, utils_js_1.assertWarning)(false, deprecatedReturn('url'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.url;
         delete hookReturn.pageContext.url;
     }
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlOriginal')) {
-        (0, utils_js_1.assertUsageUrl)(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlOriginal } }')} but ${picocolors_1.default.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
-        (0, utils_js_1.objectAssign)(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+        (0, utils_js_1.assertWarning)(false, deprecatedReturn('urlOriginal'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.urlOriginal;
+        delete hookReturn.pageContext.urlOriginal;
+    }
+    if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlLogical')) {
+        (0, utils_js_1.assertUsageUrl)(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} but ${picocolors_1.default.cyan('urlLogical')}`);
     }
     (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,
         hookName: 'onBeforeRoute'
     });
+    const pageContextAddendumHook = {};
     (0, utils_js_1.objectAssign)(pageContextAddendumHook, hookReturn.pageContext);
     return pageContextAddendumHook;
 }
-exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;

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

@@ -18,35 +18,25 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function route(pageContext) {
-    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContext);
-    (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
-    const pageContextAddendum = {};
-    if (pageContext._onBeforeRouteHook) {
-        const pageContextAddendumHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext._onBeforeRouteHook, pageContext);
-        if (pageContextAddendumHook) {
-            (0, utils_js_1.objectAssign)(pageContextAddendum, pageContextAddendumHook);
-            if ((0, utils_js_1.hasProp)(pageContextAddendum, '_pageId', 'string') || (0, utils_js_1.hasProp)(pageContextAddendum, '_pageId', 'null')) {
-                // We bypass Vike's routing
-                if (!(0, utils_js_1.hasProp)(pageContextAddendum, 'routeParams')) {
-                    (0, utils_js_1.objectAssign)(pageContextAddendum, { routeParams: {} });
-                }
-                else {
-                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextAddendum, 'routeParams', 'object'));
-                }
-                (0, utils_js_1.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.
-            (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
+async function route(pageContextForRoute) {
+    (0, debug_js_1.debug)('Pages routes:', pageContextForRoute._pageRoutes);
+    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContextForRoute);
+    const pageContextFromRoute = {};
+    // onBeforeRoute()
+    const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContextForRoute);
+    if (pageContextFromOnBeforeRouteHook) {
+        if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
+            (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook._pageId);
+            return pageContextFromOnBeforeRouteHook;
+        }
+        else {
+            (0, utils_js_1.objectAssign)(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
         }
     }
-    (0, utils_js_1.objectAssign)(pageContextAddendum, {
-        _routingProvidedByOnBeforeRouteHook: false
-    });
+    // We take into account pageContext.urlLogical set by onBeforeRoute()
+    const pageContext = {};
+    (0, utils_js_1.objectAssign)(pageContext, pageContextForRoute);
+    (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
     (0, utils_js_1.assert)(allPageIds.length >= 0);
@@ -98,22 +88,22 @@ async function route(pageContext) {
     (0, resolvePrecedence_js_1.resolvePrecendence)(routeMatches);
     const winner = routeMatches[0];
     (0, debug_js_1.debug)(`Route matches for URL ${picocolors_1.default.cyan(urlPathname)} (in precedence order):`, routeMatches);
-    (0, utils_js_1.objectAssign)(pageContextAddendum, { _routeMatches: routeMatches });
+    (0, utils_js_1.objectAssign)(pageContextFromRoute, { _debugRouteMatches: routeMatches });
     if (!winner) {
-        (0, utils_js_1.objectAssign)(pageContextAddendum, {
+        (0, utils_js_1.objectAssign)(pageContextFromRoute, {
             _pageId: null,
             routeParams: {}
         });
-        return { pageContextAddendum };
+        return pageContextFromRoute;
     }
     {
         const { routeParams } = winner;
         (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(routeParams));
-        (0, utils_js_1.objectAssign)(pageContextAddendum, {
+        (0, utils_js_1.objectAssign)(pageContextFromRoute, {
             _pageId: winner.pageId,
             routeParams: winner.routeParams
         });
     }
-    return { pageContextAddendum };
+    return pageContextFromRoute;
 }
 exports.route = route;

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

@@ -5,10 +5,10 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const utils_js_3 = require("../page-configs/utils.js");
+const helpers_js_1 = require("../page-configs/helpers.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 async function loadPageRoutes(
-// TODO: remove all arguments and use GlobalContext instead
+// Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
     const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
@@ -31,10 +31,10 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
+                const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue, configName);
+                    const definedAt = (0, helpers_js_1.getDefinedAtString)(configValue.definedAt, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -46,7 +46,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, utils_js_3.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, helpers_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,
@@ -139,12 +139,13 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
-            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+        const hookName = 'onBeforeRoute';
+        if (pageConfigGlobal.configValues[hookName]?.value) {
+            const configValue = pageConfigGlobal.configValues[hookName];
             const { value: hookFn } = configValue;
-            const hookFilePath = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
-            // TODO: use getConfigDefinedAtString()
-            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
+            const hookDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Hook', hookName, configValue);
+            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `${hookDefinedAt} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,
                 onBeforeRoute: hookFn

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/shared/route/resolveRouteFunction.js

@@ -11,7 +11,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     (0, addUrlComputedProps_js_1.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/cjs/shared/utils.js

@@ -35,7 +35,7 @@ __exportStar(require("../utils/stringifyStringArray.js"), exports);
 __exportStar(require("../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../utils/cast.js"), exports);
 __exportStar(require("../utils/projectInfo.js"), exports);
-__exportStar(require("../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../utils/isPromise.js"), exports);
 __exportStar(require("../utils/checkType.js"), exports);
 __exportStar(require("../utils/objectEntries.js"), exports);

package/dist/cjs/utils/getFilePathAbsolute.js

@@ -34,27 +34,27 @@ function getFilePathAbsolute(filePath, config) {
         filePathUnresolved = path_1.default.posix.join(root, filePath);
         (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathUnresolved);
     }
-    let filePathAbsolute;
+    let filePathAbsoluteFilesystem;
     try {
-        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+        filePathAbsoluteFilesystem = require_.resolve(filePathUnresolved, { paths: [config.root] });
     }
     catch (err) {
         console.error(err);
         (0, assert_js_1.assert)(false);
     }
-    filePathAbsolute = (0, filesystemPathHandling_js_1.toPosixPath)(filePathAbsolute);
-    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathAbsolute);
-    return filePathAbsolute;
+    filePathAbsoluteFilesystem = (0, filesystemPathHandling_js_1.toPosixPath)(filePathAbsoluteFilesystem);
+    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    return filePathAbsoluteFilesystem;
 }
 exports.getFilePathAbsolute = getFilePathAbsolute;
-function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsolute);
+function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem, userRootDir, alwaysRelative = false) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, filesystemPathHandling_js_1.assertPosixPath)(userRootDir);
-    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsolute);
-    if (filePathAbsolute.startsWith(userRootDir)) {
+    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         (0, assert_js_1.assert)(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
         // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
-        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem, userRootDir });
         filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
         return filePathRelativeToUserRootDir;
     }
@@ -63,7 +63,7 @@ function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysR
             return filePathRelativeToUserRootDir;
         }
         else {
-            return filePathAbsolute;
+            return filePathAbsoluteFilesystem;
         }
     }
 }

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/{hasPropertyGetter.js → isPropertyGetter.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasPropertyGetter = void 0;
-function hasPropertyGetter(obj, prop) {
+exports.isPropertyGetter = void 0;
+function isPropertyGetter(obj, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
     return !!descriptor && !('value' in descriptor) && !!descriptor.get;
 }
-exports.hasPropertyGetter = hasPropertyGetter;
+exports.isPropertyGetter = isPropertyGetter;

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/parseUrl.js

@@ -52,7 +52,7 @@ function parseUrl(url, baseServer) {
     const searchAll = {};
     Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
         search[key] = val;
-        searchAll[key] = [...(searchAll[key] || []), val];
+        searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
     const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);

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';
+const PROJECT_VERSION = '0.4.145-commit-2520555';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/cjs/utils/truncateString.js

@@ -1,17 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truncateString = void 0;
-function truncateString(str, lenMax, dim) {
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+function truncateString(str, lenMax) {
+    const lenMaxReal = lenMax - 3;
+    (0, assert_js_1.assert)(lenMaxReal >= 1); // Show at least one character before the ellipsis
     if (str.length < lenMax) {
         return str;
     }
     else {
-        // May break ANSI codes
-        //  - So far, the str we pass to truncateString(str) are expected to not contain any ANSI code
-        str = str.substring(0, lenMax - 3);
-        let ellipsis = '...';
-        if (dim)
-            ellipsis = dim(ellipsis);
+        // Breaks ANSI codes.
+        //  - So far, the `str` we pass to truncateString(str) is always expected to not contain any ANSI code
+        str = str.substring(0, lenMaxReal);
+        const ellipsis = picocolors_1.default.dim('...');
         str = str + ellipsis;
         return str;
     }

package/dist/esm/__internal/index.d.ts

@@ -1,8 +1,8 @@
-import { route, type PageRoutes } from '../shared/route/index.js';
-import { type PageFile } from '../shared/getPageFiles.js';
-import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
+import { route as routeInternal, type PageRoutes } from '../shared/route/index.js';
+import { type PageFile } from '../shared/getPageFiles.js';
+import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
  * to compute some rewrite rules and extract { isr } configs.
@@ -15,3 +15,6 @@ declare function getPagesAndRoutes(): Promise<{
     pageConfigs: PageConfigRuntime[];
     allPageIds: string[];
 }>;
+declare function route(pageContext: Parameters<typeof routeInternal>[0]): Promise<{
+    pageContextAddendum: import("../shared/route/index.js").PageContextFromRoute;
+}>;

package/dist/esm/__internal/index.js

@@ -1,10 +1,10 @@
-// Internal functions of vike needed by other plugins are exported via this file
-import { route } from '../shared/route/index.js';
+// Internals needed by vite-plugin-vercel
+export { route, getPagesAndRoutes };
+import { route as routeInternal } from '../shared/route/index.js';
 import { getGlobalContext, initGlobalContext } from '../node/runtime/globalContext.js';
 import { setNodeEnvToProduction } from '../utils/nodeEnv.js';
 import { assert } from '../utils/assert.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
-export { route, getPagesAndRoutes };
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
  * to compute some rewrite rules and extract { isr } configs.
@@ -25,3 +25,8 @@ async function getPagesAndRoutes() {
         allPageIds
     };
 }
+async function route(pageContext) {
+    const pageContextFromRoute = await routeInternal(pageContext);
+    // Old interface
+    return { pageContextAddendum: pageContextFromRoute };
+}

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

@@ -1,7 +1,6 @@
 export { createPageContext };
-declare function createPageContext<T extends {
+declare function createPageContext(urlOriginal: string): Promise<{
     urlOriginal: string;
-}>(pageContextBase?: T): Promise<{
     _objectCreatedByVike: boolean;
     _urlHandler: null;
     _urlRewrite: null;
@@ -13,6 +12,6 @@ declare function createPageContext<T extends {
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;
-} & T & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+} & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
     _urlRewrite: string | null;
 }>;

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

@@ -3,9 +3,9 @@ import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
-import { assert, isBaseServer, objectAssign, getGlobalObject } from './utils.js';
+import { assert, isBaseServer, getGlobalObject } from './utils.js';
 const globalObject = getGlobalObject('createPageContext.ts', {});
-async function createPageContext(pageContextBase) {
+async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
         globalObject.pageFilesData = await getPageFilesAll(true);
     }
@@ -16,12 +16,12 @@ async function createPageContext(pageContextBase) {
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const isProd = import.meta.env.PROD;
     const pageContext = {
+        urlOriginal,
         _objectCreatedByVike: true,
         _urlHandler: null,
         _urlRewrite: null,
         _baseServer: baseServer,
         _isProduction: isProd,
-        // TODO: use GlobalContext instead
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
@@ -29,7 +29,6 @@ async function createPageContext(pageContextBase) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook
     };
-    objectAssign(pageContext, pageContextBase);
     addUrlComputedProps(pageContext);
     return pageContext;
 }

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

@@ -1,9 +1,9 @@
 import { assertClientRouting } from '../../utils/assertRoutingType.js';
 assertClientRouting();
 import './pageFiles';
-import { useClientRouter } from './useClientRouter.js';
+import { installClientRouter } from './installClientRouter.js';
 import { onClientEntry_ClientRouting } from './utils.js';
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
 const isProd = import.meta.env.PROD;
 onClientEntry_ClientRouting(isProd);
-useClientRouter();
+installClientRouter();

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;