vike 0.4.220 → 0.4.221-commit-8577456

package/dist/cjs/__internal/index.js

@@ -3,20 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setGlobalContext_buildEntry = void 0;
 exports.route = route;
 exports.getPagesAndRoutes = getPagesAndRoutes;
-exports.getMiddlewares = getMiddlewares;
-// Internals needed by Vike
+// Needed by Vike
 var globalContext_js_1 = require("../node/runtime/globalContext.js");
 Object.defineProperty(exports, "setGlobalContext_buildEntry", { enumerable: true, get: function () { return globalContext_js_1.setGlobalContext_buildEntry; } });
 const index_js_1 = require("../shared/route/index.js");
-const getPageFiles_js_1 = require("../shared/getPageFiles/getPageFiles.js");
 const globalContext_js_2 = require("../node/runtime/globalContext.js");
 const assertSetup_js_1 = require("../utils/assertSetup.js");
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
+ *
+ * TODO/eventually: remove
  */
 async function getPagesAndRoutes() {
     (0, assertSetup_js_1.setNodeEnvProduction)();
-    const globalContext = (0, globalContext_js_2.getGlobalContext)();
+    await (0, globalContext_js_2.initGlobalContext_getPagesAndRoutes)();
+    const globalContext = await (0, globalContext_js_2.getGlobalContextInternal)();
     const { 
     //
     pageRoutes, pageFilesAll, pageConfigs, allPageIds } = globalContext;
@@ -27,25 +28,6 @@ async function getPagesAndRoutes() {
         allPageIds
     };
 }
-// TODO/eventually:
-//  - Remove the need for `isProduction` after Vike's CLI is implemented
-//  - Remove it in favor of https://vike.dev/getGlobalContext
-async function getMiddlewares() {
-    const isProduction = process.env.NODE_ENV === 'production';
-    const { pageConfigs } = await getPageFilesAllSafe(isProduction);
-    const middlewares = pageConfigs[0].configValues.middleware.value.flat(Infinity);
-    return middlewares;
-}
-// TODO/eventually:
-//  - Make it cleaner once the internal refactoring about global configs is done.
-//  - Remove it in favor of https://vike.dev/getGlobalContext
-// Demo usage: https://github.com/vikejs/vike/pull/1823
-async function getPageFilesAllSafe(isProduction) {
-    await (0, globalContext_js_2.initGlobalContext_getGlobalContextAsync)(isProduction);
-    const globalContext = (0, globalContext_js_2.getGlobalContext)();
-    const pageFilesAll = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
-    return pageFilesAll;
-}
 async function route(pageContext) {
     const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
     // Old interface

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

@@ -32,41 +32,50 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = build;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
-const isPrerenderAutoRunEnabled_js_1 = require("../prerender/isPrerenderAutoRunEnabled.js");
+const assert_1 = __importDefault(require("assert"));
+const context_js_1 = require("../cli/context.js");
+const context_js_2 = require("../prerender/context.js");
+const utils_js_1 = require("./utils.js");
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfigGlobal } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'build');
-    // Build client-side
-    const outputClient = await (0, vite_1.build)(viteConfigEnhanced);
-    // Build server-side
-    const outputServer = await (0, vite_1.build)(setSSR(viteConfigEnhanced));
-    // Pre-render
-    if ((0, isPrerenderAutoRunEnabled_js_1.isPrerenderAutoRunEnabled)(vikeConfigGlobal)) {
-        const { runPrerenderFromAutoRun } = await Promise.resolve().then(() => __importStar(require('../prerender/runPrerender.js')));
-        await runPrerenderFromAutoRun(viteConfigEnhanced);
+    const { viteConfigEnhanced, vikeConfig } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (vikeConfig.global.config.viteEnvironmentAPI) {
+        (0, utils_js_1.assertVersion)('Vite', vite_1.version, '6.0.0');
+        const { createBuilder } = await Promise.resolve().then(() => __importStar(require('vite')));
+        const builder = await createBuilder(viteConfigEnhanced);
+        await builder.buildApp();
+    }
+    else {
+        // This buildVite() call does everything:
+        // 1. Build client-side
+        // 2. Build server-side
+        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+        // 3. Pre-render (if enabled)
+        //    > 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);
+        // 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,
-        */
-        rollupOutputClient: outputClient,
-        rollupOutputServer: outputServer
-    };
-}
-function setSSR(viteConfig) {
-    return {
-        ...viteConfig,
-        build: {
-            ...viteConfig?.build,
-            ssr: true
-        }
+    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigEnhanced,
+    */
     };
 }

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

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setOperation = setOperation;
-exports.clearOperation = clearOperation;
 exports.isVikeCliOrApi = isVikeCliOrApi;
