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

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

@@ -73,7 +73,7 @@ exports.buildConfig = buildConfig;
 async function getEntries(config) {
     const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
     const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
-    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, false, configVike.extensions);
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, false, configVike.extensions);
     (0, utils_js_1.assertUsage)(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if ((0, utils_js_1.viteIsSSR)(config)) {
         const serverEntries = analyzeServerEntries(pageConfigs);

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

@@ -30,7 +30,7 @@ async function resolveConfig(vikeConfig, config) {
     const fromStemPackages = await (0, findConfigVikeFromStemPackages_js_1.findConfigVikeFromStemPackages)(config.root);
     const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
     const extensions = (0, resolveExtensions_js_1.resolveExtensions)(configs, config);
-    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, (0, utils_js_1.isDev2)(config), extensions);
+    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, (0, utils_js_1.isDev2)(config), extensions);
     configs.push(fromPlusConfigFile);
     (0, assertVikeConfig_js_1.assertVikeConfig)(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

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

@@ -8,7 +8,7 @@ const getConfigValueSourcesRelevant_js_1 = require("../../shared/getConfigValueS
 const buildConfig_js_1 = require("../buildConfig.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
 async function determineOptimizeDeps(config, configVike, isDev) {
-    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, isDev, configVike.extensions);
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config.root, (0, utils_js_1.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.
@@ -24,7 +24,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 })
 }
 exports.determineOptimizeDeps = determineOptimizeDeps;
 async function getPageDeps(config, pageConfigs, isDev) {
@@ -37,15 +37,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;
                     (0, utils_js_1.assert)(filePathAbsolute);
-                    // Surpsingly Vite expects entries to be absolute paths
+                    // Surprisingly Vite expects entries to be absolute paths
                     entries.push(filePathAbsolute);
                 }
                 else {

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

@@ -146,7 +146,7 @@ export const pageFilesList = [];
 export const neverLoaded = {};
 export const isGeneratedFile = true;
 
-${await (0, getVirtualFilePageConfigs_js_1.getVirtualFilePageConfigs)(config.root, isForClientSide, isDev, id, configVike, isClientRouting)}
+${await (0, getVirtualFilePageConfigs_js_1.getVirtualFilePageConfigs)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting)}
 
 `;
     fileTypes_js_1.fileTypes
@@ -210,10 +210,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 });
             (0, utils_js_1.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(',')}};`,
@@ -222,19 +224,26 @@ function getGlobs(globRoots, isBuild, fileType, query) {
     ].join('\n');
 }
 function getGlobRoots(config, configVike) {
-    const globRoots = ['/'];
+    const globRoots = [
+        {
+            includeDir: '/',
+            excludeDir: path_1.default.posix.relative(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot)
+        }
+    ];
     configVike.extensions
         .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
         .filter(utils_js_1.isNotNullish)
         .forEach((pageConfigsSrcDir) => {
-        const globRoot = path_1.default.posix.relative(config.root, pageConfigsSrcDir);
+        const globRoot = {
+            includeDir: path_1.default.posix.relative(config.root, pageConfigsSrcDir)
+        };
         globRoots.push(globRoot);
     });
     return globRoots;
 }
-function getGlobPath(globRoot, fileType) {
-    (0, utils_js_1.assertPosixPath)(globRoot);
-    let globPath = [...globRoot.split('/'), '**', `*${fileType}.${utils_js_1.scriptFileExtensions}`].filter(Boolean).join('/');
+function getGlobPath(globRootDir, fileType) {
+    (0, utils_js_1.assertPosixPath)(globRootDir);
+    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${utils_js_1.scriptFileExtensions}`].filter(Boolean).join('/');
     if (!globPath.startsWith('/')) {
         globPath = '/' + globPath;
     }

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

@@ -52,7 +52,7 @@ function importUserCode() {
                 return undefined;
             id = (0, utils_js_1.getVirtualFileId)(id);
             if ((0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id)) {
-                const code = await (0, getVirtualFilePageConfigValuesAll_js_1.getVirtualFilePageConfigValuesAll)(id, config.root, isDev, configVike);
+                const code = await (0, getVirtualFilePageConfigValuesAll_js_1.getVirtualFilePageConfigValuesAll)(id, config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, isDev, configVike);
                 return code;
             }
             if ((0, virtualFileImportUserCode_js_1.isVirtualFileIdImportUserCode)(id)) {
@@ -126,7 +126,7 @@ function reloadConfig(filePath, config, configVike, op) {
         const msg = `${op} ${filePathToShowToUser}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }
-    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, configVike.extensions);
+    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot, configVike.extensions);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

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

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

