vike 0.4.214 → 0.4.216

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

@@ -11,9 +11,9 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_isDev };
+export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
-import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -89,8 +89,8 @@ function assertIsNotInitilizedYet() {
     // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     assert(!globalObject.globalContext);
 }
-function setGlobalContext_isDev(isDev) {
-    globalObject.isDev = isDev;
+function setGlobalContext_isViteDev(isViteDev) {
+    globalObject.isViteDev = isViteDev;
 }
 function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
@@ -102,7 +102,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)
@@ -138,8 +138,8 @@ async function initGlobalContext(isProduction) {
         assert(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
     }
-    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
-    assertNodeEnv_runtime(isDev ?? false);
+    const { viteDevServer, viteConfig, isPrerendering } = globalObject;
+    onSetupRuntime();
     if (!isProduction) {
         assert(viteConfig);
         assert(viteDevServer);

package/dist/esm/node/runtime/index-common.d.ts

@@ -3,6 +3,7 @@ export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
 export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
 import './page-files/setup.js';

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

@@ -3,6 +3,7 @@ export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
 export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
 // TODO/v1-release: remove
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -31,7 +31,7 @@ const renderPage_addWrapper = (wrapper) => {
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
-    assertEnv();
+    onSetupRuntime();
     assertIsUrl(pageContextInit.urlOriginal);
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
@@ -332,7 +332,9 @@ function assertIsUrl(urlOriginal) {
 }
 function assertIsNotViteRequest(urlPathname, urlOriginal) {
     const isViteRequest = urlPathname.startsWith('/@vite/client') || urlPathname.startsWith('/@fs/') || urlPathname.startsWith('/__vite_ping');
-    assertUsage(!isViteRequest, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.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;
+    assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();

package/dist/esm/node/runtime/utils.d.ts

@@ -39,9 +39,8 @@ export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
-export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/path-shim.js';
-export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';

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

@@ -43,9 +43,8 @@ export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
-export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/path-shim.js';
-export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.d.ts

@@ -0,0 +1,10 @@
+export { createDevMiddleware };
+import type { ResolvedConfig, Connect, ViteDevServer } from 'vite';
+import type { APIOptions } from '../api/types.js';
+declare function createDevMiddleware(options?: {
+    root?: string;
+} & APIOptions): Promise<{
+    devMiddleware: Connect.Server;
+    viteServer: ViteDevServer;
+    viteConfig: ResolvedConfig;
+}>;

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

@@ -0,0 +1,23 @@
+export { createDevMiddleware };
+import { createServer } from 'vite';
+import { prepareViteApiCall } from '../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 prepareViteApiCall(viteConfig, 'dev');
+    const server = await createServer(viteConfigEnhanced);
+    const devMiddleware = server.middlewares;
+    return { devMiddleware, viteServer: server, viteConfig: server.config };
+}

package/dist/esm/node/runtime-dev/index.d.ts

@@ -0,0 +1,3 @@
+export { createDevMiddleware_ as createDevMiddleware };
+import type { createDevMiddleware as createDevMiddlewareType } from '../runtime-dev/createDevMiddleware.js';
+declare const createDevMiddleware_: typeof createDevMiddlewareType;

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

@@ -0,0 +1,6 @@
+export { createDevMiddleware_ as createDevMiddleware };
+const createDevMiddleware_ = async (...args) => {
+    const p = './createDevMiddleware.js';
+    const { createDevMiddleware } = await import(/*webpackIgnore: true*/ /* @vite-ignore */ p);
+    return createDevMiddleware(...args);
+};

package/dist/esm/shared/page-configs/getConfigValue.d.ts

@@ -1,14 +1,8 @@
 export { getConfigValueRuntime };
-export { getConfigValueTyped };
-export type { TypeAsString };
 import { type ResolveTypeAsString } from '../utils.js';
 import type { PageConfigRuntime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-type ConfigName = ConfigNameBuiltIn;
-type TypeAsString = 'string' | 'boolean' | undefined;
-declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigName, type?: Type): null | (ConfigValue & {
-    value: ResolveTypeAsString<Type>;
-});
-declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+import { type TypeAsString } from './getConfigValueTyped.js';
+declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;
 });

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

@@ -1,34 +1,8 @@
 export { getConfigValueRuntime };
-export { getConfigValueTyped };
-import { assert, assertUsage, getValuePrintable } from '../utils.js';
-import pc from '@brillout/picocolors';
-import { getConfigDefinedAtOptional } from './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;
-}
+import { getConfigValueTyped } from './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) {
-    assert(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = getValuePrintable(value);
-    const problem = valuePrintable !== null
-        ? `value ${pc.cyan(valuePrintable)}`
-        : `type ${pc.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
-    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
-    assertUsage(false, errMsg);
-}

package/dist/esm/shared/page-configs/getConfigValueBuildTime.d.ts

@@ -2,8 +2,7 @@ export { getConfigValueBuildTime };
 import { type ResolveTypeAsString } from '../utils.js';
 import type { PageConfigBuildTime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-import { type TypeAsString } from './getConfigValue.js';
-type ConfigName = ConfigNameBuiltIn;
-declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+import { type TypeAsString } from './getConfigValueTyped.js';
+declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;
 });

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

@@ -1,7 +1,7 @@
 export { getConfigValueBuildTime };
 import { assert } from '../utils.js';
-import { getConfigValueTyped } from './getConfigValue.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
+import { getConfigValueTyped } from './getConfigValueTyped.js';
 assertIsNotProductionRuntime();
 function getConfigValueBuildTime(pageConfig, configName, type) {
     const configValue = getConfigValue(pageConfig, configName);

package/dist/esm/shared/page-configs/getConfigValueTyped.d.ts

@@ -0,0 +1,9 @@
+export { getConfigValueTyped };
+export type { TypeAsString };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { ConfigValue } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
+type TypeAsString = 'string' | 'boolean' | undefined;
+declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -0,0 +1,27 @@
+export { getConfigValueTyped };
+import { assert, assertUsage, getValuePrintable } from '../utils.js';
+import pc from '@brillout/picocolors';
+import { getConfigDefinedAtOptional } from './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) {
+    assert(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = getValuePrintable(value);
+    const problem = valuePrintable !== null
+        ? `value ${pc.cyan(valuePrintable)}`
+        : `type ${pc.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
+    assertUsage(false, errMsg);
+}

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

@@ -1,5 +1,5 @@
 export { serializeConfigValues };
-import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
 import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.214";
+export declare const PROJECT_VERSION: "0.4.216";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.214';
+export const PROJECT_VERSION = '0.4.216';

package/dist/esm/utils/assertSetup.d.ts

@@ -0,0 +1,20 @@
+export { assertIsNotProductionRuntime };
+export { onSetupRuntime };
+export { onSetupBuild };
+export { onSetupPrerender };
+export { setNodeEnvProduction };
+export { markSetup_viteDevServer };
+export { markSetup_vitePreviewServer };
+export { markSetup_vikeVitePlugin };
+export { markSetup_isViteDev };
+export { markSetup_isPrerendering };
+declare function assertIsNotProductionRuntime(): void | undefined;
+declare function onSetupRuntime(): void | undefined;
+declare function onSetupBuild(): void;
+declare function onSetupPrerender(): void;
+declare function markSetup_viteDevServer(): void | undefined;
+declare function markSetup_vitePreviewServer(): void | undefined;
+declare function markSetup_vikeVitePlugin(): void;
+declare function markSetup_isViteDev(isViteDev: boolean): void;
+declare function markSetup_isPrerendering(): void;
+declare function setNodeEnvProduction(): void | undefined;

package/dist/esm/utils/assertSetup.js

@@ -0,0 +1,130 @@
+export { assertIsNotProductionRuntime };
+export { onSetupRuntime };
+export { onSetupBuild };
+export { onSetupPrerender };
+export { setNodeEnvProduction };
+export { markSetup_viteDevServer };
+export { markSetup_vitePreviewServer };
+export { markSetup_vikeVitePlugin };
+export { markSetup_isViteDev };
+export { markSetup_isPrerendering };
+import { assert, assertUsage, assertWarning } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { createDebugger } from './debug.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { isVitest } from './isVitest.js';
+import pc from '@brillout/picocolors';
+assertIsNotBrowser();
+const debug = createDebugger('vike:setup');
+const setup = 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.
+        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 });
+        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()
+        assert(!setup.shouldNotBeProduction);
+    }
+    else {
+        // TODO: make it assertUsage() again once https://github.com/vikejs/vike/issues/1528 is implemented.
+        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
+        assert(setup.vikeVitePlugin);
+        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 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.
+    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 ${pc.bold(envType)} by ${pc.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';
+    assert(getNodeEnvValue() === 'production');
+}

package/dist/esm/utils/isDocker.js

@@ -1,6 +1,6 @@
 export { isDocker };
 import fs from 'node:fs';
-import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
 assertIsNotProductionRuntime();
 function isDocker() {
     return hasContainerEnv() || isDockerContainer();

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.214";
+    projectVersion: "0.4.216";
 };

package/dist/esm/utils/requireResolve.js

@@ -1,7 +1,7 @@
 export { requireResolve };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from './assertSetup.js';
 import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
 import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'module';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.214",
+  "version": "0.4.216",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/cjs/utils/assertIsNotProductionRuntime.js

@@ -1,62 +0,0 @@
-"use strict";
-// Mechanism to ensure code isn't loaded by production runtime
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vikeVitePluginLoadedInProductionError = void 0;
-exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
-exports.markEnvAsViteDev = markEnvAsViteDev;
-exports.markEnvAsVitePreview = markEnvAsVitePreview;
-exports.markEnvAsVikePluginLoaded = markEnvAsVikePluginLoaded;
-exports.assertEnv = assertEnv;
-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");
-(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-const debug = (0, debug_js_1.createDebugger)('vike:setup');
-const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
-exports.vikeVitePluginLoadedInProductionError = vikeVitePluginLoadedInProductionError;
-const env = (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);
-    env.shouldNotBeProduction = true;
-}
-// Called by Vite hook configureServer()
-function markEnvAsViteDev() {
-    if (debug.isActivated)
-        debug('markEnvAsViteDev()', new Error().stack);
-    env.isViteDev = true;
-}
-// Called by Vite hook configurePreviewServer()
-function markEnvAsVitePreview() {
-    if (debug.isActivated)
-        debug('markEnvAsVitePreview()', new Error().stack);
-    env.isVitePreview = true;
-}
-// Called by ../node/plugin/index.ts
-function markEnvAsVikePluginLoaded() {
-    if (debug.isActivated)
-        debug('markEnvAsVikePluginLoaded()', new Error().stack);
-    env.isVikePluginLoaded = true;
-}
-// Called by ../node/runtime/index.ts
-function assertEnv() {
-    if (debug.isActivated)
-        debug('assertEnv()', new Error().stack);
-    if ((0, isVitest_js_1.isVitest)())
-        return;
-    const isProduction = !env.isViteDev && !env.isVitePreview;
-    if (isProduction) {
-        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
-        (0, assert_js_1.assertUsage)(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
-        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
-        (0, assert_js_1.assert)(!env.shouldNotBeProduction);
-    }
-    else {
-        // This assert() is obious and boring
-        (0, assert_js_1.assert)(env.shouldNotBeProduction);
-        (0, assert_js_1.assert)(env.isVikePluginLoaded);
-    }
-}