vike 0.4.248 → 0.4.249-commit-55681da

package/dist/node/vite/shared/resolveVikeConfigInternal/{getPlusFilesAll.js → getPlusFilesByLocationId.js}

@@ -1,61 +1,51 @@
-export { getPlusFilesAll };
+export { getPlusFilesByLocationId };
 import { assert } from '../../utils.js';
 import { configDefinitionsBuiltIn } from './configDefinitionsBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
-import { crawlPlusFiles, getPlusFileValueConfigName } from './crawlPlusFiles.js';
+import { crawlPlusFilePaths, getPlusFileValueConfigName } from './crawlPlusFilePaths.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../getFilePath.js';
 import { assertExtensionsConventions, assertExtensionsRequire } from './assertExtensions.js';
-async function getPlusFilesAll(userRootDir, esbuildCache) {
-    const plusFiles = await findPlusFiles(userRootDir);
-    const configFiles = [];
-    const valueFiles = [];
-    plusFiles.forEach((f) => {
-        if (getPlusFileValueConfigName(f.filePathAbsoluteFilesystem) === 'config') {
-            configFiles.push(f);
-        }
-        else {
-            valueFiles.push(f);
-        }
-    });
-    let plusFilesAll = {};
-    await Promise.all([
-        // Config files
-        ...configFiles.map(async (filePath) => {
+async function getPlusFilesByLocationId(userRootDir, esbuildCache) {
+    const plusFilePaths = (await crawlPlusFilePaths(userRootDir)).map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
+    const plusFilesByLocationId = {};
+    await Promise.all(plusFilePaths.map(async (filePath) => {
+        if (getPlusFileValueConfigName(filePath.filePathAbsoluteFilesystem) === 'config') {
+            // +config.js files
             const { filePathAbsoluteUserRootDir } = filePath;
             assert(filePathAbsoluteUserRootDir);
             const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const plusFile = getPlusFileFromConfigFile(configFile, false, locationId, userRootDir);
-            plusFilesAll[locationId] = plusFilesAll[locationId] ?? [];
-            plusFilesAll[locationId].push(plusFile);
+            plusFilesByLocationId[locationId] = plusFilesByLocationId[locationId] ?? [];
+            plusFilesByLocationId[locationId].push(plusFile);
             extendsConfigs.forEach((extendsConfig) => {
                 /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
-                ```js
-                // /pages/admin/+config.js
-        
-                import vikeVue from 'vike-vue/config'
-                // Should only apply to /pages/admin/**
-                export default { extends: [vikeVue] }
-                ```
-                ```js
-                // /pages/marketing/+config.js
-        
-                import vikeReact from 'vike-react/config'
-                // Should only apply to /pages/marketing/**
-                export default { extends: [vikeReact] }
-                ```
-                */
+              ```js
+              // /pages/admin/+config.js
+      
+              import vikeVue from 'vike-vue/config'
+              // Should only apply to /pages/admin/**
+              export default { extends: [vikeVue] }
+              ```
+              ```js
+              // /pages/marketing/+config.js
+      
+              import vikeReact from 'vike-react/config'
+              // Should only apply to /pages/marketing/**
+              export default { extends: [vikeReact] }
+              ```
+              */
                 const plusFile = getPlusFileFromConfigFile(extendsConfig, true, locationId, userRootDir);
                 assertExtensionsConventions(plusFile);
-                plusFilesAll[locationId].push(plusFile);
+                plusFilesByLocationId[locationId].push(plusFile);
             });
-        }),
-        // Value files
-        ...valueFiles.map(async (filePath) => {
+        }
+        else {
+            // +{configName}.js files
             const { filePathAbsoluteUserRootDir } = filePath;
             assert(filePathAbsoluteUserRootDir);
             const configName = getPlusFileValueConfigName(filePathAbsoluteUserRootDir);
@@ -68,23 +58,23 @@ async function getPlusFilesAll(userRootDir, esbuildCache) {
                 isNotLoaded: true,
                 configName,
             };
-            plusFilesAll[locationId] = plusFilesAll[locationId] ?? [];
-            plusFilesAll[locationId].push(plusFile);
+            plusFilesByLocationId[locationId] = plusFilesByLocationId[locationId] ?? [];
+            plusFilesByLocationId[locationId].push(plusFile);
             // We don't have access to the custom config definitions defined by the user yet.
             //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
             //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
             await loadValueFile(plusFile, configDefinitionsBuiltIn, userRootDir, esbuildCache);
-        }),
-    ]);
+        }
+    }));
     // Make lists element order deterministic
-    Object.entries(plusFilesAll).forEach(([_locationId, plusFiles]) => {
+    Object.entries(plusFilesByLocationId).forEach(([_locationId, plusFiles]) => {
         plusFiles.sort(sortMakeDeterministic);
     });
-    assertPlusFiles(plusFilesAll);
-    return plusFilesAll;
+    assertPlusFiles(plusFilesByLocationId);
+    return plusFilesByLocationId;
 }
-function assertPlusFiles(plusFilesAll) {
-    const plusFiles = Object.values(plusFilesAll).flat();
+function assertPlusFiles(plusFilesByLocationId) {
+    const plusFiles = Object.values(plusFilesByLocationId).flat();
     // The earlier we call it the better, so that +require can be used by Vike extensions to depend on new Vike features
     assertExtensionsRequire(plusFiles);
 }
@@ -95,12 +85,14 @@ function getPlusFileFromConfigFile(configFile, isExtensionConfig, locationId, us
     const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
     Object.entries(fileExport).forEach(([configName, configValue]) => {
         fileExportsByConfigName[configName] = configValue;
-        const pointerImport = resolvePointerImport(configValue, configFile.filePath, userRootDir, configName);
-        if (pointerImport) {
-            pointerImportsByConfigName[configName] = {
-                ...pointerImport,
-                fileExportValueLoaded: false,
-            };
+        // Pointer imports
+        const values = Array.isArray(configValue) ? configValue : [configValue];
+        const pointerImports = values
+            .map((value) => resolvePointerImport(value, configFile.filePath, userRootDir, configName))
+            .filter((pointerImport) => pointerImport !== null)
+            .map((pointerImport) => ({ ...pointerImport, fileExportValueLoaded: false }));
+        if (pointerImports.length > 0) {
+            pointerImportsByConfigName[configName] = pointerImports;
         }
     });
     const plusFile = {
@@ -116,10 +108,6 @@ function getPlusFileFromConfigFile(configFile, isExtensionConfig, locationId, us
 }
 // Make order deterministic (no other purpose)
 function sortMakeDeterministic(plusFile1, plusFile2) {
+    // Sort by file path
     return plusFile1.filePath.filePathAbsoluteVite < plusFile2.filePath.filePathAbsoluteVite ? -1 : 1;
 }
-async function findPlusFiles(userRootDir) {
-    const files = await crawlPlusFiles(userRootDir);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
-    return plusFiles;
-}

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.d.ts

@@ -5,7 +5,7 @@ export type { ConfigFile };
 export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 import { type EsbuildCache } from './transpileAndExecuteFile.js';
-import type { PlusFileValue } from './getPlusFilesAll.js';
+import type { PlusFileValue } from './getPlusFilesByLocationId.js';
 import { PointerImport } from './resolvePointerImport.js';
 import type { ConfigDefinitionsInternal } from './configDefinitionsBuiltIn.js';
 type ConfigFile = {

package/dist/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -14,7 +14,7 @@ export type { PageConfigBuildTimeBeforeComputed };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
 import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { type GlobalConfigPublic } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
-import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
+import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
 import { type DangerouslyUseInternals } from '../../../shared-server-client/getProxyForPublicUsage.js';

package/dist/node/vite/shared/resolveVikeConfigInternal.js

@@ -25,7 +25,7 @@ import { getFilePathResolved } from './getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
 import { resolveGlobalConfigPublic, } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue, } from '../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
-import { getPlusFilesAll, } from './resolveVikeConfigInternal/getPlusFilesAll.js';
+import { getPlusFilesByLocationId, } from './resolveVikeConfigInternal/getPlusFilesByLocationId.js';
 import { getEnvVarObject } from './getEnvVarObject.js';
 import { getVikeApiOperation } from '../../../shared-server-node/api-context.js';
 import { getCliOptions } from '../../cli/context.js';
@@ -169,9 +169,9 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     }
 }
 async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
-    const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
-    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
-    const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
+    const plusFilesByLocationId = await getPlusFilesByLocationId(userRootDir, esbuildCache);
+    const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache);
+    const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir);
     if (!globalObject.isV1Design_)
         globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
@@ -197,21 +197,21 @@ function resolveGlobalConfig(pageConfigGlobal, pageConfigs) {
     const globalConfigPublic = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues);
     return globalConfigPublic;
 }
-async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
-    const plusFilesAllOrdered = Object.values(plusFilesAll)
+async function resolveConfigDefinitions(plusFilesByLocationId, userRootDir, esbuildCache) {
+    const plusFilesByLocationIdOrdered = Object.values(plusFilesByLocationId)
         .flat()
-        .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesAll, null));
+        .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesByLocationId, null));
     const configDefinitionsGlobal = getConfigDefinitions(
-    // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
-    plusFilesAllOrdered, (configDef) => !!configDef.global);
-    await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
-    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesAll).flat());
+    // We use `plusFilesByLocationId` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
+    plusFilesByLocationIdOrdered, (configDef) => !!configDef.global);
+    await loadCustomConfigBuildTimeFiles(plusFilesByLocationId, configDefinitionsGlobal, userRootDir, esbuildCache);
+    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesByLocationId).flat());
     const configNamesKnownAll = Object.keys(configDefinitionsAll);
     const configNamesKnownGlobal = Object.keys(configDefinitionsGlobal);
     assert(configNamesKnownGlobal.every((configName) => configNamesKnownAll.includes(configName)));
     const configDefinitionsLocal = {};
