vike 0.4.143 → 0.4.144-commit-e40e9b1

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

@@ -2,7 +2,7 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, assertDefaultExportUnknown, assertDefaultExportObject, objectEntries, hasProp, arrayIncludes, objectKeys, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, resolve } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import glob from 'fast-glob';
@@ -16,17 +16,18 @@ import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } fro
 import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
+import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
 import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-const codeFilesEnv = new Map();
-function reloadVikeConfig(userRootDir, extensions) {
+const filesEnv = new Map();
+function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
-    codeFilesEnv.clear();
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, extensions, true);
+    filesEnv.clear();
+    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
@@ -60,14 +61,14 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(userRootDir, isDev, extensions, tolerateInvalidConfig = false) {
+async function getVikeConfig(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig = false) {
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions, tolerateInvalidConfig);
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig);
     }
     return await vikeConfigPromise;
 }
-async function loadInterfaceFiles(userRootDir, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, isDev, extensions);
+async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
+    const plusFiles = await findPlusFiles(userRootDir, [outDirRoot], isDev, extensions);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -83,7 +84,8 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
         const configFilePath = {
             filePathAbsolute: filePathAbsolute,
-            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
         };
         const { configFile, extendsConfigs } = await loadConfigFile(configFilePath, userRootDir, []);
         const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
@@ -97,27 +99,28 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     }));
     // Value files
     await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configNameDefault = getConfigName(filePathRelativeToUserRootDir);
-        assert(configNameDefault);
+        const configName = getConfigName(filePathRelativeToUserRootDir);
+        assert(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute
+                filePathAbsolute,
+                importPathAbsolute: null
             },
             configMap: {
-                [configNameDefault]: {}
+                [configName]: {}
             },
             isConfigFile: false,
             isValueFile: true,
-            configNameDefault
+            configName
         };
         {
             // We don't have access to custom config definitions yet
-            //  - We load +someCustomConifg.js later
+            //  - We load +{configName}.js later
             //  - But we do need to eagerly load +meta.js (to get all the custom config definitions)
-            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configNameDefault);
+            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
             if (configDef?.env === 'config-only') {
-                await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+                await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
         {
@@ -137,14 +140,13 @@ function getConfigDefinition(configDefinitionsRelevant, configName, definedByFil
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-async function loadValueFile(interfaceValueFile, configNameDefault, userRootDir) {
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
-    assertDefaultExportUnknown(fileExports, getFilePathToShowToUser(interfaceValueFile.filePath));
-    Object.entries(fileExports).forEach(([configName, configValue]) => {
-        if (configName === 'default') {
-            configName = configNameDefault;
-        }
-        interfaceValueFile.configMap[configName] = { configValue };
+    const filePathToShowToUser = getFilePathToShowToUser(interfaceValueFile.filePath);
+    assertExportsOfValueFile(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
@@ -157,19 +159,19 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const interfaceFilePathToShowToUser = getFilePathToShowToUser(filePath);
-    assertDefaultExportObject(fileExports, interfaceFilePathToShowToUser);
+    const filePathToShowToUser = getFilePathToShowToUser(filePath);
+    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
     Object.entries(fileExports.default).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
     });
     return interfaceFile;
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, isDev, extensions);
+        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev, extensions);
     }
     catch (err_) {
         hasError = true;
@@ -197,8 +199,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
-                    onPrerenderStart: null,
-                    onBeforeRoute: null
+                    configValueSources: {}
                 },
                 globalVikeConfig: {}
             };
@@ -206,8 +207,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
         }
     }
 }
-async function loadVikeConfig(userRootDir, isDev, extensions) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, isDev, extensions);
+async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
     const { globalVikeConfig, pageConfigGlobal } = getGlobalConfigs(interfaceFilesByLocationId, userRootDir);
     const pageConfigs = await Promise.all(Object.entries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
@@ -218,18 +219,18 @@ async function loadVikeConfig(userRootDir, isDev, extensions) {
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
                 return;
-            const { configNameDefault } = interfaceFile;
-            if (isGlobalConfig(configNameDefault))
+            const { configName } = interfaceFile;
+            if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configNameDefault, getFilePathToShowToUser(interfaceFile.filePath));
+            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, getFilePathToShowToUser(interfaceFile.filePath));
             if (configDef.env !== 'config-only')
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
                 return;
             // Value files for built-in confg-only configs should have already been loaded at loadInterfaceFiles()
