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

package/dist/cjs/__internal/index.js

@@ -1,9 +1,7 @@
 "use strict";
-// Internal functions of vike needed by other plugins are exported via this file
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPagesAndRoutes = exports.route = void 0;
 const index_js_1 = require("../shared/route/index.js");
-Object.defineProperty(exports, "route", { enumerable: true, get: function () { return index_js_1.route; } });
 const globalContext_js_1 = require("../node/runtime/globalContext.js");
 const nodeEnv_js_1 = require("../utils/nodeEnv.js");
 const assert_js_1 = require("../utils/assert.js");
@@ -29,3 +27,9 @@ async function getPagesAndRoutes() {
     };
 }
 exports.getPagesAndRoutes = getPagesAndRoutes;
+async function route(pageContext) {
+    const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
+    // Old interface
+    return { pageContextAddendum: pageContextFromRoute };
+}
+exports.route = route;

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

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

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

@@ -23,6 +23,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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -110,11 +110,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             configName
         };
         {
-            // We don't have access to custom config definitions yet
-            //  - We load +{configName}.js later
-            //  - But we do need to eagerly load +meta.js (to get all the custom config definitions)
+            // We don't have access to the custom config definitions defined by the user yet.
+            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
             const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configName);
-            if (configDef?.env === 'config-only') {
+            if (configDef && isConfigEnv(configDef, configName)) {
                 await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
@@ -144,6 +144,22 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
         interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
+async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
+    const f = filePath.filePathAbsoluteFilesystem;
+    if (!importedFilesLoaded[f]) {
+        importedFilesLoaded[f] = (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(filePath, true, userRootDir).then((r) => r.fileExports);
+    }
+    const fileExports = await importedFilesLoaded[f];
+    return fileExports;
+}
+function isConfigEnv(configDef, configName) {
+    if (configDef.cumulative)
+        return true;
+    if (configDef.env === 'config-only')
+        return true;
+    // TODO: replace with proper `env: { config: boolean }` implementation
+    return configName === 'clientRouting';
+}
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
     const interfaceFile = {
@@ -204,7 +220,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
 }
 async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
-    const { globalVikeConfig, pageConfigGlobal } = getGlobalConfigs(interfaceFilesByLocationId, userRootDir);
+    const importedFilesLoaded = {};
+    const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -218,24 +235,24 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitionsRelevant, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (configDef.env !== 'config-only')
+            if (!isConfigEnv(configDef, configName))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
                 return;
-            // Value files for built-in confg-only configs should have already been loaded at loadInterfaceFiles()
+            // Value files of built-in configs should have already been loaded at loadInterfaceFiles()
             (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
-        (0, utils_js_1.objectEntries)(configDefinitionsRelevant)
+        await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsRelevant)
             .filter(([configName]) => !isGlobalConfig(configName))
-            .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir);
-            if (!sources)
+            .map(async ([configName, configDef]) => {
+            const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded);
+            if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
-        });
+        }));
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitionsRelevant);
         const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
@@ -285,7 +302,7 @@ function getInterfaceFileList(interfaceFilesByLocationId) {
     });
     return interfaceFiles;
 }
-function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
     const locationIds = Object.keys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = Object.fromEntries(Object.entries(interfaceFilesByLocationId).filter(([locationId]) => {
         return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
@@ -321,9 +338,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     const pageConfigGlobal = {
         configValueSources: {}
     };
-    (0, utils_js_1.objectEntries)(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
-        const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
-        const configValueSource = sources?.[0];
+    await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
+        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
+        const configValueSource = sources[0];
         if (!configValueSource)
             return;
         if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
@@ -338,23 +355,21 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
-    });
+    }));
     return { pageConfigGlobal, globalVikeConfig };
 }
-function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir) {
-    let sources = null;
+async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
+    const sourcesInfo = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
     for (const interfaceFiles of Object.values(interfaceFilesRelevant)) {
         const interfaceFilesDefiningConfig = interfaceFiles.filter((interfaceFile) => interfaceFile.configMap[configName]);
         if (interfaceFilesDefiningConfig.length === 0)
             continue;
-        sources = sources ?? [];
         const visited = new WeakSet();
         const add = (interfaceFile) => {
             (0, utils_js_1.assert)(!visited.has(interfaceFile));
             visited.add(interfaceFile);
-            const configValueSource = getConfigValueSource(configName, interfaceFile, configDef, userRootDir);
-            sources.push(configValueSource);
+            sourcesInfo.push([configName, interfaceFile, configDef, userRootDir, importedFilesLoaded]);
         };
         // Main resolution logic
         {
@@ -378,7 +393,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             if (interfaceFileWinner) {
                 const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
                 // A user-land conflict of interfaceFiles with the same locationId means that the user has superfluously defined the config twice; the user should remove such redundancy making things unnecessarily ambiguous
-                warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName, configDef, userRootDir);
+                warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName);
                 [interfaceFileWinner, ...interfaceFilesOverriden].forEach((interfaceFile) => {
                     add(interfaceFile);
                 });
@@ -403,7 +418,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             (0, utils_js_1.assert)(visited.has(interfaceFile));
         });
     }
-    (0, utils_js_1.assert)(sources === null || sources.length > 0);
+    const sources = await Promise.all(sourcesInfo.map(async (args) => await getConfigValueSource(...args)));
     return sources;
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
@@ -414,22 +429,17 @@ function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
         return filePathRelativeToUserRootDir.length;
     })(interfaceFile1, interfaceFile2);
 }
