@askviraj/linter 1.1.4 → 1.1.6

package/node_modules/eslint/lib/rules/no-duplicate-imports.js

@@ -22,7 +22,7 @@ const NAMESPACE_TYPES = [
  * Check if an import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier).
  * @param {string} importExportType An import/export type to check.
  * @param {string} type Can be "named" or "namespace"
- * @returns {boolean} True if import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier) and false if it doesn't.
+ * @returns {boolean} `true` if import/export type belongs to (ImportSpecifier|ExportSpecifier) or (ImportNamespaceSpecifier|ExportNamespaceSpecifier) and `false` if it doesn't.
  */
 function isImportExportSpecifier(importExportType, type) {
 	const arrayToCheck = type === "named" ? NAMED_TYPES : NAMESPACE_TYPES;
@@ -60,7 +60,7 @@ function getImportExportType(node) {
  * Returns a boolean indicates if two (import|export) can be merged
  * @param {ASTNode} node1 A node to check.
  * @param {ASTNode} node2 A node to check.
- * @returns {boolean} True if two (import|export) can be merged, false if they can't.
+ * @returns {boolean} `true` if two (import|export) can be merged, `false` if they can't.
  */
 function isImportExportCanBeMerged(node1, node2) {
 	const importExportType1 = getImportExportType(node1);
@@ -106,7 +106,7 @@ function isImportExportCanBeMerged(node1, node2) {
  * @param {ASTNode} node A node to be reported or not.
  * @param {[ASTNode]} previousNodes An array contains previous nodes of the module imported or exported.
  * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
- * @returns {boolean} True if the (import|export) should be reported.
+ * @returns {boolean} `true` if the (import|export) should be reported.
  */
 function shouldReportImportExport(
 	node,

package/node_modules/eslint/lib/rules/no-loss-of-precision.js

@@ -178,11 +178,16 @@ function convertNumberToScientificNotation(stringNumber, parseAsFloat) {
  * @returns {boolean} true if they do not match
  */
 function baseTenLosesPrecision(node) {
-	const rawNumber = getRaw(node).toLowerCase();
+	const rawNumber = getRaw(node).toLowerCase().replace(/\.$/u, "");
 	const normalizedRawNumber = convertNumberToScientificNotation(
 		rawNumber,
 		false,
 	);
+
+	if (node.value === 0) {
+		return !/^0+$/u.test(normalizedRawNumber.coefficient);
+	}
+
 	const requestedPrecision = normalizedRawNumber.coefficient.length;
 
 	if (requestedPrecision > 100) {
@@ -236,7 +241,7 @@ module.exports = {
 	create(context) {
 		return {
 			Literal(node) {
-				if (node.value && isNumber(node) && losesPrecision(node)) {
+				if (isNumber(node) && losesPrecision(node)) {
 					context.report({
 						messageId: "noLossOfPrecision",
 						node,

package/node_modules/eslint/lib/rules/no-setter-return.js

@@ -15,94 +15,6 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
- * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
- * @param {ASTNode} node The node to check.
- * @param {SourceCode} sourceCode Source code to which the node belongs.
- * @param {string} objectName Name of the global object.
- * @param {string} methodName Name of the method.
- * @param {number} index The given position.
- * @returns {boolean} `true` if the node is argument at the given position.
- */
-function isArgumentOfGlobalMethodCall(
-	node,
-	sourceCode,
-	objectName,
-	methodName,
-	index,
-) {
-	const callNode = node.parent;
-
-	return (
-		callNode.type === "CallExpression" &&
-		callNode.arguments[index] === node &&
-		astUtils.isSpecificMemberAccess(
-			callNode.callee,
-			objectName,
-			methodName,
-		) &&
-		sourceCode.isGlobalReference(
-			astUtils.skipChainExpression(callNode.callee).object,
-		)
-	);
-}
-
-/**
- * Determines whether the given node is used as a property descriptor.
- * @param {ASTNode} node The node to check.
- * @param {SourceCode} sourceCode Source code to which the node belongs.
- * @returns {boolean} `true` if the node is a property descriptor.
- */
-function isPropertyDescriptor(node, sourceCode) {
-	if (
-		isArgumentOfGlobalMethodCall(
-			node,
-			sourceCode,
-			"Object",
-			"defineProperty",
-			2,
-		) ||
-		isArgumentOfGlobalMethodCall(
-			node,
-			sourceCode,
-			"Reflect",
-			"defineProperty",
-			2,
-		)
-	) {
-		return true;
-	}
-
-	const parent = node.parent;
-
-	if (parent.type === "Property" && parent.value === node) {
-		const grandparent = parent.parent;
-
-		if (
-			grandparent.type === "ObjectExpression" &&
-			(isArgumentOfGlobalMethodCall(
-				grandparent,
-				sourceCode,
-				"Object",
-				"create",
-				1,
-			) ||
-				isArgumentOfGlobalMethodCall(
-					grandparent,
-					sourceCode,
-					"Object",
-					"defineProperties",
-					1,
-				))
-		) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Determines whether the given function node is used as a setter function.
  * @param {ASTNode} node The node to check.
@@ -126,7 +38,7 @@ function isSetter(node, sourceCode) {
 		parent.value === node &&
 		astUtils.getStaticPropertyName(parent) === "set" &&
 		parent.parent.type === "ObjectExpression" &&
-		isPropertyDescriptor(parent.parent, sourceCode)
+		astUtils.isPropertyDescriptor(parent.parent, sourceCode)
 	) {
 		// Setter in a property descriptor
 		return true;

package/node_modules/eslint/lib/rules/no-unmodified-loop-condition.js

@@ -26,7 +26,6 @@ const Traverser = require("../shared/traverser"),
 const SENTINEL_PATTERN =
 	/(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;
 const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.
-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;
 const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;
 const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
 
@@ -190,7 +189,19 @@ module.exports = {
 			url: "https://eslint.org/docs/latest/rules/no-unmodified-loop-condition",
 		},
 
-		schema: [],
+		schema: [
+			{
+				type: "object",
+				properties: {
+					checkConditionalExpressions: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [{ checkConditionalExpressions: false }],
 
 		messages: {
 			loopConditionNotModified:
@@ -199,6 +210,7 @@ module.exports = {
 	},
 
 	create(context) {
+		const [{ checkConditionalExpressions }] = context.options;
 		const sourceCode = context.sourceCode;
 		let groupMap = null;
 
@@ -305,10 +317,14 @@ module.exports = {
 				}
 
 				/*
-				 * If it's inside of a group, OK if either operand is modified.
-				 * So stores the group this reference belongs to.
+				 * If it's inside of a group, OK if any reference in that group is
+				 * modified. So stores the group this reference belongs to.
 				 */
-				if (GROUP_PATTERN.test(node.type)) {
+				if (
+					node.type === "BinaryExpression" ||
+					(!checkConditionalExpressions &&
+						node.type === "ConditionalExpression")
+				) {
 					// If this expression is dynamic, no need to check.
 					if (hasDynamicExpressions(node)) {
 						break;

package/node_modules/eslint/lib/rules/no-unused-labels.js

@@ -97,6 +97,25 @@ module.exports = {
 					return false; // potential directive
 				}
 			}
+
+			/*
+			 * Do not fix if removing the label would create an ASI hazard.
+			 * e.g. `foo()\nLABEL: [1].forEach(x => x)` → `foo()\n[1].forEach(x => x)`
+			 * would be parsed as `foo()[1].forEach(x => x)`.
+			 */
+			const SAFE_TOKENS_BEFORE = /^[:;{]$/u;
+			const UNSAFE_FIRST_CHARS = /^[([\-+/`]/u;
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			const firstBodyToken = sourceCode.getFirstToken(node.body);
+
+			if (
+				tokenBefore &&
+				!SAFE_TOKENS_BEFORE.test(tokenBefore.value) &&
+				UNSAFE_FIRST_CHARS.test(firstBodyToken.value)
+			) {
+				return false;
+			}
+
 			return true;
 		}
 

package/node_modules/eslint/lib/rules/no-unused-vars.js

@@ -1042,6 +1042,48 @@ module.exports = {
 				return node.specifiers.some(e => e.type === type);
 			}
 
+			/**
+			 * Check whether a closing brace token belongs to a block-level
+			 * construct (safe for ASI) rather than an expression (unsafe).
+			 *
+			 * Block-level `}` (e.g., if/for/while/function declaration body)
+			 * always triggers ASI, so it's safe to have adjacent tokens.
+			 *
+			 * Expression-level `}` (e.g., object literal, function expression,
+			 * arrow function body) does NOT trigger ASI, so adjacent tokens
+			 * could merge and change the parse.
+			 * @param {Token} token The token to check
+			 * @returns {boolean} true if the token is `}` from a block construct
+			 */
+			function isClosingBraceOfBlock(token) {
+				if (!astUtils.isClosingBraceToken(token)) {
+					return false;
+				}
+
+				const node = sourceCode.getNodeByRangeIndex(token.range[0]);
+
+				switch (node.type) {
+					case "BlockStatement":
+						/*
+						 * Safe only if the block belongs to a statement construct,
+						 * not an expression (FunctionExpression, ArrowFunctionExpression)
+						 */
+						return (
+							node.parent.type !== "FunctionExpression" &&
+							node.parent.type !== "ArrowFunctionExpression"
+						);
+
+					case "ClassBody":
+						return node.parent.type === "ClassDeclaration";
+
+					case "SwitchStatement":
+						return true;
+
+					default:
+						return false;
+				}
+			}
+
 			/**
 			 * Check whether declaration is safe to remove or not
 			 * @param {ASTNode} nextToken next token of unused variable
@@ -1053,7 +1095,8 @@ module.exports = {
 					nextToken.type === "String" ||
 					(prevToken &&
 						!astUtils.isSemicolonToken(prevToken) &&
-						!astUtils.isOpeningBraceToken(prevToken))
+						!astUtils.isOpeningBraceToken(prevToken) &&
+						!isClosingBraceOfBlock(prevToken))
 				);
 			}
 
@@ -1137,6 +1180,36 @@ module.exports = {
 					 * fix 'let bar = "hello", { a } = foo;' to 'let bar = "hello";' if 'a' is unused, same for arrays.
 					 */
 					if (getTokenBeforeValue(parentNode) === ",") {
+						// If this is the last declarator, removing it may create an ASI hazard
+						if (
+							parentNode === parentNode.parent.declarations.at(-1)
+						) {
+							const lastTokenOfDecl = sourceCode.getLastToken(
+								parentNode.parent,
+							);
+
+							// If the declaration has a trailing semicolon, the removal is safe
+							if (!astUtils.isSemicolonToken(lastTokenOfDecl)) {
+								const nextToken = sourceCode.getTokenAfter(
+									parentNode.parent,
+								);
+								const lastRemainingToken =
+									sourceCode.getTokenBefore(parentNode, {
+										skip: 1,
+									});
+
+								if (
+									nextToken &&
+									isDeclarationNotSafeToRemove(
+										nextToken,
+										lastRemainingToken,
+									)
+								) {
+									return null;
+								}
+							}
+						}
+
 						return fixer.removeRange([
 							getPreviousTokenStart(parentNode),
 							parentNode.range[1],
@@ -1364,6 +1437,32 @@ module.exports = {
 
 				// remove unused declared variable with multiple declaration except first one like 'var a = b, c = d;'
 				if (tokenBefore.value === ",") {
+					// If this is the last declarator, removing it may create an ASI hazard
+					if (parent === parent.parent.declarations.at(-1)) {
+						const lastTokenOfDecl = sourceCode.getLastToken(
+							parent.parent,
+						);
+
+						// If the declaration has a trailing semicolon, the removal is safe
+						if (!astUtils.isSemicolonToken(lastTokenOfDecl)) {
+							const nextToken = sourceCode.getTokenAfter(
+								parent.parent,
+							);
+							const lastRemainingToken =
+								sourceCode.getTokenBefore(parent, { skip: 1 });
+
+							if (
+								nextToken &&
+								isDeclarationNotSafeToRemove(
+									nextToken,
+									lastRemainingToken,
+								)
+							) {
+								return null;
+							}
+						}
+					}
+
 					return fixer.removeRange([
 						tokenBefore.range[0],
 						parent.range[1],
@@ -1540,8 +1639,21 @@ module.exports = {
 				}
 			}
 
-			// remove unused functions
-			if (parentType === "FunctionDeclaration" && parent.id === id) {
+			// remove unused functions and classes
+			if (
+				(parentType === "FunctionDeclaration" && parent.id === id) ||
+				parentType === "ClassDeclaration"
+			) {
+				const nextToken = sourceCode.getTokenAfter(parent);
+				const prevToken = sourceCode.getTokenBefore(parent);
+
+				if (
+					nextToken &&
+					isDeclarationNotSafeToRemove(nextToken, prevToken)
+				) {
+					return null;
+				}
+
 				return fixer.removeRange(parent.range);
 			}
 
@@ -1627,11 +1739,6 @@ module.exports = {
 				return null;
 			}
 
-			// remove unused declared classes
-			if (parentType === "ClassDeclaration") {
-				return fixer.removeRange(parent.range);
-			}
-
 			// remove unused variable that is in a sequence [a,b] fixes to [a]
 			if (tokenBefore?.value === ",") {
 				return fixer.removeRange([tokenBefore.range[0], id.range[1]]);

package/node_modules/eslint/lib/rules/no-useless-escape.js

@@ -373,8 +373,8 @@ module.exports = {
 
 			if (typeof node.value === "string" || isTemplateElement) {
 				/*
-				 * JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.
-				 * In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.
+				 * JSXAttribute doesn't have any escape sequence: https://react.github.io/jsx/.
+				 * In addition, backticks are not supported by JSX yet: https://github.com/react/jsx/issues/25.
 				 */
 				if (
 					node.parent.type === "JSXAttribute" ||

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

@@ -221,6 +221,80 @@ function hasReferenceBeforeDeclaration(variable) {
 	});
 }
 
+/**
+ * Checks whether a given variable is referenced inside a hoisted function
+ * declaration that is called before the variable's declaration.
+ * @param {Variable} variable The variable to check.
+ * @returns {boolean} `true` if the variable is referenced from a hoisted
+ *      function called before its declaration.
+ */
+function hasUnsafeHoistedFunctionReference(variable) {
+	const declarationNode = variable.defs[0].node;
+	const declarationStart = declarationNode.range[0];
+
+	for (const reference of variable.references) {
+		if (reference.init) {
+			continue;
+		}
+
+		if (reference.identifier.range[0] < declarationStart) {
+			continue;
+		}
+
+		let currentScope = reference.from.variableScope;
+
+		while (currentScope !== variable.scope) {
+			if (
+				currentScope.block.type === "FunctionDeclaration" &&
+				currentScope.block.id
+			) {
+				const funcName = currentScope.block.id.name;
+				const funcVariable = currentScope.upper.set.get(funcName);
+
+				for (const funcRef of funcVariable.references) {
+					const refId = funcRef.identifier;
+
+					if (
+						refId.parent.type === "CallExpression" &&
+						refId.parent.callee === refId &&
+						refId.range[0] < declarationStart
+					) {
+						return true;
+					}
+				}
+			}
+
+			currentScope = currentScope.upper.variableScope;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Checks whether a given variable is shadowed by the parameter of an enclosing
+ * `catch` clause.
+ *
+ * Scope analysis does not report this as a redeclaration, because the catch
+ * parameter and the `var` are distinct variables living in distinct scopes, so
+ * neither one has more than one definition.
+ *
+ * Resolving the name from the scope of the declaration is enough to detect it.
+ * A simple catch parameter is the only binding a `var` is allowed to shadow:
+ * any other block-scoped declaration of the same name makes the `var` itself a
+ * syntax error, and a function parameter shares its variable with the `var`, so
+ * that case is reported by `isRedeclared` instead.
+ * @param {ASTNode} node A `VariableDeclaration` node to check.
+ * @param {SourceCode} sourceCode The source code object.
+ * @returns {Function} The predicate function which checks whether a given
+ *      variable is shadowed by a `catch` clause parameter.
+ */
+function isShadowedByCatchParameter(node, sourceCode) {
+	return variable =>
+		astUtils.getVariableByName(sourceCode.getScope(node), variable.name) !==
+		variable;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -276,6 +350,7 @@ module.exports = {
 		 * - A variable is referenced before its declaration.
 		 * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
 		 * - A variable has name that is disallowed for `let` declarations.
+		 * - A variable is shadowed by a `catch` clause parameter.
 		 *
 		 * ## A variable is declared on a SwitchCase node.
 		 *
@@ -312,6 +387,15 @@ module.exports = {
 		 * the implementation simple, we only convert `var` to `let` within
 		 * loops when the variable is a loop assignee or the declaration has an
 		 * initializer.
+		 *
+		 * ## A variable is shadowed by a `catch` clause parameter.
+		 *
+		 * A `var` declaration may reuse the name of a simple catch clause
+		 * parameter, but the equivalent `let` declaration may not. Directly
+		 * inside the catch block, `let` would be a syntax error. In a nested
+		 * block, `let` is valid but changes behavior: the `var` assigns to the
+		 * catch parameter, while the `let` introduces a separate binding and
+		 * leaves the catch parameter untouched.
 		 * @param {ASTNode} node A variable declaration node to check.
 		 * @returns {boolean} `true` if it can fix the node.
 		 */
@@ -330,7 +414,9 @@ module.exports = {
 				variables.some(isRedeclared) ||
 				variables.some(isUsedFromOutsideOf(scopeNode)) ||
 				variables.some(hasNameDisallowedForLetDeclarations) ||
-				variables.some(hasReferenceBeforeDeclaration)
+				variables.some(hasReferenceBeforeDeclaration) ||
+				variables.some(hasUnsafeHoistedFunctionReference) ||
+				variables.some(isShadowedByCatchParameter(node, sourceCode))
 			) {
 				return false;
 			}

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

@@ -299,9 +299,15 @@ module.exports = {
 				return null;
 			}
 
+			const prefix =
+				astUtils.isStartOfExpressionStatement(topBinaryExpr) &&
+				astUtils.needsPrecedingSemicolon(sourceCode, topBinaryExpr)
+					? ";"
+					: "";
+
 			return fixer.replaceText(
 				topBinaryExpr,
-				getTemplateLiteral(topBinaryExpr, null, null),
+				`${prefix}${getTemplateLiteral(topBinaryExpr, null, null)}`,
 			);
 		}
 

package/node_modules/eslint/lib/rules/utils/ast-utils.js

@@ -551,6 +551,91 @@ function isMethodWhichHasThisArg(node) {
 	return isSpecificMemberAccess(node, null, arrayMethodWithThisArgPattern);
 }
 
+/**
+ * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
+ * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
+ * @param {ASTNode} node The node to check.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
+ * @param {string} objectName Name of the global object.
+ * @param {string} methodName Name of the method.
+ * @param {number} index The given position.
+ * @returns {boolean} `true` if the node is argument at the given position.
+ * @private
+ */
+function isArgumentOfGlobalMethodCall(
+	node,
+	sourceCode,
+	objectName,
+	methodName,
+	index,
+) {
+	const callNode = node.parent;
+
+	return (
+		callNode.type === "CallExpression" &&
+		callNode.arguments[index] === node &&
+		isSpecificMemberAccess(callNode.callee, objectName, methodName) &&
+		sourceCode.isGlobalReference(
+			skipChainExpression(callNode.callee).object,
+		)
+	);
+}
+
+/**
+ * Determines whether the given node is used as a property descriptor.
+ * @param {ASTNode} node The node to check.
+ * @param {SourceCode} sourceCode Source code to which the node belongs.
+ * @returns {boolean} `true` if the node is a property descriptor.
+ */
+function isPropertyDescriptor(node, sourceCode) {
+	if (
+		isArgumentOfGlobalMethodCall(
+			node,
+			sourceCode,
+			"Object",
+			"defineProperty",
+			2,
+		) ||
+		isArgumentOfGlobalMethodCall(
+			node,
+			sourceCode,
+			"Reflect",
+			"defineProperty",
+			2,
+		)
+	) {
+		return true;
+	}
+
+	const parent = node.parent;
+
+	if (parent.type === "Property" && parent.value === node) {
+		const grandparent = parent.parent;
+
+		if (
+			grandparent.type === "ObjectExpression" &&
+			(isArgumentOfGlobalMethodCall(
+				grandparent,
+				sourceCode,
+				"Object",
+				"create",
+				1,
+			) ||
+				isArgumentOfGlobalMethodCall(
+					grandparent,
+					sourceCode,
+					"Object",
+					"defineProperties",
+					1,
+				))
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
 /**
  * Creates the negate function of the given function.
  * @param {Function} f The function to negate.
@@ -1510,6 +1595,7 @@ module.exports = {
 	isInLoop,
 	isArrayFromMethod,
 	isArrayFromAsyncMethod,
+	isPropertyDescriptor,
 	isParenthesised,
 	createGlobalLinebreakMatcher,
 	equalTokens,

package/node_modules/eslint/lib/types/index.d.ts

@@ -968,7 +968,7 @@ export namespace Linter {
 					 */
 					impliedStrict?: boolean | undefined;
 					/**
-					 * Enable [JSX](https://facebook.github.io/jsx/).
+					 * Enable [JSX](https://react.github.io/jsx/).
 					 *
 					 * @default false
 					 */

package/node_modules/eslint/lib/types/rules.d.ts

@@ -4040,7 +4040,16 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 2.0.0-alpha-2
 	 * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition
 	 */
-	"no-unmodified-loop-condition": Linter.RuleEntry<[]>;
+	"no-unmodified-loop-condition": Linter.RuleEntry<
+		[
+			Partial<{
+				/**
+				 * @default false
+				 */
+				checkConditionalExpressions: boolean;
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow ternary operators when simpler alternatives exist.

package/node_modules/eslint/messages/config-file-missing.js

@@ -2,9 +2,9 @@
 
 module.exports = function () {
 	return `
-ESLint couldn't find an eslint.config.(js|mjs|cjs) file.
+ESLint couldn't find an eslint.config.* file.
 
-From ESLint v9.0.0, the default configuration file is now eslint.config.js.
+From ESLint v9.0.0, the default configuration file is now eslint.config.*.
 If you are using a .eslintrc.* file, please follow the migration guide
 to update your configuration file to the new format: