vike 0.4.144-commit-6aef8a6 → 0.4.144-commit-7f5e99a

package/dist/cjs/node/shared/getClientEntryFilePath.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClientEntryFilePath = void 0;
-const utils_js_1 = require("../../shared/page-configs/utils.js");
+const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
-    const configValue = (0, utils_js_1.getConfigValue)(pageConfig, configName, 'string');
+    const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName, 'string');
     if (!configValue)
         return null;
     return configValue.value;

package/dist/cjs/shared/addUrlComputedProps.js

@@ -6,24 +6,36 @@ const utils_js_1 = require("./utils.js");
 function addUrlComputedProps(pageContext, enumerable = true) {
     (0, utils_js_1.assert)(pageContext.urlOriginal);
     if ('urlPathname' in pageContext) {
-        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'urlPathname'));
+        (0, utils_js_1.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)
+           ```
+        */
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
     }
+    if ('urlParsed' in pageContext)
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        (0, utils_js_1.assert)((0, utils_js_1.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)
-        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'url'));
     Object.defineProperty(pageContext, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    if ('urlParsed' in pageContext) {
-        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'urlParsed'));
-    }
     Object.defineProperty(pageContext, 'urlParsed', {
         get: urlParsedGetter,
         enumerable,
@@ -32,17 +44,17 @@ function addUrlComputedProps(pageContext, enumerable = true) {
 }
 exports.addUrlComputedProps = addUrlComputedProps;
 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;
-    (0, utils_js_1.assert)(url && typeof url === 'string');
-    const urlLogical = urlHandler(url);
+    let urlResolved = pageContext._urlRewrite ?? pageContext.urlLogical ?? pageContext.urlOriginal;
+    urlResolved = urlHandler(urlResolved);
     const baseServer = pageContext._baseServer;
+    (0, utils_js_1.assert)(urlResolved && typeof urlResolved === 'string');
     (0, utils_js_1.assert)(baseServer.startsWith('/'));
-    return (0, utils_js_1.parseUrl)(urlLogical, baseServer);
+    return (0, utils_js_1.parseUrl)(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
     const { pathname } = getUrlParsed(this);

package/dist/cjs/shared/getPageFiles/analyzeClientSide.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeClientSide = void 0;
-const utils_js_1 = require("../page-configs/utils.js");
+const helpers_js_1 = require("../page-configs/helpers.js");
 const analyzePageClientSide_js_1 = require("./analyzePageClientSide.js");
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
     if (pageConfig) {
-        const isClientRouting = (0, utils_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-        const isClientSideRenderable = (0, utils_js_1.getConfigValue)(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
+        const isClientRouting = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        const isClientSideRenderable = (0, helpers_js_1.getConfigValue)(pageConfig, 'isClientSideRenderable', 'boolean')?.value ?? false;
         return { isClientSideRenderable, isClientRouting };
     }
     else {
-        // TODO/v1-release:
-        //  - remove V0.4 implementation
-        //  - globally rename isHtmlOnly to !isClientSideRenderable
+        // TODO/v1-release: remove
         // V0.4 design
         const { isHtmlOnly, isClientRouting } = (0, analyzePageClientSide_js_1.analyzePageClientSide)(pageFilesAll, pageId);
         return { isClientSideRenderable: !isHtmlOnly, isClientRouting };

package/dist/cjs/shared/getPageFiles/getExports.js

@@ -7,7 +7,7 @@ exports.getExports = exports.getExportUnion = void 0;
 const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
 const utils_js_1 = require("../utils.js");
 const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
-const utils_js_2 = require("../page-configs/utils.js");
+const helpers_js_1 = require("../page-configs/helpers.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function getExports(pageFiles, pageConfig) {
     const configEntries = {};
@@ -34,8 +34,8 @@ function getExports(pageFiles, pageConfig) {
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
-            const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
-            const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+            const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(configValue);
+            const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValue);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
             // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)

package/dist/cjs/shared/hooks/getHook.js

@@ -25,7 +25,7 @@ exports.assertHook = assertHook;
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     (0, utils_js_1.assert)(hookName && hookFilePath);
     (0, utils_js_1.assert)(!hookName.endsWith(')'));
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `hook ${hookName}() defined by ${hookFilePath} should be a function`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     (0, utils_js_1.checkType)(hookFn);
 }
 exports.assertHookFn = assertHookFn;

package/dist/cjs/shared/page-configs/helpers/getConfigDefinedAtString.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefinedAtString = exports.getConfigDefinedAtString = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getExportPath_js_1 = require("../getExportPath.js");
+function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
+    const definedAtString = getDefinedAtString(definedAt, configName);
+    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
+    let configNameStr = `${configName}${sentenceBegin === 'Hook' ? '()' : ''}`;
+    const configDefinedAt = `${sentenceBegin} ${picocolors_1.default.cyan(configNameStr)} defined ${definedAtStr}`;
+    return configDefinedAt;
+}
+exports.getConfigDefinedAtString = getConfigDefinedAtString;
+function getDefinedAtString(definedAt, configName) {
+    if ('isComputed' in definedAt) {
+        return 'internally';
+    }
+    let files;
+    if ('files' in definedAt) {
+        files = definedAt.files;
+    }
+    else {
+        files = [definedAt];
+    }
+    (0, utils_js_1.assert)(files.length >= 1);
+    const definedAtString = files
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+        let s = filePathToShowToUser;
+        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPathToShowToUser, configName);
+        if (exportPath) {
+            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return definedAtString;
+}
+exports.getDefinedAtString = getDefinedAtString;

package/dist/cjs/shared/page-configs/helpers/getConfigValue.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValue = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getConfigDefinedAtString_js_1 = require("./getConfigDefinedAtString.js");
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAt } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
+}
+exports.getConfigValue = getConfigValue;
+function assertConfigValueType(value, type, configName, definedAt) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null
+        ? `value ${picocolors_1.default.cyan(valuePrintable)}`
+        : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = (0, getConfigDefinedAtString_js_1.getConfigDefinedAtString)('Config', configName, {
+        definedAt
+    });
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`;
+    (0, utils_js_1.assertUsage)(false, errMsg);
+}
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null)
+        return null;
+    return configValue;
+}

