vike 0.4.144-commit-7f5e99a → 0.4.144-commit-de18325

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/prerender/runPrerender.js

@@ -272,7 +272,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             _providedByHook: null,
             routeParams,
             _pageId: pageId,
-            _routeMatches: [
+            _debugRouteMatches: [
                 {
                     pageId,
                     routeType: pageRoute.routeType,
@@ -450,7 +450,7 @@ 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.

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

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

@@ -8,7 +8,36 @@ 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
@@ -51,4 +80,3 @@ async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     (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/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-7f5e99a';
+const PROJECT_VERSION = '0.4.144-commit-de18325';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

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

@@ -38,7 +38,7 @@ async function getPageContextFirstRender(pageContext) {
         isHydration: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContextAddendum._pageId, pageContext));
     {
         const pageContextForHook = { ...pageContext, ...pageContextAddendum };
         if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
@@ -69,7 +69,7 @@ async function getPageContextUponNavigation(pageContext) {
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
     let pageContextAddendum = {};
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageId));
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageId, pageContext));
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
@@ -87,7 +87,7 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
                 isHydration: false,
                 _pageId: errorPageId
             });
-            objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+            objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContextAddendum._pageId, pageContext));
             assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
             assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
             assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));

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

@@ -1,9 +1,8 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, checkIfClientRouting, objectAssign } from './utils.js';
+import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, objectAssign } from './utils.js';
 import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
 import { skipLink } from './skipLink.js';
-import { getPageId } from './getPageId.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
 import { disableClientRouting } from './installClientRouter.js';
