vite 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/node/chunks/{dep-DKZVy3_n.js → dep-BJOLgJFH.js}

@@ -1,4 +1,4 @@
-import { H as commonjsGlobal, G as getDefaultExportFromCjs } from './dep-E4cF1RpV.js';
+import { b as commonjsGlobal, g as getDefaultExportFromCjs } from './dep-C7zR1Rh8.js';
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
 import require$$0$1 from 'path';

package/dist/node/chunks/dep-C7zR1Rh8.js

@@ -0,0 +1,233 @@
+import readline from 'node:readline';
+import require$$0 from 'tty';
+
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var picocolors = {exports: {}};
+
+let tty = require$$0;
+
+let isColorSupported =
+	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
+	("FORCE_COLOR" in process.env ||
+		process.argv.includes("--color") ||
+		process.platform === "win32" ||
+		(tty.isatty(1) && process.env.TERM !== "dumb") ||
+		"CI" in process.env);
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input;
+		let index = string.indexOf(close, open.length);
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	};
+
+let replaceClose = (string, close, replace, index) => {
+	let start = string.substring(0, index) + replace;
+	let end = string.substring(index + close.length);
+	let nextIndex = end.indexOf(close);
+	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
+};
+
+let createColors = (enabled = isColorSupported) => ({
+	isColorSupported: enabled,
+	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
+	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
+	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
+	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
+	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
+	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
+	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
+	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
+	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
+	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
+	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
+	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
+	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
+	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
+	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
+	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
+	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
+	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
+	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
+	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
+	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
+	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
+	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
+	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
+	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
+});
+
+picocolors.exports = createColors();
+picocolors.exports.createColors = createColors;
+
+var picocolorsExports = picocolors.exports;
+var colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+
+/* eslint no-console: 0 */
+const LogLevels = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+};
+let lastType;
+let lastMsg;
+let sameCount = 0;
+function clearScreen() {
+    const repeatCount = process.stdout.rows - 2;
+    const blank = repeatCount > 0 ? '\n'.repeat(repeatCount) : '';
+    console.log(blank);
+    readline.cursorTo(process.stdout, 0, 0);
+    readline.clearScreenDown(process.stdout);
+}
+// Only initialize the timeFormatter when the timestamp option is used, and
+// reuse it across all loggers
+let timeFormatter;
+function getTimeFormatter() {
+    timeFormatter ??= new Intl.DateTimeFormat(undefined, {
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+    });
+    return timeFormatter;
+}
+function createLogger(level = 'info', options = {}) {
+    if (options.customLogger) {
+        return options.customLogger;
+    }
+    const loggedErrors = new WeakSet();
+    const { prefix = '[vite]', allowClearScreen = true } = options;
+    const thresh = LogLevels[level];
+    const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+    const clear = canClearScreen ? clearScreen : () => { };
+    function format(type, msg, options = {}) {
+        if (options.timestamp) {
+            const color = type === 'info'
+                ? colors.cyan
+                : type === 'warn'
+                    ? colors.yellow
+                    : colors.red;
+            const tag = color(colors.bold(prefix));
+            const environment = options.environment ? options.environment + ' ' : '';
+            return `${colors.dim(getTimeFormatter().format(new Date()))} ${tag} ${environment}${msg}`;
+        }
+        else {
+            return msg;
+        }
+    }
+    function output(type, msg, options = {}) {
+        if (thresh >= LogLevels[type]) {
+            const method = type === 'info' ? 'log' : type;
+            if (options.error) {
+                loggedErrors.add(options.error);
+            }
+            if (canClearScreen) {
+                if (type === lastType && msg === lastMsg) {
+                    sameCount++;
+                    clear();
+                    console[method](format(type, msg, options), colors.yellow(`(x${sameCount + 1})`));
+                }
+                else {
+                    sameCount = 0;
+                    lastMsg = msg;
+                    lastType = type;
+                    if (options.clear) {
+                        clear();
+                    }
+                    console[method](format(type, msg, options));
+                }
+            }
+            else {
+                console[method](format(type, msg, options));
+            }
+        }
+    }
+    const warnedMessages = new Set();
+    const logger = {
+        hasWarned: false,
+        info(msg, opts) {
+            output('info', msg, opts);
+        },
+        warn(msg, opts) {
+            logger.hasWarned = true;
+            output('warn', msg, opts);
+        },
+        warnOnce(msg, opts) {
+            if (warnedMessages.has(msg))
+                return;
+            logger.hasWarned = true;
+            output('warn', msg, opts);
+            warnedMessages.add(msg);
+        },
+        error(msg, opts) {
+            logger.hasWarned = true;
+            output('error', msg, opts);
+        },
+        clearScreen(type) {
+            if (thresh >= LogLevels[type]) {
+                clear();
+            }
+        },
+        hasErrorLogged(error) {
+            return loggedErrors.has(error);
+        },
+    };
+    return logger;
+}
+function printServerUrls(urls, optionsHost, info) {
+    const colorUrl = (url) => colors.cyan(url.replace(/:(\d+)\//, (_, port) => `:${colors.bold(port)}/`));
+    for (const url of urls.local) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Local')}:   ${colorUrl(url)}`);
+    }
+    for (const url of urls.network) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Network')}: ${colorUrl(url)}`);
+    }
+    if (urls.network.length === 0 && optionsHost === undefined) {
+        info(colors.dim(`  ${colors.green('➜')}  ${colors.bold('Network')}: use `) +
+            colors.bold('--host') +
+            colors.dim(' to expose'));
+    }
+}
+
+export { LogLevels as L, colors as a, commonjsGlobal as b, createLogger as c, getAugmentedNamespace as d, printServerUrls as e, getDefaultExportFromCjs as g, picocolorsExports as p };