-            assert(!(configNameDefault in configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+            assert(!(configName in configDefinitionsBuiltIn));
+            await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
         objectEntries(configDefinitionsRelevant)
@@ -241,17 +242,17 @@ async function loadVikeConfig(userRootDir, isDev, extensions) {
             configValueSources[configName] = sources;
         });
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
+        applyEffectsAll(configValueSources, configDefinitionsRelevant);
+        const configValuesComputed = getComputed(configValueSources, configDefinitionsRelevant);
+        const configValues = getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
             configValueSources,
-            configValues: getConfigValues(configValueSources, configDefinitionsRelevant)
+            configValuesComputed,
+            configValues
         };
-        applyEffects(pageConfig, configDefinitionsRelevant);
-        pageConfig.configValues = getConfigValues(configValueSources, configDefinitionsRelevant);
-        applyComputed(pageConfig, configDefinitionsRelevant);
-        pageConfig.configValues = getConfigValues(configValueSources, configDefinitionsRelevant);
         return pageConfig;
     }));
     // Show error message upon unknown config
@@ -323,24 +324,24 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
-        onBeforeRoute: null,
-        onPrerenderStart: null
+        configValueSources: {}
     };
     objectEntries(configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
         const configValueSource = sources?.[0];
         if (!configValueSource)
             return;
-        if (arrayIncludes(objectKeys(pageConfigGlobal), configName)) {
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
             assert(!('value' in configValueSource));
-            pageConfigGlobal[configName] = configValueSource;
+            pageConfigGlobal.configValueSources[configName] = [configValueSource];
         }
         else {
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            assert(!configValueSource.isComputed);
-            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${configValueSource.definedAtInfo.filePath} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
+            const sourceFilePath = getDefinedAtFilePathToShowToUser(configValueSource.definedAtInfo);
+            assert(sourceFilePath);
+            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${sourceFilePath} 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;
         }
     });
@@ -365,8 +366,8 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
         {
             const interfaceValueFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isValueFile &&
-                // We consider side-effect exports (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
-                interfaceFile.configNameDefault === configName)
+                // We consider side-effect configs (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
+                interfaceFile.configName === configName)
                 .sort(makeOrderDeterministic);
             const interfaceConfigFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isConfigFile &&
@@ -376,9 +377,9 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             const interfaceValueFile = interfaceValueFiles[0];
             const interfaceConfigFile = interfaceConfigFiles[0];
             // Make this value:
-            //   /pages/some-page/+someConfig.js > `export default`
+            //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
-            //   /pages/some-page/+config > `export default { someConfig }`
+            //   /pages/some-page/+config.h.js > `export default { someConfig }`
             const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
             if (interfaceFileWinner) {
                 const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
@@ -392,8 +393,8 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
         // Side-effect configs such as `export { frontmatter }` in .mdx files
         interfaceFilesDefiningConfig
             .filter((interfaceFile) => interfaceFile.isValueFile &&
-            // Is side-effect export
-            interfaceFile.configNameDefault !== configName)
+            // Is side-effect config
+            interfaceFile.configName !== configName)
             .forEach((interfaceValueFileSideEffect) => {
             add(interfaceValueFileSideEffect);
         });