-function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName, configDef, userRootDir) {
+function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
-        const configValueSourceLoser_ = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
-        // prettier-ignore
-        const configLoser_DefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSourceLoser_);
-        // prettier-ignore
-        const configWinnerDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('config', configName, configValueSourceWinner);
-        const errMsg = `${configLoser_DefinedAt} is overriden by another ${configWinnerDefinedAt}, remove one of the two`;
-        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: false });
+        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
+        (0, utils_js_1.assertWarning)(false, `Config ${configName} defined at ${loserFilePath} is always overwritten by ${configName} defined at ${winnerFilePath}, remove the superfluous ${configName} value defined at ${interfaceFileLoser}`, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
-function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
+async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded) {
     const conf = interfaceFile.configMap[configName];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
@@ -475,6 +485,18 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
             };
+            // Load config value
+            if (isConfigEnv(configDef, configName)) {
+                if (import_.filePathAbsoluteFilesystem) {
+                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExports[import_.fileExportName];
+                }
+                else {
+                    const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
+                    (0, utils_js_1.assertUsage)(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
+                }
+            }
             return configValueSource;
         }
         else {
@@ -1115,12 +1137,8 @@ function mergeCumulative(configName, configValueSources) {
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
         const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValueSource);
-        const configNameColored = picocolors_1.default.cyan(configName);
-        // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
-        (0, utils_js_1.assertUsage)('value' in configValueSource, `${configDefinedAt} is only allowed to be defined in a +config.h.js file. (Because the values of ${configNameColored} are cumulative.)`);
-        /* This is more confusing than adding value. For example, this explanation shouldn't be shown for the passToClient config.
-        const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
-        */
+        // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
+        (0, utils_js_1.assert)('value' in configValueSource);
         // Make sure configValueSource.value is serializable
         (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {

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

@@ -118,6 +118,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/cjs/node/plugin/plugins/previewConfig.js

@@ -18,6 +18,7 @@ function previewConfig() {
         apply: 'serve',
         config(config) {
             return {
+                appType: 'custom',
                 build: {
                     outDir: (0, utils_js_1.resolveOutDir)(config)
                 }
@@ -28,6 +29,10 @@ function previewConfig() {
             configVike = await (0, getConfigVike_js_1.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'
+            */
             (0, utils_js_1.markEnvAsPreview)();
             return () => {
                 assertDist();

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

@@ -272,7 +272,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             _providedByHook: null,
             routeParams,
             _pageId: pageId,
-            _routeMatches: [
+            _debugRouteMatches: [
                 {
                     pageId,
                     routeType: pageRoute.routeType,
@@ -371,7 +371,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             enumerable: false,
             configurable: true
         });
-        (0, utils_js_1.assert)((0, utils_js_1.hasPropertyGetter)(pageContext, 'url'));
+        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
         (0, utils_js_1.assert)(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
@@ -410,7 +410,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     prerenderContext.pageContexts = result.prerenderContext.pageContexts;
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TODO/v1-release: remove
-        if (!(0, utils_js_1.hasPropertyGetter)(pageContext, 'url') && pageContext.url) {
+        if (pageContext.url && !(0, utils_js_1.isPropertyGetter)(pageContext, 'url')) {
             (0, utils_js_1.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;
@@ -435,10 +435,9 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         const { urlOriginal } = pageContext;
         (0, utils_js_1.assert)(urlOriginal);
-        const routeResult = await (0, index_js_1.route)(pageContext);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(routeResult.pageContextAddendum, '_pageId', 'null') ||
-            (0, utils_js_1.hasProp)(routeResult.pageContextAddendum, '_pageId', 'string'));
-        if (routeResult.pageContextAddendum._pageId === null) {
+        const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'string'));
+        if (pageContextFromRoute._pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -451,17 +450,17 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             if (hookName) {
                 (0, utils_js_1.assert)(hookFilePath);
-                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that doesn't match any of your page routes. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
+                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that doesn't match the route of any of your pages. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
             }
             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.
-                (0, utils_js_1.assert)(routeResult.pageContextAddendum._routingProvidedByOnBeforeRouteHook);
+                (0, utils_js_1.assert)(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
                 // Abort since the URL doesn't correspond to any page
                 return;
             }
         }
-        (0, utils_js_1.assert)(routeResult.pageContextAddendum._pageId);
-        (0, utils_js_1.objectAssign)(pageContext, routeResult.pageContextAddendum);
+        (0, utils_js_1.assert)(pageContextFromRoute._pageId);
+        (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
         (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageFilesServerSide_js_1.loadPageFilesServerSide)(pageContext));
         let usesClientRouter;

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

@@ -23,7 +23,7 @@ __exportStar(require("../../utils/objectAssign.js"), exports);
 __exportStar(require("../../utils/isObjectWithKeys.js"), exports);
 __exportStar(require("../../utils/isCallable.js"), exports);
 __exportStar(require("../../utils/getOutDirs.js"), exports);
-__exportStar(require("../../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../shared/hooks/executeHook.js"), exports);

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

@@ -58,6 +58,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/cjs/node/runtime/renderPage/debugPageFiles.js

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

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

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

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

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

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

@@ -44,7 +44,7 @@ __exportStar(require("../../utils/capitalizeFirstLetter.js"), exports);
 __exportStar(require("../../utils/debugGlob.js"), exports);
 __exportStar(require("../../utils/isEquivalentError.js"), exports);
 __exportStar(require("../../utils/styleFileRE.js"), exports);
-__exportStar(require("../../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../../utils/debug.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);

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