@askviraj/linter 1.1.0 → 1.1.3

package/node_modules/eslint/lib/rules/preserve-caught-error.js

@@ -15,6 +15,8 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /** @typedef {import("estree").Node} ASTNode */
+/** @typedef {import("eslint").Rule.Fix} Fix */
+/** @typedef {import("eslint").Rule.RuleFixer} RuleFixer */
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -40,18 +42,13 @@ const BUILT_IN_ERROR_TYPES = new Set([
 /**
  * Finds and returns information about the `cause` property of an error being thrown.
  * @param {ASTNode} throwStatement `ThrowStatement` to be checked.
+ * @param {number} optionsIndex The index of the options argument in the error constructor.
  * @returns {{ value: ASTNode; multipleDefinitions: boolean; } | UNKNOWN_CAUSE | null}
  * Information about the `cause` of the error being thrown, such as the value node and
  * whether there are multiple definitions of `cause`. `null` if there is no `cause`.
  */
-function getErrorCause(throwStatement) {
+function getErrorCause(throwStatement, optionsIndex) {
 	const throwExpression = throwStatement.argument;
-	/*
-	 * Determine which argument index holds the options object
-	 * `AggregateError` is a special case as it accepts the `options` object as third argument.
-	 */
-	const optionsIndex =
-		throwExpression.callee.name === "AggregateError" ? 2 : 1;
 
 	/*
 	 * Make sure there is no `SpreadElement` at or before the `optionsIndex`
@@ -152,6 +149,7 @@ module.exports = {
 		defaultOptions: [
 			{
 				requireCatchParameter: false,
+				errorClassNames: [],
 			},
 		],
 
@@ -161,14 +159,6 @@ module.exports = {
 			recommended: true,
 			url: "https://eslint.org/docs/latest/rules/preserve-caught-error", // URL to the documentation page for this rule
 		},
-		/*
-		 * TODO: We should allow passing `customErrorTypes` option once something like `typescript-eslint`'s
-		 * 		`TypeOrValueSpecifier` is implemented in core Eslint.
-		 *      See:
-		 * 		1. https://typescript-eslint.io/packages/type-utils/type-or-value-specifier/
-		 *      2. https://github.com/eslint/eslint/pull/19913#discussion_r2192608593
-		 *      3. https://github.com/eslint/eslint/discussions/16540
-		 */
 		schema: [
 			{
 				type: "object",
@@ -178,6 +168,33 @@ module.exports = {
 						description:
 							"Requires the catch blocks to always have the caught error parameter so it is not discarded.",
 					},
+					errorClassNames: {
+						type: "array",
+						description:
+							"Additional error class names to check for cause preservation.",
+						items: {
+							oneOf: [
+								{
+									type: "string",
+								},
+								{
+									type: "object",
+									required: ["name", "argumentPosition"],
+									properties: {
+										name: {
+											type: "string",
+										},
+										argumentPosition: {
+											type: "integer",
+											minimum: 1,
+										},
+									},
+									additionalProperties: false,
+								},
+							],
+						},
+						uniqueItems: true,
+					},
 				},
 				additionalProperties: false,
 			},
@@ -201,12 +218,34 @@ module.exports = {
 
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const [{ requireCatchParameter }] = context.options;
+		const [{ requireCatchParameter, errorClassNames }] = context.options;
+
+		const errorClassNamesMap = new Map();
+		for (const item of errorClassNames) {
+			const name = typeof item === "string" ? item : item.name;
+			const argumentPosition =
+				typeof item === "string" ? 2 : item.argumentPosition;
+
+			errorClassNamesMap.set(name, argumentPosition);
+		}
 
 		//----------------------------------------------------------------------
 		// Helpers
 		//----------------------------------------------------------------------
 
+		/**
+		 * Checks if the given callee refers to a built-in global Error constructor.
+		 * @param {ASTNode} callee The callee node.
+		 * @returns {boolean} `true` if the callee is a built-in global Error constructor.
+		 */
+		function isBuiltInGlobalError(callee) {
+			return (
+				callee.type === "Identifier" &&
+				BUILT_IN_ERROR_TYPES.has(callee.name) &&
+				sourceCode.isGlobalReference(callee)
+			);
+		}
+
 		/**
 		 * Checks if a `ThrowStatement` is constructing and throwing a new `Error` object.
 		 *
@@ -216,18 +255,33 @@ module.exports = {
 		 * @returns {boolean} `true` if a new "Error" is being thrown, else `false`.
 		 */
 		function isThrowingNewError(throwStatement) {
+			if (!(
+				throwStatement.argument.type === "NewExpression" ||
+				throwStatement.argument.type === "CallExpression"
+			)) {
+				return false;
+			}
+
+			const callee = throwStatement.argument.callee;
+
+			/*
+			 * Make sure the thrown Error instance is one of the built-in global error types.
+			 * Custom imports could shadow this, which would lead to false positives.
+			 * e.g. import { Error } from "./my-custom-error.js";
+			 *      throw Error("Failed to perform error prone operations");
+			 */
+			if (isBuiltInGlobalError(callee)) {
+				return true;
+			}
+
+			const target =
+				callee.type === "MemberExpression" && !callee.computed
+					? callee.property
+					: callee;
+
 			return (
-				(throwStatement.argument.type === "NewExpression" ||
-					throwStatement.argument.type === "CallExpression") &&
-				throwStatement.argument.callee.type === "Identifier" &&
-				BUILT_IN_ERROR_TYPES.has(throwStatement.argument.callee.name) &&
-				/*
-				 * Make sure the thrown Error is instance is one of the built-in global error types.
-				 * Custom imports could shadow this, which would lead to false positives.
-				 * e.g. import { Error } from "./my-custom-error.js";
-				 *      throw Error("Failed to perform error prone operations");
-				 */
-				sourceCode.isGlobalReference(throwStatement.argument.callee)
+				target.type === "Identifier" &&
+				errorClassNamesMap.has(target.name)
 			);
 		}
 
@@ -256,6 +310,83 @@ module.exports = {
 			);
 		}
 
+		/**
+		 * Finds the first token that isn't followed by a closing parenthesis in a specified range.
+		 * This is the token after which new arguments should be inserted.
+		 * @param {Token} firstToken The first token to start searching from.
+		 * @param {Token} lastToken The last token to scan up to (inclusive).
+		 * @returns {Token} The first token that isn't followed by a closing parenthesis, or `lastToken` if none is found.
+		 */
+		function findInsertionTokenAfterParens(firstToken, lastToken) {
+			const lastIndex = lastToken.range[1];
+			let token = firstToken;
+			let nextToken = sourceCode.getTokenAfter(token);
+
+			while (
+				nextToken.range[1] <= lastIndex &&
+				astUtils.isClosingParenToken(nextToken)
+			) {
+				token = nextToken;
+				nextToken = sourceCode.getTokenAfter(token);
+			}
+			return token;
+		}
+
+		/**
+		 * Adds arguments for a call/new expression with no arguments.
+		 * Works for `new Error`, `new (Error)`, and forms that already include empty argument parentheses.
+		 * @param {RuleFixer} fixer The fixer instance.
+		 * @param {ASTNode & { callee: ASTNode }} throwExpression The thrown CallExpression or NewExpression node.
+		 * @param {string} text The arguments to insert.
+		 * @returns {Fix} The fixer operation.
+		 */
+		function addArgumentsToEmptyCall(fixer, throwExpression, text) {
+			const callClosingParenToken =
+				sourceCode.getLastToken(throwExpression);
+			const lastCalleeToken = sourceCode.getLastToken(
+				throwExpression.callee,
+			);
+			const parenToken = sourceCode.getFirstTokenBetween(
+				lastCalleeToken,
+				callClosingParenToken,
+				astUtils.isOpeningParenToken,
+			);
+
+			if (parenToken) {
+				return fixer.insertTextAfter(parenToken, text);
+			}
+
+			const insertionToken = findInsertionTokenAfterParens(
+				lastCalleeToken,
+				callClosingParenToken,
+			);
+
+			return fixer.insertTextAfter(insertionToken, `(${text})`);
+		}
+
+		/**
+		 * Appends additional arguments after the last argument of a call/new expression,
+		 * accounting for any wrapping parentheses around that argument.
+		 * @param {RuleFixer} fixer The fixer instance.
+		 * @param {ASTNode & { arguments: ASTNode[] }} throwExpression The thrown CallExpression or NewExpression node.
+		 * @param {string} text The additional arguments to insert, including the leading comma.
+		 * @returns {Fix} The fixer operation.
+		 */
+		function appendArguments(fixer, throwExpression, text) {
+			const lastArgument = throwExpression.arguments.at(-1);
+			const lastArgumentToken = sourceCode.getLastToken(lastArgument);
+			const lastTokenBeforeArgListParen = sourceCode.getLastToken(
+				throwExpression,
+				{ skip: 1 },
+			);
+			const insertionToken = findInsertionTokenAfterParens(
+				lastArgumentToken,
+				lastTokenBeforeArgListParen,
+			);
+
+			return fixer.insertTextAfter(insertionToken, text);
+		}
+
 		//----------------------------------------------------------------------
 		// Public
 		//----------------------------------------------------------------------
@@ -299,8 +430,30 @@ module.exports = {
 						return;
 					}
 
+					// Determine the options argument index
+					const callee = throwStatement.argument.callee;
+					const errorClassName =
+						callee.type === "Identifier"
+							? callee.name
+							: callee.property.name;
+
+					const builtInGlobalError = isBuiltInGlobalError(callee);
+
+					let optionsIndex;
+					if (builtInGlobalError) {
+						optionsIndex =
+							errorClassName === "AggregateError" ? 2 : 1;
+					} else {
+						const argumentPosition =
+							errorClassNamesMap.get(errorClassName);
+						optionsIndex = argumentPosition - 1;
+					}
+
 					// Check if there is a cause attached to the new error
-					const errorCauseInfo = getErrorCause(throwStatement);
+					const errorCauseInfo = getErrorCause(
+						throwStatement,
+						optionsIndex,
+					);
 
 					if (errorCauseInfo === UNKNOWN_CAUSE) {
 						// Error options exist, but too complicated to be analyzed/fixed
@@ -319,127 +472,128 @@ module.exports = {
 										const throwExpression =
 											throwStatement.argument;
 										const args = throwExpression.arguments;
-										const errorType =
-											throwExpression.callee.name;
+
+										/**
+										 * Inserts `cause` into the options argument if it is an `ObjectExpression`.
+										 * @param {ASTNode} optionsArg The options argument node.
+										 * @returns {Fix | null} The fix, or `null` if the argument is not an object.
+										 */
+										function fixExistingOptions(
+											optionsArg,
+										) {
+											if (
+												optionsArg.type ===
+												"ObjectExpression"
+											) {
+												return insertCauseIntoOptions(
+													fixer,
+													optionsArg,
+													caughtError.name,
+												);
+											}
+											return null;
+										}
 
 										// AggregateError: errors, message, options
-										if (errorType === "AggregateError") {
+										if (
+											builtInGlobalError &&
+											errorClassName === "AggregateError"
+										) {
 											const errorsArg = args[0];
 											const messageArg = args[1];
 											const optionsArg = args[2];
 
 											if (!errorsArg) {
 												// Case: `throw new AggregateError()` → insert all arguments
-												const lastToken =
-													sourceCode.getLastToken(
-														throwExpression,
-													);
-												const lastCalleeToken =
-													sourceCode.getLastToken(
-														throwExpression.callee,
-													);
-												const parenToken =
-													sourceCode.getFirstTokenBetween(
-														lastCalleeToken,
-														lastToken,
-														astUtils.isOpeningParenToken,
-													);
-
-												if (parenToken) {
-													return fixer.insertTextAfter(
-														parenToken,
-														`[], "", { cause: ${caughtError.name} }`,
-													);
-												}
-												return fixer.insertTextAfter(
-													throwExpression.callee,
-													`([], "", { cause: ${caughtError.name} })`,
+												return addArgumentsToEmptyCall(
+													fixer,
+													throwExpression,
+													`[], "", { cause: ${caughtError.name} }`,
 												);
 											}
 
 											if (!messageArg) {
 												// Case: `throw new AggregateError([])` → insert message and options
-												return fixer.insertTextAfter(
-													errorsArg,
+												return appendArguments(
+													fixer,
+													throwExpression,
 													`, "", { cause: ${caughtError.name} }`,
 												);
 											}
 
 											if (!optionsArg) {
 												// Case: `throw new AggregateError([], "")` → insert error options only
-												return fixer.insertTextAfter(
-													messageArg,
-													`, { cause: ${caughtError.name} }`,
-												);
-											}
-
-											if (
-												optionsArg.type ===
-												"ObjectExpression"
-											) {
-												return insertCauseIntoOptions(
+												return appendArguments(
 													fixer,
-													optionsArg,
-													caughtError.name,
+													throwExpression,
+													`, { cause: ${caughtError.name} }`,
 												);
 											}
 
-											// Complex dynamic options — skip
-											return null;
+											return fixExistingOptions(
+												optionsArg,
+											);
 										}
 
 										// Normal Error types
-										const messageArg = args[0];
-										const optionsArg = args[1];
+										if (builtInGlobalError) {
+											const messageArg = args[0];
+											const optionsArg = args[1];
 
-										if (!messageArg) {
-											// Case: `throw new Error()` → insert both message and options
-											const lastToken =
-												sourceCode.getLastToken(
+											if (!messageArg) {
+												// Case: `throw new Error()` → insert both message and options
+												return addArgumentsToEmptyCall(
+													fixer,
 													throwExpression,
-												);
-											const lastCalleeToken =
-												sourceCode.getLastToken(
-													throwExpression.callee,
-												);
-											const parenToken =
-												sourceCode.getFirstTokenBetween(
-													lastCalleeToken,
-													lastToken,
-													astUtils.isOpeningParenToken,
-												);
-
-											if (parenToken) {
-												return fixer.insertTextAfter(
-													parenToken,
 													`"", { cause: ${caughtError.name} }`,
 												);
 											}
-											return fixer.insertTextAfter(
-												throwExpression.callee,
-												`("", { cause: ${caughtError.name} })`,
+											if (!optionsArg) {
+												// Case: `throw new Error("Some message")` → insert only options
+												return appendArguments(
+													fixer,
+													throwExpression,
+													`, { cause: ${caughtError.name} }`,
+												);
+											}
+
+											return fixExistingOptions(
+												optionsArg,
 											);
 										}
-										if (!optionsArg) {
-											// Case: `throw new Error("Some message")` → insert only options
-											return fixer.insertTextAfter(
-												messageArg,
-												`, { cause: ${caughtError.name} }`,
-											);
+
+										// Custom error types
+										const optionsArg = args[optionsIndex];
+
+										/*
+										 * Custom error signature is unknown, so skip the suggestion rather
+										 * than synthesize placeholder values for missing positional args.
+										 */
+										if (args.length < optionsIndex) {
+											return null;
 										}
 
-										if (
-											optionsArg.type ===
-											"ObjectExpression"
-										) {
-											return insertCauseIntoOptions(
+										if (!optionsArg) {
+											const lastProvidedArg = args.at(-1);
+
+											if (lastProvidedArg) {
+												// Options slot missing, all prior args provided → append options
+												return appendArguments(
+													fixer,
+													throwExpression,
+													`, { cause: ${caughtError.name} }`,
+												);
+											}
+
+											// argumentPosition: 1 and no args → insert options inside parens
+											return addArgumentsToEmptyCall(
 												fixer,
-												optionsArg,
-												caughtError.name,
+												throwExpression,
+												`{ cause: ${caughtError.name} }`,
 											);
 										}
 
-										return null; // Identifier or spread — do not fix
+										return fixExistingOptions(optionsArg);
 									},
 								},
 							],
@@ -452,12 +606,10 @@ module.exports = {
 					const { value: thrownErrorCause } = errorCauseInfo;
 
 					// If there is an attached cause, verify that it matches the caught error
-					if (
-						!(
-							thrownErrorCause.type === "Identifier" &&
-							thrownErrorCause.name === caughtError.name
-						)
-					) {
+					if (!(
+						thrownErrorCause.type === "Identifier" &&
+						thrownErrorCause.name === caughtError.name
+					)) {
 						const suggest = errorCauseInfo.multipleDefinitions
 							? null // If there are multiple `cause` definitions, a suggestion could be confusing.
 							: [

package/node_modules/eslint/lib/rules/quotes.js

@@ -220,7 +220,7 @@ module.exports = {
 
 		/**
 		 * Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
-		 * @see {@link http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive}
+		 * @see {@link https://262.ecma-international.org/6.0/#sec-directive-prologues-and-the-use-strict-directive}
 		 * @param {ASTNode} node A node to check.
 		 * @returns {boolean} Whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
 		 * @private

package/node_modules/eslint/lib/rules/radix.js

@@ -34,21 +34,6 @@ function isShadowed(variable) {
 	return variable.defs.length >= 1;
 }
 
-/**
- * Checks whether a given node is a MemberExpression of `parseInt` method or not.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
- *      method.
- */
-function isParseIntMethod(node) {
-	return (
-		node.type === "MemberExpression" &&
-		!node.computed &&
-		node.property.type === "Identifier" &&
-		node.property.name === "parseInt"
-	);
-}
-
 /**
  * Checks whether a given node is a valid value of radix or not.
  *
@@ -61,6 +46,20 @@ function isParseIntMethod(node) {
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidRadix(radix, sourceCode) {
+	if (
+		radix.type === "UnaryExpression" &&
+		(radix.operator === "-" || radix.operator === "+") &&
+		radix.argument.type === "Literal" &&
+		typeof radix.argument.value === "number"
+	) {
+		const value =
+			radix.operator === "-"
+				? -radix.argument.value
+				: radix.argument.value;
+
+		return validRadixValues.has(value);
+	}
+
 	return !(
 		(radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
 		(radix.type === "Identifier" &&
@@ -115,49 +114,47 @@ module.exports = {
 		 */
 		function checkArguments(node) {
 			const args = node.arguments;
+			const spreadIndex = args.findIndex(
+				arg => arg.type === "SpreadElement",
+			);
 
-			switch (args.length) {
-				case 0:
-					context.report({
-						node,
-						messageId: "missingParameters",
-					});
-					break;
-
-				case 1:
-					context.report({
-						node,
-						messageId: "missingRadix",
-						suggest: [
-							{
-								messageId: "addRadixParameter10",
-								fix(fixer) {
-									const tokens = sourceCode.getTokens(node);
-									const lastToken = tokens.at(-1); // Parenthesis.
-									const secondToLastToken = tokens.at(-2); // May or may not be a comma.
-									const hasTrailingComma =
-										secondToLastToken.type ===
-											"Punctuator" &&
-										secondToLastToken.value === ",";
-
-									return fixer.insertTextBefore(
-										lastToken,
-										hasTrailingComma ? " 10," : ", 10",
-									);
-								},
+			if (spreadIndex !== -1 && spreadIndex < 2) {
+				return;
+			}
+
+			if (args.length === 0) {
+				context.report({
+					node,
+					messageId: "missingParameters",
+				});
+			} else if (args.length === 1) {
+				context.report({
+					node,
+					messageId: "missingRadix",
+					suggest: [
+						{
+							messageId: "addRadixParameter10",
+							fix(fixer) {
+								const lastToken = sourceCode.getLastToken(node);
+								const prevToken =
+									sourceCode.getTokenBefore(lastToken);
+
+								const hasTrailingComma =
+									astUtils.isCommaToken(prevToken);
+
+								return fixer.insertTextBefore(
+									lastToken,
+									hasTrailingComma ? " 10," : ", 10",
+								);
 							},
-						],
-					});
-					break;
-
-				default:
-					if (!isValidRadix(args[1], sourceCode)) {
-						context.report({
-							node,
-							messageId: "invalidRadix",
-						});
-					}
-					break;
+						},
+					],
+				});
+			} else if (!isValidRadix(args[1], sourceCode)) {
+				context.report({
+					node,
+					messageId: "invalidRadix",
+				});
 			}
 		}
 
@@ -189,7 +186,11 @@ module.exports = {
 								: parentNode;
 
 						if (
-							isParseIntMethod(parentNode) &&
+							astUtils.isSpecificMemberAccess(
+								parentNode,
+								"Number",
+								"parseInt",
+							) &&
 							astUtils.isCallee(maybeCallee)
 						) {
 							checkArguments(maybeCallee.parent);