vike 0.4.225-commit-2b7971f → 0.4.225-commit-6fc12fc

package/dist/cjs/node/api/build.js

@@ -16,13 +16,13 @@ const utils_js_1 = require("./utils.js");
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'build');
+    const { viteConfigFromUserEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'build');
     // Pass it to pluginAutoFullBuild()
-    if (viteConfigEnhanced)
-        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (viteConfigFromUserEnhanced)
+        viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
     if (vikeConfig.global.config.vite6BuilderApp) {
         (0, utils_js_1.assertVersion)('Vite', vite_1.version, '6.0.0');
-        const builder = await (0, vite_1.createBuilder)(viteConfigEnhanced);
+        const builder = await (0, vite_1.createBuilder)(viteConfigFromUserEnhanced);
         // See Vite plugin vike:build:pluginBuildApp
         await builder.buildApp();
     }
@@ -35,14 +35,14 @@ async function build(options = {}) {
         //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
         //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
-        await (0, vite_1.build)(viteConfigEnhanced);
+        await (0, vite_1.build)(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
         if ((0, context_js_1.isVikeCli)() && (0, context_js_2.isPrerendering)())
             (0, assert_1.default)(false);
     }
     return {
-    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigEnhanced,
+    /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigFromUserEnhanced,
     */
     };
 }

package/dist/cjs/node/api/dev.js

