vike 0.4.210 → 0.4.211-commit-be2fe23

package/dist/cjs/node/runtime/renderPage/logErrorHint.js

@@ -10,10 +10,15 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const hintDefault = 'The error could be a CJS/ESM issue, see https://vike.dev/broken-npm-package';
 const hintLinkPrefix = 'To fix this error, see ';
 const errorsMisc = [
+    {
+        errMsg: 'window is not defined',
+        link: 'https://vike.dev/hints#window-is-not-defined',
+        mustMentionNodeModules: false
+    },
     {
         errMsg: 'jsxDEV is not a function',
         link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096',
-        shouldMentionNodeModules: false
+        mustMentionNodeModules: false
     },
     {
         // ```
@@ -21,7 +26,7 @@ const errorsMisc = [
         // ```
         errMsg: 'assets.json',
         link: 'https://vike.dev/getGlobalContext',
-        shouldMentionNodeModules: false
+        mustMentionNodeModules: false
     }
 ];
 const errorsReact = [
@@ -29,7 +34,7 @@ const errorsReact = [
         errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
         link: 'https://vike.dev/broken-npm-package#react-invalid-component',
         // The stack trace can be user-land while the import is coming from node_modules
-        shouldMentionNodeModules: false
+        mustMentionNodeModules: false
     },
     {
         // React's "Invalid hook call.", see https://github.com/vikejs/vike/discussions/1637#discussioncomment-9424712
@@ -42,7 +47,7 @@ const errorsCjsEsm_withPreciseLink = [
         errMsg: /Named export.*not found/i,
         link: 'https://vike.dev/broken-npm-package#named-export-not-found',
         // It seems that this always points to an npm package import.
-        shouldMentionNodeModules: false
+        mustMentionNodeModules: false
     }
 ];
 const errorsCjsEsm = [
@@ -56,7 +61,7 @@ const errorsCjsEsm = [
     {
         errMsg: 'Cannot use import statement',
         // Since user code is always ESM, this error must always originate from an npm package.
-        shouldMentionNodeModules: false
+        mustMentionNodeModules: false
     },
     { errMsg: 'is not exported' },
     { errMsg: 'Cannot read properties of undefined' },
@@ -65,7 +70,6 @@ const errorsCjsEsm = [
     { errMsg: 'require is not a function' },
     { errMsg: 'exports is not defined' },
     { errMsg: 'module is not defined' },
-    { errMsg: 'window is not defined' },
     { errMsg: 'not defined in ES' },
     { errMsg: "Unexpected token 'export'" }
 ];
@@ -107,7 +111,7 @@ function isKnownError(error) {
     ].find((knownErorr) => {
         if (!includesLowercase(anywhere, knownErorr.errMsg))
             return false;
-        if (knownErorr.shouldMentionNodeModules !== false && !includesLowercase(anywhere, 'node_modules'))
+        if (knownErorr.mustMentionNodeModules !== false && !includesLowercase(anywhere, 'node_modules'))
             return false;
         return true;
     });

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.210';
+exports.PROJECT_VERSION = '0.4.211-commit-be2fe23';

package/dist/cjs/utils/assertVersion.js

@@ -4,6 +4,8 @@ exports.assertVersion = assertVersion;
 exports.isVersionOrAbove = isVersionOrAbove;
 const assert_js_1 = require("./assert.js");
 function assertVersion(dependencyName, versionActual, versionExpected) {
+    (0, assert_js_1.assert)(versionActual);
+    (0, assert_js_1.assert)(versionExpected);
     (0, assert_js_1.assertUsage)(isVersionOrAbove(versionActual, versionExpected), `${dependencyName} ${versionActual} isn't supported, use ${dependencyName} >= ${versionExpected} instead.`);
 }
 function isVersionOrAbove(versionActual, versionExpected) {

package/dist/cjs/utils/isDev.js

@@ -1,23 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDev2 = isDev2;
-exports.isDev3 = isDev3;
+exports.isDevCheck = isDevCheck;
+exports.applyDev = applyDev;
+exports.applyPreview = applyPreview;
 const assert_js_1 = require("./assert.js");
-function isDev3(configEnv) {
+function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
-    if (command !== 'serve')
-        return false;
-    // `isPreview` is `undefined` in older Vite versions.
-    // https://github.com/vitejs/vite/pull/14855
-    // https://github.com/vitejs/vite/pull/15695O
-    // - Released at `vite@5.1.0`: https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#510-beta4-2024-01-26:~:text=fix(preview)%3A%20set%20isPreview%20true%20(%2315695)%20(93fce55)%2C%20closes%20%2315695
+    // Released at vite@5.1.0 which is guaranteed with `assertVersion('Vite', version, '5.1.0')`
     (0, assert_js_1.assert)(typeof isPreview === 'boolean');
-    return !isPreview;
+    return command === 'serve' && !isPreview;
 }
-function isDev2(config) {
-    const isDev = config.command === 'serve' &&
-        // Mode is 'development' by default: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/config.ts#L383
-        // Note that user can override this: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/cli.ts#L126
-        config.mode === 'development';
-    return isDev;
+function applyDev(_, env) {
+    return isDevCheck(env);
+}
+function applyPreview(_, env) {
+    return env.command == 'serve' && !isDevCheck(env);
 }

package/dist/cjs/utils/isDocker.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDocker = isDocker;
+const node_fs_1 = __importDefault(require("node:fs"));
+const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function isDocker() {
+    return hasContainerEnv() || isDockerContainer();
+}
+// Podman detection
+// https://github.com/sindresorhus/is-inside-container/blob/7f0dc884bda6b368d89ec90e77f2bef3b87e6f09/index.js
+function hasContainerEnv() {
+    try {
+        node_fs_1.default.statSync('/run/.containerenv');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Docker detection
+// https://github.com/sindresorhus/is-docker/blob/1cfd2b5bfa9fbd87d2b22e6f514e7d5cc60a794b/index.js
+function isDockerContainer() {
+    return hasDockerEnv() || hasDockerCGroup();
+}
+function hasDockerEnv() {
+    try {
+        node_fs_1.default.statSync('/.dockerenv');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasDockerCGroup() {
+    try {
+        return node_fs_1.default.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+    }
+    catch {
+        return false;
+    }
+}

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -13,7 +13,10 @@ import { ResolvedConfig } from 'vite';
  */
 declare function fixServerAssets_isEnabled(): boolean;
 /** https://github.com/vikejs/vike/issues/1339 */
-declare function fixServerAssets(config: ResolvedConfig): Promise<ViteManifest>;
+declare function fixServerAssets(config: ResolvedConfig): Promise<{
+    clientManifestMod: ViteManifest;
+    serverManifestMod: ViteManifest;
+}>;
 declare function fixServerAssets_assertCssCodeSplit(config: ResolvedConfig): void;
 declare function fixServerAssets_assertCssTarget_populate(config: ResolvedConfig): void;
 declare function fixServerAssets_assertCssTarget(config: ResolvedConfig): Promise<void>;

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

@@ -4,6 +4,7 @@ export { fixServerAssets_assertCssCodeSplit };
 export { fixServerAssets_assertCssTarget };
 export { fixServerAssets_assertCssTarget_populate };
 import fs from 'fs/promises';
+import fs_sync from 'fs';
 import path from 'path';
 import { existsSync } from 'fs';
 import { assert, assertWarning, getOutDirs, isEqualStringList, pLimit, unique, viteIsSSR } from '../../utils.js';
@@ -28,9 +29,9 @@ async function fixServerAssets(config) {
     const outDirs = getOutDirs(config);
     const clientManifest = await loadManifest(outDirs.outDirClient);
     const serverManifest = await loadManifest(outDirs.outDirServer);
-    const { clientManifestMod, filesToCopy } = addServerAssets(clientManifest, serverManifest);
-    await copyAssets(filesToCopy, config);
-    return clientManifestMod;
+    const { clientManifestMod, serverManifestMod, filesToCopy, filesToRemove } = addServerAssets(clientManifest, serverManifest);
+    await copyAssets(filesToCopy, filesToRemove, config);
+    return { clientManifestMod, serverManifestMod };
 }
 async function loadManifest(outDir) {
     const manifestFilePath = path.posix.join(outDir, manifestTempFile);
@@ -40,26 +41,32 @@ async function loadManifest(outDir) {
     assert(manifest);
     return manifest;
 }
-async function copyAssets(filesToCopy, config) {
+async function copyAssets(filesToCopy, filesToRemove, config) {
     const { outDirClient, outDirServer } = getOutDirs(config);
     const assetsDir = getAssetsDir(config);
     const assetsDirServer = path.posix.join(outDirServer, assetsDir);
-    if (!filesToCopy.length)
+    if (!filesToCopy.length && !filesToRemove.length && !existsSync(assetsDirServer))
         return;
     assert(existsSync(assetsDirServer));
     const concurrencyLimit = pLimit(10);
-    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => 
-    // TODO: move instead of copying
-    fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
-        recursive: true
-    }))));
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(async () => {
+        const source = path.posix.join(outDirServer, file);
+        const target = path.posix.join(outDirClient, file);
+        await fs.mkdir(path.posix.dirname(target), { recursive: true });
+        await fs.rename(source, target);
+    })));
+    filesToRemove.forEach((file) => {
+        const filePath = path.posix.join(outDirServer, file);
+        fs_sync.unlinkSync(filePath);
+    });
     /* We cannot do that because, with some edge case Rollup settings (outputing JavaScript chunks and static assets to the same directoy), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
     await fs.rm(assetsDirServer, { recursive: true })
     */
+    removeEmptyDirectories(assetsDirServer);
 }
 // Add serverManifest resources to clientManifest
 function addServerAssets(clientManifest, serverManifest) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const entriesClient = new Map();
     const entriesServer = new Map();
     for (const [key, entry] of Object.entries(clientManifest)) {
@@ -76,36 +83,64 @@ function addServerAssets(clientManifest, serverManifest) {
             continue;
         const resources = collectResources(entry, serverManifest);
         assert(!entriesServer.has(pageId));
-        entriesServer.set(pageId, resources);
+        entriesServer.set(pageId, { key, ...resources });
     }
     let filesToCopy = [];
+    let filesToRemove = [];
     for (const [pageId, entryClient] of entriesClient.entries()) {
+        const entryServer = entriesServer.get(pageId);
+        if (!entryServer)
+            continue;
         const cssToAdd = [];
+        const cssToRemove = [];
         const assetsToAdd = [];
-        const entryServer = entriesServer.get(pageId);
-        if (entryServer) {
-            cssToAdd.push(...entryServer.css
-                .filter((cssServer) => !entryClient.css.some((cssClient) => cssServer.hash === cssClient.hash))
-                .map((css) => css.src));
-            assetsToAdd.push(...entryServer.assets
-                .filter((assertServer) => !entryClient.assets.some((assetClient) => assertServer.hash === assetClient.hash))
-                .map((asset) => asset.src));
-        }
-        const { key } = entryClient;
+        const assetsToRemove = [];
+        entryServer.css.forEach((cssServer) => {
+            if (!entryClient.css.some((cssClient) => cssServer.hash === cssClient.hash)) {
+                cssToAdd.push(cssServer.src);
+            }
+            else {
+                cssToRemove.push(cssServer.src);
+            }
+        });
+        entryServer.assets.forEach((assetServer) => {
+            if (!entryClient.assets.some((assetClient) => assetServer.hash === assetClient.hash)) {
+                assetsToAdd.push(assetServer.src);
+            }
+            else {
+                assetsToRemove.push(assetServer.src);
+            }
+        });
         if (cssToAdd.length) {
+            const { key } = entryClient;
             filesToCopy.push(...cssToAdd);
             (_a = clientManifest[key]).css ?? (_a.css = []);
             clientManifest[key].css?.push(...cssToAdd);
         }
+        if (cssToRemove.length) {
+            const { key } = entryServer;
+            filesToRemove.push(...cssToRemove);
+            (_b = serverManifest[key]).css ?? (_b.css = []);
+            serverManifest[key].css = serverManifest[key].css.filter((entry) => !cssToRemove.includes(entry));
+        }
         if (assetsToAdd.length) {
+            const { key } = entryClient;
             filesToCopy.push(...assetsToAdd);
-            (_b = clientManifest[key]).assets ?? (_b.assets = []);
+            (_c = clientManifest[key]).assets ?? (_c.assets = []);
             clientManifest[key].assets?.push(...assetsToAdd);
         }
+        if (assetsToRemove.length) {
+            const { key } = entryServer;
+            filesToRemove.push(...assetsToRemove);
+            (_d = serverManifest[key]).assets ?? (_d.assets = []);
+            serverManifest[key].assets = serverManifest[key].assets.filter((entry) => !assetsToRemove.includes(entry));
+        }
     }
     const clientManifestMod = clientManifest;
+    const serverManifestMod = serverManifest;
     filesToCopy = unique(filesToCopy);
-    return { clientManifestMod, filesToCopy };
+    filesToRemove = unique(filesToRemove).filter((file) => !filesToCopy.includes(file));
+    return { clientManifestMod, serverManifestMod, filesToCopy, filesToRemove };
 }
 function getPageId(key) {
     // Normalize from:
@@ -189,3 +224,23 @@ async function fixServerAssets_assertCssTarget(config) {
 function resolveCssTarget(target) {
     return target.css ?? target.global;
 }
+/**
+ * Recursively remove all empty directories in a given directory.
+ */
+function removeEmptyDirectories(dirPath) {
+    // Read the directory contents
+    const files = fs_sync.readdirSync(dirPath);
+    // Iterate through the files and subdirectories
+    for (const file of files) {
+        const fullPath = path.join(dirPath, file);
+        // Check if it's a directory
+        if (fs_sync.statSync(fullPath).isDirectory()) {
+            // Recursively clean up the subdirectory
+            removeEmptyDirectories(fullPath);
+        }
+    }
+    // Re-check the directory; remove it if it's now empty
+    if (fs_sync.readdirSync(dirPath).length === 0) {
+        fs_sync.rmdirSync(dirPath);
+    }
+}

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

@@ -94,7 +94,7 @@ function buildConfig() {
                             await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
                         }
                         else {
-                            const clientManifestMod = await fixServerAssets(config);
+                            const { clientManifestMod } = await fixServerAssets(config);
                             await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
                         }
                         await fs.rm(clientManifestFilePath);

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

@@ -1,5 +1,5 @@
 export { commonConfig };
-import { assert, assertUsage, assertWarning, findPackageJson } from '../utils.js';
+import { assert, assertUsage, assertWarning, findPackageJson, isDocker } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -33,18 +33,24 @@ function commonConfig() {
             // Override Vite's default port without overriding the user
             config: {
                 order: 'post',
-                handler(config) {
-                    const configMod = {};
-                    if (config.server?.port === undefined)
-                        configMod.server = { port: 3000 };
-                    if (config.preview?.port === undefined)
-                        configMod.preview = { port: 3000 };
-                    return configMod;
+                handler(configFromUser) {
+                    const configFromVike = { server: {}, preview: {} };
+                    setDefault('port', 3000, configFromUser, configFromVike);
+                    if (isDocker()) {
+                        setDefault('host', true, configFromUser, configFromVike);
+                    }
+                    return configFromVike;
                 }
             }
         }
     ];
 }
+function setDefault(setting, value, configFromUser, configFromVike) {
+    if (configFromUser.server?.[setting] === undefined)
+        configFromVike.server[setting] = value;
+    if (configFromUser.preview?.[setting] === undefined)
+        configFromVike.preview[setting] = value;
+}
 /*
 import { version } from 'vite'
 function overrideViteDefaultSsrExternal(config: ResolvedConfig) {

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

@@ -1,22 +1,28 @@
 export { resolveVikeConfig };
 import { assertVikeConfig } from './assertVikeConfig.js';
-import { isDev2 } from '../../utils.js';
+import { assert, isDevCheck } from '../../utils.js';
 import { pickFirst } from './pickFirst.js';
 import { resolveBase } from './resolveBase.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 function resolveVikeConfig(vikeConfig) {
+    let isDev;
     return {
         name: 'vike:resolveVikeConfig',
         enforce: 'pre',
+        apply(_config, env) {
+            isDev = isDevCheck(env);
+            return true;
+        },
         async configResolved(config) {
-            const promise = getConfigVikPromise(vikeConfig, config);
+            assert(typeof isDev === 'boolean');
+            const promise = getConfigVikPromise(vikeConfig, config, isDev);
             config.configVikePromise = promise;
             await promise;
         }
     };
 }
-async function getConfigVikPromise(vikeConfig, config) {
+async function getConfigVikPromise(vikeConfig, config, isDev) {
     const fromPluginOptions = (vikeConfig ?? {});
     const fromViteConfig = (config.vike ?? {});
     const configs = [fromPluginOptions, fromViteConfig];
@@ -24,7 +30,7 @@ async function getConfigVikPromise(vikeConfig, config) {
     // TODO/v1-release: deprecate this
     assertVikeConfig(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
     const crawlWithGit = fromPluginOptions.crawl?.git ?? null;
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config), { crawlWithGit });
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev, { crawlWithGit });
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

package/dist/esm/node/plugin/plugins/devConfig/index.d.ts

@@ -1,3 +1,5 @@
 export { devConfig };
-import type { Plugin } from 'vite';
+export { logDockerHint };
+import type { Plugin, ResolvedConfig } from 'vite';
 declare function devConfig(): Plugin[];
+declare function logDockerHint(configHost: ResolvedConfig['server']['host']): void;

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

@@ -1,23 +1,22 @@
 export { devConfig };
+export { logDockerHint };
 import { determineOptimizeDeps } from './determineOptimizeDeps.js';
 import { determineFsAllowList } from './determineFsAllowList.js';
 import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
-import { markEnvAsViteDev } from '../../utils.js';
+import { applyDev, assertWarning, isDocker, markEnvAsViteDev } from '../../utils.js';
 import { improveViteLogs } from '../../shared/loggerVite.js';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { installHttpRequestAsyncStore } from '../../shared/getHttpRequestAsyncStore.js';
+import pc from '@brillout/picocolors';
 if (isErrorDebug()) {
     Error.stackTraceLimit = Infinity;
 }
-// There doesn't seem to be a straightforward way to discriminate between `$ vite preview` and `$ vite dev`
-const apply = 'serve';
-const isDev = true;
 function devConfig() {
     let config;
     return [
         {
             name: 'vike:devConfig',
-            apply,
+            apply: applyDev,
             config() {
                 return {
                     appType: 'custom',
@@ -59,12 +58,13 @@ function devConfig() {
             },
             async configResolved(config_) {
                 config = config_;
-                await determineOptimizeDeps(config, isDev);
+                await determineOptimizeDeps(config, true);
                 await determineFsAllowList(config);
                 if (!isErrorDebug()) {
                     await installHttpRequestAsyncStore();
                     improveViteLogs(config);
                 }
+                logDockerHint(config.server.host);
             },
             configureServer() {
                 markEnvAsViteDev();
@@ -72,7 +72,7 @@ function devConfig() {
         },
         {
             name: 'vike:devConfig:addSsrMiddleware',
-            apply,
+            apply: applyDev,
             // The SSR middleware should be last middleware
             enforce: 'post',
             configureServer: {
@@ -98,3 +98,8 @@ function devConfig() {
         }
     ];
 }
+function logDockerHint(configHost) {
+    if (isDocker()) {
+        assertWarning(configHost, `Your app seems to be running inside a Docker or Podman container but ${pc.cyan('--host')} isn't set which means that your Vike app won't be accessible from outside the container, see https://vike.dev/docker`, { onlyOnce: true });
+    }
+}

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, getOutDirs, isDev3 } from '../../utils.js';
+import { assert, assertPosixPath, getOutDirs, isDevCheck } from '../../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../../shared/virtual-files.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
@@ -18,7 +18,7 @@ function importUserCode() {
     return {
         name: 'vike:importUserCode',
         config(_, env) {
-            isDev = isDev3(env);
+            isDev = isDevCheck(env);
         },
         async configResolved(config_) {
             configVike = await getConfigVike(config_);

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

@@ -62,11 +62,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         assert(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
-    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
-        const result = await loadConfigFile(configFilePath, userRootDir, visited, true);
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true)));
+    results.forEach((result) => {
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
-    }));
+    });
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }

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

@@ -1,12 +1,22 @@
 export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
 export { clearFilesEnvMap };
+export { resolveConfigEnvWithFileName };
 import type { ConfigEnvInternal, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
 import { type PointerImportData } from './transformPointerImports.js';
 import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 type PointerImportResolved = DefinedAtFilePath & {
     fileExportName: string;
 };
-declare function resolvePointerImportOfConfig(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | PointerImportResolved;
+declare function resolvePointerImportOfConfig(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | {
+    pointerImport: PointerImportResolved;
+    configEnvResolved: ConfigEnvInternal;
+};
 declare function resolvePointerImport(pointerImportData: PointerImportData, importerFilePath: FilePathResolved, userRootDir: string): FilePath;
 declare function clearFilesEnvMap(): void;
+declare function resolveConfigEnvWithFileName(configEnv: ConfigEnvInternal, filePath: FilePathResolved): {
+    server?: boolean | undefined;
+    config?: boolean | undefined;
+    client?: boolean | "if-client-routing";
+    production?: boolean;
+};