@@ -12,7 +11,20 @@ import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { createPageContext } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 assertClientRouting();
-const linkPrefetchHandlerAdded = new Map();
+const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new Map() });
+async function prefetchAssets(pageId, pageContext) {
+    try {
+        await loadPageFilesClientSide(pageId, pageContext);
+    }
+    catch (err) {
+        if (isErrorFetchingStaticAssets(err)) {
+            disableClientRouting(err, true);
+        }
+        else {
+            throw err;
+        }
+    }
+}
 /**
  * Programmatically prefetch client assets.
  *
@@ -24,33 +36,38 @@ async function prefetch(url) {
     assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
         showStackTrace: true
     });
-    assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`, { showStackTrace: true });
+    const errPrefix = `Cannot prefetch URL ${url} because it`;
+    assertUsage(!isExternalLink(url), `${errPrefix} lives on another domain`, { showStackTrace: true });
     if (isAlreadyPrefetched(url))
         return;
     markAsAlreadyPrefetched(url);
-    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
-    if (pageId) {
-        try {
-            await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId);
-        }
-        catch (err) {
-            if (isErrorFetchingStaticAssets(err)) {
-                disableClientRouting(err, true);
-            }
-            else {
-                throw err;
-            }
-        }
+    const pageContext = await createPageContext(url);
+    let pageContextFromRoute;
+    try {
+        pageContextFromRoute = await route(pageContext);
     }
+    catch {
+        // If a route() hook has a bug or `throw render()` / `throw redirect()`
+        return;
+    }
+    const pageId = pageContextFromRoute._pageId;
+    if (!pageId) {
+        assertWarning(false, `${errPrefix} doesn't match the route of any of your pages`, {
+            showStackTrace: true,
+            onlyOnce: false
+        });
+        return;
+    }
+    await prefetchAssets(pageId, pageContext);
 }
 function addLinkPrefetchHandlers(pageContext) {
     // Current URL is already prefetched
     markAsAlreadyPrefetched(pageContext.urlPathname);
     const linkTags = [...document.getElementsByTagName('A')];
     linkTags.forEach((linkTag) => {
-        if (linkPrefetchHandlerAdded.has(linkTag))
+        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
             return;
-        linkPrefetchHandlerAdded.set(linkTag, true);
+        globalObject.linkPrefetchHandlerAdded.set(linkTag, true);
         const url = linkTag.getAttribute('href');
         if (skipLink(linkTag))
             return;
@@ -62,17 +79,17 @@ function addLinkPrefetchHandlers(pageContext) {
             return;
         if (prefetchStaticAssets === 'hover') {
             linkTag.addEventListener('mouseover', () => {
-                prefetchIfClientSideRoutable(url);
+                prefetchIfPossible(url);
             });
             linkTag.addEventListener('touchstart', () => {
-                prefetchIfClientSideRoutable(url);
+                prefetchIfPossible(url);
             }, { passive: true });
         }
         if (prefetchStaticAssets === 'viewport') {
             const observer = new IntersectionObserver((entries) => {
                 entries.forEach((entry) => {
                     if (entry.isIntersecting) {
-                        prefetchIfClientSideRoutable(url);
+                        prefetchIfPossible(url);
                         observer.disconnect();
                     }
                 });
@@ -81,7 +98,7 @@ function addLinkPrefetchHandlers(pageContext) {
         }
     });
 }
-async function prefetchIfClientSideRoutable(url) {
+async function prefetchIfPossible(url) {
     const pageContext = await createPageContext(url);
     let pageContextFromRoute;
     try {
@@ -92,7 +109,9 @@ async function prefetchIfClientSideRoutable(url) {
         return;
     }
     objectAssign(pageContext, pageContextFromRoute);
+    if (!pageContext._pageId)
+        return;
     if (!(await isClientSideRoutable(pageContext)))
         return;
-    await prefetch(url);
+    await prefetchAssets(pageContext._pageId, pageContext);
 }

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -26,7 +26,7 @@ async function loadPageFiles(pageId) {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId));
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageId, pageContextAddendum));
     pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {

package/dist/esm/client/shared/loadPageFilesClientSide.d.ts

@@ -1,8 +1,13 @@
-import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
-import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 export { loadPageFilesClientSide };
 export { isErrorFetchingStaticAssets };
-declare function loadPageFilesClientSide(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageId: string): Promise<PageContextExports & {
+export type { PageContextPageFiles };
+import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+type PageContextPageFiles = {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+};
+declare function loadPageFilesClientSide(pageId: string, pageContext: PageContextPageFiles): Promise<PageContextExports & {
     _pageFilesLoaded: PageFile[];
 }>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,12 +1,12 @@
+export { loadPageFilesClientSide };
+export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
-export { loadPageFilesClientSide };
-export { isErrorFetchingStaticAssets };
 const stamp = '__whileFetchingAssets';
-async function loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId) {
-    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
-    const pageConfig = findPageConfig(pageConfigs, pageId);
+async function loadPageFilesClientSide(pageId, pageContext) {
+    const pageFilesClientSide = getPageFilesClientSide(pageContext._pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
     let pageConfigLoaded;
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const isDev = import.meta.env.DEV;

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

@@ -105,11 +105,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, configName);
-            if (configDef?.env === 'config-only') {
+            if (configDef && isConfigEnv(configDef, configName)) {
                 await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
@@ -139,6 +139,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] = 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 = {
@@ -199,7 +215,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]) => {
@@ -213,24 +230,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()
             assert(!(configName in configDefinitionsBuiltIn));
             await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
-        objectEntries(configDefinitionsRelevant)
+        await Promise.all(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);
@@ -280,7 +297,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 isGlobalLocation(locationId, locationIds);
@@ -316,9 +333,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     const pageConfigGlobal = {
         configValueSources: {}
     };
-    objectEntries(configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
-        const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
-        const configValueSource = sources?.[0];
+    await Promise.all(objectEntries(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') {
@@ -333,23 +350,21 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.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) => {
             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
         {
@@ -373,7 +388,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);
                 });
@@ -398,7 +413,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             assert(visited.has(interfaceFile));
         });
     }
-    assert(sources === null || sources.length > 0);
+    const sources = await Promise.all(sourcesInfo.map(async (args) => await getConfigValueSource(...args)));
     return sources;
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
@@ -409,22 +424,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 = getConfigDefinedAtString('Config', configName, configValueSourceLoser_);
-        // prettier-ignore
-        const configWinnerDefinedAt = getConfigDefinedAtString('config', configName, configValueSourceWinner);
-        const errMsg = `${configLoser_DefinedAt} is overriden by another ${configWinnerDefinedAt}, remove one of the two`;
-        assertWarning(false, errMsg, { onlyOnce: false });
+        const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
+        const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
+        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];
     assert(conf);
     const configEnv = configDef.env;
@@ -470,6 +480,18 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 valueIsImportedAtRuntime: true,
                 definedAt: import_
             };
+            // Load config value
+            if (isConfigEnv(configDef, configName)) {
+                if (import_.filePathAbsoluteFilesystem) {
+                    assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    const fileExports = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
+                    configValueSource.value = fileExports[import_.fileExportName];
+                }
+                else {
+                    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
+                    assertUsage(!configDef.cumulative, `${configDefinedAt} cannot be defined over an aliased import`);
+                }
+            }
             return configValueSource;
         }
         else {
@@ -1109,12 +1131,8 @@ function mergeCumulative(configName, configValueSources) {
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
         const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
-        const configNameColored = pc.cyan(configName);
-        // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
-        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.
+        assert('value' in configValueSource);
         // Make sure configValueSource.value is serializable
         getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {

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

@@ -244,7 +244,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             _providedByHook: null,
             routeParams,
             _pageId: pageId,
-            _routeMatches: [
+            _debugRouteMatches: [
                 {
                     pageId,
                     routeType: pageRoute.routeType,
@@ -422,7 +422,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             if (hookName) {
                 assert(hookFilePath);
-                assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.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.`);
+                assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.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.

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

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

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

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

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

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

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

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

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

@@ -268,7 +268,7 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
         routeParams: {}
     };
     objectAssign(pageContext, {
-        _routeMatches: pageContextNominalPagePartial._routeMatches || 'ROUTE_ERROR'
+        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
     });
     assert(pageContext.errorWhileRendering);
     return pageContext;

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

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

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

@@ -1,9 +1,37 @@
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 export { executeOnBeforeRouteHook };
-async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+async function executeOnBeforeRouteHook(pageContext) {
+    const pageContextFromOnBeforeRouteHook = {};
+    if (!pageContext._onBeforeRouteHook)
+        return null;
+    const pageContextFromHook = await executeHook(pageContext._onBeforeRouteHook, pageContext);
+    if (pageContextFromHook) {
+        objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
+        if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
+            hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'null')) {
+            // We bypass Vike's routing
+            if (!hasProp(pageContextFromOnBeforeRouteHook, 'routeParams')) {
+                objectAssign(pageContextFromOnBeforeRouteHook, { routeParams: {} });
+            }
+            else {
+                assert(hasProp(pageContextFromOnBeforeRouteHook, 'routeParams', 'object'));
+            }
+            objectAssign(pageContextFromOnBeforeRouteHook, {
+                _routingProvidedByOnBeforeRouteHook: true,
+                _debugRouteMatches: 'CUSTOM_ROUTING'
+            });
+            return pageContextFromOnBeforeRouteHook;
+        }
+    }
+    objectAssign(pageContextFromOnBeforeRouteHook, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    return pageContextFromOnBeforeRouteHook;
+}
+async function executeHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync

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

@@ -19,8 +19,8 @@ type PageContextForRoute = PageContextUrlComputedPropsInternal & {
 type PageContextFromRoute = {
     _pageId: string | null;
     routeParams: Record<string, string>;
-    _routingProvidedByOnBeforeRouteHook: boolean;
-    _routeMatches: RouteMatches;
+    _routingProvidedByOnBeforeRouteHook?: boolean;
+    _debugRouteMatches: RouteMatches;
 };
 type RouteMatch = {
     pageId: string;
@@ -29,5 +29,5 @@ type RouteMatch = {
     routeType: RouteType;
     routeParams: Record<string, string>;
 };
-type RouteMatches = 'CUSTOM_ROUTE' | RouteMatch[];
-declare function route(pageContext: PageContextForRoute): Promise<PageContextFromRoute>;
+type RouteMatches = 'CUSTOM_ROUTING' | RouteMatch[];
+declare function route(pageContextForRoute: PageContextForRoute): Promise<PageContextFromRoute>;

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

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

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

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

package/dist/esm/utils/projectInfo.js

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

package/package.json

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

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

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

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

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