vike 0.4.209 → 0.4.211

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/client/client-routing-runtime/renderPageClientSide.js

@@ -23,6 +23,7 @@ import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
+        previousPageContext: null,
         renderCounter: 0,
         firstRenderStartPromise,
         firstRenderStartPromiseResolve
@@ -218,10 +219,20 @@ async function renderPageClientSide(renderArgs) {
             isBackwardNavigation,
             isClientSideNavigation,
             isHydration: isFirstRender && !isForErrorPage,
-            // Make it public as `pageContext.previous`? Maybe after https://github.com/vikejs/vike/issues/1268
-            _previousPageContext: previousPageContext,
+            previousPageContext,
             ...pageContextInitClient
         });
+        // TODO/next-major-release: remove
+        Object.defineProperty(pageContext, '_previousPageContext', {
+            get() {
+                assertWarning(false, 'pageContext._previousPageContext has been renamed pageContext.previousPageContext', {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return previousPageContext;
+            },
+            enumerable: false
+        });
         {
             const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
             assert(!('urlOriginal' in pageContextFromAllRewrites));

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';
@@ -48,14 +49,16 @@ async function copyAssets(filesToCopy, config) {
         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);
+    })));
     /* 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) {
@@ -189,3 +192,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/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';
@@ -21,7 +21,6 @@ function commonConfig() {
             configResolved: {
                 order: 'post',
                 handler(config) {
-                    overrideViteDefaultPort(config);
                     /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
                     overrideViteDefaultSsrExternal(config)
                     //*/
@@ -30,18 +29,27 @@ function commonConfig() {
                     assertResolveAlias(config);
                     assertEsm(config.root);
                 }
+            },
+            // Override Vite's default port without overriding the user
+            config: {
+                order: 'post',
+                handler(configFromUser) {
+                    const configFromVike = { server: {}, preview: {} };
+                    setDefault('port', 3000, configFromUser, configFromVike);
+                    if (isDocker()) {
+                        setDefault('host', true, configFromUser, configFromVike);
+                    }
+                    return configFromVike;
+                }
             }
         }
     ];
 }
-function overrideViteDefaultPort(config) {
-    var _a, _b;
-    // @ts-ignore
-    config.server ?? (config.server = {});
-    (_a = config.server).port ?? (_a.port = 3000);
-    // @ts-ignore
-    config.preview ?? (config.preview = {});
-    (_b = config.preview).port ?? (_b.port = 3000);
+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'

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;
+};

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

@@ -1,8 +1,9 @@
 export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
 export { clearFilesEnvMap };
+export { resolveConfigEnvWithFileName };
 import pc from '@brillout/picocolors';
-import { assert, assertIsNpmPackageImport, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
+import { assert, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
 import { parsePointerImportData } from './transformPointerImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
@@ -16,12 +17,16 @@ function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir
     const { importPath, exportName } = pointerImportData;
     const filePath = resolvePointerImport(pointerImportData, importerFilePath, userRootDir);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    assertUsageFileEnv(filePath.filePathAbsoluteFilesystem, importPath, configEnv, configName);
-    return {
+    let configEnvResolved = configEnv;
+    if (filePath.filePathAbsoluteFilesystem)
+        configEnvResolved = resolveConfigEnvWithFileName(configEnv, filePath);
+    assertUsageFileEnv(filePath, importPath, configEnvResolved, configName);
+    const pointerImport = {
         ...filePath,
         fileExportName: exportName,
         fileExportPathToShowToUser
     };
+    return { pointerImport, configEnvResolved };
 }
 function resolvePointerImport(pointerImportData, importerFilePath, userRootDir) {
     // `importPath` should be one of the following:
@@ -34,7 +39,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     assertPosixPath(importPath);
     if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
         if (importPath.startsWith('.')) {
-            assertUsage(importPath.startsWith('./') || importPath.startsWith('../'), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
+            assertUsage(isRelativeImportPath(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
         }
         // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
         assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
@@ -62,6 +67,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
             });
         }
         else {
+            // We cannot resolve path aliases defined only in Vite
             filePath = getFilePathUnresolved({
                 importPathAbsolute
             });
@@ -89,7 +95,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             : `The import ${pc.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
-            assert(importPath.startsWith('./') || importPath.startsWith('../'));
+            assert(isRelativeImportPath(importPath));
             assertUsage(false, `${errIntro2} point to an existing file?`);
         }
         else {
@@ -97,13 +103,14 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
         }
     }
 }
-function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
+function assertUsageFileEnv(filePath, importPath, configEnvResolved, configName) {
     let key;
-    if (filePathAbsoluteFilesystem) {
-        key = filePathAbsoluteFilesystem;
+    if (filePath.filePathAbsoluteFilesystem) {
+        key = filePath.filePathAbsoluteFilesystem;
     }
     else {
-        assertIsNpmPackageImport(importPath);
+        // Path alias
+        assert(!isRelativeImportPath(importPath));
         key = importPath;
     }
     assertPosixPath(key);
@@ -111,12 +118,12 @@ function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, c
         filesEnvMap.set(key, []);
     }
     const fileEnv = filesEnvMap.get(key);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
+    fileEnv.push({ configEnvResolved, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnvResolved, configEnvResolved))[0];
     if (configDifferentEnv) {
         assertUsage(false, [
             `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnv))}`),
+            ...[configDifferentEnv, { configName, configEnvResolved }].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnvResolved))}`),
             'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
         ].join('\n'));
     }
@@ -124,3 +131,23 @@ function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, c
 function clearFilesEnvMap() {
     filesEnvMap.clear();
 }