@@ -9,8 +9,8 @@ const vite_1 = require("vite");
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'dev');
-    const server = await (0, vite_1.createServer)(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'dev');
+    const server = await (0, vite_1.createServer)(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
         viteConfig: server.config

package/dist/cjs/node/api/prepareViteApiCall.js

@@ -52,34 +52,37 @@ const globalObject = (0, utils_js_1.getGlobalObject)('api/prepareViteApiCall.ts'
 async function prepareViteApiCall(options, operation) {
     clear();
     (0, context_js_1.setContextApiOperation)(operation, options);
-    const viteConfigFromOptions = options.viteConfig;
-    return enhanceViteConfig(viteConfigFromOptions, operation);
+    const viteConfigFromUserApiOptions = options.viteConfig;
+    return resolveConfigs(viteConfigFromUserApiOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     (0, context_js_1.clearContextApiOperation)();
     (0, globalContext_js_1.clearGlobalContext)();
 }
-async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getViteInfo(viteConfigFromOptions, operation);
-    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
+async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
+    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteInfo.viteConfigFromUserEnhanced, operation);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
     return {
         vikeConfig,
-        viteConfigEnhanced
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserEnhanced
     };
 }
-function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
-        return viteConfigEnhanced;
+        return viteConfigFromUserEnhanced;
     viteConfigs.values.forEach((v) => {
         (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = (0, vite_1.mergeConfig)(viteConfigEnhanced ?? {}, v.value);
+        viteConfigFromUserEnhanced = (0, vite_1.mergeConfig)(viteConfigFromUserEnhanced ?? {}, v.value);
         (0, utils_js_1.assertUsage)(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
-    return viteConfigEnhanced;
+    return viteConfigFromUserEnhanced;
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
@@ -87,19 +90,30 @@ async function getViteRoot(operation) {
     (0, utils_js_1.assert)(globalObject.root);
     return globalObject.root;
 }
-async function getViteInfo(viteConfigFromOptions, operation) {
-    let viteConfigEnhanced = viteConfigFromOptions;
+async function getViteInfo(viteConfigFromUserApiOptions, operation) {
+    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
     // Precedence:
-    //  - viteConfigFromUserEnvVar (highest precendence)
-    //  - viteConfigFromOptions
-    //  - viteConfigFromUserViteFile (lowest precendence)
+    //  1) viteConfigFromUserEnvVar (highest precendence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precendence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = (0, utils_js_1.pick)((0, getVikeConfig_js_1.getVikeConfigFromCliOrEnv)().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserEnhanced = (0, vite_1.mergeConfig)(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
     const viteConfigFromUserEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar)
-        viteConfigEnhanced = (0, vite_1.mergeConfig)(viteConfigEnhanced ?? {}, viteConfigFromUserEnvVar);
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigEnhanced, operation);
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserEnhanced = (0, vite_1.mergeConfig)(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromUserEnhanced, operation);
     // Correct precedence, replicates Vite:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    const viteConfigResolved = (0, vite_1.mergeConfig)(viteConfigFromUserViteFile ?? {}, viteConfigEnhanced ?? {});
+    const viteConfigResolved = (0, vite_1.mergeConfig)(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
     const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
     // - Find options `vike(options)` set in vite.config.js
@@ -114,16 +128,16 @@ async function getViteInfo(viteConfigFromOptions, operation) {
         // Add Vike to plugins if not present.
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await Promise.resolve().then(() => __importStar(require('../plugin/index.js')));
-        viteConfigEnhanced = {
-            ...viteConfigEnhanced,
-            plugins: [...(viteConfigEnhanced?.plugins ?? []), vikePlugin()]
+        viteConfigFromUserEnhanced = {
+            ...viteConfigFromUserEnhanced,
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced);
+        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         (0, utils_js_1.assert)(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     (0, utils_js_1.assert)(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigEnhanced };
+    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -141,8 +155,8 @@ function findVikeVitePlugin(viteConfig) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
+async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {
@@ -174,11 +188,12 @@ function normalizeViteRoot(root) {
     path_1.default.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${picocolors_1.default.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
-    // We can eventually this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {
+    const args = getResolveConfigArgs(viteConfigFromUserEnhanced, operation);
+    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
     const viteConfigResolved = await (0, vite_1.resolveConfig)(...args);
     (0, utils_js_1.assertUsage)(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
 }
 function assertViteRoot(root, config) {
     if (globalObject.root)

package/dist/cjs/node/api/prerender.js

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prerender = prerender;
 const runPrerender_js_1 = require("../prerender/runPrerender.js");
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
-// TODO/soon use importServerProductionIndex()
 /**
  * Programmatically trigger `$ vike prerender`
  *
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
-    options.viteConfig = viteConfigEnhanced;
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'prerender');
+    options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await (0, runPrerender_js_1.runPrerenderFromAPI)(options);
     return {
         viteConfig

package/dist/cjs/node/api/preview.js

@@ -1,18 +1,37 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preview = preview;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
+const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
+const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const node_path_1 = __importDefault(require("node:path"));
 /**
  * Programmatically trigger `$ vike preview`
  *
  * https://vike.dev/api#preview
  */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
-    const server = await (0, vite_1.preview)(viteConfigEnhanced);
-    return {
-        viteServer: server,
-        viteConfig: server.config
-    };
+    const { viteConfigFromUserEnhanced, viteConfigResolved } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options, 'preview');
+    if (viteConfigResolved.vitePluginServerEntry?.inject) {
+        const outDir = (0, getOutDirs_js_1.getOutDirs)(viteConfigResolved).outDirRoot;
+        const { outServerIndex } = await (0, runtime_1.importServerProductionIndex)({ outDir });
+        const outServerIndexRelative = node_path_1.default.relative(viteConfigResolved.root, outServerIndex);
+        (0, utils_js_1.assertWarning)(false, `Never run ${picocolors_1.default.cyan('$ vike preview')} in production, run ${picocolors_1.default.cyan(`$ node ${outServerIndexRelative}`)} instead.`, { onlyOnce: true });
+        return {
+            viteConfig: viteConfigResolved
+        };
+    }
+    else {
+        const server = await (0, vite_1.preview)(viteConfigFromUserEnhanced);
+        return {
+            viteServer: server,
+            viteConfig: server.config
+        };
+    }
 }

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

@@ -23,3 +23,4 @@ __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/path.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/assertVersion.js"), exports);
+__exportStar(require("../../utils/pick.js"), exports);

package/dist/cjs/node/cli/entry.js

@@ -95,8 +95,10 @@ async function cmdBuild() {
 async function cmdPreview() {
     try {
         const { viteServer } = await (0, index_js_1.preview)();
-        viteServer.printUrls();
-        viteServer.bindCLIShortcuts({ print: true });
+        if (viteServer) {
+            viteServer.printUrls();
+            viteServer.bindCLIShortcuts({ print: true });
+        }
     }
     catch (err) {
         console.error(picocolors_1.default.red(`Error while starting preview server:`));

package/dist/cjs/node/cli/parseCli.js

@@ -11,7 +11,7 @@ const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
     { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
+    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' }
 ];
 function parseCli() {
     const command = getCommand();
@@ -62,10 +62,16 @@ function showHelp() {
         `vike@${utils_js_1.PROJECT_VERSION}`,
         '',
         'Usage:',
-        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${picocolors_1.default.dim('$')} ${picocolors_1.default.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${picocolors_1.default.dim(`# ${c.desc}`)}`),
+        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${picocolors_1.default.dim('$')} vike ${c.name.startsWith('-') ? picocolors_1.default.cyan(`${c.name}`) : picocolors_1.default.bold(`${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${picocolors_1.default.dim(`# ${c.desc}`)}`),
         '',
-        `Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')} such as --host.`,
-        `Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
+        'Common CLI options:',
+        [`vike dev ${picocolors_1.default.cyan('--host')}`, `vike dev ${picocolors_1.default.cyan('--port')} 80`, `vike build ${picocolors_1.default.cyan('--mode')} staging`]
+            .map((o) => `  ${picocolors_1.default.dim('$')} ${o}`)
+            .join('\n'),
+        '',
+        `More Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')}.`,
+        `More Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
+        ``,
         `See ${picocolors_1.default.underline('https://vike.dev/cli')} for more information.`
     ].join('\n'));
     process.exit(1);

package/dist/cjs/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -129,8 +129,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
-    if (config._viteConfigEnhanced) {
-        return config._viteConfigEnhanced;
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
     }
     else {
         return {

package/dist/cjs/node/plugin/plugins/build/pluginModuleBanner.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginModuleBanner = pluginModuleBanner;
+const utils_js_1 = require("../../utils.js");
+const virtual_files_js_1 = require("../../../shared/virtual-files.js");
+const isViteServerBuild_js_1 = require("../../shared/isViteServerBuild.js");
+// Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
+// But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
+const vikeModuleBannerPlaceholder = 'vikeModuleBannerPlaceholder';
+function pluginModuleBanner() {
+    let config;
+    return {
+        name: 'vike:pluginModuleBanner',
+        enforce: 'post',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        generateBundle: {
+            order: 'post',
+            handler(_options, bundle) {
+                for (const module of Object.values(bundle)) {
+                    if (module.type === 'chunk') {
+                        if ((0, isViteServerBuild_js_1.isViteServerBuild)(config)) {
+                            const codeOld = module.code;
+                            const codeNew = codeOld.replace(/vikeModuleBannerPlaceholder\("([^"]*)"\);/g, '/* $1 [vike:pluginModuleBanner] */');
+                            (0, utils_js_1.assert)(!codeNew.includes(vikeModuleBannerPlaceholder));
+                            module.code = codeNew;
+                        }
+                        else {
+                            (0, utils_js_1.assert)(!module.code.includes(vikeModuleBannerPlaceholder));
+                        }
+                    }
+                }
+            }
+        },
+        transform: {
+            order: 'post',
+            handler(code, id, options) {
+                if (!(0, isViteServerBuild_js_1.isViteServerBuild_safe)(config, options))
+                    return;
+                if (id.startsWith('\0'))
+                    id = id;
+                id = (0, virtual_files_js_1.removeVirtualIdTag)(id);
+                if (id.startsWith(config.root))
+                    id = id.slice(config.root.length + 1);
+                return `${vikeModuleBannerPlaceholder}(${JSON.stringify(id)}); ${code}`;
+            }
+        }
+    };
+}

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

@@ -8,6 +8,7 @@ const pluginDistFileNames_js_1 = require("./build/pluginDistFileNames.js");
 const pluginAutoFullBuild_js_1 = require("./build/pluginAutoFullBuild.js");
 const pluginBuildEntry_js_1 = require("./build/pluginBuildEntry.js");
 const pluginBuildConfig_js_1 = require("./build/pluginBuildConfig.js");
+const pluginModuleBanner_js_1 = require("./build/pluginModuleBanner.js");
 function build() {
     return [
         ...(0, pluginBuildConfig_js_1.pluginBuildConfig)(),
@@ -16,6 +17,7 @@ function build() {
         ...(0, pluginBuildEntry_js_1.pluginBuildEntry)(),
         (0, pluginDistPackageJsonFile_js_1.pluginDistPackageJsonFile)(),
         (0, pluginSuppressRollupWarning_js_1.pluginSuppressRollupWarning)(),
-        (0, pluginDistFileNames_js_1.pluginDistFileNames)()
+        (0, pluginDistFileNames_js_1.pluginDistFileNames)(),
+        (0, pluginModuleBanner_js_1.pluginModuleBanner)()
     ];
 }

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

@@ -71,6 +71,10 @@ function commonConfig(vikeVitePluginOptions) {
                     assertEsm(config.root);
                     assertVikeCliOrApi(config);
                     temp_supportOldInterface(config);
+                    // Only emit dist/server/entry.mjs if necessary
+                    if (config.vitePluginServerEntry?.inject &&
+                        !(0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(config._vikeConfigObject).isPrerenderingEnabled)
+                        config.vitePluginServerEntry.disableServerEntryEmit = true;
                 }
             },
             config: {

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

@@ -133,6 +133,10 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true
     },
+    mode: {
+        env: { config: true },
+        global: true
+    },
     injectScriptsAt: {
         env: { server: true }
     },

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

@@ -10,6 +10,7 @@ exports.reloadVikeConfig = reloadVikeConfig;
 exports.isV1Design = isV1Design;
 exports.getConfVal = getConfVal;
 exports.getConfigDefinitionOptional = getConfigDefinitionOptional;
+exports.getVikeConfigFromCliOrEnv = getVikeConfigFromCliOrEnv;
 exports.isOverriden = isOverriden;
 const utils_js_1 = require("../../../utils.js");
 const configDefinitionsBuiltIn_js_1 = require("./getVikeConfig/configDefinitionsBuiltIn.js");
@@ -395,15 +396,14 @@ function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
     if (apiOperation?.options.vikeConfig) {
         addSources(apiOperation.options.vikeConfig, { definedBy: 'api', operation: apiOperation.operation }, false);
     }
+    const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
-    const cliOptions = (0, context_js_2.getCliOptions)();
-    if (cliOptions) {
-        addSources(cliOptions, { definedBy: 'cli' }, true);
+    if (configFromCliOptions) {
+        addSources(configFromCliOptions, { definedBy: 'cli' }, true);
     }
     // VIKE_CONFIG [highest precedence]
-    const configFromEnv = (0, getEnvVarObject_js_1.getEnvVarObject)('VIKE_CONFIG');
-    if (configFromEnv) {
-        addSources(configFromEnv, { definedBy: 'env' }, false);
+    if (configFromEnvVar) {
+        addSources(configFromEnvVar, { definedBy: 'env' }, false);
     }
     return;
     function addSources(configValues, definedBy, exitOnError) {
@@ -416,6 +416,19 @@ function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
         });
     }
 }
+function getVikeConfigFromCliOrEnv() {
+    const configFromCliOptions = (0, context_js_2.getCliOptions)();
+    const configFromEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VIKE_CONFIG');
+    const vikeConfigFromCliOrEnv = {
+        ...configFromCliOptions, // Lower precedence
+        ...configFromEnvVar // Higher precedence
+    };
+    return {
+        vikeConfigFromCliOrEnv,
+        configFromCliOptions,
+        configFromEnvVar
+    };
+}
 function getSourceNonConfigFile(configName, value, definedAt) {
     (0, utils_js_1.assert)((0, utils_js_1.includes)((0, utils_js_1.objectKeys)(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn), configName));
     const configDef = configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn[configName];

package/dist/cjs/node/plugin/shared/getEnvVarObject.js

@@ -23,8 +23,15 @@ function parseJson5(valueStr, what) {
         value = json5_1.default.parse(valueStr);
     }
     catch (err) {
+        if (isNotJavaScriptLike(valueStr)) {
+            // Interpret as string
+            return valueStr;
+        }
         console.error(err);
         (0, utils_js_1.assertUsage)(false, `Cannot parse ${picocolors_1.default.cyan(what)} (see error above) because it's set to the following which isn't a valid JSON5 string: ${picocolors_1.default.bold(valueStr)}`);
     }
     return value;
 }
+function isNotJavaScriptLike(valueStr) {
+    return ![':', ',', '{', '}', '(', ')'].some((c) => valueStr.includes(c));
+}

package/dist/cjs/node/prerender/runPrerender.js

@@ -76,8 +76,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);

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

@@ -33,4 +33,4 @@ __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
 __exportStar(require("../../utils/makePublicCopy.js"), exports);
-__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);

package/dist/cjs/node/runtime/globalContext.js

@@ -311,10 +311,14 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         (0, utils_js_1.assert)(globalObject.buildEntry);
-        (0, utils_js_1.assertWarning)(!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject, 
-        // TODO/soon: show precise path
-        // TODO/soon: make this warning work on test/vike-node/
-        `Run the server production build (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(
+        // vike-server => `vitePluginServerEntry.inject === true`
+        // vike-node => `vitePluginServerEntry.inject === [ 'index' ]`
+        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true, 
+        /* TO-DO/eventually:
+        !!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject,
+        */
+        `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);

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

@@ -51,7 +51,7 @@ __exportStar(require("../../utils/urlToFile.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/freezePartial.js"), exports);
 __exportStar(require("../../utils/isNpmPackage.js"), exports);
-__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/isScriptFile.js"), exports);
 __exportStar(require("../../utils/removeFileExtention.js"), exports);
 __exportStar(require("../../utils/objectKeys.js"), exports);

package/dist/cjs/node/runtime-dev/createDevMiddleware.js

@@ -22,8 +22,8 @@ async function createDevMiddleware(options = {}) {
             }
         }
     };
-    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
-    const server = await (0, vite_1.createServer)(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(optionsMod, 'dev');
+    const server = await (0, vite_1.createServer)(viteConfigFromUserEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

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

@@ -28,6 +28,6 @@ __exportStar(require("../../utils/parseUrl.js"), exports);
 __exportStar(require("../../utils/parseUrl-extras.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/assertIsNotBrowser.js"), exports);
-__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports);
 __exportStar(require("../../utils/debug.js"), exports);

package/dist/cjs/node/shared/virtual-files.js

@@ -6,32 +6,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isVirtualFileId = isVirtualFileId;
 exports.getVirtualFileId = getVirtualFileId;
 exports.resolveVirtualFileId = resolveVirtualFileId;
+exports.removeVirtualIdTag = removeVirtualIdTag;
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("./utils.js");
 const idBase = 'virtual:vike:';
 // https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
-const tag = '\0';
+const virtualIdTag = '\0';
 function isVirtualFileId(id) {
     if (id.startsWith(idBase))
         return true;
-    if (id.startsWith(tag + idBase))
+    if (id.startsWith(virtualIdTag + idBase))
         return true;
     // https://github.com/vikejs/vike/issues/1985
     (0, utils_js_1.assertUsage)(!id.includes(idBase), `Encountered a module ID ${picocolors_1.default.cyan(id)} that is unexpected. Are you using a tool that modifies the ID of modules? For example, the baseUrl setting in tsconfig.json cannot be used.`);
     return false;
 }
 function getVirtualFileId(id) {
-    if (id.startsWith(tag)) {
-        id = id.slice(tag.length);
-    }
-    (0, utils_js_1.assert)(!id.startsWith(tag));
-    return id;
+    return removeVirtualIdTag(id);
 }
 function resolveVirtualFileId(id) {
     (0, utils_js_1.assert)(isVirtualFileId(id));
-    if (!id.startsWith(tag)) {
-        id = tag + id;
+    if (!id.startsWith(virtualIdTag)) {
+        id = virtualIdTag + id;
+    }
+    (0, utils_js_1.assert)(id.startsWith(virtualIdTag));
+    return id;
+}
+function removeVirtualIdTag(id) {
+    if (id.startsWith(virtualIdTag)) {
+        id = id.slice(virtualIdTag.length);
     }
-    (0, utils_js_1.assert)(id.startsWith(tag));
+    (0, utils_js_1.assert)(!id.startsWith(virtualIdTag));
     return id;
 }

package/dist/cjs/shared/modifyUrl.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modifyUrl = modifyUrl;
+const modifyUrlSameOrigin_js_1 = require("./modifyUrlSameOrigin.js");
 const utils_js_1 = require("./utils.js");
 /**
  * Modify a URL.
@@ -10,9 +11,8 @@ const utils_js_1 = require("./utils.js");
  * https://vike.dev/modifyUrl
  */
 function modifyUrl(url, modify) {
+    url = (0, modifyUrlSameOrigin_js_1.modifyUrlSameOrigin)(url, modify);
     const urlParsed = (0, utils_js_1.parseUrl)(url, '/');
-    // Pathname
-    const pathname = modify.pathname ?? urlParsed.pathname;
     // Origin
     const originParts = [
         modify.protocol ?? urlParsed.protocol ?? '',
@@ -23,8 +23,6 @@ function modifyUrl(url, modify) {
         originParts.push(`:${port}`);
     }
     const origin = originParts.join('');
-    const urlModified = (0, utils_js_1.createUrlFromComponents)(origin, pathname, 
-    // Should we also support modifying search and hash?
-    urlParsed.searchOriginal, urlParsed.hashOriginal);
+    const urlModified = (0, utils_js_1.createUrlFromComponents)(origin, urlParsed.pathname, urlParsed.searchOriginal, urlParsed.hashOriginal);
     return urlModified;
 }