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

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

@@ -1,15 +1,30 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, checkIfClientRouting } from './utils.js';
+import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, objectAssign } from './utils.js';
 import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
-import { isClientSideRoutable, skipLink } from './skipLink.js';
-import { getPageId } from './getPageId.js';
+import { skipLink } from './skipLink.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
-import { disableClientRouting } from './useClientRouter.js';
+import { disableClientRouting } from './installClientRouter.js';
 import { isExternalLink } from './isExternalLink.js';
+import { isClientSideRoutable } from './isClientSideRoutable.js';
+import { createPageContext } from './createPageContext.js';
+import { route } from '../../shared/route/index.js';
 assertClientRouting();
-const linkPrefetchHandlerAdded = new Map();
+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.
  *
@@ -21,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;
@@ -59,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();
                     }
                 });
@@ -78,14 +98,20 @@ function addLinkPrefetchHandlers(pageContext) {
         }
     });
 }
-async function prefetchIfClientSideRoutable(url) {
+async function prefetchIfPossible(url) {
+    const pageContext = await createPageContext(url);
+    let pageContextFromRoute;
     try {
-        if (!(await isClientSideRoutable(url)))
-            return;
+        pageContextFromRoute = await route(pageContext);
     }
     catch {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
         return;
     }
-    await prefetch(url);
+    objectAssign(pageContext, pageContextFromRoute);
+    if (!pageContext._pageId)
+        return;
+    if (!(await isClientSideRoutable(pageContext)))
+        return;
+    await prefetchAssets(pageContext._pageId, pageContext);
 }

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

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

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

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

package/dist/esm/client/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/executeOnRenderClientHook.js

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

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

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

package/dist/esm/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/commonConfig.js

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

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

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

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/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/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

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

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

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

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

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

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

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

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

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