eslint 8.57.1 → 9.39.1

package/lib/rules/new-cap.js

@@ -16,36 +16,19 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const CAPS_ALLOWED = [
-    "Array",
-    "Boolean",
-    "Date",
-    "Error",
-    "Function",
-    "Number",
-    "Object",
-    "RegExp",
-    "String",
-    "Symbol",
-    "BigInt"
+	"Array",
+	"Boolean",
+	"Date",
+	"Error",
+	"Function",
+	"Number",
+	"Object",
+	"RegExp",
+	"String",
+	"Symbol",
+	"BigInt",
 ];
 
-/**
- * Ensure that if the key is provided, it must be an array.
- * @param {Object} obj Object to check with `key`.
- * @param {string} key Object key to check on `obj`.
- * @param {any} fallback If obj[key] is not present, this will be returned.
- * @throws {TypeError} If key is not an own array type property of `obj`.
- * @returns {string[]} Returns obj[key] if it's an Array, otherwise `fallback`
- */
-function checkArray(obj, key, fallback) {
-
-    /* c8 ignore start */
-    if (Object.prototype.hasOwnProperty.call(obj, key) && !Array.isArray(obj[key])) {
-        throw new TypeError(`${key}, if provided, must be an Array`);
-    }/* c8 ignore stop */
-    return obj[key] || fallback;
-}
-
 /**
  * A reducer function to invert an array to an Object mapping the string form of the key, to `true`.
  * @param {Object} map Accumulator object for the reduce.
@@ -53,8 +36,8 @@ function checkArray(obj, key, fallback) {
  * @returns {Object} Returns the updated Object for further reduction.
  */
 function invert(map, key) {
-    map[key] = true;
-    return map;
+	map[key] = true;
+	return map;
 }
 
 /**
@@ -63,214 +46,232 @@ function invert(map, key) {
  * @returns {Object} Object with cap is new exceptions.
  */
 function calculateCapIsNewExceptions(config) {
-    let capIsNewExceptions = checkArray(config, "capIsNewExceptions", CAPS_ALLOWED);
-
-    if (capIsNewExceptions !== CAPS_ALLOWED) {
-        capIsNewExceptions = capIsNewExceptions.concat(CAPS_ALLOWED);
-    }
+	const capIsNewExceptions = Array.from(
+		new Set([...config.capIsNewExceptions, ...CAPS_ALLOWED]),
+	);
 
-    return capIsNewExceptions.reduce(invert, {});
+	return capIsNewExceptions.reduce(invert, {});
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require constructor names to begin with a capital letter",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/new-cap"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    newIsCap: {
-                        type: "boolean",
-                        default: true
-                    },
-                    capIsNew: {
-                        type: "boolean",
-                        default: true
-                    },
-                    newIsCapExceptions: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        }
-                    },
-                    newIsCapExceptionPattern: {
-                        type: "string"
-                    },
-                    capIsNewExceptions: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        }
-                    },
-                    capIsNewExceptionPattern: {
-                        type: "string"
-                    },
-                    properties: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-        messages: {
-            upper: "A function with a name starting with an uppercase letter should only be used as a constructor.",
-            lower: "A constructor name should not start with a lowercase letter."
-        }
-    },
-
-    create(context) {
-
-        const config = Object.assign({}, context.options[0]);
-
-        config.newIsCap = config.newIsCap !== false;
-        config.capIsNew = config.capIsNew !== false;
-        const skipProperties = config.properties === false;
-
-        const newIsCapExceptions = checkArray(config, "newIsCapExceptions", []).reduce(invert, {});
-        const newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern, "u") : null;
-
-        const capIsNewExceptions = calculateCapIsNewExceptions(config);
-        const capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern, "u") : null;
-
-        const listeners = {};
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Get exact callee name from expression
-         * @param {ASTNode} node CallExpression or NewExpression node
-         * @returns {string} name
-         */
-        function extractNameFromExpression(node) {
-            return node.callee.type === "Identifier"
-                ? node.callee.name
-                : astUtils.getStaticPropertyName(node.callee) || "";
-        }
-
-        /**
-         * Returns the capitalization state of the string -
-         * Whether the first character is uppercase, lowercase, or non-alphabetic
-         * @param {string} str String
-         * @returns {string} capitalization state: "non-alpha", "lower", or "upper"
-         */
-        function getCap(str) {
-            const firstChar = str.charAt(0);
-
-            const firstCharLower = firstChar.toLowerCase();
-            const firstCharUpper = firstChar.toUpperCase();
-
-            if (firstCharLower === firstCharUpper) {
-
-                // char has no uppercase variant, so it's non-alphabetic
-                return "non-alpha";
-            }
-            if (firstChar === firstCharLower) {
-                return "lower";
-            }
-            return "upper";
-
-        }
-
-        /**
-         * Check if capitalization is allowed for a CallExpression
-         * @param {Object} allowedMap Object mapping calleeName to a Boolean
-         * @param {ASTNode} node CallExpression node
-         * @param {string} calleeName Capitalized callee name from a CallExpression
-         * @param {Object} pattern RegExp object from options pattern
-         * @returns {boolean} Returns true if the callee may be capitalized
-         */
-        function isCapAllowed(allowedMap, node, calleeName, pattern) {
-            const sourceText = sourceCode.getText(node.callee);
-
-            if (allowedMap[calleeName] || allowedMap[sourceText]) {
-                return true;
-            }
-
-            if (pattern && pattern.test(sourceText)) {
-                return true;
-            }
-
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (calleeName === "UTC" && callee.type === "MemberExpression") {
-
-                // allow if callee is Date.UTC
-                return callee.object.type === "Identifier" &&
-                    callee.object.name === "Date";
-            }
-
-            return skipProperties && callee.type === "MemberExpression";
-        }
-
-        /**
-         * Reports the given messageId for the given node. The location will be the start of the property or the callee.
-         * @param {ASTNode} node CallExpression or NewExpression node.
-         * @param {string} messageId The messageId to report.
-         * @returns {void}
-         */
-        function report(node, messageId) {
-            let callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type === "MemberExpression") {
-                callee = callee.property;
-            }
-
-            context.report({ node, loc: callee.loc, messageId });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        if (config.newIsCap) {
-            listeners.NewExpression = function(node) {
-
-                const constructorName = extractNameFromExpression(node);
-
-                if (constructorName) {
-                    const capitalization = getCap(constructorName);
-                    const isAllowed = capitalization !== "lower" || isCapAllowed(newIsCapExceptions, node, constructorName, newIsCapExceptionPattern);
-
-                    if (!isAllowed) {
-                        report(node, "lower");
-                    }
-                }
-            };
-        }
-
-        if (config.capIsNew) {
-            listeners.CallExpression = function(node) {
-
-                const calleeName = extractNameFromExpression(node);
-
-                if (calleeName) {
-                    const capitalization = getCap(calleeName);
-                    const isAllowed = capitalization !== "upper" || isCapAllowed(capIsNewExceptions, node, calleeName, capIsNewExceptionPattern);
-
-                    if (!isAllowed) {
-                        report(node, "upper");
-                    }
-                }
-            };
-        }
-
-        return listeners;
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Require constructor names to begin with a capital letter",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/new-cap",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					newIsCap: {
+						type: "boolean",
+					},
+					capIsNew: {
+						type: "boolean",
+					},
+					newIsCapExceptions: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+					},
+					newIsCapExceptionPattern: {
+						type: "string",
+					},
+					capIsNewExceptions: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+					},
+					capIsNewExceptionPattern: {
+						type: "string",
+					},
+					properties: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [
+			{
+				capIsNew: true,
+				capIsNewExceptions: CAPS_ALLOWED,
+				newIsCap: true,
+				newIsCapExceptions: [],
+				properties: true,
+			},
+		],
+
+		messages: {
+			upper: "A function with a name starting with an uppercase letter should only be used as a constructor.",
+			lower: "A constructor name should not start with a lowercase letter.",
+		},
+	},
+
+	create(context) {
+		const [config] = context.options;
+		const skipProperties = !config.properties;
+
+		const newIsCapExceptions = config.newIsCapExceptions.reduce(invert, {});
+		const newIsCapExceptionPattern = config.newIsCapExceptionPattern
+			? new RegExp(config.newIsCapExceptionPattern, "u")
+			: null;
+
+		const capIsNewExceptions = calculateCapIsNewExceptions(config);
+		const capIsNewExceptionPattern = config.capIsNewExceptionPattern
+			? new RegExp(config.capIsNewExceptionPattern, "u")
+			: null;
+
+		const listeners = {};
+
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Get exact callee name from expression
+		 * @param {ASTNode} node CallExpression or NewExpression node
+		 * @returns {string} name
+		 */
+		function extractNameFromExpression(node) {
+			return node.callee.type === "Identifier"
+				? node.callee.name
+				: astUtils.getStaticPropertyName(node.callee) || "";
+		}
+
+		/**
+		 * Returns the capitalization state of the string -
+		 * Whether the first character is uppercase, lowercase, or non-alphabetic
+		 * @param {string} str String
+		 * @returns {string} capitalization state: "non-alpha", "lower", or "upper"
+		 */
+		function getCap(str) {
+			const firstChar = str.charAt(0);
+
+			const firstCharLower = firstChar.toLowerCase();
+			const firstCharUpper = firstChar.toUpperCase();
+
+			if (firstCharLower === firstCharUpper) {
+				// char has no uppercase variant, so it's non-alphabetic
+				return "non-alpha";
+			}
+			if (firstChar === firstCharLower) {
+				return "lower";
+			}
+			return "upper";
+		}
+
+		/**
+		 * Check if capitalization is allowed for a CallExpression
+		 * @param {Object} allowedMap Object mapping calleeName to a Boolean
+		 * @param {ASTNode} node CallExpression node
+		 * @param {string} calleeName Capitalized callee name from a CallExpression
+		 * @param {Object} pattern RegExp object from options pattern
+		 * @returns {boolean} Returns true if the callee may be capitalized
+		 */
+		function isCapAllowed(allowedMap, node, calleeName, pattern) {
+			const sourceText = sourceCode.getText(node.callee);
+
+			if (allowedMap[calleeName] || allowedMap[sourceText]) {
+				return true;
+			}
+
+			if (pattern && pattern.test(sourceText)) {
+				return true;
+			}
+
+			const callee = astUtils.skipChainExpression(node.callee);
+
+			if (calleeName === "UTC" && callee.type === "MemberExpression") {
+				// allow if callee is Date.UTC
+				return (
+					callee.object.type === "Identifier" &&
+					callee.object.name === "Date"
+				);
+			}
+
+			return skipProperties && callee.type === "MemberExpression";
+		}
+
+		/**
+		 * Reports the given messageId for the given node. The location will be the start of the property or the callee.
+		 * @param {ASTNode} node CallExpression or NewExpression node.
+		 * @param {string} messageId The messageId to report.
+		 * @returns {void}
+		 */
+		function report(node, messageId) {
+			let callee = astUtils.skipChainExpression(node.callee);
+
+			if (callee.type === "MemberExpression") {
+				callee = callee.property;
+			}
+
+			context.report({ node, loc: callee.loc, messageId });
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		if (config.newIsCap) {
+			listeners.NewExpression = function (node) {
+				const constructorName = extractNameFromExpression(node);
+
+				if (constructorName) {
+					const capitalization = getCap(constructorName);
+					const isAllowed =
+						capitalization !== "lower" ||
+						isCapAllowed(
+							newIsCapExceptions,
+							node,
+							constructorName,
+							newIsCapExceptionPattern,
+						);
+
+					if (!isAllowed) {
+						report(node, "lower");
+					}
+				}
+			};
+		}
+
+		if (config.capIsNew) {
+			listeners.CallExpression = function (node) {
+				const calleeName = extractNameFromExpression(node);
+
+				if (calleeName) {
+					const capitalization = getCap(calleeName);
+					const isAllowed =
+						capitalization !== "upper" ||
+						isCapAllowed(
+							capIsNewExceptions,
+							node,
+							calleeName,
+							capIsNewExceptionPattern,
+						);
+
+					if (!isAllowed) {
+						report(node, "upper");
+					}
+				}
+			};
+		}
+
+		return listeners;
+	},
 };

