vike 0.4.143-commit-fa295e1 → 0.4.144-commit-e40e9b1

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.143-commit-fa295e1';
+const PROJECT_VERSION = '0.4.144-commit-e40e9b1';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/cjs/utils/warnIfErrorIsNotObject.js

@@ -12,7 +12,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 // It would be cleaner to:
 //  - Call assertUsageErrorIsObject() right after calling the user's hook
 //    - Attach the original error: assertUsageError.originalErrorValue = err
-//      - Show the original error in vike's error handling
+//      - Show the original error in Vike's error handling
 //  - Use assertErrorIsObject() throughout Vike's source code
 function warnIfErrorIsNotObject(err) {
     if (!(0, isObject_js_1.isObject)(err)) {

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

@@ -320,7 +320,7 @@ function onBrowserHistoryNavigation(callback) {
         if (isHashNavigation) {
             // - `history.state` is uninitialized (`null`) when:
             //   - The vike app runs `window.location.hash = '#section'`.
-            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because vike's `onLinkClick()` handler skips hash links.)
+            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because Vike's `onLinkClick()` handler skips hash links.)
             // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
             // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
             //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)

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

@@ -1,7 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
+import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs, } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/utils.js';
@@ -69,7 +69,7 @@ function buildConfig() {
 async function getEntries(config) {
     const configVike = await getConfigVike(config);
     const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
-    const { pageConfigs } = await getVikeConfig(config.root, false, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, false, configVike.extensions);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const serverEntries = analyzeServerEntries(pageConfigs);

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

@@ -1,6 +1,6 @@
 export { resolveVikeConfig };
 import { assertVikeConfig } from './assertVikeConfig.js';
-import { isDev2 } from '../../utils.js';
+import { getOutDirs, isDev2 } from '../../utils.js';
 import { findConfigVikeFromStemPackages } from './findConfigVikeFromStemPackages.js';
 import { pickFirst } from './pickFirst.js';
 import { resolveExtensions } from './resolveExtensions.js';
@@ -24,7 +24,7 @@ async function resolveConfig(vikeConfig, config) {
     const fromStemPackages = await findConfigVikeFromStemPackages(config.root);
     const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
     const extensions = resolveExtensions(configs, config);
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, isDev2(config), extensions);
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev2(config), extensions);
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

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

@@ -1,12 +1,12 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
+import { assert, getFilePathAbsolute, getOutDirs, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSourcesRelevant.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 async function determineOptimizeDeps(config, configVike, isDev) {
-    const { pageConfigs } = await getVikeConfig(config.root, isDev, configVike.extensions);
+    const { pageConfigs } = await getVikeConfig(config.root, getOutDirs(config).outDirRoot, isDev, configVike.extensions);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
     {
         // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
@@ -22,7 +22,7 @@ async function determineOptimizeDeps(config, configVike, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    console.log('config.optimizeDeps', config.optimizeDeps);
+    // console.log('config.optimizeDeps', { entries: config.optimizeDeps.entries, include: config.optimizeDeps.include })
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -34,15 +34,13 @@ async function getPageDeps(config, pageConfigs, isDev) {
             configValueSourcesRelevant.forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                if (configValueSource.isComputed)
-                    return;
                 const { definedAtInfo, configEnv } = configValueSource;
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
                 if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
                     const { filePathAbsolute } = definedAtInfo;
                     assert(filePathAbsolute);
-                    // Surpsingly Vite expects entries to be absolute paths
+                    // Surprisingly Vite expects entries to be absolute paths
                     entries.push(filePathAbsolute);
                 }
                 else {

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,5 +1,5 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob } from '../../utils.js';
+import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob, getOutDirs } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
@@ -140,7 +140,7 @@ export const pageFilesList = [];
 export const neverLoaded = {};
 export const isGeneratedFile = true;
 
-${await getVirtualFilePageConfigs(config.root, isForClientSide, isDev, id, configVike, isClientRouting)}
+${await getVirtualFilePageConfigs(config.root, getOutDirs(config).outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting)}
 
 `;
     fileTypes
@@ -204,10 +204,12 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ...globRoots.map((globRoot, i) => {
             const varNameLocal = `${varName}${i + 1}`;
             varNameLocals.push(varNameLocal);
-            const globPath = `'${getGlobPath(globRoot, fileType)}'`;
+            const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
+            const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
             const globOptions = JSON.stringify({ eager: isEager, as: query });
             assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPath}, ${globOptions});`;
+            const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -216,19 +218,26 @@ function getGlobs(globRoots, isBuild, fileType, query) {
     ].join('\n');
 }
 function getGlobRoots(config, configVike) {
-    const globRoots = ['/'];
+    const globRoots = [
+        {
+            includeDir: '/',
+            excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
+        }
+    ];
     configVike.extensions
         .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
         .filter(isNotNullish)
         .forEach((pageConfigsSrcDir) => {
-        const globRoot = path.posix.relative(config.root, pageConfigsSrcDir);
+        const globRoot = {
+            includeDir: path.posix.relative(config.root, pageConfigsSrcDir)
+        };
         globRoots.push(globRoot);
     });
     return globRoots;
 }
-function getGlobPath(globRoot, fileType) {
-    assertPosixPath(globRoot);
-    let globPath = [...globRoot.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
+function getGlobPath(globRootDir, fileType) {
+    assertPosixPath(globRootDir);
+    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
     if (!globPath.startsWith('/')) {
         globPath = '/' + globPath;
     }

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

@@ -3,7 +3,7 @@ import { normalizePath } from 'vite';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
@@ -47,7 +47,7 @@ function importUserCode() {
                 return undefined;
             id = getVirtualFileId(id);
             if (isVirtualFileIdPageConfigValuesAll(id)) {
-                const code = await getVirtualFilePageConfigValuesAll(id, config.root, isDev, configVike);
+                const code = await getVirtualFilePageConfigValuesAll(id, config.root, getOutDirs(config).outDirRoot, isDev, configVike);
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
@@ -120,7 +120,7 @@ function reloadConfig(filePath, config, configVike, op) {
         const msg = `${op} ${filePathToShowToUser}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config.root, configVike.extensions);
+    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot, configVike.extensions);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -4,7 +4,7 @@ export type { ConfigDefinition };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, PageConfigBuildTime } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources } from '../../../../../../shared/page-configs/PageConfig.js';
 import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
 /** The meta definition of a config.
  *
@@ -44,7 +44,7 @@ type ConfigEffect = (config: {
 }) => Config | undefined;
 /** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
-    _computed?: (pageConfig: PageConfigBuildTime) => unknown;
+    _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
     env: ConfigEnvInternal;
 };

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

@@ -67,13 +67,13 @@ const configDefinitionsBuiltIn = {
     },
     isClientSideRenderable: {
         env: 'server-and-client',
-        _computed: (pageConfig) => isConfigSet(pageConfig, 'onRenderClient') &&
-            isConfigSet(pageConfig, 'Page') &&
-            getConfigEnv(pageConfig, 'Page') !== 'server-only'
+        _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
+            isConfigSet(configValueSources, 'Page') &&
+            getConfigEnv(configValueSources, 'Page') !== 'server-only'
     },
     onBeforeRenderEnv: {
         env: 'client-only',
-        _computed: (pageConfig) => !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender')
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 const configDefinitionsBuiltInGlobal = {

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

@@ -10,6 +10,6 @@ type VikeConfig = {
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;
-declare function reloadVikeConfig(userRootDir: string, extensions: ExtensionResolved[]): void;
-declare function getVikeConfig(userRootDir: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function reloadVikeConfig(userRootDir: string, outDirRoot: string, extensions: ExtensionResolved[]): void;
+declare function getVikeConfig(userRootDir: string, outDirRoot: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
 declare function isVikeConfigFile(filePath: string): boolean;

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

@@ -24,10 +24,10 @@ let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 const filesEnv = new Map();
-function reloadVikeConfig(userRootDir, extensions) {
+function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
     vikeConfigDependencies.clear();
     filesEnv.clear();
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, extensions, true);
+    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
@@ -61,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) => {
@@ -166,12 +166,12 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     });
     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;
@@ -207,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))
@@ -242,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
@@ -339,10 +339,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            assert(!configValueSource.isComputed);
-            const sourceFilePath = getFilePathToShowToUser2(configValueSource.definedAtInfo);
+            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 });
+            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;
         }
     });
@@ -367,7 +366,7 @@ 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)
+                // 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
@@ -394,7 +393,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
         // Side-effect configs such as `export { frontmatter }` in .mdx files
         interfaceFilesDefiningConfig
             .filter((interfaceFile) => interfaceFile.isValueFile &&
-            // Is side-effect export
+            // Is side-effect config
             interfaceFile.configName !== configName)
             .forEach((interfaceValueFileSideEffect) => {
             add(interfaceValueFileSideEffect);
@@ -425,8 +424,6 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assert(!configValueSourceLoser.isComputed);
-        assert(!configValueSourceWinner.isComputed);
         assertWarning(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
     });
 }
@@ -465,7 +462,6 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            isComputed: false,
             definedAtInfo
         };
         return configValueSource;
@@ -478,7 +474,6 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                isComputed: false,
                 definedAtInfo: import_
             };
             return configValueSource;
@@ -488,22 +483,22 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 value: configValue,
                 configEnv,
                 valueIsImportedAtRuntime: false,
-                isComputed: false,
                 definedAtInfo: definedAtConfigFile
             };
             return configValueSource;
         }
     }
     else if (interfaceFile.isValueFile) {
-        // TODO: rethink file paths of ConfigElement
         const valueAlreadyLoaded = 'configValue' in conf;
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            isComputed: false,
             definedAtInfo: {
                 ...interfaceFile.filePath,
-                fileExportPath: configName === interfaceFile.configName ? [] : [configName]
+                fileExportPath: configName === interfaceFile.configName
+                    ? []
+                    : // Side-effect config (e.g. `export { frontmatter }` of .md files)
+                        [configName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -663,20 +658,21 @@ 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 source = pageConfig.configValueSources[configName]?.[0];
+        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;
-        assert(!source.isComputed);
+        // The config value is eagerly loaded since `configDef.env === 'config-only``
+        assert('value' in source);
+        // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
             configDefinedAt: getConfigSourceDefinedAtString(configName, source)
@@ -684,14 +680,13 @@ function applyEffects(pageConfig, configDefinitionsRelevant) {
         if (!configModFromEffect)
             return;
         assert(hasProp(source, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, source, pageConfig.configValueSources);
+        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') {
-            assert(!configValueEffectSource.isComputed);
             assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
@@ -702,6 +697,7 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
                 const envOverriden = configTargetDef.env;
                 const sources = configValueSources[configTargetName];
                 sources?.forEach((configValueSource) => {
+                    // Apply effect
                     configValueSource.configEnv = envOverriden;
                 });
             });
@@ -713,29 +709,29 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
         }
     });
 }
-function applyComputed(pageConfig, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitionsRelevant) {
+    const configValuesComputed = {};
     objectEntries(configDefinitionsRelevant).forEach(([configName, configDef]) => {
-        var _a;
         if (!configDef._computed)
             return;
-        const value = configDef._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/**',
@@ -744,7 +740,8 @@ async function findPlusFiles(userRootDir, isDev, extensions) {
             // +Page.js
             // +Page.telefunc.js
             // ```
-            '**/*.telefunc.*'
+            '**/*.telefunc.*',
+            ...ignorePatterns
         ],
         cwd: userRootDir,
         dot: false
@@ -752,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'
         });
     }
@@ -1004,13 +1001,12 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    assert(!configFilesystemRoutingRoot.isComputed);
     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);
-    assert(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir);
-    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir));
+    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAtInfo;
+    assert(filePathRelativeToUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1047,19 +1043,23 @@ function assertImportPath(filePathAbsolute, 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 } = configValueSource;
-                const definedAt = configValueSource.isComputed ? { isComputed: true } : getDefinedAt(configValueSource);
                 configValues[configName] = {
-                    value,
-                    definedAt
+                    value: configValueSource.value,
+                    definedAt: getDefinedAt(configValueSource)
                 };
             }
         }
@@ -1069,7 +1069,7 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
                 value,
                 definedAt: {
                     isCumulative: true,
-                    sources: sources.map((source) => getSourceDefinedAt(source))
+                    files: sources.map((source) => getDefinedAtFile(source))
                 }
             };
         }
@@ -1081,7 +1081,6 @@ function mergeCumulative(configName, configValueSources) {
     const valuesSet = [];
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
-        assert(!configValueSource.isComputed);
         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
@@ -1100,8 +1099,7 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            assert(!configValueSourcePrevious.isComputed);
-            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, true);
+            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;
@@ -1138,40 +1136,24 @@ function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect
     return getConfigDefinedAtString(configName, {
         definedAt: {
             isEffect,
-            source: {
-                filePathToShowToUser: getFilePathToShowToUser2(definedAtInfo),
+            file: {
+                filePathToShowToUser: getDefinedAtFilePathToShowToUser(definedAtInfo),
                 fileExportPath: definedAtInfo.fileExportPath
             }
         }
     }, sentenceBegin);
 }
-// TODO: rename
-function getFilePathToShowToUser2(definedAtInfo) {
+function getDefinedAtFilePathToShowToUser(definedAtInfo) {
     return definedAtInfo.filePathRelativeToUserRootDir ?? definedAtInfo.importPathAbsolute;
-    /*
-    if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-      return definedAtInfo.filePathRelativeToUserRootDir
-    }
-    if (definedAtInfo.importPathAbsolute !== null) {
-      return definedAtInfo.importPathAbsolute
-    } else {
-      const filePathToShowToUser = definedAtInfo.filePathAbsolute
-      // TypeScript failes to infer that definedAtInfo.filePathAbsolute cannot be null
-      assert(filePathToShowToUser)
-      return filePathToShowToUser
-    }
-    */
 }
-// TODO: rename
-function getSourceDefinedAt(source) {
-    assert(!source.isComputed);
+function getDefinedAtFile(source) {
     return {
-        filePathToShowToUser: getFilePathToShowToUser2(source.definedAtInfo),
+        filePathToShowToUser: getDefinedAtFilePathToShowToUser(source.definedAtInfo),
         fileExportPath: source.definedAtInfo.fileExportPath
     };
 }
 function getDefinedAt(configValueSource) {
     return {
-        source: getSourceDefinedAt(configValueSource)
+        file: getDefinedAtFile(configValueSource)
     };
 }