-    await Promise.all(objectEntries(plusFilesAll).map(async ([locationIdPage, plusFiles]) => {
-        const plusFilesRelevant = objectEntries(plusFilesAll)
+    await Promise.all(objectEntries(plusFilesByLocationId).map(async ([locationIdPage, plusFiles]) => {
+        const plusFilesRelevant = objectEntries(plusFilesByLocationId)
             .filter(([locationId]) => isInherited(locationId, locationIdPage))
             .map(([, plusFiles]) => plusFiles)
             .flat()
@@ -238,7 +238,7 @@ async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache)
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
-// - The value files of *built-in* configs are already loaded at `getPlusFilesAll()`.
+// - The value files of *built-in* configs are already loaded at `getPlusFilesByLocationId()`.
 async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache) {
     const plusFileList = Object.values(plusFiles).flat(1);
     await Promise.all(plusFileList.map(async (plusFile) => {
@@ -246,28 +246,28 @@ async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, user
             await loadValueFile(plusFile, configDefinitions, userRootDir, esbuildCache);
         }
         else {
-            await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImport]) => {
-                await loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache);
+            await Promise.all(Object.entries(plusFile.pointerImportsByConfigName).map(async ([configName, pointerImports]) => {
+                await Promise.all(pointerImports.map((pointerImport) => loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache)));
             }));
         }
     }));
 }