@@ -423,66 +424,57 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assertWarning(false, `${getConfigDefinedAtString(configName, configValueSourceLoser, true)} overriden by another ${getConfigDefinedAtString(configName, configValueSourceWinner, false)}, remove one of the two`, { onlyOnce: false });
+        assertWarning(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
-    // TODO: rethink file paths of ConfigElement
-    const configFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
     const conf = interfaceFile.configMap[configName];
     assert(conf);
     const configEnv = configDef.env;
-    const definedAtInfoConfigFile = {
-        filePath: configFilePath,
+    const definedAtConfigFile = {
+        ...interfaceFile.filePath,
         fileExportPath: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
-        let filePath;
+        let definedAtInfo;
+        let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
-            const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
+            const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
             assertUsage(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.importFilePath;
+            valueFilePath = import_.filePathRelativeToUserRootDir ?? import_.importPathAbsolute;
+            definedAtInfo = import_;
         }
         else {
             assert(interfaceFile.isValueFile);
-            filePath =
-                interfaceFile.filePath.filePathRelativeToUserRootDir ??
-                    // Experimental: is this needed? Would it work?
-                    interfaceFile.filePath.filePathAbsolute;
+            valueFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir;
+            definedAtInfo = {
+                ...interfaceFile.filePath,
+                fileExportPath: []
+            };
         }
         const configValueSource = {
-            value: filePath,
+            value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            isComputed: false,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: []
-            }
+            definedAtInfo
         };
         return configValueSource;
     }
     if (interfaceFile.isConfigFile) {
         assert('configValue' in conf);
         const { configValue } = conf;
-        const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
+        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
-            const { importFilePath, importFileExportName } = import_;
-            assertCodeFileEnv(importFilePath, configEnv, configName);
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                isComputed: false,
-                definedAtInfo: {
-                    filePath: importFilePath,
-                    fileExportPath: [importFileExportName]
-                }
+                definedAtInfo: import_
             };
             return configValueSource;
         }
@@ -491,24 +483,22 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 value: configValue,
                 configEnv,
                 valueIsImportedAtRuntime: false,