@@ -27,10 +27,10 @@ let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
 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();
 }
 exports.reloadVikeConfig = reloadVikeConfig;
@@ -65,15 +65,15 @@ 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;
 }
 exports.getVikeConfig = getVikeConfig;
-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) => {
@@ -171,12 +171,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;
@@ -212,8 +212,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))
@@ -247,17 +247,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
@@ -344,10 +344,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             (0, utils_js_1.assert)('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            (0, utils_js_1.assert)(!configValueSource.isComputed);
-            const sourceFilePath = getFilePathToShowToUser2(configValueSource.definedAtInfo);
+            const sourceFilePath = getDefinedAtFilePathToShowToUser(configValueSource.definedAtInfo);
             (0, utils_js_1.assert)(sourceFilePath);
-            (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${sourceFilePath} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
+            (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${sourceFilePath} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
     });
@@ -372,7 +371,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
@@ -399,7 +398,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);
@@ -430,8 +429,6 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        (0, utils_js_1.assert)(!configValueSourceLoser.isComputed);
-        (0, utils_js_1.assert)(!configValueSourceWinner.isComputed);
         (0, utils_js_1.assertWarning)(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
     });
 }
@@ -470,7 +467,6 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            isComputed: false,
             definedAtInfo
         };
         return configValueSource;
@@ -483,7 +479,6 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                isComputed: false,
                 definedAtInfo: import_
             };
             return configValueSource;
@@ -493,22 +488,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) {
@@ -668,20 +663,21 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
         }
     });
 }
-function applyEffects(pageConfig, configDefinitionsRelevant) {
+function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
     (0, utils_js_1.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.)
-        (0, utils_js_1.assertWarning)(configDef.env === 'config-only', [
-            `Adding an effect to ${picocolors_1.default.cyan(configName)} may not work as expected because ${picocolors_1.default.cyan(configName)} has an ${picocolors_1.default.cyan('env')} that is different than ${picocolors_1.default.cyan('config-only')} (its env is ${picocolors_1.default.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];
+        (0, utils_js_1.assertUsage)(configDef.env === 'config-only', [
+            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(configDef.env)}: effects can only be added to configs with an env that is ${picocolors_1.default.cyan('config-only')}.`
+        ].join(' '));
+        const source = configValueSources[configName]?.[0];
         if (!source)
             return;
-        (0, utils_js_1.assert)(!source.isComputed);
+        // The config value is eagerly loaded since `configDef.env === 'config-only``
+        (0, utils_js_1.assert)('value' in source);
+        // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
             configDefinedAt: getConfigSourceDefinedAtString(configName, source)
@@ -689,14 +685,13 @@ function applyEffects(pageConfig, configDefinitionsRelevant) {
         if (!configModFromEffect)
             return;
         (0, utils_js_1.assert)((0, utils_js_1.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 ${picocolors_1.default.cyan('env')} of a config. Reach out to a maintainer if you need more capabilities.`;
+    const notSupported = `Effects currently only supports modifying the the ${picocolors_1.default.cyan('env')} of a config.`;
     (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            (0, utils_js_1.assert)(!configValueEffectSource.isComputed);
             assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
@@ -707,6 +702,7 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
                 const envOverriden = configTargetDef.env;
                 const sources = configValueSources[configTargetName];
                 sources?.forEach((configValueSource) => {
+                    // Apply effect
                     configValueSource.configEnv = envOverriden;
                 });
             });
@@ -718,29 +714,29 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
         }
     });
 }
-function applyComputed(pageConfig, configDefinitionsRelevant) {
+function getComputed(configValueSources, configDefinitionsRelevant) {
+    const configValuesComputed = {};
     (0, utils_js_1.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();
     (0, utils_js_1.assertPosixPath)(userRootDir);
+    const ignorePatterns = [];
+    for (const dir of ignoreDirs) {
+        (0, utils_js_1.assertPosixPath)(dir);
+        ignorePatterns.push(`${path_1.default.posix.relative(userRootDir, dir)}/**`);
+    }
     const result = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
         ignore: [
             '**/node_modules/**',
@@ -749,7 +745,8 @@ async function findPlusFiles(userRootDir, isDev, extensions) {
             // +Page.js
             // +Page.telefunc.js
             // ```
-            '**/*.telefunc.*'
+            '**/*.telefunc.*',
+            ...ignorePatterns
         ],
         cwd: userRootDir,
         dot: false
@@ -757,7 +754,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
-        (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on vike's GitHub.`, {
+        (0, utils_js_1.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'
         });
     }
@@ -1009,13 +1006,12 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    (0, utils_js_1.assert)(!configFilesystemRoutingRoot.isComputed);
     const configDefinedAt = getConfigSourceDefinedAtString(configName, configFilesystemRoutingRoot);
     (0, utils_js_1.assertUsage)(typeof value === 'string', `${configDefinedAt} should be a string`);
     (0, utils_js_1.assertUsage)(value.startsWith('/'), `${configDefinedAt} is ${picocolors_1.default.cyan(value)} but it should start with a leading slash ${picocolors_1.default.cyan('/')}`);
-    (0, utils_js_1.assert)(!configFilesystemRoutingRoot.isComputed);
-    (0, utils_js_1.assert)(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir);
-    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir));
+    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAtInfo;
+    (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
+    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1053,19 +1049,23 @@ function isVikeConfigFile(filePath) {
     return !!getConfigName(filePath);
 }
 exports.isVikeConfigFile = isVikeConfigFile;
-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];
         (0, utils_js_1.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)
                 };
             }
         }
