@askviraj/linter 1.1.2 → 1.1.3

package/node_modules/eslint/lib/rules/key-spacing.js

@@ -14,7 +14,7 @@ const { getGraphemeCount } = require("../shared/string-utils");
 
 /**
  * Checks whether a string contains a line terminator as defined in
- * http://www.ecma-international.org/ecma-262/5.1/#sec-7.3
+ * https://262.ecma-international.org/5.1/#sec-7.3
  * @param {string} str String to test.
  * @returns {boolean} True if str contains a line terminator.
  */
@@ -380,12 +380,10 @@ module.exports = {
 		 */
 		function isKeyValueProperty(property) {
 			return !(
-				(
-					property.method ||
-					property.shorthand ||
-					property.kind !== "init" ||
-					property.type !== "Property"
-				) // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+				property.method ||
+				property.shorthand ||
+				property.kind !== "init" ||
+				property.type !== "Property" // Could be "ExperimentalSpreadProperty" or "SpreadElement"
 			);
 		}
 

package/node_modules/eslint/lib/rules/max-len.js

@@ -110,7 +110,7 @@ module.exports = {
 
 	create(context) {
 		/*
-		 * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
+		 * Inspired by https://datatracker.ietf.org/doc/html/rfc3986#appendix-B, however:
 		 * - They're matching an entire string that we know is a URI
 		 * - We're matching part of a string where we think there *might* be a URL
 		 * - We're only concerned about URLs, as picking out any URI would cause

package/node_modules/eslint/lib/rules/max-nested-callbacks.js

@@ -44,6 +44,9 @@ module.exports = {
 								type: "integer",
 								minimum: 0,
 							},
+							checkConstructorCallCallbacks: {
+								type: "boolean",
+							},
 						},
 						additionalProperties: false,
 					},
@@ -91,7 +94,14 @@ module.exports = {
 		function checkFunction(node) {
 			const parent = node.parent;
 
-			if (parent.type !== "CallExpression" || parent.callee === node) {
+			if (
+				(parent.type !== "CallExpression" &&
+					!(
+						option.checkConstructorCallCallbacks &&
+						parent.type === "NewExpression"
+					)) ||
+				parent.callee === node
+			) {
 				return;
 			}
 

package/node_modules/eslint/lib/rules/no-compare-neg-zero.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { getVariableByName } = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -20,15 +26,24 @@ module.exports = {
 		},
 
 		fixable: null,
+		hasSuggestions: true,
 		schema: [],
 
 		messages: {
 			unexpected:
 				"Do not use the '{{operator}}' operator to compare against -0.",
+			suggestRemoveMinus:
+				"Replace '-0' with '0' (keeps the current comparison behavior).",
+			suggestObjectIs:
+				"Replace with 'Object.is()' (changes the comparison to distinguish -0 from +0).",
+			suggestNotObjectIs:
+				"Replace with '!Object.is()' (changes the comparison to distinguish -0 from +0).",
 		},
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		//--------------------------------------------------------------------------
 		// Helpers
 		//--------------------------------------------------------------------------
@@ -46,6 +61,18 @@ module.exports = {
 				node.argument.value === 0
 			);
 		}
+
+		/**
+		 * Gets the source text of an operand, keeping parentheses where required.
+		 * @param {ASTNode} operand A comparison operand node.
+		 * @returns {string} The source text of the operand.
+		 */
+		function getOperandText(operand) {
+			const text = sourceCode.getText(operand);
+
+			return operand.type === "SequenceExpression" ? `(${text})` : text;
+		}
+
 		const OPERATORS_TO_CHECK = new Set([
 			">",
 			">=",
@@ -59,15 +86,71 @@ module.exports = {
 
 		return {
 			BinaryExpression(node) {
-				if (OPERATORS_TO_CHECK.has(node.operator)) {
-					if (isNegZero(node.left) || isNegZero(node.right)) {
-						context.report({
-							node,
-							messageId: "unexpected",
-							data: { operator: node.operator },
-						});
-					}
+				if (!OPERATORS_TO_CHECK.has(node.operator)) {
+					return;
 				}
+
+				const leftIsNegZero = isNegZero(node.left);
+				const rightIsNegZero = isNegZero(node.right);
+
+				if (!leftIsNegZero && !rightIsNegZero) {
+					return;
+				}
+
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: { operator: node.operator },
+					suggest: [
+						{
+							messageId: "suggestRemoveMinus",
+							*fix(fixer) {
+								if (leftIsNegZero) {
+									yield fixer.replaceText(node.left, "0");
+								}
+								if (rightIsNegZero) {
+									yield fixer.replaceText(node.right, "0");
+								}
+							},
+						},
+						{
+							messageId:
+								node.operator === "==="
+									? "suggestObjectIs"
+									: "suggestNotObjectIs",
+							fix(fixer) {
+								if (
+									(node.operator !== "===" &&
+										node.operator !== "!==") ||
+									sourceCode.getCommentsInside(node).length >
+										0
+								) {
+									return null;
+								}
+
+								const objectVariable = getVariableByName(
+									sourceCode.getScope(node),
+									"Object",
+								);
+
+								if (
+									!objectVariable ||
+									objectVariable.identifiers.length > 0
+								) {
+									return null;
+								}
+
+								const negation =
+									node.operator === "===" ? "" : "!";
+
+								return fixer.replaceText(
+									node,
+									`${negation}Object.is(${getOperandText(node.left)}, ${getOperandText(node.right)})`,
+								);
+							},
+						},
+					],
+				});
 			},
 		};
 	},

package/node_modules/eslint/lib/rules/no-control-regex.js

@@ -81,6 +81,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		/**
 		 * Get the regex expression
 		 * @param {ASTNode} node `Literal` node to evaluate
@@ -99,6 +101,7 @@ module.exports = {
 					node.parent.type === "CallExpression") &&
 				node.parent.callee.type === "Identifier" &&
 				node.parent.callee.name === "RegExp" &&
+				sourceCode.isGlobalReference(node.parent.callee) &&
 				node.parent.arguments[0] === node
 			) {
 				const pattern = node.value;

package/node_modules/eslint/lib/rules/no-implicit-coercion.js

@@ -244,6 +244,21 @@ module.exports = {
 		const [options] = context.options;
 		const sourceCode = context.sourceCode;
 
+		/**
+		 * Gets the source text of a node to be used as the argument of a
+		 * `Boolean()`, `Number()`, or `String()` call in a recommendation. A
+		 * `SequenceExpression` operand must be parenthesized, otherwise its commas
+		 * would be parsed as argument separators, which changes the evaluated
+		 * operand (for example `!!(a, b)` becomes `Boolean(a, b)`).
+		 * @param {ASTNode} node The operand node.
+		 * @returns {string} The source text, parenthesized if needed.
+		 */
+		function getOperandText(node) {
+			const text = sourceCode.getText(node);
+
+			return node.type === "SequenceExpression" ? `(${text})` : text;
+		}
+
 		/**
 		 * Reports an error and autofixes the node
 		 * @param {ASTNode} node An ast node to report the error on.
@@ -309,7 +324,7 @@ module.exports = {
 					options.boolean &&
 					isDoubleLogicalNegating(node)
 				) {
-					const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+					const recommendation = `Boolean(${getOperandText(node.argument.argument)})`;
 					const variable = astUtils.getVariableByName(
 						sourceCode.getScope(node),
 						"Boolean",
@@ -344,7 +359,7 @@ module.exports = {
 					node.operator === "+" &&
 					!isNumeric(node.argument)
 				) {
-					const recommendation = `Number(${sourceCode.getText(node.argument)})`;
+					const recommendation = `Number(${getOperandText(node.argument)})`;
 
 					report(node, recommendation, true, false);
 				}
@@ -359,7 +374,7 @@ module.exports = {
 					node.argument.operator === "-" &&
 					!isNumeric(node.argument.argument)
 				) {
-					const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+					const recommendation = `Number(${getOperandText(node.argument.argument)})`;
 
 					report(node, recommendation, true, false);
 				}
@@ -379,7 +394,7 @@ module.exports = {
 					getNonNumericOperand(node);
 
 				if (nonNumericOperand) {
-					const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
+					const recommendation = `Number(${getOperandText(nonNumericOperand)})`;
 
 					report(node, recommendation, true, false);
 				}
@@ -394,7 +409,7 @@ module.exports = {
 					node.right.value === 0 &&
 					!isNumeric(node.left)
 				) {
-					const recommendation = `Number(${sourceCode.getText(node.left)})`;
+					const recommendation = `Number(${getOperandText(node.left)})`;
 
 					report(node, recommendation, true, false);
 				}
@@ -406,7 +421,7 @@ module.exports = {
 					options.string &&
 					isConcatWithEmptyString(node)
 				) {
-					const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
+					const recommendation = `String(${getOperandText(getNonEmptyOperand(node))})`;
 
 					report(node, recommendation, true, false);
 				}
@@ -458,8 +473,7 @@ module.exports = {
 					return;
 				}
 
-				const code = sourceCode.getText(node.expressions[0]);
-				const recommendation = `String(${code})`;
+				const recommendation = `String(${getOperandText(node.expressions[0])})`;
 
 				report(node, recommendation, true, false);
 			},

package/node_modules/eslint/lib/rules/no-invalid-regexp.js

@@ -53,6 +53,7 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
 		const [{ allowConstructorFlags }] = context.options;
 		let allowedFlags = [];
 
@@ -180,7 +181,8 @@ module.exports = {
 			"CallExpression, NewExpression"(node) {
 				if (
 					node.callee.type !== "Identifier" ||
-					node.callee.name !== "RegExp"
+					node.callee.name !== "RegExp" ||
+					!sourceCode.isGlobalReference(node.callee)
 				) {
 					return;
 				}

package/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js

@@ -125,14 +125,12 @@ module.exports = {
 									sourceCode.getIndexFromLoc(loc.start),
 								);
 
-							if (
-								!(
-									containingNode &&
-									["Literal", "TemplateElement"].includes(
-										containingNode.type,
-									)
+							if (!(
+								containingNode &&
+								["Literal", "TemplateElement"].includes(
+									containingNode.type,
 								)
-							) {
+							)) {
 								context.report({
 									node,
 									loc,

package/node_modules/eslint/lib/rules/no-promise-executor-return.js

@@ -200,13 +200,11 @@ module.exports = {
 					}
 
 					// Do not suggest wrapping an unnamed function or class expression in braces as that would be invalid syntax.
-					if (
-						!(
-							(node.body.type === "FunctionExpression" ||
-								node.body.type === "ClassExpression") &&
-							!node.body.id
-						)
-					) {
+					if (!(
+						(node.body.type === "FunctionExpression" ||
+							node.body.type === "ClassExpression") &&
+						!node.body.id
+					)) {
 						suggest.push({
 							messageId: "wrapBraces",
 							fix(fixer) {

package/node_modules/eslint/lib/rules/no-script-url.js

@@ -54,12 +54,10 @@ module.exports = {
 				}
 			},
 			TemplateLiteral(node) {
-				if (
-					!(
-						node.parent &&
-						node.parent.type === "TaggedTemplateExpression"
-					)
-				) {
+				if (!(
+					node.parent &&
+					node.parent.type === "TaggedTemplateExpression"
+				)) {
 					check(node);
 				}
 			},

package/node_modules/eslint/lib/rules/no-shadow.js

@@ -275,12 +275,10 @@ module.exports = {
 
 			const { variableScope } = variable.scope;
 
-			if (
-				!(
-					FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) &&
-					getOuterScope(variableScope) === shadowedVariable.scope
-				)
-			) {
+			if (!(
+				FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) &&
+				getOuterScope(variableScope) === shadowedVariable.scope
+			)) {
 				return false;
 			}
 
@@ -405,14 +403,12 @@ module.exports = {
 				return false;
 			}
 
-			if (
-				!(
-					(innerDef.type === "FunctionName" &&
-						innerDef.node.type === "FunctionExpression") ||
-					(innerDef.type === "ClassName" &&
-						innerDef.node.type === "ClassExpression")
-				)
-			) {
+			if (!(
+				(innerDef.type === "FunctionName" &&
+					innerDef.node.type === "FunctionExpression") ||
+				(innerDef.type === "ClassName" &&
+					innerDef.node.type === "ClassExpression")
+			)) {
 				return false;
 			}
 
@@ -432,12 +428,10 @@ module.exports = {
 			const nodeToCheck = innerDef.node; // FunctionExpression or ClassExpression node
 
 			// Exit early if the node to check isn't inside the initializer
-			if (
-				!(
-					initializerNode.range[0] <= nodeToCheck.range[0] &&
-					nodeToCheck.range[1] <= initializerNode.range[1]
-				)
-			) {
+			if (!(
+				initializerNode.range[0] <= nodeToCheck.range[0] &&
+				nodeToCheck.range[1] <= initializerNode.range[1]
+			)) {
 				return false;
 			}
 

package/node_modules/eslint/lib/rules/no-unreachable-loop.js

@@ -98,11 +98,15 @@ module.exports = {
 
 	create(context) {
 		const [{ ignore: ignoredLoopTypes }] = context.options;
-		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
-			loopSelector = loopTypesToCheck.join(","),
-			loopsByTargetSegments = new Map(),
-			loopsToReport = new Set();
+		const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes);
+		const loopSelector = loopTypesToCheck.join(",");
 
+		if (!loopSelector) {
+			return {};
+		}
+
+		const loopsByTargetSegments = new Map();
+		const loopsToReport = new Set();
 		const codePathSegments = [];
 		let currentCodePathSegments = new Set();
 

package/node_modules/eslint/lib/rules/prefer-numeric-literals.js

@@ -25,14 +25,22 @@ const radixMap = new Map([
  * Checks to see if a CallExpression's callee node is `parseInt` or
  * `Number.parseInt`.
  * @param {ASTNode} calleeNode The callee node to evaluate.
+ * @param {SourceCode} sourceCode The source code object.
  * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
  * false otherwise.
  */
-function isParseInt(calleeNode) {
-	return (
-		astUtils.isSpecificId(calleeNode, "parseInt") ||
-		astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
-	);
+function isParseInt(calleeNode, sourceCode) {
+	if (astUtils.isSpecificId(calleeNode, "parseInt")) {
+		return sourceCode.isGlobalReference(calleeNode);
+	}
+
+	if (astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")) {
+		const objectNode = astUtils.skipChainExpression(calleeNode).object;
+
+		return sourceCode.isGlobalReference(objectNode);
+	}
+
+	return false;
 }
 
 //------------------------------------------------------------------------------
@@ -81,7 +89,7 @@ module.exports = {
 					radixNode.type === "Literal" &&
 					typeof radix === "number" &&
 					radixMap.has(radix) &&
-					isParseInt(node.callee)
+					isParseInt(node.callee, sourceCode)
 				) {
 					const { system, literalPrefix } = radixMap.get(radix);
 

package/node_modules/eslint/lib/rules/prefer-object-has-own.js

@@ -75,12 +75,10 @@ module.exports = {
 
 		return {
 			CallExpression(node) {
-				if (
-					!(
-						node.callee.type === "MemberExpression" &&
-						node.callee.object.type === "MemberExpression"
-					)
-				) {
+				if (!(
+					node.callee.type === "MemberExpression" &&
+					node.callee.object.type === "MemberExpression"
+				)) {
 					return;
 				}
 

package/node_modules/eslint/lib/rules/prefer-object-spread.js

@@ -11,6 +11,8 @@ const {
 	isOpeningParenToken,
 	isClosingParenToken,
 	isParenthesised,
+	isStartOfExpressionStatement,
+	needsPrecedingSemicolon,
 } = require("./utils/ast-utils");
 
 const ANY_SPACE = /\s/u;
@@ -194,7 +196,13 @@ function defineFixer(node, sourceCode) {
 
 		// Replace the parens of argument list to braces.
 		if (needsParens(node, sourceCode)) {
-			yield fixer.replaceText(leftParen, "({");
+			const prefix =
+				isStartOfExpressionStatement(node) &&
+				needsPrecedingSemicolon(sourceCode, node)
+					? ";({"
+					: "({";
+
+			yield fixer.replaceText(leftParen, prefix);
 			yield fixer.replaceText(rightParen, "})");
 		} else {
 			yield fixer.replaceText(leftParen, "{");

package/node_modules/eslint/lib/rules/prefer-template.js

@@ -204,7 +204,7 @@ module.exports = {
 				 */
 				return `\`${currentNode.raw
 					.slice(1, -1)
-					.replace(/\\*(\$\{|`)/gu, matched => {
+					.replace(/(?<!\\)\\*(\$\{|`)/gu, matched => {
 						if (matched.lastIndexOf("\\") % 2) {
 							return `\\${matched}`;
 						}