-function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir) {
+function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesByLocationId, userRootDir) {
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsResolved.configDefinitionsGlobal,
         configValueSources: {},
     };
     objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, 
-        // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
-        Object.values(plusFilesAll).flat(), userRootDir, true, plusFilesAll);
+        // We use `plusFilesByLocationId` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
+        Object.values(plusFilesByLocationId).flat(), userRootDir, true, plusFilesByLocationId);
         if (sources.length === 0)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
     });
-    applyEffects(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal, plusFilesAll);
+    applyEffects(pageConfigGlobal.configValueSources, configDefinitionsResolved.configDefinitionsGlobal, plusFilesByLocationId);
     sortConfigValueSources(pageConfigGlobal.configValueSources, null);
-    assertPageConfigGlobal(pageConfigGlobal, plusFilesAll);
+    assertPageConfigGlobal(pageConfigGlobal, plusFilesByLocationId);
     const pageConfigs = objectEntries(configDefinitionsResolved.configDefinitionsLocal)
         .filter(([_locationId, { plusFiles }]) => isDefiningPage(plusFiles))
         .map(([locationId, { configDefinitions, plusFilesRelevant }]) => {
@@ -276,13 +276,13 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         objectEntries(configDefinitionsLocal)
             .filter(([_configName, configDef]) => configDef.global !== true)
             .forEach(([configName, configDef]) => {
-            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false, plusFilesAll);
+            const sources = resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, false, plusFilesByLocationId);
             if (sources.length === 0)
                 return;
             configValueSources[configName] = sources;
         });
         const pageConfigRoute = determineRouteFilesystem(locationId, configValueSources);