-                isComputed: false,
-                definedAtInfo: definedAtInfoConfigFile
+                definedAtInfo: definedAtConfigFile
             };
             return configValueSource;
         }
     }
     else if (interfaceFile.isValueFile) {
-        // TODO: rethink file paths of ConfigElement
-        const importFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
-        const importFileExportName = configName === interfaceFile.configNameDefault ? 'default' : configName;
         const valueAlreadyLoaded = 'configValue' in conf;
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            isComputed: false,
             definedAtInfo: {
-                filePath: importFilePath,
-                fileExportPath: [importFileExportName]
+                ...interfaceFile.filePath,
+                fileExportPath: configName === interfaceFile.configName
+                    ? []
+                    : // Side-effect config (e.g. `export { frontmatter }` of .md files)
+                        [configName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -521,16 +511,17 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     assert(false);
 }
-function assertCodeFileEnv(importFilePath, configEnv, configName) {
-    if (!codeFilesEnv.has(importFilePath)) {
-        codeFilesEnv.set(importFilePath, []);
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    assertPosixPath(filePathForEnvCheck);
+    if (!filesEnv.has(filePathForEnvCheck)) {
+        filesEnv.set(filePathForEnvCheck, []);
     }
-    const codeFileEnv = codeFilesEnv.get(importFilePath);
-    codeFileEnv.push({ configEnv, configName });
-    const configDifferentEnv = codeFileEnv.filter((c) => c.configEnv !== configEnv)[0];
+    const fileEnv = filesEnv.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => c.configEnv !== configEnv)[0];
     if (configDifferentEnv) {
         assertUsage(false, [
-            `${importFilePath} defines the value of configs living in different environments:`,
+            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
             ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(c.configEnv)}`),
             'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file/import-from-same-file'
         ].join('\n'));
@@ -548,53 +539,65 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getImport(configValue, configFilePath, userRootDir) {
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
         return null;
     const importData = parseImportData(configValue);
     if (!importData)
         return null;
-    let { importFilePath, importFileExportName } = importData;
-    if (importFilePath.startsWith('.')) {
+    const { importPath, exportName } = importData;
+    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
+    const fileExportPath = exportName === 'default' || exportName === configName ? [] : [exportName];
+    if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
-        importFilePath = resolveRelativeCodeFilePath(importData, configFilePath, userRootDir);
+        assertImportPath(filePathAbsolute, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
     }
     else {
-        // importFilePath can be:
+        // importPath can be:
         //  - an npm package import
         //  - a path alias
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir: null,
+            importPathAbsolute: importPath
+        };
     }
-    return {
-        importFilePath,
-        importFileExportName
-    };
 }
-function resolveRelativeCodeFilePath(importData, configFilePath, userRootDir) {
-    let importFilePath = resolveImport(importData, configFilePath);
-    // Make it a Vite path
+function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
-    assertPosixPath(importFilePath);
-    if (importFilePath.startsWith(userRootDir)) {
-        importFilePath = getVitePathFromAbsolutePath(importFilePath, userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
     }
     else {
-        assertUsage(false, `${getFilePathToShowToUser(configFilePath)} imports from a relative path ${pc.cyan(importData.importFilePath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        assertUsage(false, `${getFilePathToShowToUser(configFilePath)} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
         // None of the following works. Seems to be a Vite bug?
         // /*
-        // assert(importFilePath.startsWith('/'))
-        // importFilePath = `/@fs${importFilePath}`
+        // assert(filePathAbsolute.startsWith('/'))
+        // filePath = `/@fs${filePathAbsolute}`
         // /*/
-        // importFilePath = path.posix.relative(userRootDir, importFilePath)
-        // assert(importFilePath.startsWith('../'))
-        // importFilePath = '/' + importFilePath
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
     }
-    assertPosixPath(importFilePath);
-    assert(importFilePath.startsWith('/'));
-    return importFilePath;
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
 }
 function getVitePathFromAbsolutePath(filePathAbsolute, root) {
     assertPosixPath(filePathAbsolute);
@@ -655,34 +658,36 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffects(pageConfig, configDefinitionsRelevant) {
+function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
     objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
         if (!configDef.effect)
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
         // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
-        assertWarning(configDef.env === 'config-only', [
-            `Adding an effect to ${pc.cyan(configName)} may not work as expected because ${pc.cyan(configName)} has an ${pc.cyan('env')} that is different than ${pc.cyan('config-only')} (its env is ${pc.cyan(configDef.env)}).`,
-            'Reach out to a maintainer if you want to use this in production.'
-        ].join(' '), { onlyOnce: true });
-        const configValue = pageConfig.configValueSources[configName]?.[0];
-        if (!configValue)
+        assertUsage(configDef.env === 'config-only', [
+            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(configDef.env)}: effects can only be added to configs with an env that is ${pc.cyan('config-only')}.`
+        ].join(' '));
+        const source = configValueSources[configName]?.[0];
+        if (!source)
             return;
+        // The config value is eagerly loaded since `configDef.env === 'config-only``
+        assert('value' in source);
+        // Call effect
         const configModFromEffect = configDef.effect({
-            configValue: configValue.value,
-            configDefinedAt: getConfigDefinedAtString(configName, configValue, true)
+            configValue: source.value,
+            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
         });
         if (!configModFromEffect)
             return;
-        assert(hasProp(configValue, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, configValue, pageConfig.configValueSources);
+        assert(hasProp(source, 'value')); // We need to assume that the config value is loaded at build-time
+        applyEffect(configModFromEffect, source, configValueSources);
     });
 }
 function applyEffect(configModFromEffect, configValueEffectSource, configValueSources) {
-    const notSupported = `config.meta[configName].effect currently only supports modifying the the ${pc.cyan('env')} of a config. Reach out to a maintainer if you need more capabilities.`;
+    const notSupported = `Effects currently only supports modifying the the ${pc.cyan('env')} of a config.`;
     objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            assertMetaValue(configValue, getConfigDefinedAtString(configName, configValueEffectSource, true, 'effect'));
+            assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -692,6 +697,7 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
                 const envOverriden = configTargetDef.env;
                 const sources = configValueSources[configTargetName];
                 sources?.forEach((configValueSource) => {
+                    // Apply effect
                     configValueSource.configEnv = envOverriden;
                 });
             });
@@ -703,30 +709,29 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
         }
     });
 }
-function applyComputed(pageConfig, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitionsRelevant) {
+    const configValuesComputed = {};
     objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
-        var _a;
-        const computed = configDef._computed;
-        if (!computed)
+        if (!configDef._computed)
             return;
-        const value = computed(pageConfig);
+        const value = configDef._computed(configValueSources);
         if (value === undefined)
             return;
-        const configValueSource = {
+        configValuesComputed[configName] = {
             value,
-            configEnv: configDef.env,
-            definedAtInfo: null,
-            isComputed: true,
-            valueIsImportedAtRuntime: false
+            configEnv: configDef.env
         };
-        (_a = pageConfig.configValueSources)[configName] ?? (_a[configName] = []);
-        // Computed values are inserted last: they have the least priority (i.e. computed can be overriden)
-        pageConfig.configValueSources[configName].push(configValueSource);
     });
