vike 0.4.215 → 0.4.217-commit-99ea561

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.217-commit-99ea561";
 };

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.217-commit-99ea561",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/cjs/node/plugin/plugins/config/assertVikeConfig.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertVikeConfig = assertVikeConfig;
-const utils_js_1 = require("../../utils.js");
-function assertVikeConfig(vikeConfig, wrongUsageMsg) {
-    const wrongUsageError = checkConfigVike(vikeConfig);
-    if (wrongUsageError) {
-        (0, utils_js_1.assertUsage)(false, wrongUsageMsg(wrongUsageError));
-    }
-}
-function checkConfigVike(configVike) {
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(configVike));
-    {
-        const prop = 'disableUrlNormalization';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'trailingSlash';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'redirects';
-        const { redirects } = configVike;
-        if (!(redirects === undefined ||
-            ((0, utils_js_1.isObject)(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
-            return { prop, errMsg: 'should be an object of strings' };
-    }
-    {
-        const prop = 'disableAutoFullBuild';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'undefined') &&
-            !(configVike[prop] === 'prerender'))
-            return { prop, errMsg: "should be a boolean or 'prerender'" };
-    }
-    {
-        const prop = 'includeAssetsImportedByServer';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'prerender';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'object') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be an object or a boolean' };
-    }
-    const configVikePrerender = configVike.prerender;
-    if (typeof configVikePrerender === 'object') {
-        {
-            const p = 'partial';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'noExtraDir';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'disableAutoRun';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'parallel';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') &&
-                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'number') &&
-                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
-        }
-    }
-    return null;
-}

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

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVikeConfig = resolveVikeConfig;
-const assertVikeConfig_js_1 = require("./assertVikeConfig.js");
-const utils_js_1 = require("../../utils.js");
-const pickFirst_js_1 = require("./pickFirst.js");
-const resolveBase_js_1 = require("./resolveBase.js");
-const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function resolveVikeConfig(vikeConfig) {
-    let isDev;
-    return {
-        name: 'vike:resolveVikeConfig',
-        enforce: 'pre',
-        apply(_config, env) {
-            isDev = (0, utils_js_1.isDevCheck)(env);
-            return true;
-        },
-        async configResolved(config) {
-            (0, utils_js_1.assert)(typeof isDev === 'boolean');
-            const promise = getConfigVikPromise(vikeConfig, config, isDev);
-            config.configVikePromise = promise;
-            await promise;
-        }
-    };
-}
-async function getConfigVikPromise(vikeConfig, config, isDev) {
-    const fromPluginOptions = (vikeConfig ?? {});
-    const fromViteConfig = (config.vike ?? {});
-    const configs = [fromPluginOptions, fromViteConfig];
-    (0, assertVikeConfig_js_1.assertVikeConfig)(fromViteConfig, ({ prop, errMsg }) => `vite.config.js#vike.${prop} ${errMsg}`);
-    // TODO/v1-release: deprecate this
-    (0, assertVikeConfig_js_1.assertVikeConfig)(fromPluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
-    const crawlWithGit = fromPluginOptions.crawl?.git ?? null;
-    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev, { crawlWithGit });
-    configs.push(fromPlusConfigFile);
-    (0, assertVikeConfig_js_1.assertVikeConfig)(fromPlusConfigFile, ({ prop, errMsg }) => {
-        // TODO: add config file path ?
-        return `config ${picocolors_1.default.cyan(prop)} ${errMsg}`;
-    });
-    const { baseServer, baseAssets } = (0, resolveBase_js_1.resolveBase)(configs, config);
-    const configVike = {
-        disableAutoFullBuild: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.disableAutoFullBuild)) ?? null,
-        prerender: resolvePrerenderOptions(configs),
-        includeAssetsImportedByServer: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
-        baseServer,
-        baseAssets,
-        redirects: merge(configs.map((c) => c.redirects)) ?? {},
-        disableUrlNormalization: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.disableUrlNormalization)) ?? false,
-        trailingSlash: (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.trailingSlash)) ?? false,
-        crawl: {
-            git: crawlWithGit
-        }
-    };
-    return configVike;
-}
-function resolvePrerenderOptions(configs) {
-    if (!configs.some((c) => c.prerender)) {
-        return false;
-    }
-    const configsPrerender = configs.map((c) => c.prerender).filter(isObject);
-    return {
-        partial: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.partial)) ?? false,
-        noExtraDir: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.noExtraDir)) ?? false,
-        parallel: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.parallel)) ?? true,
-        disableAutoRun: (0, pickFirst_js_1.pickFirst)(configsPrerender.map((c) => c.disableAutoRun)) ?? false
-    };
-}
-function isObject(p) {
-    return typeof p === 'object';
-}
-function merge(objs) {
-    const obj = {};
-    objs.forEach((e) => {
-        Object.assign(obj, e);
-    });
-    return obj;
-}

package/dist/cjs/node/plugin/plugins/config/pickFirst.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pickFirst = pickFirst;
-function pickFirst(arr) {
-    return arr.filter((v) => v !== undefined)[0];
-}