-        applyEffects(configValueSources, configDefinitionsLocal, plusFilesAll);
+        applyEffects(configValueSources, configDefinitionsLocal, plusFilesByLocationId);
         sortConfigValueSources(configValueSources, locationId);
         const pageConfig = {
             pageId: locationId,
@@ -299,15 +299,15 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
     assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal };
 }
-function assertPageConfigGlobal(pageConfigGlobal, plusFilesAll) {
+function assertPageConfigGlobal(pageConfigGlobal, plusFilesByLocationId) {
     Object.entries(pageConfigGlobal.configValueSources).forEach(([configName, sources]) => {
-        assertGlobalConfigLocation(configName, sources, plusFilesAll, pageConfigGlobal.configDefinitions);
+        assertGlobalConfigLocation(configName, sources, plusFilesByLocationId, pageConfigGlobal.configDefinitions);
     });
 }
-function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDefinitionsGlobal) {
+function assertGlobalConfigLocation(configName, sources, plusFilesByLocationId, configDefinitionsGlobal) {
     // Determine existing global +config.js files
     const configFilePathsGlobal = [];
-    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesAll).filter(([locationId]) => isGlobalLocation(locationId, plusFilesAll)))).flat();
+    const plusFilesGlobal = Object.values(objectFromEntries(objectEntries(plusFilesByLocationId).filter(([locationId]) => isGlobalLocation(locationId, plusFilesByLocationId)))).flat();
     plusFilesGlobal
         .filter((i) => i.isConfigFile)
         .forEach((plusFile) => {
@@ -326,7 +326,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
         if (!filePathAbsoluteUserRootDir)
             return;
         assert(!plusFile.isExtensionConfig);
-        if (!isGlobalLocation(source.locationId, plusFilesAll)) {
+        if (!isGlobalLocation(source.locationId, plusFilesByLocationId)) {
             const configDef = configDefinitionsGlobal[configName];
             assert(configDef);
             const isConditionallyGlobal = isCallable(configDef.global);
@@ -502,9 +502,9 @@ function sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, con
     }
     return 0;
 }
-function sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesAll, configName) {
-    if (plusFilesAll) {
-        const ret = makeFirst((plusFile) => isGlobalLocation(plusFile.locationId, plusFilesAll))(plusFile1, plusFile2);
+function sortAfterInheritanceOrderGlobal(plusFile1, plusFile2, plusFilesByLocationId, configName) {
+    if (plusFilesByLocationId) {
+        const ret = makeFirst((plusFile) => isGlobalLocation(plusFile.locationId, plusFilesByLocationId))(plusFile1, plusFile2);
         if (ret !== 0)
             return ret;
     }
@@ -552,13 +552,13 @@ function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
             return ret;
     }
     // Config set by +{configName}.js (highest precedence)
-    // No need to make it deterministic: the overall order is already deterministic, see sortMakeDeterministic() at getPlusFilesAll()
+    // No need to make it deterministic: the overall order is already deterministic, see sortMakeDeterministic() at getPlusFilesByLocationId()
     return 0;
 }
-function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesAll) {
+function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesByLocationId) {
     let sources = plusFilesRelevant
         .filter((plusFile) => isDefiningConfig(plusFile, configName))
-        .map((plusFile) => getConfigValueSource(configName, plusFile, configDef, userRootDir));
+        .flatMap((plusFile) => getConfigValueSources(configName, plusFile, configDef, userRootDir));
     // Filter hydrid global-local configs
     if (!isCallable(configDef.global)) {
         // Already filtered
@@ -570,7 +570,7 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
         sources = sources.filter((source) => {
             assert(source.configEnv.config);
             assert(source.valueIsLoaded);
-            const valueIsGlobal = resolveIsGlobalValue(configDef.global, source, plusFilesAll);
+            const valueIsGlobal = resolveIsGlobalValue(configDef.global, source, plusFilesByLocationId);
             return isGlobal ? valueIsGlobal : !valueIsGlobal;
         });
     }
@@ -579,7 +579,7 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
 function isDefiningConfig(plusFile, configName) {
     return getConfigNamesSetByPlusFile(plusFile).includes(configName);
 }
-function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
+function getConfigValueSources(configName, plusFile, configDef, userRootDir) {
     const confVal = getConfVal(plusFile, configName);
     assert(confVal);
     const configValueSourceCommon = {
@@ -622,7 +622,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             valueIsDefinedByPlusValueFile: false,
             definedAt: definedAtFilePath,
         };
-        return configValueSource;
+        return [configValueSource];
     }
     // +config.js
     if (plusFile.isConfigFile) {
@@ -630,23 +630,25 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
         // Defined over pointer import
         const pointerImport = plusFile.pointerImportsByConfigName[configName];
         if (pointerImport) {
-            const value = pointerImport.fileExportValueLoaded
-                ? {
-                    valueIsLoaded: true,
-                    value: pointerImport.fileExportValue,
-                }
-                : {
-                    valueIsLoaded: false,
+            return pointerImport.map((pointerImport) => {
+                const value = pointerImport.fileExportValueLoaded
+                    ? {
+                        valueIsLoaded: true,
+                        value: pointerImport.fileExportValue,
+                    }
+                    : {
+                        valueIsLoaded: false,
+                    };
+                const configValueSource = {
+                    ...configValueSourceCommon,
+                    ...value,
+                    configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
+                    valueIsLoadedWithImport: true,
+                    valueIsDefinedByPlusValueFile: false,
+                    definedAt: pointerImport.fileExportPath,
                 };
-            const configValueSource = {
-                ...configValueSourceCommon,
-                ...value,
-                configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
-                valueIsLoadedWithImport: true,
-                valueIsDefinedByPlusValueFile: false,
-                definedAt: pointerImport.fileExportPath,
-            };
-            return configValueSource;
+                return configValueSource;
+            });
         }
         // Defined inside +config.js
         const configValueSource = {
@@ -658,7 +660,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             valueIsDefinedByPlusValueFile: false,
             definedAt: definedAtFilePath_,
         };
-        return configValueSource;
+        return [configValueSource];
     }
     // Defined by value file, i.e. +{configName}.js
     if (!plusFile.isConfigFile) {
@@ -678,7 +680,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
                         [configName],
             },
         };
-        return configValueSource;
+        return [configValueSource];
     }
     assert(false);
 }
