webpack 5.97.1 → 5.104.1

package/lib/cli.js

@@ -6,25 +6,32 @@
 "use strict";
 
 const path = require("path");
+const tty = require("tty");
 const webpackSchema = require("../schemas/WebpackOptions.json");
 
-/** @typedef {TODO & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean } }} Schema */
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
+/** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 
 // TODO add originPath to PathItem for better errors
 /**
  * @typedef {object} PathItem
- * @property {any} schema the part of the schema
+ * @property {Schema} schema the part of the schema
  * @property {string} path the path in the config
  */
 
 /** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
 
+/** @typedef {string | number | boolean | RegExp} Value */
+
 /**
  * @typedef {object} Problem
  * @property {ProblemType} type
  * @property {string} path
  * @property {string} argument
- * @property {any=} value
+ * @property {Value=} value
  * @property {number=} index
  * @property {string=} expected
  */
@@ -36,14 +43,18 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
  * @property {string=} expected
  */
 
+/** @typedef {{ [key: string]: EnumValue }} EnumValueObject */
+/** @typedef {EnumValue[]} EnumValueArray */
+/** @typedef {string | number | boolean | EnumValueObject | EnumValueArray | null} EnumValue */
+
 /**
  * @typedef {object} ArgumentConfig
- * @property {string | undefined} description
- * @property {string} [negatedDescription]
+ * @property {string=} description
+ * @property {string=} negatedDescription
  * @property {string} path
  * @property {boolean} multiple
- * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
- * @property {any[]=} values
+ * @property {"enum" | "string" | "path" | "number" | "boolean" | "RegExp" | "reset"} type
+ * @property {EnumValue[]=} values
  */
 
 /** @typedef {"string" | "number" | "boolean"} SimpleType */
@@ -56,10 +67,10 @@ const webpackSchema = require("../schemas/WebpackOptions.json");
  * @property {ArgumentConfig[]} configs
  */
 
-/** @typedef {string | number | boolean | RegExp | (string | number | boolean | RegExp)} Value */
-
 /** @typedef {Record<string, Argument>} Flags */
 
+/** @typedef {Record<string, EXPECTED_ANY>} ObjectConfiguration */
+
 /**
  * @param {Schema=} schema a json schema to create arguments for (by default webpack schema is used)
  * @returns {Flags} object of arguments
@@ -72,7 +83,7 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {string} input input
 	 * @returns {string} result
 	 */
-	const pathToArgumentName = input =>
+	const pathToArgumentName = (input) =>
 		input
 			.replace(/\./g, "-")
 			.replace(/\[\]/g, "")
@@ -87,13 +98,13 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {string} path path
 	 * @returns {Schema} schema part
 	 */