+function resolveConfigEnvWithFileName(configEnv, filePath) {
+    const { fileName } = filePath;
+    const configEnvResolved = { ...configEnv };
+    if (fileName.includes('.server.')) {
+        configEnvResolved.server = true;
+        configEnvResolved.client = false;
+    }
+    else if (fileName.includes('.client.')) {
+        configEnvResolved.client = true;
+        configEnvResolved.server = false;
+    }
+    else if (fileName.includes('.shared.')) {
+        configEnvResolved.server = true;
+        configEnvResolved.client = true;
+    }
+    return configEnvResolved;
+}
+function isRelativeImportPath(importPath) {
+    return importPath.startsWith('./') || importPath.startsWith('../');
+}

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

@@ -18,7 +18,7 @@ import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfig
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { clearFilesEnvMap, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
+import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
@@ -237,7 +237,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
-        .filter(([pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
         const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);
@@ -333,22 +333,6 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
         });
     });
 }
-function deriveConfigEnvFromFileName(env, fileName) {
-    env = { ...env };
-    if (fileName.includes('.server.')) {
-        env.server = true;
-        env.client = false;
-    }
-    else if (fileName.includes('.client.')) {
-        env.client = true;
-        env.server = false;
-    }
-    else if (fileName.includes('.shared.')) {
-        env.server = true;
-        env.client = true;
-    }
-    return env;
-}
 function assertPageConfigs(pageConfigs) {
     pageConfigs.forEach((pageConfig) => {
         assertOnBeforeRenderEnv(pageConfig);
@@ -529,7 +513,6 @@ function isInterfaceFileUserLand(interfaceFile) {
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
-    const configEnv = deriveConfigEnvFromFileName(configDef.env, interfaceFile.filePath.fileName);
     const { locationId } = interfaceFile;
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
@@ -541,14 +524,15 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         let definedAtFilePath;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
-            const { configValue } = conf;
-            const pointerImport = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            // Defined over pointer import
+            const resolved = resolvePointerImportOfConfig(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
-            assertUsage(pointerImport, `${configDefinedAt} should be an import`);
-            valueFilePath = pointerImport.filePathAbsoluteVite;
-            definedAtFilePath = pointerImport;
+            assertUsage(resolved, `${configDefinedAt} should be an import`);
+            valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
+            definedAtFilePath = resolved.pointerImport;
         }
         else {
+            // Defined by value file, i.e. +{configName}.js
             assert(interfaceFile.isValueFile);
             valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
             definedAtFilePath = {
@@ -560,7 +544,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             value: valueFilePath,
             valueIsFilePath: true,
-            configEnv,
+            configEnv: configDef.env,
             valueIsImportedAtRuntime: true,
             valueIsDefinedByPlusFile: false,
             isOverriden,
@@ -572,23 +556,23 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     if (interfaceFile.isConfigFile) {
         assert('configValue' in conf);
         const { configValue } = conf;
-        // Pointer import
-        const pointerImport = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-        if (pointerImport) {
+        // Defined over pointer import
+        const resolved = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
+        if (resolved) {
             const configValueSource = {
                 locationId,
-                configEnv,
+                configEnv: resolved.configEnvResolved,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
                 isOverriden,
-                definedAtFilePath: pointerImport
+                definedAtFilePath: resolved.pointerImport
             };
             // Load pointer import
             if (isLoadableAtBuildTime(configDef) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
-                if (pointerImport.filePathAbsoluteFilesystem) {
-                    const fileExport = await loadImportedFile(pointerImport, userRootDir, importedFilesLoaded);
+                if (resolved.pointerImport.filePathAbsoluteFilesystem) {
+                    const fileExport = await loadImportedFile(resolved.pointerImport, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
                 else {
@@ -598,11 +582,11 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             }
             return configValueSource;
         }
-        // Defined by config file, i.e. +config.js file
+        // Defined inside +config.js
         const configValueSource = {
             locationId,
             value: configValue,
-            configEnv,
+            configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
             valueIsDefinedByPlusFile: false,
             isOverriden,
@@ -612,11 +596,12 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // Defined by value file, i.e. +{configName}.js
     if (interfaceFile.isValueFile) {
+        const configEnvResolved = resolveConfigEnvWithFileName(configDef.env, interfaceFile.filePath);
         const valueAlreadyLoaded = 'configValue' in conf;
-        assert(valueAlreadyLoaded === !!configEnv.config);
+        assert(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
             locationId,
-            configEnv,
+            configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
             isOverriden,

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

@@ -1,16 +1,16 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview } from '../utils.js';
-import { getConfigVike } from '../../shared/getConfigVike.js';
+import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview, applyPreview } from '../utils.js';
 import fs from 'fs';
 import path from 'path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
+import { logDockerHint } from './devConfig/index.js';
 function previewConfig() {
     let config;
-    let configVike;
+    // let configVike: ConfigVikeResolved
     return {
         name: 'vike:previewConfig',
-        apply: 'serve',
+        apply: applyPreview,
         config(config) {
             return {
                 appType: 'custom',
@@ -21,7 +21,8 @@ function previewConfig() {
         },
         async configResolved(config_) {
             config = config_;
-            configVike = await getConfigVike(config);
+            logDockerHint(config.preview.host);
+            // configVike = await getConfigVike(config)
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c

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

@@ -1,6 +1,6 @@
 export { setGlobalContext };
 import { setGlobalContext_isDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
-import { assertFilePathAbsoluteFilesystem, getOutDirs, isDev3 } from '../utils.js';
+import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck } from '../utils.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -13,7 +13,7 @@ function setGlobalContext() {
         },
         config: {
             handler(_, env) {
-                const isDev = isDev3(env);
+                const isDev = isDevCheck(env);
                 setGlobalContext_isDev(isDev);
             }
         },