@@ -694,12 +696,12 @@ function isDefiningPage(plusFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function resolveIsGlobalValue(configDefGlobal, source, plusFilesAll) {
+function resolveIsGlobalValue(configDefGlobal, source, plusFilesByLocationId) {
     assert(source.valueIsLoaded);
     let isGlobal;
     if (isCallable(configDefGlobal))
         isGlobal = configDefGlobal(source.value, {
-            isGlobalLocation: isGlobalLocation(source.locationId, plusFilesAll),
+            isGlobalLocation: isGlobalLocation(source.locationId, plusFilesByLocationId),
         });
     else
         isGlobal = configDefGlobal ?? false;
@@ -802,7 +804,7 @@ function assertMetaUsage(metaVal, metaConfigDefinedAt) {
     });
 }
 // Test: https://github.com/vikejs/vike/blob/871a111a77d637bbd156b07be5ae728c3d595501/test/playground/pages/config-meta/effect/e2e-test.ts
-function applyEffects(configValueSources, configDefinitions, plusFilesAll) {
+function applyEffects(configValueSources, configDefinitions, plusFilesByLocationId) {
     objectEntries(configDefinitions).forEach(([configNameEffect, configDefEffect]) => {
         const sourceEffect = configValueSources[configNameEffect]?.[0];
         if (!sourceEffect)
@@ -812,7 +814,7 @@ function applyEffects(configValueSources, configDefinitions, plusFilesAll) {
             return;
         const configModFromEffect = effect;
         // Apply config value changes first to create sources, then meta.env changes to modify their env
-        applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesAll);
+        applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesByLocationId);
         applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEffect);
     });
 }