-	const getSchemaPart = path => {
+	const getSchemaPart = (path) => {
 		const newPath = path.split("/");
 
 		let schemaPart = schema;
 
 		for (let i = 1; i < newPath.length; i++) {
-			const inner = schemaPart[newPath[i]];
+			const inner = schemaPart[/** @type {keyof Schema} */ (newPath[i])];
 
 			if (!inner) {
 				break;
@@ -109,7 +120,7 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {PathItem[]} path path in the schema
 	 * @returns {string | undefined} description
 	 */
-	const getDescription = path => {
+	const getDescription = (path) => {
 		for (const { schema } of path) {
 			if (schema.cli) {
 				if (schema.cli.helper) continue;
@@ -123,7 +134,7 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {PathItem[]} path path in the schema
 	 * @returns {string | undefined} negative description
 	 */
-	const getNegatedDescription = path => {
+	const getNegatedDescription = (path) => {
 		for (const { schema } of path) {
 			if (schema.cli) {
 				if (schema.cli.helper) continue;
@@ -136,7 +147,7 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {PathItem[]} path path in the schema
 	 * @returns {string | undefined} reset description
 	 */
-	const getResetDescription = path => {
+	const getResetDescription = (path) => {
 		for (const { schema } of path) {
 			if (schema.cli) {
 				if (schema.cli.helper) continue;
@@ -147,9 +158,9 @@ const getArguments = (schema = webpackSchema) => {
 
 	/**
 	 * @param {Schema} schemaPart schema
-	 * @returns {Pick<ArgumentConfig, "type"|"values"> | undefined} partial argument config
+	 * @returns {Pick<ArgumentConfig, "type" | "values"> | undefined} partial argument config
 	 */
-	const schemaToArgumentConfig = schemaPart => {
+	const schemaToArgumentConfig = (schemaPart) => {
 		if (schemaPart.enum) {
 			return {
 				type: "enum",
@@ -182,7 +193,7 @@ const getArguments = (schema = webpackSchema) => {
 	 * @param {PathItem[]} path path in the schema
 	 * @returns {void}
 	 */
-	const addResetFlag = path => {
+	const addResetFlag = (path) => {
 		const schemaPath = path[0].path;
 		const name = pathToArgumentName(`${schemaPath}.reset`);
 		const description =
@@ -243,7 +254,7 @@ const getArguments = (schema = webpackSchema) => {
 
 		if (
 			flags[name].configs.some(
-				item => JSON.stringify(item) === JSON.stringify(argConfig)
+				(item) => JSON.stringify(item) === JSON.stringify(argConfig)
 			)
 		) {
 			return 0;
@@ -251,7 +262,7 @@ const getArguments = (schema = webpackSchema) => {
 
 		if (
 			flags[name].configs.some(
-				item => item.type === argConfig.type && item.multiple !== multiple
+				(item) => item.type === argConfig.type && item.multiple !== multiple
 			)
 		) {
 			if (multiple) {
@@ -272,7 +283,7 @@ const getArguments = (schema = webpackSchema) => {
 	/**
 	 * @param {Schema} schemaPart the current schema
 	 * @param {string} schemaPath the current path in the schema
-	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
+	 * @param {PathItem[]} path all previous visited schemaParts
 	 * @param {string | null} inArray if inside of an array, the path to the array
 	 * @returns {number} added arguments
 	 */
@@ -291,6 +302,7 @@ const getArguments = (schema = webpackSchema) => {
 
 		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
 
+		/** @type {PathItem[]} */
 		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
 
 		let addedArguments = 0;
@@ -400,8 +412,8 @@ const getArguments = (schema = webpackSchema) => {
 								/** @type {NonNullable<ArgumentConfig["values"]>} */
 								(argConfig.values);
 
-							if (values.every(v => typeof v === "boolean")) type = "boolean";
-							if (values.every(v => typeof v === "number")) type = "number";
+							if (values.every((v) => typeof v === "boolean")) type = "boolean";
+							if (values.every((v) => typeof v === "number")) type = "number";
 							break;
 						}
 					}
@@ -409,7 +421,7 @@ const getArguments = (schema = webpackSchema) => {
 					return t === type ? t : "string";
 				}, /** @type {SimpleType | undefined} */ (undefined))
 			);
-		argument.multiple = argument.configs.some(c => c.multiple);
+		argument.multiple = argument.configs.some((c) => c.multiple);
 	}
 
 	return flags;
@@ -420,10 +432,10 @@ const cliAddedItems = new WeakMap();
 /** @typedef {string | number} Property */
 
 /**
- * @param {Configuration} config configuration
+ * @param {ObjectConfiguration} config configuration
  * @param {string} schemaPath path in the config
  * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {{ problem?: LocalProblem, object?: any, property?: Property, value?: any }} problem or object with property and value
+ * @returns {{ problem?: LocalProblem, object?: ObjectConfiguration, property?: Property, value?: EXPECTED_OBJECT | EXPECTED_ANY[] }} problem or object with property and value
  */
 const getObjectAndProperty = (config, schemaPath, index = 0) => {
 	if (!schemaPath) return { value: config };
@@ -520,9 +532,9 @@ const getObjectAndProperty = (config, schemaPath, index = 0) => {
 };
 
 /**
- * @param {Configuration} config configuration
+ * @param {ObjectConfiguration} config configuration
  * @param {string} schemaPath path in the config
- * @param {any} value parsed value
+ * @param {ParsedValue} value parsed value
  * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
  * @returns {LocalProblem | null} problem or null for success
  */
@@ -533,13 +545,14 @@ const setValue = (config, schemaPath, value, index) => {
 		index
 	);
 	if (problem) return problem;
-	object[/** @type {Property} */ (property)] = value;
+	/** @type {ObjectConfiguration} */
+	(object)[/** @type {Property} */ (property)] = value;
 	return null;
 };
 
 /**
  * @param {ArgumentConfig} argConfig processing instructions
- * @param {Configuration} config configuration
+ * @param {ObjectConfiguration} config configuration
  * @param {Value} value the value
  * @param {number | undefined} index the index if multiple values provided
  * @returns {LocalProblem | null} a problem if any
@@ -568,7 +581,7 @@ const processArgumentConfig = (argConfig, config, value, index) => {
  * @param {ArgumentConfig} argConfig processing instructions
  * @returns {string | undefined} expected message
  */
-const getExpectedValue = argConfig => {
+const getExpectedValue = (argConfig) => {
 	switch (argConfig.type) {
 		case "boolean":
 			return "true | false";
@@ -578,7 +591,7 @@ const getExpectedValue = argConfig => {
 			return /** @type {NonNullable<ArgumentConfig["values"]>} */ (
 				argConfig.values
 			)
-				.map(v => `${v}`)
+				.map((v) => `${v}`)
 				.join(" | ");
 		case "reset":
 			return "true (will reset the previous value to an empty array)";
@@ -587,10 +600,12 @@ const getExpectedValue = argConfig => {
 	}
 };
 
+/** @typedef {null | string | number | boolean | RegExp | EnumValue | []} ParsedValue */
+
 /**
  * @param {ArgumentConfig} argConfig processing instructions
  * @param {Value} value the value
- * @returns {any | undefined} parsed value
+ * @returns {ParsedValue | undefined} parsed value
  */
 const parseValueForArgumentConfig = (argConfig, value) => {
 	switch (argConfig.type) {
@@ -621,15 +636,18 @@ const parseValueForArgumentConfig = (argConfig, value) => {
 			if (typeof value === "string") {
 				// cspell:word yugi
 				const match = /^\/(.*)\/([yugi]*)$/.exec(value);
-				if (match && !/[^\\]\//.test(match[1]))
+				if (match && !/[^\\]\//.test(match[1])) {
 					return new RegExp(match[1], match[2]);
+				}
 			}
 			break;
 		case "enum": {
 			const values =
-				/** @type {NonNullable<ArgumentConfig["values"]>} */
+				/** @type {EnumValue[]} */
 				(argConfig.values);
-			if (values.includes(value)) return value;
+			if (values.includes(/** @type {Exclude<Value, RegExp>} */ (value))) {
+				return value;
+			}
 			for (const item of values) {
 				if (`${item}` === value) return item;
 			}
@@ -641,12 +659,12 @@ const parseValueForArgumentConfig = (argConfig, value) => {
 	}
 };
 
-/** @typedef {any} Configuration */
+/** @typedef {Record<string, Value[]>} Values */
 
 /**
  * @param {Flags} args object of arguments
- * @param {Configuration} config configuration
- * @param {Record<string, Value[]>} values object with values
+ * @param {ObjectConfiguration} config configuration
+ * @param {Values} values object with values
  * @returns {Problem[] | null} problems or null for success
  */
 const processArguments = (args, config, values) => {
@@ -695,5 +713,145 @@ const processArguments = (args, config, values) => {
 	return problems;
 };
 
+/**
+ * @returns {boolean} true when colors supported, otherwise false
+ */
+const isColorSupported = () => {
+	const { env = {}, argv = [], platform = "" } = process;
+
+	const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+	const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+	const isWindows = platform === "win32";
+	const isDumbTerminal = env.TERM === "dumb";
+
+	const isCompatibleTerminal = tty.isatty(1) && env.TERM && !isDumbTerminal;
+
+	const isCI =
+		"CI" in env &&
+		("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+	return (
+		!isDisabled &&
+		(isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI)
+	);
+};
+
+/**
+ * @param {number} index index
+ * @param {string} string string
+ * @param {string} close close
+ * @param {string=} replace replace
+ * @param {string=} head head
+ * @param {string=} tail tail
+ * @param {number=} next next
+ * @returns {string} result
+ */
+const replaceClose = (
+	index,
+	string,
+	close,
+	replace,
+	head = string.slice(0, Math.max(0, index)) + replace,
+	tail = string.slice(Math.max(0, index + close.length)),
+	next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+/**
+ * @param {number} index index to replace
+ * @param {string} string string
+ * @param {string} open open string
+ * @param {string} close close string
+ * @param {string=} replace extra replace
+ * @returns {string} result
+ */
+const clearBleed = (index, string, open, close, replace) =>
+	index < 0
+		? open + string + close
+		: open + replaceClose(index, string, close, replace) + close;
+
+/** @typedef {(value: EXPECTED_ANY) => string} PrintFunction */
+
+/**
+ * @param {string} open open string
+ * @param {string} close close string
+ * @param {string=} replace extra replace
+ * @param {number=} at at
+ * @returns {PrintFunction} function to create color
+ */
+const filterEmpty =
+	(open, close, replace = open, at = open.length + 1) =>
+	(string) =>
+		string || !(string === "" || string === undefined)
+			? clearBleed(`${string}`.indexOf(close, at), string, open, close, replace)
+			: "";
+
+/**
+ * @param {number} open open code
+ * @param {number} close close code
+ * @param {string=} replace extra replace
+ * @returns {PrintFunction} result
+ */
+const init = (open, close, replace) =>
+	filterEmpty(`\u001B[${open}m`, `\u001B[${close}m`, replace);
+
+/**
+ * @typedef {{ reset: PrintFunction, bold: PrintFunction, dim: PrintFunction, italic: PrintFunction, underline: PrintFunction, inverse: PrintFunction, hidden: PrintFunction, strikethrough: PrintFunction, black: PrintFunction, red: PrintFunction, green: PrintFunction, yellow: PrintFunction, blue: PrintFunction, magenta: PrintFunction, cyan: PrintFunction, white: PrintFunction, gray: PrintFunction, bgBlack: PrintFunction, bgRed: PrintFunction, bgGreen: PrintFunction, bgYellow: PrintFunction, bgBlue: PrintFunction, bgMagenta: PrintFunction, bgCyan: PrintFunction, bgWhite: PrintFunction, blackBright: PrintFunction, redBright: PrintFunction, greenBright: PrintFunction, yellowBright: PrintFunction, blueBright: PrintFunction, magentaBright: PrintFunction, cyanBright: PrintFunction, whiteBright: PrintFunction, bgBlackBright: PrintFunction, bgRedBright: PrintFunction, bgGreenBright: PrintFunction, bgYellowBright: PrintFunction, bgBlueBright: PrintFunction, bgMagentaBright: PrintFunction, bgCyanBright: PrintFunction, bgWhiteBright: PrintFunction }} Colors
+ */
+
+/**
+ * @typedef {object} ColorsOptions
+ * @property {boolean=} useColor force use colors
+ */
+
+/**
+ * @param {ColorsOptions=} options options
+ * @returns {Colors} colors
+ */
+const createColors = ({ useColor = isColorSupported() } = {}) => ({
+	reset: useColor ? init(0, 0) : String,
+	bold: useColor ? init(1, 22, "\u001B[22m\u001B[1m") : String,
+	dim: useColor ? init(2, 22, "\u001B[22m\u001B[2m") : String,
+	italic: useColor ? init(3, 23) : String,
+	underline: useColor ? init(4, 24) : String,
+	inverse: useColor ? init(7, 27) : String,
+	hidden: useColor ? init(8, 28) : String,
+	strikethrough: useColor ? init(9, 29) : String,
+	black: useColor ? init(30, 39) : String,
+	red: useColor ? init(31, 39) : String,
+	green: useColor ? init(32, 39) : String,
+	yellow: useColor ? init(33, 39) : String,
+	blue: useColor ? init(34, 39) : String,
+	magenta: useColor ? init(35, 39) : String,
+	cyan: useColor ? init(36, 39) : String,
+	white: useColor ? init(37, 39) : String,
+	gray: useColor ? init(90, 39) : String,
+	bgBlack: useColor ? init(40, 49) : String,
+	bgRed: useColor ? init(41, 49) : String,
+	bgGreen: useColor ? init(42, 49) : String,
+	bgYellow: useColor ? init(43, 49) : String,
+	bgBlue: useColor ? init(44, 49) : String,
+	bgMagenta: useColor ? init(45, 49) : String,
+	bgCyan: useColor ? init(46, 49) : String,
+	bgWhite: useColor ? init(47, 49) : String,
+	blackBright: useColor ? init(90, 39) : String,
+	redBright: useColor ? init(91, 39) : String,
+	greenBright: useColor ? init(92, 39) : String,
+	yellowBright: useColor ? init(93, 39) : String,
+	blueBright: useColor ? init(94, 39) : String,
+	magentaBright: useColor ? init(95, 39) : String,
+	cyanBright: useColor ? init(96, 39) : String,
+	whiteBright: useColor ? init(97, 39) : String,
+	bgBlackBright: useColor ? init(100, 49) : String,
+	bgRedBright: useColor ? init(101, 49) : String,
+	bgGreenBright: useColor ? init(102, 49) : String,
+	bgYellowBright: useColor ? init(103, 49) : String,
+	bgBlueBright: useColor ? init(104, 49) : String,
+	bgMagentaBright: useColor ? init(105, 49) : String,
+	bgCyanBright: useColor ? init(106, 49) : String,
+	bgWhiteBright: useColor ? init(107, 49) : String
+});
+
+module.exports.createColors = createColors;
 module.exports.getArguments = getArguments;
+module.exports.isColorSupported = isColorSupported;
 module.exports.processArguments = processArguments;