package/dist/node/chunks/{dep-DK04Q0H9.js → dep-m9gtlanK.js}

@@ -1,4 +1,4 @@
-import { G as getDefaultExportFromCjs } from './dep-E4cF1RpV.js';
+import { g as getDefaultExportFromCjs } from './dep-C7zR1Rh8.js';
 import require$$0 from 'path';
 import require$$0__default from 'fs';
 import { l as lib } from './dep-IQS-Za7F.js';

package/dist/node/cli.js

@@ -2,45 +2,11 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { E as colors, x as createLogger, r as resolveConfig, F as Environment } from './chunks/dep-E4cF1RpV.js';
+import { a as colors, c as createLogger } from './chunks/dep-C7zR1Rh8.js';
 import { VERSION } from './constants.js';
-import 'node:fs/promises';
-import 'node:url';
-import 'node:util';
-import 'node:module';
-import 'tty';
-import 'path';
-import 'esbuild';
-import 'fs';
-import 'assert';
-import 'node:child_process';
-import 'node:http';
-import 'node:https';
-import 'util';
-import 'net';
-import 'url';
-import 'http';
-import 'stream';
-import 'os';
-import 'child_process';
-import 'node:os';
-import 'node:crypto';
-import 'node:dns';
-import 'node:assert';
-import 'node:v8';
-import 'module';
-import 'node:worker_threads';
-import 'rollup/parseAst';
-import 'node:events';
-import 'crypto';
-import 'node:buffer';
 import 'node:readline';
-import 'zlib';
-import 'buffer';
-import 'https';
-import 'tls';
-import 'querystring';
-import 'node:zlib';
+import 'tty';
+import 'node:url';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -719,8 +685,7 @@ function cleanGlobalCLIOptions(options) {
  */
 function cleanBuilderCLIOptions(options) {
     const ret = { ...options };
-    delete ret.environment;
-    delete ret.all;
+    delete ret.app;
     return ret;
 }
 /**
@@ -766,7 +731,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-E4cF1RpV.js').then(function (n) { return n.I; });
+    const { createServer } = await import('./chunks/dep-8UjKy9Ch.js').then(function (n) { return n.C; });
     try {
         const server = await createServer({
             root,
@@ -844,10 +809,10 @@ cli
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .option('--environment [name]', `[string] build a single environment`)
-    .option('--all', `[boolean] build all environments`)
+    .option('--app', `[boolean] same as builder.entireApp`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build, createViteBuilder } = await import('./chunks/dep-E4cF1RpV.js').then(function (n) { return n.K; });
+    const { createBuilder, buildEnvironment } = await import('./chunks/dep-8UjKy9Ch.js').then(function (n) { return n.E; });
     const buildOptions = cleanGlobalCLIOptions(cleanBuilderCLIOptions(options));
     const config = {
         root,
@@ -859,22 +824,19 @@ cli
         build: buildOptions,
     };
     try {
-        if (options.all || options.environment) {
-            const builder = await createViteBuilder({}, config);
-            if (options.environment) {
-                const environment = builder.environments[options.environment];
-                if (!environment) {
-                    throw new Error(`The environment ${options.environment} isn't configured.`);
-                }
-                await builder.build(environment);
-            }
-            else {
-                // --all: build all environments
-                await builder.buildEnvironments();
-            }
+        const builder = await createBuilder(config);
+        // TODO: Backward compatibility with lib and single environment build
+        // Ideally we would move to only building the entire app with this command
+        if (builder.config.build.lib) {
+            await buildEnvironment(builder.config, builder.environments.client, builder.config.build.lib);
+        }
+        else if (builder.config.builder.entireApp || options.app) {
+            await builder.buildApp();
         }
         else {
-            await build(config);
+            const ssr = !!builder.config.build.ssr;
+            const environment = builder.environments[ssr ? 'ssr' : 'client'];
+            await builder.build(environment);
         }
     }
     catch (e) {
@@ -890,23 +852,31 @@ cli
     .command('optimize [root]', 'pre-bundle dependencies')
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
-    filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-E4cF1RpV.js').then(function (n) { return n.J; });
+    /* TODO: do we need this command?
+
+    filterDuplicateOptions(options)
+    const { optimizeDeps } = await import('./optimizer')
     try {
-        const config = await resolveConfig({
-            root,
-            base: options.base,
-            configFile: options.config,
-            logLevel: options.logLevel,
-            mode: options.mode,
-        }, 'serve');
-        const environment = new Environment('client', config);
-        await optimizeDeps(environment, options.force, true);
-    }
-    catch (e) {
-        createLogger(options.logLevel).error(colors.red(`error when optimizing deps:\n${e.stack}`), { error: e });
-        process.exit(1);
-    }
+      const config = await resolveConfig(
+        {
+          root,
+          base: options.base,
+          configFile: options.config,
+          logLevel: options.logLevel,
+          mode: options.mode,
+        },
+        'serve',
+      )
+      const environment = new Environment('client', config)
+      await optimizeDeps(environment, options.force, true)
+    } catch (e) {
+      createLogger(options.logLevel).error(
+        colors.red(`error when optimizing deps:\n${e.stack}`),
+        { error: e },
+      )
+      process.exit(1)
+    }
+    */
 });
 // preview
 cli
@@ -918,7 +888,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-E4cF1RpV.js').then(function (n) { return n.L; });
+    const { preview } = await import('./chunks/dep-8UjKy9Ch.js').then(function (n) { return n.F; });
     try {
         const server = await preview({
             root,