vike 0.4.214 → 0.4.216

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

@@ -14,7 +14,7 @@ exports.initGlobalContext_runPrerender = initGlobalContext_runPrerender;
 exports.initGlobalContext_getGlobalContextAsync = initGlobalContext_getGlobalContextAsync;
 exports.setGlobalContext_viteDevServer = setGlobalContext_viteDevServer;
 exports.setGlobalContext_viteConfig = setGlobalContext_viteConfig;
-exports.setGlobalContext_isDev = setGlobalContext_isDev;
+exports.setGlobalContext_isViteDev = setGlobalContext_isViteDev;
 exports.setGlobalContext_isPrerendering = setGlobalContext_isPrerendering;
 const utils_js_1 = require("./utils.js");
 const loadImportBuild_js_1 = require("./globalContext/loadImportBuild.js");
@@ -92,8 +92,8 @@ function assertIsNotInitilizedYet() {
     // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     (0, utils_js_1.assert)(!globalObject.globalContext);
 }
-function setGlobalContext_isDev(isDev) {
-    globalObject.isDev = isDev;
+function setGlobalContext_isViteDev(isViteDev) {
+    globalObject.isViteDev = isViteDev;
 }
 function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
@@ -105,7 +105,7 @@ function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
 async function initGlobalContext_renderPage() {
-    await initGlobalContext(!globalObject.isDev);
+    await initGlobalContext(!globalObject.isViteDev);
 }
 async function initGlobalContext_runPrerender() {
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
@@ -141,8 +141,8 @@ async function initGlobalContext(isProduction) {
         (0, utils_js_1.assert)(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
     }
-    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
-    (0, utils_js_1.assertNodeEnv_runtime)(isDev ?? false);
+    const { viteDevServer, viteConfig, isPrerendering } = globalObject;
+    (0, utils_js_1.onSetupRuntime)();
     if (!isProduction) {
         (0, utils_js_1.assert)(viteConfig);
         (0, utils_js_1.assert)(viteDevServer);

package/dist/cjs/node/runtime/index-common.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPageRenderer = exports._injectAssets = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
+exports.createPageRenderer = exports._injectAssets = exports.createDevMiddleware = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
 var renderPage_js_1 = require("./renderPage.js");
 Object.defineProperty(exports, "renderPage", { enumerable: true, get: function () { return renderPage_js_1.renderPage; } });
 var renderHtml_js_1 = require("./html/renderHtml.js");
@@ -16,6 +16,8 @@ Object.defineProperty(exports, "version", { enumerable: true, get: function () {
 var globalContext_js_1 = require("./globalContext.js");
 Object.defineProperty(exports, "getGlobalContextSync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextSync; } });
 Object.defineProperty(exports, "getGlobalContextAsync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextAsync; } });
+var index_js_1 = require("../runtime-dev/index.js");
+Object.defineProperty(exports, "createDevMiddleware", { enumerable: true, get: function () { return index_js_1.createDevMiddleware; } });
 // TODO/v1-release: remove
 var injectAssets__public_js_1 = require("./html/injectAssets/injectAssets__public.js");
 Object.defineProperty(exports, "_injectAssets", { enumerable: true, get: function () { return injectAssets__public_js_1.injectAssets__public; } });

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

@@ -37,7 +37,7 @@ exports.renderPage_addWrapper = renderPage_addWrapper;
 async function renderPage(pageContextInit) {
     (0, assertArguments_js_1.assertArguments)(...arguments);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
-    (0, utils_js_1.assertEnv)();
+    (0, utils_js_1.onSetupRuntime)();
     assertIsUrl(pageContextInit.urlOriginal);
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
@@ -338,7 +338,9 @@ function assertIsUrl(urlOriginal) {
 }
 function assertIsNotViteRequest(urlPathname, urlOriginal) {
     const isViteRequest = urlPathname.startsWith('/@vite/client') || urlPathname.startsWith('/@fs/') || urlPathname.startsWith('/__vite_ping');
-    (0, utils_js_1.assertUsage)(!isViteRequest, `${picocolors_1.default.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because this URL should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`);
+    if (!isViteRequest)
+        return;
+    (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.code('renderPage(pageContextInit)')} called with ${picocolors_1.default.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${picocolors_1.default.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${picocolors_1.default.cyan('createDevMiddleware()')} middleware is executed *before* the ${picocolors_1.default.cyan('renderPage()')} middleware, see ${picocolors_1.default.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = (0, globalContext_js_1.getGlobalContext)();

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

@@ -59,9 +59,8 @@ __exportStar(require("../../utils/objectKeys.js"), exports);
 __exportStar(require("../../utils/objectEntries.js"), exports);
 __exportStar(require("../../utils/objectFromEntries.js"), exports);
 __exportStar(require("../../utils/getFileExtension.js"), exports);
-__exportStar(require("../../utils/assertIsNotProductionRuntime.js"), exports);
+__exportStar(require("../../utils/assertSetup.js"), exports);
 __exportStar(require("../../utils/path-shim.js"), exports);
-__exportStar(require("../../utils/assertNodeEnv.js"), exports);
 __exportStar(require("../../utils/isHtml.js"), exports);
 __exportStar(require("../../utils/warnIfErrorIsNotObject.js"), exports);
 __exportStar(require("../../utils/stripAnsi.js"), exports);

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevMiddleware = createDevMiddleware;
+const vite_1 = require("vite");
+const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+/*
+ * Create server middleware for development with HMR and lazy-transpiling.
+ *
+ * https://vike.dev/createDevMiddleware
+ */
+async function createDevMiddleware(options = {}) {
+    const viteConfig = {
+        ...options.viteConfig,
+        server: {
+            ...options.viteConfig?.server,
+            middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+        }
+    };
+    if (options.root)
+        viteConfig.root = options.root;
+    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(viteConfig, 'dev');
+    const server = await (0, vite_1.createServer)(viteConfigEnhanced);
+    const devMiddleware = server.middlewares;
+    return { devMiddleware, viteServer: server, viteConfig: server.config };
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevMiddleware = void 0;
+const createDevMiddleware_ = async (...args) => {
+    const p = './createDevMiddleware.js';
+    const { createDevMiddleware } = await Promise.resolve(`${p}`).then(s => __importStar(require(s)));
+    return createDevMiddleware(...args);
+};
+exports.createDevMiddleware = createDevMiddleware_;

package/dist/cjs/shared/page-configs/getConfigValue.js

@@ -1,39 +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.getConfigValueRuntime = getConfigValueRuntime;
-exports.getConfigValueTyped = getConfigValueTyped;
-const utils_js_1 = require("../utils.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
-function getConfigValueTyped(configValue, configName, type) {
-    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null) return null
-    */
-    const { value, definedAtData } = configValue;
-    if (type)
-        assertConfigValueType(value, type, configName, definedAtData);
-    return configValue;
-}
+const getConfigValueTyped_js_1 = require("./getConfigValueTyped.js");
 function getConfigValueRuntime(pageConfig, configName, type) {
     const configValue = pageConfig.configValues[configName];
     if (!configValue)
         return null;
-    return getConfigValueTyped(configValue, configName, type);
-}
-function assertConfigValueType(value, type, configName, definedAtData) {
-    (0, utils_js_1.assert)(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
-    const problem = valuePrintable !== null
-        ? `value ${picocolors_1.default.cyan(valuePrintable)}`
-        : `type ${picocolors_1.default.cyan(typeActual)}`;
-    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, definedAtData);
-    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`;
-    (0, utils_js_1.assertUsage)(false, errMsg);
+    return (0, getConfigValueTyped_js_1.getConfigValueTyped)(configValue, configName, type);
 }

package/dist/cjs/shared/page-configs/getConfigValueBuildTime.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfigValueBuildTime = getConfigValueBuildTime;
 const utils_js_1 = require("../utils.js");
-const getConfigValue_js_1 = require("./getConfigValue.js");
-const assertIsNotProductionRuntime_js_1 = require("../../utils/assertIsNotProductionRuntime.js");
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+const assertSetup_js_1 = require("../../utils/assertSetup.js");
+const getConfigValueTyped_js_1 = require("./getConfigValueTyped.js");
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function getConfigValueBuildTime(pageConfig, configName, type) {
     const configValue = getConfigValue(pageConfig, configName);
     if (!configValue)
         return null;
-    return (0, getConfigValue_js_1.getConfigValueTyped)(configValue, configName, type);
+    return (0, getConfigValueTyped_js_1.getConfigValueTyped)(configValue, configName, type);
 }
 function getConfigValue(pageConfig, configName) {
     const { configValueSources, configValuesComputed, configDefinitions } = pageConfig;

package/dist/cjs/shared/page-configs/getConfigValueTyped.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValueTyped = getConfigValueTyped;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
+function getConfigValueTyped(configValue, configName, type) {
+    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null) return null
+    */
+    const { value, definedAtData } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAtData);
+    return configValue;
+}
+function assertConfigValueType(value, type, configName, definedAtData) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null
+        ? `value ${picocolors_1.default.cyan(valuePrintable)}`
+        : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, definedAtData);
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`;
+    (0, utils_js_1.assertUsage)(false, errMsg);
+}

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeConfigValues = serializeConfigValues;
-const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
+const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
 const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
@@ -16,7 +16,7 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 // This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
 // - vike/shared/page-configs/serialize/parsePageConfigs.ts
 // - parsePageConfigs() is loaded on both the client- and server-side.
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     const lines = [];
     tabspace += '  ';

package/dist/cjs/utils/PROJECT_VERSION.js

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

package/dist/cjs/utils/assertSetup.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
+exports.onSetupRuntime = onSetupRuntime;
+exports.onSetupBuild = onSetupBuild;
+exports.onSetupPrerender = onSetupPrerender;
+exports.setNodeEnvProduction = setNodeEnvProduction;
+exports.markSetup_viteDevServer = markSetup_viteDevServer;
+exports.markSetup_vitePreviewServer = markSetup_vitePreviewServer;
+exports.markSetup_vikeVitePlugin = markSetup_vikeVitePlugin;
+exports.markSetup_isViteDev = markSetup_isViteDev;
+exports.markSetup_isPrerendering = markSetup_isPrerendering;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const debug_js_1 = require("./debug.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const isVitest_js_1 = require("./isVitest.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const debug = (0, debug_js_1.createDebugger)('vike:setup');
+const setup = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertIsNotProductionRuntime.ts', {});
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
+function assertIsNotProductionRuntime() {
+    if (debug.isActivated)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    setup.shouldNotBeProduction = true;
+}
+function onSetupRuntime() {
+    if (debug.isActivated)
+        debug('assertSetup()', new Error().stack);
+    if (isTest())
+        return;
+    if (!isViteLoaded()) {
+        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+        (0, assert_js_1.assertWarning)(!isNodeEnvDev(), `The ${getEnvDescription()}, which seems contradictory because the environment seems to be a production environment (Vite isn't loaded), see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        (0, assert_js_1.assertUsage)(!setup.vikeVitePlugin, "Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.");
+        // This assert() one of the main goal of this file: it ensures assertIsNotProductionRuntime()
+        (0, assert_js_1.assert)(!setup.shouldNotBeProduction);
+    }
+    else {
+        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+        (0, assert_js_1.assertWarning)(isNodeEnvDev() || setup.vitePreviewServer || setup.isPrerendering, `The ${getEnvDescription()}, but Vite is loaded which is prohibited in production, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+        // These two assert() calls aren't that interesting
+        (0, assert_js_1.assert)(setup.vikeVitePlugin);
+        (0, assert_js_1.assert)(setup.shouldNotBeProduction);
+    }
+}
+// Ensure NODE_ENV is 'production' when building.
+// - Used by both Vue and React for bundling minified version:
+//   - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
+//   - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
+// - Required for React: setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/vikejs/vike/issues/1469#issuecomment-1969301797
+// - Not required for Vue: when building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
+function onSetupBuild() {
+    assertUsageNodeEnvIsNotDev('building');
+    /* Not needed: Vite already sets `process.env.NODE_ENV = 'production'`
+    setNodeEnvProduction()
+    */
+}
+function onSetupPrerender() {
+    markSetup_isPrerendering();
+    if (getNodeEnvValue())
+        assertUsageNodeEnvIsNotDev('pre-rendering');
+    setNodeEnvProduction();
+}
+function isViteLoaded() {
+    // Do we need setup.viteDevServer or setup.vitePreviewServer ?
+    return setup.viteDevServer || setup.vitePreviewServer || setup.isViteDev !== undefined;
+}
+function isTest() {
+    return (0, isVitest_js_1.isVitest)() || getNodeEnvValue() === 'test';
+}
+// Called by Vite hook configureServer()
+function markSetup_viteDevServer() {
+    if (debug.isActivated)
+        debug('markSetup_viteDevServer()', new Error().stack);
+    setup.viteDevServer = true;
+}
+// Called by Vite hook configurePreviewServer()
+function markSetup_vitePreviewServer() {
+    if (debug.isActivated)
+        debug('markSetup_vitePreviewServer()', new Error().stack);
+    setup.vitePreviewServer = true;
+}
+// Called by ../node/plugin/index.ts
+function markSetup_vikeVitePlugin() {
+    if (debug.isActivated)
+        debug('markSetup_vikeVitePlugin()', new Error().stack);
+    setup.vikeVitePlugin = true;
+}
+// Whether Vite is loaded and whether it's in dev mode (the value returned by `isDevCheck()`)
+function markSetup_isViteDev(isViteDev) {
+    if (debug.isActivated)
+        debug('markSetup_isViteDev()', new Error().stack);
+    setup.isViteDev = isViteDev;
+}
+// Called by ../node/prerender/runPrerender.ts
+function markSetup_isPrerendering() {
+    if (debug.isActivated)
+        debug('markSetup_isPrerendering()', new Error().stack);
+    setup.isPrerendering = true;
+}
+function assertUsageNodeEnvIsNotDev(operation) {
+    if (!isNodeEnvDev())
+        return;
+    // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+    (0, assert_js_1.assertWarning)(false, `The ${getEnvDescription()} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+}
+function getEnvDescription() {
+    const nodeEnv = getNodeEnvValue();
+    const isDev = isNodeEnvDev();
+    const envType = `${(isDev ? 'development' : 'production')} environment`;
+    const nodeEnvDesc = `environment is set to be a ${picocolors_1.default.bold(envType)} by ${picocolors_1.default.cyan(`process.env.NODE_ENV===${JSON.stringify(nodeEnv)}`)}`;
+    return nodeEnvDesc;
+}
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnvValue();
+    // That's quite strict, let's see if some user complains
+    return !nodeEnv || ['development', 'dev'].includes(nodeEnv);
+}
+function getNodeEnvValue() {
+    if (typeof process === 'undefined')
+        return null;
+    return process.env.NODE_ENV?.toLowerCase();
+}
+function setNodeEnvProduction() {
+    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
+    const proc = process;
+    const { env } = proc;
+    env.NODE_ENV = 'production';
+    (0, assert_js_1.assert)(getNodeEnvValue() === 'production');
+}

package/dist/cjs/utils/isDocker.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDocker = isDocker;
 const node_fs_1 = __importDefault(require("node:fs"));
-const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+const assertSetup_js_1 = require("./assertSetup.js");
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 function isDocker() {
     return hasContainerEnv() || isDockerContainer();
 }

package/dist/cjs/utils/requireResolve.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireResolve = requireResolve;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
-const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const assertSetup_js_1 = require("./assertSetup.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const module_1 = require("module");
@@ -11,7 +11,7 @@ const module_1 = require("module");
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+(0, assertSetup_js_1.assertIsNotProductionRuntime)();
 // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
 // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
 function requireResolve(importPath, cwd) {

package/dist/esm/__internal/index.js

@@ -5,7 +5,7 @@ export { getMiddlewares };
 import { route as routeInternal } from '../shared/route/index.js';
 import { getPageFilesAll } from '../shared/getPageFiles.js';
 import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
-import { handleNodeEnv_vitePluginVercel } from '../utils/assertNodeEnv.js';
+import { setNodeEnvProduction } from '../utils/assertSetup.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
  * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
@@ -14,7 +14,7 @@ import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRo
  * @param config
  */
 async function getPagesAndRoutes() {
-    handleNodeEnv_vitePluginVercel();
+    setNodeEnvProduction();
     const renderContext = await getRenderContext();
     const { 
     //

package/dist/esm/node/api/build.d.ts

@@ -1,6 +1,13 @@
 export { build };
-import type { APIOptions } from './APIOptions.js';
+import { type Rollup } from 'vite';
+import type { APIOptions } from './types.js';
+type RollupOutput = Rollup.RollupOutput | Rollup.RollupOutput[] | Rollup.RollupWatcher;
+/**
+ * Programmatically trigger `$ vike build`
+ *
+ * https://vike.dev/api#build
+ */
 declare function build(options?: APIOptions): Promise<{
-    outputClient: import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher;
-    outputServer: import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher;
+    rollupOutputClient: RollupOutput;
+    rollupOutputServer: RollupOutput;
 }>;

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

@@ -1,8 +1,13 @@
 export { build };
-import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
+/**
+ * Programmatically trigger `$ vike build`
+ *
+ * https://vike.dev/api#build
+ */
 async function build(options = {}) {
-    const { viteConfigEnhanced, configVike } = await enhanceViteConfig(options.viteConfig, 'build');
+    const { viteConfigEnhanced, configVike } = await prepareViteApiCall(options.viteConfig, 'build');
     // Build client-side
     const outputClient = await buildVite(viteConfigEnhanced);
     // Build server-side
@@ -12,7 +17,13 @@ async function build(options = {}) {
         const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
         await runPrerenderFromAutoRun(viteConfigEnhanced, true);
     }
-    return { outputClient, outputServer };
+    return {
+        /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+        viteConfig: viteConfigEnhanced,
+        */
+        rollupOutputClient: outputClient,
+        rollupOutputServer: outputServer
+    };
 }
 function setSSR(viteConfig) {
     return {

package/dist/esm/node/api/context.d.ts

@@ -0,0 +1,5 @@
+export { isVikeCliOrApi };
+export { setOperation as setOperation };
+import type { Operation } from './types.js';
+declare function isVikeCliOrApi(): boolean;
+declare function setOperation(operation: Operation): void;

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

@@ -0,0 +1,19 @@
+export { isVikeCliOrApi };
+// export { getOperation }
+export { setOperation as setOperation };
+import { assert, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('context.ts', {
+    apiOperation: undefined
+});
+function getOperation() {
+    assert(globalObject.apiOperation);
+    return globalObject.apiOperation;
+}
+function isVikeCliOrApi() {
+    // The CLI uses the API
+    return !!globalObject.apiOperation;
+}
+function setOperation(operation) {
+    assert(!globalObject.apiOperation);
+    globalObject.apiOperation = operation;
+}

package/dist/esm/node/api/dev.d.ts

@@ -1,3 +1,12 @@
 export { dev };
-import type { APIOptions } from './APIOptions.js';
-declare function dev(options?: APIOptions): Promise<import("vite").ViteDevServer>;
+import { type ResolvedConfig, type ViteDevServer } from 'vite';
+import type { APIOptions } from './types.js';
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
+declare function dev(options?: APIOptions): Promise<{
+    viteServer: ViteDevServer;
+    viteConfig: ResolvedConfig;
+}>;

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

@@ -1,8 +1,16 @@
 export { dev };
-import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
 async function dev(options = {}) {
-    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'dev');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'dev');
     const server = await createServer(viteConfigEnhanced);
-    return server;
+    return {
+        viteServer: server,
+        viteConfig: server.config
+    };
 }

package/dist/esm/node/api/onLoad.d.ts

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

package/dist/esm/node/api/onLoad.js

@@ -0,0 +1,7 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from '../runtime/utils.js';
+function onLoad() {
+    assertIsNotBrowser();
+    assertIsNotProductionRuntime();
+}

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -0,0 +1,7 @@
+export { prepareViteApiCall };
+import type { InlineConfig } from 'vite';
+import type { Operation } from './types.js';
+declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+    viteConfigEnhanced: InlineConfig;
+    configVike: import("../../shared/ConfigVike.js").ConfigVikeResolved;
+}>;

package/dist/esm/node/api/{enhanceViteConfig.js → prepareViteApiCall.js}

@@ -1,9 +1,14 @@
-export { enhanceViteConfig };
+export { prepareViteApiCall };
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
-async function enhanceViteConfig(viteConfig = {}, command) {
-    let viteConfigResolved = await resolveViteConfig(viteConfig, command);
+import { setOperation } from './context.js';
+async function prepareViteApiCall(viteConfig = {}, operation) {
+    setOperation(operation);
+    return enhanceViteConfig(viteConfig, operation);
+}
+async function enhanceViteConfig(viteConfig = {}, operation) {
+    let viteConfigResolved = await resolveViteConfig(viteConfig, operation);
     let viteConfigEnhanced = viteConfig;
     // Add vike to plugins if not present
     if (!viteConfigResolved.plugins.some((p) => p.name === pluginName)) {
@@ -13,7 +18,7 @@ async function enhanceViteConfig(viteConfig = {}, command) {
             ...viteConfig,
             plugins: [...(viteConfig.plugins ?? []), vikePlugin()]
         };
-        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, command);
+        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
     }
     const configVike = await getConfigVike(viteConfigResolved);
     // TODO: enable Vike extensions to add Vite plugins
@@ -22,6 +27,6 @@ async function enhanceViteConfig(viteConfig = {}, command) {
         configVike
     };
 }
-async function resolveViteConfig(viteConfig, command) {
-    return await resolveConfig(viteConfig, command === 'build' || command === 'prerender' ? 'build' : 'serve', 'custom', command === 'dev' ? 'development' : 'production', command === 'preview');
+async function resolveViteConfig(viteConfig, operation) {
+    return await resolveConfig(viteConfig, operation === 'build' || operation === 'prerender' ? 'build' : 'serve', 'custom', operation === 'dev' ? 'development' : 'production', operation === 'preview');
 }