@@ -833,7 +835,7 @@ function runEffect(configName, configDef, source) {
         return null;
     return configModFromEffect;
 }
-function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesAll) {
+function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSources, configNameEffect, configDefEffect, configDefinitions, plusFilesByLocationId) {
     objectEntries(configModFromEffect).forEach(([configNameTarget, configValue]) => {
         if (configNameTarget === 'meta')
             return;
@@ -851,8 +853,8 @@ function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSource
             value: configValue,
         };
         assert(sourceEffect.valueIsLoaded);
-        const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, sourceEffect, plusFilesAll);
-        const isValueGlobalTarget = resolveIsGlobalValue(configDef.global, configValueSource, plusFilesAll);
+        const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, sourceEffect, plusFilesByLocationId);
+        const isValueGlobalTarget = resolveIsGlobalValue(configDef.global, configValueSource, plusFilesByLocationId);
         const isGlobalHumanReadable = (isGlobal) => `${isGlobal ? 'non-' : ''}global`;
         // The error message make it sound like it's an inherent limitation, it actually isn't (both ways can make senses).
         assertUsage(isValueGlobalSource === isValueGlobalTarget, `The configuration ${pc.cyan(configNameEffect)} is set to ${pc.cyan(JSON.stringify(sourceEffect.value))} which is considered ${isGlobalHumanReadable(isValueGlobalSource)}. However, it has a meta.effect that sets the configuration ${pc.cyan(configNameTarget)} to ${pc.cyan(JSON.stringify(configValue))} which is considered ${isGlobalHumanReadable(isValueGlobalTarget)}. This is contradictory: make sure the values are either both non-global or both global.`);
@@ -1084,8 +1086,8 @@ function resolveConfigEnv(configEnv, filePath) {
     return configEnvResolved;
 }
 /** Whether configs defined in `locationId` apply to every page */
-function isGlobalLocation(locationId, plusFilesAll) {
-    const locationIdsPage = objectEntries(plusFilesAll)
+function isGlobalLocation(locationId, plusFilesByLocationId) {
+    const locationIdsPage = objectEntries(plusFilesByLocationId)
         .filter(([_locationId, plusFiles]) => isDefiningPage(plusFiles))
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));

package/dist/server/runtime/asyncHook.d.ts

@@ -1,5 +1,5 @@
 export { getPageContext_withAsyncHook };
-export { getHttpRequestId_withAsyncHook };
+export { getRequestId_withAsyncHook };
 export { getAsyncLocalStorage };
 export type { AsyncStore };
 import type { AsyncLocalStorage as AsyncLocalStorageType } from 'node:async_hooks';
@@ -8,5 +8,5 @@ type AsyncStore = null | {
     pageContext?: Record<string, unknown>;
 };
 declare function getAsyncLocalStorage(): Promise<AsyncLocalStorageType<AsyncStore> | null>;
-declare function getHttpRequestId_withAsyncHook(): number | null;
+declare function getRequestId_withAsyncHook(): number | null;
 declare function getPageContext_withAsyncHook(): any;

package/dist/server/runtime/asyncHook.js

@@ -1,5 +1,5 @@
 export { getPageContext_withAsyncHook };
-export { getHttpRequestId_withAsyncHook };
+export { getRequestId_withAsyncHook };
 export { getAsyncLocalStorage };
 import { preparePageContextForPublicUsageServer } from './renderPageServer/preparePageContextForPublicUsageServer.js';
 import { assert, assertIsNotBrowser, getGlobalObject, isObject } from '../utils.js';