package/dist/cjs/shared/page-configs/helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValue = exports.getDefinedAtString = exports.getConfigDefinedAtString = exports.getHookFilePathToShowToUser = exports.getConfigValueFilePathToShowToUser = exports.getPageConfig = void 0;
+var getConfigDefinedAtString_js_1 = require("./helpers/getConfigDefinedAtString.js");
+Object.defineProperty(exports, "getConfigDefinedAtString", { enumerable: true, get: function () { return getConfigDefinedAtString_js_1.getConfigDefinedAtString; } });
+Object.defineProperty(exports, "getDefinedAtString", { enumerable: true, get: function () { return getConfigDefinedAtString_js_1.getDefinedAtString; } });
+var getConfigValue_js_1 = require("./helpers/getConfigValue.js");
+Object.defineProperty(exports, "getConfigValue", { enumerable: true, get: function () { return getConfigValue_js_1.getConfigValue; } });
+const utils_js_1 = require("../utils.js");
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    (0, utils_js_1.assert)(pageConfigs.length > 0);
+    (0, utils_js_1.assert)(pageConfig);
+    return pageConfig;
+}
+exports.getPageConfig = getPageConfig;
+function getConfigValueFilePathToShowToUser({ definedAt }) {
+    // A unique file path only exists if the config value isn't cumulative nor computed:
+    //  - cumulative config values have multiple file paths
+    //  - computed values don't have any file path
+    if ('isComputed' in definedAt || 'files' in definedAt)
+        return null;
+    const { filePathToShowToUser } = definedAt;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getConfigValueFilePathToShowToUser = getConfigValueFilePathToShowToUser;
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getHookFilePathToShowToUser = getHookFilePathToShowToUser;

package/dist/cjs/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -13,14 +13,12 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                file: {
-                    // importPath cannot be relative to the current file, since the current file is a virtual file
-                    filePathToShowToUser: importPath,
-                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                        ? []
-                        : // Side-effect config
-                            [exportName]
-                }
+                // importPath cannot be relative to the current file, since the current file is a virtual file
+                filePathToShowToUser: importPath,
+                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                    ? []
+                    : // Side-effect config
+                        [exportName]
             }
         };
         assertIsNotNull(value, configName, importPath);

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -4,7 +4,7 @@ exports.parsePageConfigs = void 0;
 const parse_1 = require("@brillout/json-serializer/parse");
 const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
 const utils_js_1 = require("../../utils.js");
-const utils_js_2 = require("../utils.js");
+const helpers_js_1 = require("../helpers.js");
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -52,7 +52,7 @@ function assertRouteConfigValue(configValues) {
         return;
     const { value } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+    const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValue);
     (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
     /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
     * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.

package/dist/cjs/shared/page-configs/serialize/serializeConfigValue.js

@@ -28,9 +28,9 @@ exports.serializeConfigValue = serializeConfigValue;
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAtInfo;
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteVite);
     const fileName = path_1.default.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');

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

@@ -11,6 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function executeOnBeforeRouteHook(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,28 +29,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;
 }

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

@@ -38,7 +38,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.
             (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
@@ -104,7 +104,7 @@ async function route(pageContext) {
             _pageId: null,
             routeParams: {}
         });
-        return { pageContextAddendum };
+        return pageContextAddendum;
     }
     {
         const { routeParams } = winner;
@@ -114,6 +114,6 @@ async function route(pageContext) {
             routeParams: winner.routeParams
         });
     }
-    return { pageContextAddendum };
+    return pageContextAddendum;
 }
 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.definedAt, 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/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/{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/projectInfo.js

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

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,6 +16,7 @@ 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,
@@ -29,7 +30,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/getPageContext.d.ts

@@ -21,7 +21,6 @@ declare function getPageContext(pageContext: {
 declare function getPageContextErrorPage(pageContext: {
     urlOriginal: string;
     _allPageIds: string[];
-    _isFirstRenderAttempt: boolean;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 } & PageContextPassThrough): Promise<PageContextAddendum>;