+exports.setContextApiOperation = setContextApiOperation;
+exports.clearContextApiOperation = clearContextApiOperation;
 const utils_js_1 = require("./utils.js");
-const globalObject = (0, utils_js_1.getGlobalObject)('context.ts', {
-    apiOperation: undefined
-});
-function getOperation() {
+const globalObject = (0, utils_js_1.getGlobalObject)('api/context.ts', {});
+function getApiOperation() {
     (0, utils_js_1.assert)(globalObject.apiOperation);
     return globalObject.apiOperation;
 }
@@ -15,10 +13,10 @@ function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setOperation(operation) {
+function setContextApiOperation(operation) {
     (0, utils_js_1.assert)(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
-function clearOperation() {
+function clearContextApiOperation() {
     globalObject.apiOperation = undefined;
 }

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

@@ -49,33 +49,34 @@ const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalContext_js_1 = require("../runtime/globalContext.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('prepareViteApiCall.ts', {});
-async function prepareViteApiCall(viteConfig, operation) {
+async function prepareViteApiCall(viteConfigFromOptions, operation) {
     clear();
-    (0, context_js_1.setOperation)(operation);
-    return enhanceViteConfig(viteConfig, operation);
+    (0, context_js_1.setContextApiOperation)(operation);
+    return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    (0, context_js_1.clearOperation)();
+    (0, context_js_1.clearContextApiOperation)();
     (0, globalContext_js_1.clearGlobalContext)();
 }
-async function enhanceViteConfig(viteConfig, operation) {
-    const viteInfo = await getInfoFromVite(viteConfig, operation);
+async function enhanceViteConfig(viteConfigFromOptions, operation) {
+    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
-        viteConfigEnhanced,
-        vikeConfigGlobal: vikeConfig.vikeConfigGlobal
+        vikeConfig,
+        viteConfigEnhanced
     };
 }
 function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
+    const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigEnhanced;
     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);
+        (0, utils_js_1.assertUsage)(findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
     return viteConfigEnhanced;
 }
@@ -85,13 +86,14 @@ async function getViteRoot(operation) {
     (0, utils_js_1.assert)(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfig, operation) {
-    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
-    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+async function getInfoFromVite(viteConfigFromOptions, operation) {
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
+    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfig;
-    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
+    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -100,20 +102,20 @@ async function getInfoFromVite(viteConfig, operation) {
         // 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 = {
-            ...viteConfig,
-            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
+            ...viteConfigFromOptions,
+            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        const res = findVikeVitePlugin(viteConfigEnhanced);
         (0, utils_js_1.assert)(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     (0, utils_js_1.assert)(vikeVitePluginOptions);
     return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-function findVikeVitePlugin(plugins) {
+function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
-    plugins.forEach((p) => {
+    viteConfig?.plugins?.forEach((p) => {
         if (p && '__vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
             const options = p.__vikeVitePluginOptions;
@@ -126,8 +128,8 @@ function findVikeVitePlugin(plugins) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfig, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+async function loadViteConfigFile(viteConfigFromOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {

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

@@ -3,6 +3,7 @@ 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`
  *

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

@@ -20,5 +20,6 @@ const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.onLoad)();
 __exportStar(require("../../utils/assert.js"), exports);
 __exportStar(require("../../utils/getGlobalObject.js"), exports);
-__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../../utils/path.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/assertVersion.js"), exports);

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVikeCli = isVikeCli;
+exports.setContextCliCommand = setContextCliCommand;
+const utils_js_1 = require("./utils.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('cli/context.ts', {});
+function getCliCommand() {
+    return globalObject.cliCommand;
+}
+function isVikeCli() {
+    return !!globalObject.cliCommand;
+}
+function setContextCliCommand(command) {
+    (0, utils_js_1.assert)(!globalObject.cliCommand);
+    globalObject.cliCommand = command;
+}

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

@@ -40,9 +40,11 @@ const utils_js_1 = require("./utils.js");
 const index_js_1 = require("../api/index.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const parseCli_js_1 = require("./parseCli.js");
+const context_js_1 = require("./context.js");
 cli();
 async function cli() {
     const { command } = (0, parseCli_js_1.parseCli)();
+    (0, context_js_1.setContextCliCommand)(command);
     if (command === 'dev') {
         await cmdDev();
     }

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

@@ -21,3 +21,4 @@ const onLoad_js_1 = require("./onLoad.js");
 __exportStar(require("../../utils/assert.js"), exports);
 __exportStar(require("../../utils/projectInfo.js"), exports);
 __exportStar(require("../../utils/includes.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);

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

@@ -9,7 +9,6 @@ exports.ssr = plugin;
 exports.default = plugin;
 var utils_js_1 = require("./utils.js");
 Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
-const vite_1 = require("vite");
 const utils_js_2 = require("./utils.js");
 const buildConfig_js_1 = require("./plugins/buildConfig.js");
 const previewConfig_js_1 = require("./plugins/previewConfig.js");
@@ -30,11 +29,11 @@ const envVars_js_1 = require("./plugins/envVars.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const fileEnv_js_1 = require("./plugins/fileEnv.js");
 const getPageAssets_js_1 = require("../runtime/renderPage/getPageAssets.js");
-const resolveClientEntriesDev_js_1 = require("./resolveClientEntriesDev.js");
+const resolveClientEntriesDev_js_1 = require("./shared/resolveClientEntriesDev.js");
 const workaroundCssModuleHmr_js_1 = require("./plugins/workaroundCssModuleHmr.js");
 const workaroundVite6HmrRegression_js_1 = require("./plugins/workaroundVite6HmrRegression.js");
-(0, utils_js_2.markSetup_vikeVitePlugin)();
-assertViteVersion();
+const buildApp_js_1 = require("./plugins/buildApp.js");
+// We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 (0, getPageAssets_js_1.setResolveClientEntriesDev)(resolveClientEntriesDev_js_1.resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeVitePluginOptions = {}) {
@@ -43,6 +42,7 @@ function plugin(vikeVitePluginOptions = {}) {
         (0, index_js_2.importUserCode)(),
         ...(0, index_js_1.devConfig)(),
         ...(0, buildConfig_js_1.buildConfig)(),
+        ...(0, buildApp_js_1.buildApp)(),
         (0, previewConfig_js_1.previewConfig)(),
         ...(0, autoFullBuild_js_1.autoFullBuild)(),
         (0, packageJsonFile_js_1.packageJsonFile)(),
@@ -69,10 +69,6 @@ Object.defineProperty(plugin, 'apply', {
         (0, utils_js_2.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
-// package.json#peerDependencies isn't enough as users can ignore it
-function assertViteVersion() {
-    (0, utils_js_2.assertVersion)('Vite', vite_1.version, '5.1.0');
-}
 // Ensures following works: `const vike = require('vike/plugin')` / `import vike from 'vike/plugin'`
 //  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.
 try {

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

@@ -4,9 +4,14 @@ exports.onLoad = onLoad;
 const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
 const assertSetup_js_1 = require("../../utils/assertSetup.js");
 const assertNodeVersion_js_1 = require("../../utils/assertNodeVersion.js");
+const assertVersion_js_1 = require("../../utils/assertVersion.js");
+const vite_1 = require("vite");
 function onLoad() {
+    (0, assertSetup_js_1.markSetup_vikeVitePlugin)();
     (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
     (0, assertNodeVersion_js_1.assertNodeVersion)();
-    // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+    // package.json#peerDependencies isn't enough as users often ignore it
+    (0, assertVersion_js_1.assertVersion)('Vite', vite_1.version, '5.1.0');
+    // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     (0, assertSetup_js_1.assertIsNotProductionRuntime)();
 }

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

@@ -5,29 +5,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.autoFullBuild = autoFullBuild;
+const getFullBuildInlineConfig_js_1 = require("../shared/getFullBuildInlineConfig.js");
 const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const runPrerender_js_1 = require("../../prerender/runPrerender.js");
-const isPrerenderAutoRunEnabled_js_1 = require("../../prerender/isPrerenderAutoRunEnabled.js");
+const context_js_1 = require("../../prerender/context.js");
 const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const logErrorHint_js_1 = require("../../runtime/renderPage/logErrorHint.js");
 const buildConfig_js_1 = require("./buildConfig.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
+const context_js_2 = require("../../api/context.js");
 let forceExit = false;
 function autoFullBuild() {
     let config;
-    let vikeConfigGlobal;
+    let vikeConfig;
     return [
         {
             name: 'vike:autoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config_);
-                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+                vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config_);
                 config = config_;
-                abortViteBuildSsr(vikeConfigGlobal);
+                abortViteBuildSsr(vikeConfig);
             },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
@@ -36,7 +37,7 @@ function autoFullBuild() {
                 */
                 async handler(_options, bundle) {
                     try {
-                        await triggerFullBuild(config, vikeConfigGlobal, bundle);
+                        await triggerFullBuild(config, vikeConfig, bundle);
                     }
                     catch (err) {
                         // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -56,16 +57,17 @@ function autoFullBuild() {
                 handler() {
                     if (forceExit) {
                         (0, runPrerender_js_1.runPrerender_forceExit)();
+                        (0, utils_js_1.assert)(false);
                     }
                 }
             }
         }
     ];
 }
-async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
+async function triggerFullBuild(config, vikeConfig, bundle) {
     if (config.build.ssr)
         return; // already triggered
-    if (isDisabled(vikeConfigGlobal))
+    if (isDisabled(vikeConfig))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -73,44 +75,43 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
     if (!bundle[buildConfig_js_1.manifestTempFile])
         return;
-    const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
-    const configInline = {
-        ...configFromCli,
-        configFile: configFromCli?.configFile || config.configFile,
-        root: config.root,
-        build: {
-            ...configFromCli?.build
-        }
-    };
+    const configInline = (0, getFullBuildInlineConfig_js_1.getFullBuildInlineConfig)(config);
     try {
-        await (0, vite_1.build)({
-            ...configInline,
-            build: {
-                ...configInline.build,
-                ssr: true
-            }
-        });
+        await (0, vite_1.build)(setSSR(configInline));
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    if ((0, isPrerenderAutoRunEnabled_js_1.isPrerenderAutoRunEnabled)(vikeConfigGlobal)) {
-        await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline);
-        forceExit = true;
+    if ((0, context_js_1.isPrerenderAutoRunEnabled)(vikeConfig)) {
+        const res = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline, config);
+        forceExit = res.forceExit;
     }
 }
-function abortViteBuildSsr(vikeConfigGlobal) {
-    if (vikeConfigGlobal.disableAutoFullBuild !== true && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
+function abortViteBuildSsr(vikeConfig) {
+    if (vikeConfig.global.config.disableAutoFullBuild !== true && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
         (0, utils_js_1.assertWarning)(false, `The CLI call ${picocolors_1.default.cyan('$ vite build --ssr')} is superfluous since ${picocolors_1.default.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${picocolors_1.default.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
-function isDisabled(vikeConfigGlobal) {
-    const { disableAutoFullBuild } = vikeConfigGlobal;
-    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        return !(0, isViteCliCall_js_1.isViteCliCall)();
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild, viteEnvironmentAPI } = vikeConfig.global.config;
+    if (viteEnvironmentAPI) {
+        return true;
+    }
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isViteApi = !(0, isViteCliCall_js_1.isViteCliCall)() && !(0, context_js_2.isVikeCliOrApi)();
+        return isViteApi;
     }
     else {
         return disableAutoFullBuild;

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

@@ -13,7 +13,7 @@ function baseUrls() {
             const isDev = config._isDev;
             (0, utils_js_1.assert)(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = (0, resolveBase_js_1.resolveBase)(baseViteOriginal, config.vike.vikeConfigGlobal.baseServer, config.vike.vikeConfigGlobal.baseAssets);
+            basesResolved = (0, resolveBase_js_1.resolveBase)(baseViteOriginal, config.vike.config.baseServer ?? null, config.vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;
@@ -29,7 +29,7 @@ function baseUrls() {
         },
         async configResolved(config) {
             const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config);
-            const basesResolved2 = (0, resolveBase_js_1.resolveBaseFromResolvedConfig)(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
+            const basesResolved2 = (0, resolveBase_js_1.resolveBaseFromResolvedConfig)(vikeConfig.global.config.baseServer ?? null, vikeConfig.global.config.baseAssets ?? null, config);
             (0, utils_js_1.assert)(basesResolved2.baseServer === basesResolved.baseServer);
             (0, utils_js_1.assert)(basesResolved2.baseAssets === basesResolved.baseAssets);
             /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApp = buildApp;
+const runPrerender_js_1 = require("../../prerender/runPrerender.js");
+const context_js_1 = require("../../prerender/context.js");
+const getOutDirs_js_1 = require("../shared/getOutDirs.js");
+const utils_js_1 = require("../utils.js");
+const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
+const getFullBuildInlineConfig_js_1 = require("../shared/getFullBuildInlineConfig.js");
+function buildApp() {
+    let config;
+    return [
+        {
+            name: 'vike:buildApp',
+            apply: 'build',
+            config(config) {
+                if (!config.vike.config.viteEnvironmentAPI)
+                    return;
+                return {
+                    builder: {
+                        buildApp: async (builder) => {
+                            (0, utils_js_1.assert)(builder.environments.client);
+                            (0, utils_js_1.assert)(builder.environments.ssr);
+                            await builder.build(builder.environments.client);
+                            await builder.build(builder.environments.ssr);
+                        }
+                    },
+                    environments: {
+                        ssr: {
+                            consumer: 'server',
+                            build: {
+                                outDir: (0, getOutDirs_js_1.resolveOutDir)(config, true),
+                                ssr: true
+                            }
+                        },
+                        client: {
+                            consumer: 'client',
+                            build: {
+                                copyPublicDir: true,
+                                ssr: false
+                            }
+                        }
+                    }
+                };
+            }
+        },
+        {
+            name: 'vike:buildApp:prerender',
+            apply: 'build',
+            enforce: 'pre',
+            applyToEnvironment(env) {
+                return env.name === 'ssr';
+            },
+            configResolved(_config) {
+                config = _config;
+            },
+            async writeBundle() {
+                if (!config.vike.config.viteEnvironmentAPI)
+                    return;
+                const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config);
+                if (!(0, context_js_1.isPrerenderAutoRunEnabled)(vikeConfig))
+                    return;
+                const configInline = (0, getFullBuildInlineConfig_js_1.getFullBuildInlineConfig)(config);
+                const { forceExit } = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline, config);
+                if (forceExit) {
+                    (0, runPrerender_js_1.runPrerender_forceExit)();
+                    (0, utils_js_1.assert)(false);
+                }
+            }
+        }
+    ];
+}