+    return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, isDev, extensions) {
+async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
     const timeBase = new Date().getTime();
     assertPosixPath(userRootDir);
+    const ignorePatterns = [];
+    for (const dir of ignoreDirs) {
+        assertPosixPath(dir);
+        ignorePatterns.push(`${path.posix.relative(userRootDir, dir)}/**`);
+    }
     const result = await glob(`**/+*.${scriptFileExtensions}`, {
         ignore: [
             '**/node_modules/**',
@@ -735,7 +740,8 @@ async function findPlusFiles(userRootDir, isDev, extensions) {
             // +Page.js
             // +Page.telefunc.js
             // ```
-            '**/*.telefunc.*'
+            '**/*.telefunc.*',
+            ...ignorePatterns
         ],
         cwd: userRootDir,
         dot: false
@@ -743,7 +749,7 @@ async function findPlusFiles(userRootDir, isDev, extensions) {
     const time = new Date().getTime() - timeBase;
     if (isDev) {
         // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-        assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on vike's GitHub.`, {
+        assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
             onlyOnce: 'slow-page-files-search'
         });
     }
@@ -793,7 +799,7 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     assertUsage(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = configFilePath;
+    const { filePathAbsolute } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsolute);
     const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
@@ -802,10 +808,7 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     ]);
     const configFile = {
         fileExports,
-        filePath: {
-            filePathRelativeToUserRootDir,
-            filePathAbsolute
-        },
+        filePath: configFilePath,
         extendsFilePaths
     };
     return { configFile, extendsConfigs };
@@ -822,16 +825,20 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
-        const { importFilePath: importPath } = importData;
+        const { importPath: importPath } = importData;
         // TODO
         //  - validate extends configs
-        const filePathAbsolute = resolveImport(importData, configFilePath);
+        const filePathAbsolute = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsolute, importData, configFilePath);
         assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
         extendsConfigFiles.push({
             filePathAbsolute,
-            // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-            // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-            filePathRelativeToUserRootDir: determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir)
+            // TODO: fix type cast
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: importPath
         });
     });
     const extendsConfigs = [];
@@ -871,7 +878,7 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const filePathToShowToUser = getFilePathToShowToUser(configFilePath);
-    assertDefaultExportObject(configFileExports, filePathToShowToUser);
+    assertExportsOfConfigFile(configFileExports, filePathToShowToUser);
     const defaultExports = configFileExports.default;
     const wrongUsage = `${filePathToShowToUser} sets the config 'extends' to an invalid value, see https://vike.dev/extends`;
     let extendList;
