vike 0.4.215 → 0.4.216

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

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, isArray, changeEnumerable } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -28,7 +28,7 @@ import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVik
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
-import { prepareApiCall } from '../api/prepareApiCall.js';
+import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -36,7 +36,7 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareApiCall(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareViteApiCall(undefined, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -61,13 +61,13 @@ async function runPrerenderFromAutoRun(viteConfig, forceExit) {
 }
 async function runPrerender(options = {}, standaloneTrigger) {
     checkOutdatedOptions(options);
+    onSetupPrerender();
     setGlobalContext_isPrerendering();
     getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    handleNodeEnv_prerender();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);

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

@@ -9,7 +9,7 @@ export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';

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

@@ -11,7 +11,7 @@ export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';

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

@@ -9,7 +9,7 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_isDev };
+export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
@@ -52,7 +52,7 @@ declare function getGlobalContextSync(): GlobalContextPublic;
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
-declare function setGlobalContext_isDev(isDev: boolean): void;
+declare function setGlobalContext_isViteDev(isViteDev: boolean): void;
 declare function setGlobalContext_isPrerendering(): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function getViteConfig(): ResolvedConfig | null;

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/getConfigValueBuildTime.js

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

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.215";
+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.215';
+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.215";
+    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.215",
+  "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);
-    }
-}

package/dist/cjs/utils/assertNodeEnv.js

@@ -1,106 +0,0 @@
-"use strict";
-// This file serves the following three purposes:
-//   1. Upon building the app, we ensure the right NODE_ENV value is set.
-//      - Both Vue and React use NODE_ENV for enabling production-specific features:
-//        - 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
-//      - Setting NODE_ENV to 'production' doesn't seem to make any sense in development.
-//      - With React upon building the app, setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/vikejs/vike/issues/1469#issuecomment-1969301797
-//      - With Vue upon building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
-//   2. Ensure Vite isn't loaded in production.
-//      - We currently only check whether Vite's development middleware is instantiated (i.e. whether Vite's `createServer()` was called). Is there a way to detect whether Vite's code is loaded?
-//   3. Ensure NODE_ENV isn't mistakenly set to a wrong value.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNodeEnv_build = assertNodeEnv_build;
-exports.assertNodeEnv_runtime = assertNodeEnv_runtime;
-exports.assertNodeEnv_onVikePluginLoad = assertNodeEnv_onVikePluginLoad;
-exports.handleNodeEnv_prerender = handleNodeEnv_prerender;
-exports.handleNodeEnv_vitePluginVercel = handleNodeEnv_vitePluginVercel;
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
-const assert_js_1 = require("./assert.js");
-const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
-(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-function assertNodeEnv_build() {
-    assertNodeEnvIsNotDev('building');
-}
-function assertNodeEnv_runtime(isViteDev) {
-    const nodeEnv = getNodeEnv();
-    if (nodeEnv === null || nodeEnv === 'test')
-        return;
-    const isNodeDev = isNodeEnvDev();
-    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    if (isViteDev === isNodeDev)
-        return;
-    const nodeEnvDesc = getNodeEnvDesc();
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    const errMsg = `Running ${isViteDev ? picocolors_1.default.cyan('$ vike dev') : 'app in production'} while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`;
-    (0, assert_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
-}
-function assertNodeEnv_onVikePluginLoad() {
-    const nodeEnv = getNodeEnv();
-    if (nodeEnv === 'test')
-        return;
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    (0, assert_js_1.assertWarning)(
-    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
-    isNodeEnvDev() || isVikeCliBuild(),
-    /*/
-    isNodeEnvDev() || true, 
-    ///*/
-    [
-        picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
-        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
-        'while the vike/plugin module is loaded.',
-        assertIsNotProductionRuntime_js_1.vikeVitePluginLoadedInProductionError
-    ].join(' '), { onlyOnce: true });
-}
-function handleNodeEnv_prerender() {
-    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
-    if (getNodeEnv())
-        assertNodeEnv();
-    setNodeEnvToProduction();
-    assertNodeEnv();
-}
-function handleNodeEnv_vitePluginVercel() {
-    setNodeEnvToProduction();
-}
-function getNodeEnv() {
-    if (typeof process === 'undefined')
-        return null;
-    return process.env.NODE_ENV;
-}
-function setNodeEnvToProduction() {
-    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
-    const proc = process;
-    const { env } = proc;
-    env.NODE_ENV = 'production';
-}
-function isNodeEnvDev() {
-    const nodeEnv = getNodeEnv();
-    if (!nodeEnv)
-        return true;
-    if (['development', 'dev'].includes(nodeEnv))
-        return true;
-    // That's quite aggressive, let's see if some user complains
-    return false;
-}
-function getNodeEnvDesc() {
-    const nodeEnv = getNodeEnv();
-    const isDev = isNodeEnvDev();
-    const nodeEnvDesc = `environment is set to be a ${(isDev ? 'development' : 'production')} environment by ${picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}`;
-    return nodeEnvDesc;
-}
-function assertNodeEnvIsNotDev(operation) {
-    const isDev = isNodeEnvDev();
-    if (!isDev)
-        return;
-    const nodeEnvDesc = getNodeEnvDesc();
-    // TODO: make it assertUsage() again once #1528 is implemented.
-    (0, assert_js_1.assertWarning)(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, {
-        onlyOnce: true
-    });
-}