vike 0.4.215 → 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

@@ -2,6 +2,11 @@ export { build };
 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<{
     rollupOutputClient: RollupOutput;
     rollupOutputServer: RollupOutput;

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

@@ -1,8 +1,13 @@
 export { build };
-import { prepareApiCall } from './prepareApiCall.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 prepareApiCall(options.viteConfig, 'build');
+    const { viteConfigEnhanced, configVike } = await prepareViteApiCall(options.viteConfig, 'build');
     // Build client-side
     const outputClient = await buildVite(viteConfigEnhanced);
     // Build server-side

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

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

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

@@ -1,6 +1,11 @@
 export { dev };
 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,13 @@
 export { dev };
-import { prepareApiCall } from './prepareApiCall.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 prepareApiCall(options.viteConfig, 'dev');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'dev');
     const server = await createServer(viteConfigEnhanced);
     return {
         viteServer: server,

package/dist/esm/node/api/{prepareApiCall.d.ts → prepareViteApiCall.d.ts}

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

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

@@ -1,9 +1,9 @@
-export { prepareApiCall };
+export { prepareViteApiCall };
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
 import { setOperation } from './context.js';
-async function prepareApiCall(viteConfig = {}, operation) {
+async function prepareViteApiCall(viteConfig = {}, operation) {
     setOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }

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

@@ -1,6 +1,11 @@
 export { prerender };
 import { type PrerenderOptions } from '../prerender/runPrerender.js';
 import type { ResolvedConfig } from 'vite';
+/**
+ * Programmatically trigger `$ vike prerender`
+ *
+ * https://vike.dev/api#prerender
+ */
 declare function prerender(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;

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

@@ -1,8 +1,13 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
-import { prepareApiCall } from './prepareApiCall.js';
+import { prepareViteApiCall } from './prepareViteApiCall.js';
+/**
+ * Programmatically trigger `$ vike prerender`
+ *
+ * https://vike.dev/api#prerender
+ */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'prerender');
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'prerender');
     options.viteConfig = viteConfigEnhanced;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {

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

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

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

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

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

@@ -1 +1,2 @@
 export * from '../../utils/assert.js';
+export * from '../../utils/getGlobalObject.js';

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

@@ -3,3 +3,4 @@
 import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/cli/parseCli.d.ts

@@ -1,4 +1,4 @@
 export { parseCli };
 declare function parseCli(): {
-    command: "build" | "dev" | "preview" | "prerender";
+    command: "dev" | "build" | "preview" | "prerender";
 };

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

@@ -4,7 +4,7 @@ export { plugin };
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
 import { version } from 'vite';
-import { assertNodeEnv_onVikePluginLoad, assertUsage, assertVersion, markEnvAsVikePluginLoaded } from './utils.js';
+import { assertUsage, assertVersion, markSetup_vikeVitePlugin } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -28,8 +28,7 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { vite6HmrRegressionWorkaround } from './plugins/vite6HmrRegressionWorkaround.js';
-assertNodeEnv_onVikePluginLoad();
-markEnvAsVikePluginLoaded();
+markSetup_vikeVitePlugin();
 assertViteVersion();
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
@@ -48,7 +47,7 @@ function plugin(vikeConfig) {
         ...extractAssetsPlugin(),
         extractExportNamesPlugin(),
         suppressRollupWarning(),
-        setGlobalContext(),
+        ...setGlobalContext(),
         ...importBuild(),
         baseUrls(vikeConfig),
         envVarsPlugin(),

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

@@ -1,6 +1,6 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
 function onLoad() {
     assertIsNotBrowser();

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -2,7 +2,7 @@ export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, assertNodeEnv_build, assertIsNpmPackageImport } from '../utils.js';
+import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, onSetupBuild, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
@@ -27,14 +27,14 @@ function buildConfig() {
     let config;
     return [
         {
-            name: 'vike:buildConfig:configResolved',
+            name: 'vike:buildConfig:post',
             apply: 'build',
             enforce: 'post',
             configResolved: {
                 order: 'post',
                 async handler(config_) {
                     config = config_;
-                    assertNodeEnv_build();
+                    onSetupBuild();
                     assertRollupInput(config);
                     const entries = await getEntries(config);
                     assert(Object.keys(entries).length > 0);
@@ -57,7 +57,7 @@ function buildConfig() {
             config: {
                 order: 'post',
                 handler(config) {
-                    assertNodeEnv_build();
+                    onSetupBuild();
                     isSsrBuild = viteIsSSR(config);
                     return {
                         build: {
@@ -69,14 +69,15 @@ function buildConfig() {
                 }
             },
             buildStart() {
-                assertNodeEnv_build();
+                onSetupBuild();
             },
             async closeBundle() {
+                onSetupBuild();
                 await fixServerAssets_assertCssTarget(config);
             }
         },
         {
-            name: 'vike:buildConfig:writeBundle',
+            name: 'vike:buildConfig:pre',
             apply: 'build',
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
             //  - set_ASSETS_MAP() needs to be called before dist/server/ code is executed.

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

@@ -9,9 +9,7 @@ import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
 import { pluginName } from './commonConfig/pluginName.js';
 import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
-assertWarning(!isViteCliCall(), `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
-    onlyOnce: true
-});
+import { isVikeCliOrApi } from '../../api/context.js';
 function commonConfig() {
     return [
         {
@@ -34,6 +32,7 @@ function commonConfig() {
                     assertRollupInput(config);
                     assertResolveAlias(config);
                     assertEsm(config.root);
+                    assertVikeCliOrApi(config);
                 }
             },
             config: {
@@ -97,3 +96,22 @@ function assertSingleInstance(config) {
     const numberOfInstances = config.plugins.filter((o) => o.name === pluginName).length;
     assertUsage(numberOfInstances === 1, `Vike's Vite plugin (${pc.cyan("import vike from 'vike/plugin'")}) is being added ${numberOfInstances} times to the list of Vite plugins. Make sure to add it only once instead.`);
 }
+function assertVikeCliOrApi(config) {
+    if (isVikeCliOrApi())
+        return;
+    if (isViteCliCall()) {
+        assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
+            onlyOnce: true
+        });
+        return;
+    }
+    if (config.server.middlewareMode) {
+        assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
+            onlyOnce: true
+        });
+        return;
+    }
+    assertWarning(false, `Vite's JavaScript API is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
+        onlyOnce: true
+    });
+}

package/dist/esm/node/plugin/plugins/devConfig/index.js

@@ -3,7 +3,7 @@ export { logDockerHint };
 import { determineOptimizeDeps } from './determineOptimizeDeps.js';
 import { determineFsAllowList } from './determineFsAllowList.js';
 import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
-import { applyDev, assertWarning, isDocker, markEnvAsViteDev } from '../../utils.js';
+import { applyDev, assertWarning, isDocker } from '../../utils.js';
 import { improveViteLogs } from '../../shared/loggerVite.js';
 import { isErrorDebug } from '../../../shared/isErrorDebug.js';
 import { installHttpRequestAsyncStore } from '../../shared/getHttpRequestAsyncStore.js';
@@ -65,9 +65,6 @@ function devConfig() {
                     improveViteLogs(config);
                 }
                 logDockerHint(config.server.host);
-            },
-            configureServer() {
-                markEnvAsViteDev();
             }
         },
         {

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

@@ -13,12 +13,16 @@ assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, crawlWithGit) {
     assertPosixPath(userRootDir);
-    assertPosixPath(outDirAbsoluteFilesystem);
-    let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    //*/
+    const outDirRelativeFromUserRootDir = null;
+    /*/
+    assertPosixPath(outDirAbsoluteFilesystem)
+    let outDirRelativeFromUserRootDir: string | null = path.posix.relative(userRootDir, outDirAbsoluteFilesystem)
     if (outDirRelativeFromUserRootDir.startsWith('../')) {
-        // config.outDir is outside of config.root => it's going to be ignored anyways
-        outDirRelativeFromUserRootDir = null;
+      // config.outDir is outside of config.root => it's going to be ignored anyways
+      outDirRelativeFromUserRootDir = null
     }
+    //*/
     assert(outDirRelativeFromUserRootDir === null ||
         /* Not true if outDirRelativeFromUserRootDir starts with a hidden directory (i.e. a directory with a name that starts with `.`)
         !outDirRelativeFromUserRootDir.startsWith('.') &&

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -1,5 +1,5 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview, applyPreview } from '../utils.js';
+import { assertUsage, getOutDirs, resolveOutDir, applyPreview } from '../utils.js';
 import fs from 'fs';
 import path from 'path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
@@ -29,7 +29,6 @@ function previewConfig() {
                - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
             config.appType = 'mpa'
             */
-            markEnvAsVitePreview();
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.

package/dist/esm/node/plugin/plugins/setGlobalContext.d.ts

@@ -1,3 +1,3 @@
 export { setGlobalContext };
 import type { Plugin } from 'vite';
-declare function setGlobalContext(): Plugin;
+declare function setGlobalContext(): Plugin[];

package/dist/esm/node/plugin/plugins/setGlobalContext.js

@@ -1,26 +1,41 @@
 export { setGlobalContext };
-import { setGlobalContext_isDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
-import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck } from '../utils.js';
+import { setGlobalContext_isViteDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
 function setGlobalContext() {
-    return {
-        name: 'vike:setGlobalContext',
-        enforce: 'pre',
-        configureServer: {
-            order: 'pre',
-            handler(viteDevServer) {
-                setGlobalContext_viteDevServer(viteDevServer);
+    return [
+        {
+            name: 'vike:setGlobalContext:pre',
+            enforce: 'pre',
+            configureServer: {
+                order: 'pre',
+                handler(viteDevServer) {
+                    setGlobalContext_viteDevServer(viteDevServer);
+                    markSetup_viteDevServer();
+                }
+            },
+            configurePreviewServer() {
+                markSetup_vitePreviewServer();
+            },
+            config: {
+                order: 'pre',
+                handler(_, env) {
+                    const isViteDev = isDevCheck(env);
+                    setGlobalContext_isViteDev(isViteDev);
+                    markSetup_isViteDev(isViteDev);
+                }
             }
         },
-        config: {
-            handler(_, env) {
-                const isDev = isDevCheck(env);
-                setGlobalContext_isDev(isDev);
+        {
+            name: 'vike:setGlobalContext:post',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                handler(config) {
+                    const { outDirRoot } = getOutDirs(config);
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    setGlobalContext_viteConfig(config, outDirRoot);
+                }
             }
-        },
-        configResolved(config) {
-            const { outDirRoot } = getOutDirs(config);
-            assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
-            setGlobalContext_viteConfig(config, outDirRoot);
         }
-    };
+    ];
 }