package/dist/cjs/node/plugin/plugins/config/resolveBase.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveBase = resolveBase;
-exports.resolveBaseFromUserConfig = resolveBaseFromUserConfig;
-const utils_js_1 = require("../../utils.js");
-const pickFirst_js_1 = require("./pickFirst.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function resolveBase(configs, config) {
-    const baseServer = (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.baseServer)) ?? null;
-    const baseAssets = (0, pickFirst_js_1.pickFirst)(configs.map((c) => c.baseAssets)) ?? null;
-    let baseOriginal = config._baseOriginal;
-    if (baseOriginal === '/__UNSET__')
-        baseOriginal = null;
-    (0, utils_js_1.assert)(baseOriginal === null || typeof baseOriginal == 'string');
-    return resolve(baseOriginal, baseServer, baseAssets);
-}
-function resolveBaseFromUserConfig(config, configVike) {
-    return resolve(config.base ?? null, configVike?.baseServer ?? null, configVike?.baseAssets ?? null);
-}
-function resolve(base, baseServer_, baseAssets_) {
-    {
-        const wrongBase = (val) => `should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, or ${picocolors_1.default.cyan('https://')} (it's ${picocolors_1.default.cyan(val)} instead)`;
-        (0, utils_js_1.assertUsage)(base === null || (0, utils_js_1.isBaseAssets)(base), `vite.config.js#base ${wrongBase(base)}`);
-        (0, utils_js_1.assertUsage)(baseAssets_ === null || (0, utils_js_1.isBaseAssets)(baseAssets_), `Config ${picocolors_1.default.cyan('baseAssets')} ${wrongBase(baseAssets_)}`);
-        (0, utils_js_1.assertUsage)(baseServer_ === null || baseServer_.startsWith('/'), `Config ${picocolors_1.default.cyan('baseServer')} should start with a leading slash ${picocolors_1.default.cyan('/')} (it's ${picocolors_1.default.cyan(String(baseServer_))} instead)`);
-    }
-    if (base) {
-        if (base.startsWith('http')) {
-            baseAssets_ = baseAssets_ ?? base;
-        }
-        else {
-            baseAssets_ = baseAssets_ ?? base;
-            baseServer_ = baseServer_ ?? base;
-        }
-    }
-    const baseServer = baseServer_ ?? '/';
-    const baseAssets = baseAssets_ ?? '/';
-    (0, utils_js_1.assert)((0, utils_js_1.isBaseAssets)(baseAssets));
-    (0, utils_js_1.assert)((0, utils_js_1.isBaseServer)(baseServer));
-    return {
-        baseServer,
-        baseAssets
-    };
-}

package/dist/cjs/node/shared/getConfigVike.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigVike = getConfigVike;
-const utils_js_1 = require("./utils.js");
-async function getConfigVike(config) {
-    const { configVikePromise } = config;
-    (0, utils_js_1.assert)(configVikePromise);
-    const configVike = await configVikePromise;
-    return configVike;
-}

package/dist/cjs/shared/ConfigVike.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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
-    });
-}

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

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

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.d.ts

@@ -1,7 +0,0 @@
-export { assertVikeConfig };
-import type { ConfigVikeUserProvided } from '../../../../shared/ConfigVike.js';
-type WrongUsage = {
-    prop: string;
-    errMsg: `should be a${string}`;
-};
-declare function assertVikeConfig(vikeConfig: unknown, wrongUsageMsg: (wrongUsage: WrongUsage) => string): asserts vikeConfig is ConfigVikeUserProvided;

package/dist/esm/node/plugin/plugins/config/assertVikeConfig.js

@@ -1,73 +0,0 @@
-export { assertVikeConfig };
-import { assert, assertUsage, hasProp, isObject } from '../../utils.js';
-function assertVikeConfig(vikeConfig, wrongUsageMsg) {
-    const wrongUsageError = checkConfigVike(vikeConfig);
-    if (wrongUsageError) {
-        assertUsage(false, wrongUsageMsg(wrongUsageError));
-    }
-}
-function checkConfigVike(configVike) {
-    assert(isObject(configVike));
-    {
-        const prop = 'disableUrlNormalization';
-        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'trailingSlash';
-        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'redirects';
-        const { redirects } = configVike;
-        if (!(redirects === undefined ||
-            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
-            return { prop, errMsg: 'should be an object of strings' };
-    }
-    {
-        const prop = 'disableAutoFullBuild';
-        if (!hasProp(configVike, prop, 'boolean') &&
-            !hasProp(configVike, prop, 'undefined') &&
-            !(configVike[prop] === 'prerender'))
-            return { prop, errMsg: "should be a boolean or 'prerender'" };
-    }
-    {
-        const prop = 'includeAssetsImportedByServer';
-        if (!hasProp(configVike, prop, 'boolean') && !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'prerender';
-        if (!hasProp(configVike, prop, 'object') &&
-            !hasProp(configVike, prop, 'boolean') &&
-            !hasProp(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be an object or a boolean' };
-    }
-    const configVikePrerender = configVike.prerender;
-    if (typeof configVikePrerender === 'object') {
-        {
-            const p = 'partial';
-            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'noExtraDir';
-            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'disableAutoRun';
-            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'parallel';
-            if (!hasProp(configVikePrerender, p, 'boolean') &&
-                !hasProp(configVikePrerender, p, 'number') &&
-                !hasProp(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
-        }
-    }
-    return null;
-}

package/dist/esm/node/plugin/plugins/config/index.d.ts

@@ -1,3 +0,0 @@
-export { resolveVikeConfig };
-import type { Plugin } from 'vite';
-declare function resolveVikeConfig(vikeConfig: unknown): Plugin;