@@ -969,7 +976,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     const configFilesystemRoutingRoot = configValueSources[configName]?.[0];
     let filesystemRouteString = getFilesystemRouteString(locationId);
     if (determineIsErrorPage(filesystemRouteString)) {
-        return { isErrorPage: true, routeFilesystem: null };
+        return { isErrorPage: true, routeFilesystem: undefined };
     }
     let filesystemRouteDefinedBy = getFilesystemRouteDefinedBy(locationId); // for log404()
     if (configFilesystemRoutingRoot) {
@@ -987,18 +994,19 @@ function determineRouteFilesystem(locationId, configValueSources) {
         routeString: filesystemRouteString,
         definedBy: filesystemRouteDefinedBy
     };
-    return { routeFilesystem, isErrorPage: false };
+    return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     assert(configFilesystemRoutingRoot.configEnv === 'config-only');
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigDefinedAtString(configName, configFilesystemRoutingRoot, false);
+    const configDefinedAt = getConfigSourceDefinedAtString(configName, configFilesystemRoutingRoot);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    assert(!configFilesystemRoutingRoot.isComputed);
-    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePath));
+    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAtInfo;
+    assert(filePathRelativeToUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1007,22 +1015,22 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImport(importData, importerFilePath) {
-    const { filePathAbsolute } = importerFilePath;
-    assertPosixPath(filePathAbsolute);
-    const plusConfigFilDirPathAbsolute = path.posix.dirname(filePathAbsolute);
-    const importedFile = resolve(importData.importFilePath, plusConfigFilDirPathAbsolute);
-    assertImport(importedFile, importData, importerFilePath);
-    return importedFile;
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    assertPosixPath(importerFilePathAbsolute);
+    const cwd = path.posix.dirname(importerFilePathAbsolute);
+    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsolute = requireResolve(importData.importPath, cwd);
+    return filePathAbsolute;
 }
-function assertImport(importedFile, importData, importerFilePath) {
-    const { importFilePath: importPath, importWasGenerated, importDataString } = importData;
+function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
     const filePathToShowToUser = getFilePathToShowToUser(importerFilePath);
-    if (!importedFile) {
+    if (!filePathAbsolute) {
         const importPathString = pc.cyan(`'${importPath}'`);
-        const errIntro = importWasGenerated
+        const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importDataString)} defined in ${filePathToShowToUser}`;
+            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
             assertUsage(false, `${errIntro2} point to an existing file?`);
@@ -1035,18 +1043,23 @@ function assertImport(importedFile, importData, importerFilePath) {
 function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
-function getConfigValues(configValueSources, configDefinitionsRelevant) {
+function getConfigValues(configValueSources, configValuesComputed, configDefinitionsRelevant) {
     const configValues = {};
+    Object.entries(configValuesComputed).forEach(([configName, configValueComputed]) => {
+        configValues[configName] = {
+            value: configValueComputed.value,
+            definedAt: { isComputed: true }
+        };
+    });
     Object.entries(configValueSources).forEach(([configName, sources]) => {
         const configDef = configDefinitionsRelevant[configName];
         assert(configDef);
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
-                const { value, definedAtInfo } = configValueSource;
                 configValues[configName] = {
-                    value,
-                    definedAtInfo
+                    value: configValueSource.value,
+                    definedAt: getDefinedAt(configValueSource)
                 };
             }
         }
@@ -1054,7 +1067,10 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
             const value = mergeCumulative(configName, sources);
             configValues[configName] = {
                 value,
-                definedAtInfo: null
+                definedAt: {
+                    isCumulative: true,
+                    files: sources.map((source) => getDefinedAtFile(source))
+                }
             };
         }
     });
@@ -1065,8 +1081,7 @@ function mergeCumulative(configName, configValueSources) {
     const valuesSet = [];
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
-        assert(!configValueSource.isComputed);
-        const configDefinedAt = getConfigDefinedAtString(configName, configValueSource, true);
+        const configDefinedAt = getConfigSourceDefinedAtString(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.)`);
@@ -1074,7 +1089,7 @@ function mergeCumulative(configName, configValueSources) {
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
         // Make sure configValueSource.value is serializable
-        getConfigValueSerialized(configValueSource.value, configName, configValueSource.definedAtInfo);
+        getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1084,7 +1099,7 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigDefinedAtString(configName, configValueSourcePrevious, false);
+            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, false);
             assertUsage(false, `${configDefinedAt} sets ${t1} but another ${configPreviousDefinedAt} sets ${t2} which is forbidden: the values must be all arrays or all sets (you cannot mix).`);
         };
         const { value } = configValueSource;
@@ -1115,3 +1130,30 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
+// TODO: rename
+// TODO: refactor
+function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect = undefined, sentenceBegin = true) {
+    return getConfigDefinedAtString(configName, {
+        definedAt: {
+            isEffect,
+            file: {
+                filePathToShowToUser: getDefinedAtFilePathToShowToUser(definedAtInfo),
+                fileExportPath: definedAtInfo.fileExportPath
+            }
+        }
+    }, sentenceBegin);
+}
+function getDefinedAtFilePathToShowToUser(definedAtInfo) {
+    return definedAtInfo.filePathRelativeToUserRootDir ?? definedAtInfo.importPathAbsolute;
+}
+function getDefinedAtFile(source) {
+    return {
+        filePathToShowToUser: getDefinedAtFilePathToShowToUser(source.definedAtInfo),
+        fileExportPath: source.definedAtInfo.fileExportPath
+    };
+}
+function getDefinedAt(configValueSource) {
+    return {
+        file: getDefinedAtFile(configValueSource)
+    };
+}