@@ -1075,7 +1075,7 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
                 value,
                 definedAt: {
                     isCumulative: true,
-                    sources: sources.map((source) => getSourceDefinedAt(source))
+                    files: sources.map((source) => getDefinedAtFile(source))
                 }
             };
         }
@@ -1087,7 +1087,6 @@ function mergeCumulative(configName, configValueSources) {
     const valuesSet = [];
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
-        (0, utils_js_1.assert)(!configValueSource.isComputed);
         const configDefinedAt = getConfigSourceDefinedAtString(configName, configValueSource);
         const configNameColored = picocolors_1.default.cyan(configName);
         // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
@@ -1106,8 +1105,7 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             (0, utils_js_1.assert)(configValueSourcePrevious);
-            (0, utils_js_1.assert)(!configValueSourcePrevious.isComputed);
-            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, true);
+            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, false);
             (0, utils_js_1.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;
@@ -1144,40 +1142,24 @@ function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect
     return (0, utils_js_2.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) {
-    (0, utils_js_1.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)
     };
 }

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

@@ -1,20 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeConfigValueImported = exports.getVirtualFilePageConfigValuesAll = void 0;
+exports.getVirtualFilePageConfigValuesAll = void 0;
 const utils_js_1 = require("../../../utils.js");
-const generateEagerImport_js_1 = require("../generateEagerImport.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
-const path_1 = __importDefault(require("path"));
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
 const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
-const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
-async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, outDirRoot, isDev, configVike) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
     (0, utils_js_1.assert)(result);
     /* This assertion fails when using includeAssetsImportedByServer
@@ -24,7 +20,7 @@ async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configV
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, outDirRoot, isDev, configVike.extensions, true);
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     (0, utils_js_1.assert)(pageConfig);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
@@ -45,10 +41,10 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
             return;
         if (configValueSource.valueIsFilePath)
             return;
-        if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+        if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
             return;
         const whitespace = '  ';
-        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
+        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push('];');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {
@@ -57,34 +53,3 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
-function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
-    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-    (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
-    (0, utils_js_1.assert)(valueIsImportedAtRuntime);
-    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
-    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
-    (0, utils_js_1.assertPosixPath)(importPath);
-    const fileName = path_1.default.posix.basename(importPath);
-    const isValueFile = fileName.startsWith('+');
-    if (isValueFile)
-        (0, utils_js_1.assert)(exportName === undefined);
-    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importPath, varCounterContainer.varCounter++, exportName);
-    importStatements.push(importStatement);
-    const lines = [];
-    lines.push(`  {`);
-    lines.push(`    configName: '${configName}',`);
-    lines.push(`    importPath: '${importPath}',`);
-    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
-    if (isValueFile) {
-        lines.push(`    importFileExports: ${importName},`);
-    }
-    else {
-        lines.push(`    importFileExportValue: ${importName},`);
-        (0, utils_js_1.assert)(exportName);
-        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
-    }
-    lines.push(`  },`);
-    return lines;
-}
-exports.serializeConfigValueImported = serializeConfigValueImported;