@@ -30,7 +30,7 @@ function getAsyncStore() {
     assert(asyncStore === undefined || isObject(asyncStore));
     return asyncStore ?? null;
 }
-function getHttpRequestId_withAsyncHook() {
+function getRequestId_withAsyncHook() {
     const asyncStore = getAsyncStore();
     return asyncStore?.requestId ?? null;
 }

package/dist/server/runtime/renderPageServer/html/stream.js

@@ -242,7 +242,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         writeStream(injectedChunk); // Adds injectedChunk to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
-    // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
+    // We call onStreamDataOrEnd() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
     const onStreamDataOrEnd = (cb) => {
         assert(streamOriginalEnded === false);
         streamOriginalHasStartedEmitting = true;
@@ -277,26 +277,23 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 }
             });
         },
-        async onEnd(
-        /* Should we use this `isCancel`? Maybe we can skip `injectStringAtEnd()`?
-        isCancel,
-        //*/
-        ) {
+        async onEnd(isCancel) {
             try {
                 assert(!onEndWasCalled);
                 onEndWasCalled = true;
                 debug('stream end');
-                // We call onStreamEvent() also here in case the stream didn't emit any data
+                // We call onStreamDataOrEnd() also here in case the stream didn't emit any data
                 onStreamDataOrEnd(() => {
                     streamOriginalEnded = true;
                 });
-                if (injectStringAtEnd) {
+                if (injectStringAtEnd && !isCancel) {
                     const injectedChunk = await injectStringAtEnd();
                     writeStream(injectedChunk);
                 }
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 assert(isReady());
-                flushBuffer();
+                if (!isCancel)
+                    flushBuffer();
                 streamClosed = true;
                 debug('stream ended');
             }
@@ -526,7 +523,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 return;
             await onEnd(isCancel);
             isClosed = true;
-            controllerProxy.close();
+            if (!isCancel)
+                controllerProxy.close();
         };
         let controllerProxy;
         assertReadableStreamConstructor();
@@ -546,6 +544,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 });
             },
             async cancel(...args) {
+                debug('stream cancelled');
                 isCancel = true;
                 await readableOriginal.cancel(...args);
                 // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
@@ -553,9 +552,9 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             },
         });
         const writeChunk = (chunk) => {
-            if (
-            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
-            !isClosed) {
+            if (!isCancel &&
+                // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
+                !isClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
                 debugWithChunk('data written (Web Readable)', chunk);
             }

package/dist/server/utils.d.ts

@@ -42,8 +42,8 @@ export * from '../utils/assertSetup.js';
 export * from '../utils/path.js';
 export * from '../utils/isHtml.js';
 export * from '../utils/virtualFileId.js';
-export * from '../utils/colors.js';
-export * from '../utils/colorVike.js';
+export * from '../utils/colorsServer.js';
+export * from '../utils/colorsClient.js';
 export * from '../utils/getTerminalWidth.js';
 export * from '../utils/truncateString.js';
 export * from '../utils/formatHintLog.js';

package/dist/server/utils.js

@@ -46,8 +46,8 @@ export * from '../utils/assertSetup.js';
 export * from '../utils/path.js';
 export * from '../utils/isHtml.js';
 export * from '../utils/virtualFileId.js';
-export * from '../utils/colors.js';
-export * from '../utils/colorVike.js';
+export * from '../utils/colorsServer.js';
+export * from '../utils/colorsClient.js';
 export * from '../utils/getTerminalWidth.js';
 export * from '../utils/truncateString.js';
 export * from '../utils/formatHintLog.js';

package/dist/types/Config.d.ts

@@ -339,7 +339,7 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/extends
      */
-    extends?: Config | ImportString | (Config | ImportString)[];
+    extends?: Config | Config[] | ImportString;
     /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
@@ -596,4 +596,5 @@ type ConfigBuiltInResolved = {
     headersResponse?: Exclude<Config['headersResponse'], ImportString | undefined>[];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
-type ImportString = `import:${string}`;
+type ImportString = ImportStringVal | ImportStringVal[];
+type ImportStringVal = `import:${string}`;