package/lib/rules/new-parens.js

@@ -20,74 +20,101 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "new-parens",
+						url: "https://eslint.style/rules/new-parens",
+					},
+				},
+			],
+		},
+		type: "layout",
 
-        docs: {
-            description: "Enforce or disallow parentheses when invoking a constructor with no arguments",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/new-parens"
-        },
+		docs: {
+			description:
+				"Enforce or disallow parentheses when invoking a constructor with no arguments",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/new-parens",
+		},
 
-        fixable: "code",
-        schema: [
-            {
-                enum: ["always", "never"]
-            }
-        ],
-        messages: {
-            missing: "Missing '()' invoking a constructor.",
-            unnecessary: "Unnecessary '()' invoking a constructor with no arguments."
-        }
-    },
+		fixable: "code",
+		schema: [
+			{
+				enum: ["always", "never"],
+			},
+		],
+		messages: {
+			missing: "Missing '()' invoking a constructor.",
+			unnecessary:
+				"Unnecessary '()' invoking a constructor with no arguments.",
+		},
+	},
 
-    create(context) {
-        const options = context.options;
-        const always = options[0] !== "never"; // Default is always
+	create(context) {
+		const options = context.options;
+		const always = options[0] !== "never"; // Default is always
 
-        const sourceCode = context.sourceCode;
+		const sourceCode = context.sourceCode;
 
-        return {
-            NewExpression(node) {
-                if (node.arguments.length !== 0) {
-                    return; // if there are arguments, there have to be parens
-                }
+		return {
+			NewExpression(node) {
+				if (node.arguments.length !== 0) {
+					return; // if there are arguments, there have to be parens
+				}
 
-                const lastToken = sourceCode.getLastToken(node);
-                const hasLastParen = lastToken && astUtils.isClosingParenToken(lastToken);
+				const lastToken = sourceCode.getLastToken(node);
+				const hasLastParen =
+					lastToken && astUtils.isClosingParenToken(lastToken);
 
-                // `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
-                const hasParens = hasLastParen &&
-                    astUtils.isOpeningParenToken(sourceCode.getTokenBefore(lastToken)) &&
-                    node.callee.range[1] < node.range[1];
+				// `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
+				const hasParens =
+					hasLastParen &&
+					astUtils.isOpeningParenToken(
+						sourceCode.getTokenBefore(lastToken),
+					) &&
+					node.callee.range[1] < node.range[1];
 
-                if (always) {
-                    if (!hasParens) {
-                        context.report({
-                            node,
-                            messageId: "missing",
-                            fix: fixer => fixer.insertTextAfter(node, "()")
-                        });
-                    }
-                } else {
-                    if (hasParens) {
-                        context.report({
-                            node,
-                            messageId: "unnecessary",
-                            fix: fixer => [
-                                fixer.remove(sourceCode.getTokenBefore(lastToken)),
-                                fixer.remove(lastToken),
-                                fixer.insertTextBefore(node, "("),
-                                fixer.insertTextAfter(node, ")")
-                            ]
-                        });
-                    }
-                }
-            }
-        };
-    }
+				if (always) {
+					if (!hasParens) {
+						context.report({
+							node,
+							messageId: "missing",
+							fix: fixer => fixer.insertTextAfter(node, "()"),
+						});
+					}
+				} else {
+					if (hasParens) {
+						context.report({
+							node,
+							messageId: "unnecessary",
+							fix: fixer => [
+								fixer.remove(
+									sourceCode.getTokenBefore(lastToken),
+								),
+								fixer.remove(lastToken),
+								fixer.insertTextBefore(node, "("),
+								fixer.insertTextAfter(node, ")"),
+							],
+						});
+					}
+				}
+			},
+		};
+	},
 };