vike 0.4.210 → 0.4.211-commit-be2fe23

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

@@ -9,8 +9,9 @@ exports.fixServerAssets_assertCssCodeSplit = fixServerAssets_assertCssCodeSplit;
 exports.fixServerAssets_assertCssTarget = fixServerAssets_assertCssTarget;
 exports.fixServerAssets_assertCssTarget_populate = fixServerAssets_assertCssTarget_populate;
 const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const fs_1 = require("fs");
+const fs_2 = require("fs");
 const utils_js_1 = require("../../utils.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const buildConfig_js_1 = require("../buildConfig.js");
@@ -33,9 +34,9 @@ async function fixServerAssets(config) {
     const outDirs = (0, utils_js_1.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_1.default.posix.join(outDir, buildConfig_js_1.manifestTempFile);
@@ -45,26 +46,32 @@ async function loadManifest(outDir) {
     (0, utils_js_1.assert)(manifest);
     return manifest;
 }
-async function copyAssets(filesToCopy, config) {
+async function copyAssets(filesToCopy, filesToRemove, config) {
     const { outDirClient, outDirServer } = (0, utils_js_1.getOutDirs)(config);
     const assetsDir = (0, getAssetsDir_js_1.getAssetsDir)(config);
     const assetsDirServer = path_1.default.posix.join(outDirServer, assetsDir);
-    if (!filesToCopy.length)
+    if (!filesToCopy.length && !filesToRemove.length && !(0, fs_2.existsSync)(assetsDirServer))
         return;
-    (0, utils_js_1.assert)((0, fs_1.existsSync)(assetsDirServer));
+    (0, utils_js_1.assert)((0, fs_2.existsSync)(assetsDirServer));
     const concurrencyLimit = (0, utils_js_1.pLimit)(10);
-    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => 
-    // TODO: move instead of copying
-    promises_1.default.cp(path_1.default.posix.join(outDirServer, file), path_1.default.posix.join(outDirClient, file), {
-        recursive: true
-    }))));
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(async () => {
+        const source = path_1.default.posix.join(outDirServer, file);
+        const target = path_1.default.posix.join(outDirClient, file);
+        await promises_1.default.mkdir(path_1.default.posix.dirname(target), { recursive: true });
+        await promises_1.default.rename(source, target);
+    })));
+    filesToRemove.forEach((file) => {
+        const filePath = path_1.default.posix.join(outDirServer, file);
+        fs_1.default.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)) {
@@ -81,36 +88,64 @@ function addServerAssets(clientManifest, serverManifest) {
             continue;
         const resources = collectResources(entry, serverManifest);
         (0, utils_js_1.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 = (0, utils_js_1.unique)(filesToCopy);
-    return { clientManifestMod, filesToCopy };
+    filesToRemove = (0, utils_js_1.unique)(filesToRemove).filter((file) => !filesToCopy.includes(file));
+    return { clientManifestMod, serverManifestMod, filesToCopy, filesToRemove };
 }
 function getPageId(key) {
     // Normalize from:
@@ -194,3 +229,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_1.default.readdirSync(dirPath);
+    // Iterate through the files and subdirectories
+    for (const file of files) {
+        const fullPath = path_1.default.join(dirPath, file);
+        // Check if it's a directory
+        if (fs_1.default.statSync(fullPath).isDirectory()) {
+            // Recursively clean up the subdirectory
+            removeEmptyDirectories(fullPath);
+        }
+    }
+    // Re-check the directory; remove it if it's now empty
+    if (fs_1.default.readdirSync(dirPath).length === 0) {
+        fs_1.default.rmdirSync(dirPath);
+    }
+}

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

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

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

@@ -38,18 +38,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 ((0, utils_js_1.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/cjs/node/plugin/plugins/config/index.js

@@ -11,17 +11,23 @@ const resolveBase_js_1 = require("./resolveBase.js");
 const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function resolveVikeConfig(vikeConfig) {
+    let isDev;
     return {
         name: 'vike:resolveVikeConfig',
         enforce: 'pre',
+        apply(_config, env) {
+            isDev = (0, utils_js_1.isDevCheck)(env);
+            return true;
+        },
         async configResolved(config) {
-            const promise = getConfigVikPromise(vikeConfig, config);
+            (0, utils_js_1.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];
@@ -29,7 +35,7 @@ async function getConfigVikPromise(vikeConfig, config) {
     // TODO/v1-release: deprecate this
     (0, assertVikeConfig_js_1.assertVikeConfig)(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
     const crawlWithGit = fromPluginOptions.crawl?.git ?? null;
-    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config, (0, utils_js_1.isDev2)(config), { crawlWithGit });
+    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev, { crawlWithGit });
     configs.push(fromPlusConfigFile);
     (0, assertVikeConfig_js_1.assertVikeConfig)(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

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

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.devConfig = devConfig;
+exports.logDockerHint = logDockerHint;
 const determineOptimizeDeps_js_1 = require("./determineOptimizeDeps.js");
 const determineFsAllowList_js_1 = require("./determineFsAllowList.js");
 const addSsrMiddleware_js_1 = require("../../shared/addSsrMiddleware.js");
@@ -8,18 +12,16 @@ const utils_js_1 = require("../../utils.js");
 const loggerVite_js_1 = require("../../shared/loggerVite.js");
 const isErrorDebug_js_1 = require("../../../shared/isErrorDebug.js");
 const getHttpRequestAsyncStore_js_1 = require("../../shared/getHttpRequestAsyncStore.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 if ((0, isErrorDebug_js_1.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: utils_js_1.applyDev,
             config() {
                 return {
                     appType: 'custom',
@@ -61,12 +63,13 @@ function devConfig() {
             },
             async configResolved(config_) {
                 config = config_;
-                await (0, determineOptimizeDeps_js_1.determineOptimizeDeps)(config, isDev);
+                await (0, determineOptimizeDeps_js_1.determineOptimizeDeps)(config, true);
                 await (0, determineFsAllowList_js_1.determineFsAllowList)(config);
                 if (!(0, isErrorDebug_js_1.isErrorDebug)()) {
                     await (0, getHttpRequestAsyncStore_js_1.installHttpRequestAsyncStore)();
                     (0, loggerVite_js_1.improveViteLogs)(config);
                 }
+                logDockerHint(config.server.host);
             },
             configureServer() {
                 (0, utils_js_1.markEnvAsViteDev)();
@@ -74,7 +77,7 @@ function devConfig() {
         },
         {
             name: 'vike:devConfig:addSsrMiddleware',
-            apply,
+            apply: utils_js_1.applyDev,
             // The SSR middleware should be last middleware
             enforce: 'post',
             configureServer: {
@@ -100,3 +103,8 @@ function devConfig() {
         }
     ];
 }
+function logDockerHint(configHost) {
+    if ((0, utils_js_1.isDocker)()) {
+        (0, utils_js_1.assertWarning)(configHost, `Your app seems to be running inside a Docker or Podman container but ${picocolors_1.default.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/cjs/node/plugin/plugins/importUserCode/index.js

@@ -23,7 +23,7 @@ function importUserCode() {
     return {
         name: 'vike:importUserCode',
         config(_, env) {
-            isDev = (0, utils_js_1.isDev3)(env);
+            isDev = (0, utils_js_1.isDevCheck)(env);
         },
         async configResolved(config_) {
             configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);

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

@@ -67,11 +67,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         (0, utils_js_1.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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolvePointerImport.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvePointerImportOfConfig = resolvePointerImportOfConfig;
 exports.resolvePointerImport = resolvePointerImport;
 exports.clearFilesEnvMap = clearFilesEnvMap;
+exports.resolveConfigEnvWithFileName = resolveConfigEnvWithFileName;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../../../../utils.js");
 const transformPointerImports_js_1 = require("./transformPointerImports.js");
@@ -21,12 +22,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:
@@ -39,7 +44,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     (0, utils_js_1.assertPosixPath)(importPath);
     if (importPath.startsWith('.') || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
         if (importPath.startsWith('.')) {
-            (0, utils_js_1.assertUsage)(importPath.startsWith('./') || importPath.startsWith('../'), `Invalid relative import path ${picocolors_1.default.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${picocolors_1.default.code('./')} or ${picocolors_1.default.code('../')}, or use an npm package import instead.`);
+            (0, utils_js_1.assertUsage)(isRelativeImportPath(importPath), `Invalid relative import path ${picocolors_1.default.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${picocolors_1.default.code('./')} or ${picocolors_1.default.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);
@@ -67,6 +72,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
             });
         }
         else {
+            // We cannot resolve path aliases defined only in Vite
             filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
                 importPathAbsolute
             });
@@ -94,7 +100,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             : `The import ${picocolors_1.default.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
-            (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
+            (0, utils_js_1.assert)(isRelativeImportPath(importPath));
             (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
         }
         else {
@@ -102,13 +108,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 {
-        (0, utils_js_1.assertIsNpmPackageImport)(importPath);
+        // Path alias
+        (0, utils_js_1.assert)(!isRelativeImportPath(importPath));
         key = importPath;
     }
     (0, utils_js_1.assertPosixPath)(key);
@@ -116,12 +123,12 @@ function assertUsageFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, c
         filesEnvMap.set(key, []);
     }
     const fileEnv = filesEnvMap.get(key);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
+    fileEnv.push({ configEnvResolved, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnvResolved, configEnvResolved))[0];
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
             `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.code(c.configName)} which value lives in environment ${picocolors_1.default.code(JSON.stringify(c.configEnv))}`),
+            ...[configDifferentEnv, { configName, configEnvResolved }].map((c) => `  - config ${picocolors_1.default.code(c.configName)} which value lives in environment ${picocolors_1.default.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'));
     }
@@ -129,3 +136,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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -243,7 +243,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all((0, utils_js_1.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);
@@ -339,22 +339,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);
@@ -535,7 +519,6 @@ function isInterfaceFileUserLand(interfaceFile) {
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     (0, utils_js_1.assert)(conf);
-    const configEnv = deriveConfigEnvFromFileName(configDef.env, interfaceFile.filePath.fileName);
     const { locationId } = interfaceFile;
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
@@ -547,14 +530,15 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         let definedAtFilePath;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
-            const { configValue } = conf;
-            const pointerImport = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
+            // Defined over pointer import
+            const resolved = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(conf.configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
             const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, definedAtFilePath_);
-            (0, utils_js_1.assertUsage)(pointerImport, `${configDefinedAt} should be an import`);
-            valueFilePath = pointerImport.filePathAbsoluteVite;
-            definedAtFilePath = pointerImport;
+            (0, utils_js_1.assertUsage)(resolved, `${configDefinedAt} should be an import`);
+            valueFilePath = resolved.pointerImport.filePathAbsoluteVite;
+            definedAtFilePath = resolved.pointerImport;
         }
         else {
+            // Defined by value file, i.e. +{configName}.js
             (0, utils_js_1.assert)(interfaceFile.isValueFile);
             valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
             definedAtFilePath = {
@@ -566,7 +550,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             value: valueFilePath,
             valueIsFilePath: true,
-            configEnv,
+            configEnv: configDef.env,
             valueIsImportedAtRuntime: true,
             valueIsDefinedByPlusFile: false,
             isOverriden,
@@ -578,23 +562,23 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        // Pointer import
-        const pointerImport = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-        if (pointerImport) {
+        // Defined over pointer import
+        const resolved = (0, resolvePointerImport_js_1.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 (0, loadFileAtConfigTime_js_1.loadImportedFile)(pointerImport, userRootDir, importedFilesLoaded);
+                if (resolved.pointerImport.filePathAbsoluteFilesystem) {
+                    const fileExport = await (0, loadFileAtConfigTime_js_1.loadImportedFile)(resolved.pointerImport, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
                 else {
@@ -604,11 +588,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,
@@ -618,11 +602,12 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     // Defined by value file, i.e. +{configName}.js
     if (interfaceFile.isValueFile) {
+        const configEnvResolved = (0, resolvePointerImport_js_1.resolveConfigEnvWithFileName)(configDef.env, interfaceFile.filePath);
         const valueAlreadyLoaded = 'configValue' in conf;
-        (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnv.config);
+        (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
             locationId,
-            configEnv,
+            configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
             isOverriden,

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

@@ -5,17 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.previewConfig = previewConfig;
 const utils_js_1 = require("../utils.js");
-const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const addSsrMiddleware_js_1 = require("../shared/addSsrMiddleware.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const index_js_1 = require("./devConfig/index.js");
 function previewConfig() {
     let config;
-    let configVike;
+    // let configVike: ConfigVikeResolved
     return {
         name: 'vike:previewConfig',
-        apply: 'serve',
+        apply: utils_js_1.applyPreview,
         config(config) {
             return {
                 appType: 'custom',
@@ -26,7 +26,8 @@ function previewConfig() {
         },
         async configResolved(config_) {
             config = config_;
-            configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+            (0, index_js_1.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/cjs/node/plugin/plugins/setGlobalContext.js

@@ -15,7 +15,7 @@ function setGlobalContext() {
         },
         config: {
             handler(_, env) {
-                const isDev = (0, utils_js_1.isDev3)(env);
+                const isDev = (0, utils_js_1.isDevCheck)(env);
                 (0, globalContext_js_1.setGlobalContext_isDev)(isDev);
             }
         },

package/dist/cjs/node/plugin/utils.js

@@ -44,3 +44,4 @@ __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/isEqualStringList.js"), exports);
+__exportStar(require("../../utils/isDocker.js"), exports);

package/dist/cjs/node/runtime/renderPage/getPageAssets/retrieveAssetsDev.js

@@ -61,13 +61,13 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
     });
 }
 function isStyle(mod) {
-    if (utils_js_1.styleFileRE.test(mod.url) || (mod.id && /\?vue&type=style/.test(mod.id))) {
-        // `mod.type` seems broken
-        (0, utils_js_1.assert)(mod.type === 'js');
-        // logModule(mod)
-        return true;
-    }
-    return false;
+    return (
+    // CSS-in-JS libraries such as [wyw-in-js](https://github.com/vikejs/vike/issues/2039)
+    mod.type === 'css' ||
+        // .css, .less, ...
+        utils_js_1.styleFileRE.test(mod.url) ||
+        // CSS of .vue files
+        (mod.id && /\?vue&type=style/.test(mod.id)));
 }
 /*
 function logModule(mod: ModuleNode) {