feat: support TS syntax in no-magic-numbers (#19561)

snitin315 · web-flow · commit 0f773ef248af · 2025-05-28T23:42:10.000+05:30
diff --git a/docs/src/rules/no-magic-numbers.md b/docs/src/rules/no-magic-numbers.md
@@ -128,6 +128,7 @@ data[100] = a;
 f(data[0]);
 
 a = data[-0]; // same as data[0], -0 will be coerced to "0"
+a = data[+1]; // same as data[1], +1 will be coerced to "1"
 
 a = data[0xAB];
 
@@ -207,6 +208,7 @@ Examples of **correct** code for the `{ "ignoreClassFieldInitialValues": true }`
 class C {
     foo = 2;
     bar = -3;
+    tux = +1;
     #baz = 4;
     static qux = 5;
 }
@@ -290,3 +292,131 @@ const dutyFreePrice = 100,
 ```
 
 :::
+
+### ignoreEnums (TypeScript only)
+
+Whether enums used in TypeScript are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreEnums": false }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreEnums": false }]*/
+
+enum foo {
+  SECOND = 1000,
+}
+```
+
+:::
+
+Examples of **correct** code for the `{ "ignoreEnums": true }` option:
+
+::: correct
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreEnums": true }]*/
+
+enum foo {
+  SECOND = 1000,
+}
+```
+
+:::
+
+### ignoreNumericLiteralTypes (TypeScript only)
+
+Whether numbers used in TypeScript numeric literal types are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreNumericLiteralTypes": false }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": false }]*/
+
+type Foo = 1 | 2 | 3;
+```
+
+:::
+
+Examples of **correct** code for the `{ "ignoreNumericLiteralTypes": true }` option:
+
+::: correct
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreNumericLiteralTypes": true }]*/
+
+type Foo = 1 | 2 | 3;
+```
+
+:::
+
+### ignoreReadonlyClassProperties (TypeScript only)
+
+Whether numbers used in TypeScript readonly class properties are considered okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreReadonlyClassProperties": false }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreReadonlyClassProperties": false }]*/
+
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+}
+```
+
+:::
+
+Examples of **correct** code for the `{ "ignoreReadonlyClassProperties": true }` option:
+
+::: correct
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreReadonlyClassProperties": true }]*/
+
+class Foo {
+  readonly A = 1;
+  readonly B = 2;
+  public static readonly C = 1;
+  static readonly D = 1;
+}
+```
+
+:::
+
+### ignoreTypeIndexes (TypeScript only)
+
+Whether numbers used to index types are okay. `false` by default.
+
+Examples of **incorrect** code for the `{ "ignoreTypeIndexes": false }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreTypeIndexes": false }]*/
+
+type Foo = Bar[0];
+type Baz = Parameters<Foo>[2];
+```
+
+:::
+
+Examples of **correct** code for the `{ "ignoreTypeIndexes": true }` option:
+
+::: correct
+
+```ts
+/*eslint no-magic-numbers: ["error", { "ignoreTypeIndexes": true }]*/
+
+type Foo = Bar[0];
+type Baz = Parameters<Foo>[2];
+```
+
+:::
diff --git a/lib/rules/no-magic-numbers.js b/lib/rules/no-magic-numbers.js
@@ -26,10 +26,73 @@ function normalizeIgnoreValue(x) {
 	return x;
 }
 
+/**
+ * Checks if the node parent is a TypeScript enum member
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node parent is a TypeScript enum member
+ */
+function isParentTSEnumDeclaration(node) {
+	return node.parent.type === "TSEnumMember";
+}
+
+/**
+ * Checks if the node is a valid TypeScript numeric literal type.
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node is a TypeScript numeric literal type
+ */
+function isTSNumericLiteralType(node) {
+	let ancestor = node.parent;
+
+	// Go up while we're part of a type union
+	while (ancestor.parent.type === "TSUnionType") {
+		ancestor = ancestor.parent;
+	}
+
+	// Check if the final ancestor is in a type alias declaration
+	return ancestor.parent.type === "TSTypeAliasDeclaration";
+}
+
+/**
+ * Checks if the node parent is a readonly class property
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node parent is a readonly class property
+ */
+function isParentTSReadonlyPropertyDefinition(node) {
+	if (node.parent?.type === "PropertyDefinition" && node.parent.readonly) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Checks if the node is part of a type indexed access (eg. Foo[4])
+ * @param {ASTNode} node The node to be validated
+ * @returns {boolean} True if the node is part of an indexed access
+ */
+function isAncestorTSIndexedAccessType(node) {
+	let ancestor = node.parent;
+
+	/*
+	 * Go up another level while we're part of a type union (eg. 1 | 2) or
+	 * intersection (eg. 1 & 2)
+	 */
+	while (
+		ancestor.parent.type === "TSUnionType" ||
+		ancestor.parent.type === "TSIntersectionType"
+	) {
+		ancestor = ancestor.parent;
+	}
+
+	return ancestor.parent.type === "TSIndexedAccessType";
+}
+
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
 
 		docs: {
 			description: "Disallow magic numbers",
@@ -75,6 +138,22 @@ module.exports = {
 						type: "boolean",
 						default: false,
 					},
+					ignoreEnums: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreNumericLiteralTypes: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreReadonlyClassProperties: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreTypeIndexes: {
+						type: "boolean",
+						default: false,
+					},
 				},
 				additionalProperties: false,
 			},
@@ -94,7 +173,12 @@ module.exports = {
 			ignoreArrayIndexes = !!config.ignoreArrayIndexes,
 			ignoreDefaultValues = !!config.ignoreDefaultValues,
 			ignoreClassFieldInitialValues =
-				!!config.ignoreClassFieldInitialValues;
+				!!config.ignoreClassFieldInitialValues,
+			ignoreEnums = !!config.ignoreEnums,
+			ignoreNumericLiteralTypes = !!config.ignoreNumericLiteralTypes,
+			ignoreReadonlyClassProperties =
+				!!config.ignoreReadonlyClassProperties,
+			ignoreTypeIndexes = !!config.ignoreTypeIndexes;
 
 		const okTypes = detectObjects
 			? []
@@ -217,14 +301,15 @@ module.exports = {
 				let value;
 				let raw;
 
-				// Treat unary minus as a part of the number
+				// Treat unary minus/plus as a part of the number
 				if (
 					node.parent.type === "UnaryExpression" &&
-					node.parent.operator === "-"
+					["-", "+"].includes(node.parent.operator)
 				) {
 					fullNumberNode = node.parent;
-					value = -node.value;
-					raw = `-${node.raw}`;
+					value =
+						node.parent.operator === "-" ? -node.value : node.value;
+					raw = `${node.parent.operator}${node.raw}`;
 				} else {
 					fullNumberNode = node;
 					value = node.value;
@@ -239,6 +324,14 @@ module.exports = {
 					(ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
 					(ignoreClassFieldInitialValues &&
 						isClassFieldInitialValue(fullNumberNode)) ||
+					(ignoreEnums &&
+						isParentTSEnumDeclaration(fullNumberNode)) ||
+					(ignoreNumericLiteralTypes &&
+						isTSNumericLiteralType(fullNumberNode)) ||
+					(ignoreTypeIndexes &&
+						isAncestorTSIndexedAccessType(fullNumberNode)) ||
+					(ignoreReadonlyClassProperties &&
+						isParentTSReadonlyPropertyDefinition(fullNumberNode)) ||
 					isParseIntRadix(fullNumberNode) ||
 					isJSXNumber(fullNumberNode) ||
 					(ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))
diff --git a/lib/types/rules.d.ts b/lib/types/rules.d.ts
@@ -2858,6 +2858,22 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 * @default false
 				 */
 				detectObjects: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreEnums: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreNumericLiteralTypes: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreReadonlyClassProperties: boolean;
+				/**
+				 * @default false
+				 */
+				ignoreTypeIndexes: boolean;
 			}>,
 		]
 	>;
diff --git a/tests/lib/rules/no-magic-numbers.js b/tests/lib/rules/no-magic-numbers.js
