Current File : /home/vacivi36/SiteVacivitta/vacivitta/node_modules/eslint/lib/rules/no-magic-numbers.js
/**
* @fileoverview Rule to flag statements that use magic numbers (adapted from https://github.com/danielstjules/buddy.js)
* @author Vincent Lemeunier
*/
"use strict";
const astUtils = require("./utils/ast-utils");
// Maximum array length by the ECMAScript Specification.
const MAX_ARRAY_LENGTH = 2 ** 32 - 1;
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/**
* Convert the value to bigint if it's a string. Otherwise return the value as-is.
* @param {bigint|number|string} x The value to normalize.
* @returns {bigint|number} The normalized value.
*/
function normalizeIgnoreValue(x) {
if (typeof x === "string") {
return BigInt(x.slice(0, -1));
}
return x;
}
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
type: "suggestion",
docs: {
description: "Disallow magic numbers",
recommended: false,
frozen: true,
url: "https://eslint.org/docs/latest/rules/no-magic-numbers",
},
schema: [
{
type: "object",
properties: {
detectObjects: {
type: "boolean",
default: false,
},
enforceConst: {
type: "boolean",
default: false,
},
ignore: {
type: "array",
items: {
anyOf: [
{ type: "number" },
{
type: "string",
pattern: "^[+-]?(?:0|[1-9][0-9]*)n$",
},
],
},
uniqueItems: true,
},
ignoreArrayIndexes: {
type: "boolean",
default: false,
},
ignoreDefaultValues: {
type: "boolean",
default: false,
},
ignoreClassFieldInitialValues: {
type: "boolean",
default: false,
},
},
additionalProperties: false,
},
],
messages: {
useConst: "Number constants declarations must use 'const'.",
noMagic: "No magic number: {{raw}}.",
},
},
create(context) {
const config = context.options[0] || {},
detectObjects = !!config.detectObjects,
enforceConst = !!config.enforceConst,
ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
ignoreArrayIndexes = !!config.ignoreArrayIndexes,
ignoreDefaultValues = !!config.ignoreDefaultValues,
ignoreClassFieldInitialValues =
!!config.ignoreClassFieldInitialValues;
const okTypes = detectObjects
? []
: ["ObjectExpression", "Property", "AssignmentExpression"];
/**
* Returns whether the rule is configured to ignore the given value
* @param {bigint|number} value The value to check
* @returns {boolean} true if the value is ignored
*/
function isIgnoredValue(value) {
return ignore.has(value);
}
/**
* Returns whether the number is a default value assignment.
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
* @returns {boolean} true if the number is a default value
*/
function isDefaultValue(fullNumberNode) {
const parent = fullNumberNode.parent;
return (
parent.type === "AssignmentPattern" &&
parent.right === fullNumberNode
);
}
/**
* Returns whether the number is the initial value of a class field.
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
* @returns {boolean} true if the number is the initial value of a class field.
*/
function isClassFieldInitialValue(fullNumberNode) {
const parent = fullNumberNode.parent;
return (
parent.type === "PropertyDefinition" &&
parent.value === fullNumberNode
);
}
/**
* Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
* @returns {boolean} true if the node is radix
*/
function isParseIntRadix(fullNumberNode) {
const parent = fullNumberNode.parent;
return (
parent.type === "CallExpression" &&
fullNumberNode === parent.arguments[1] &&
(astUtils.isSpecificId(parent.callee, "parseInt") ||
astUtils.isSpecificMemberAccess(
parent.callee,
"Number",
"parseInt",
))
);
}
/**
* Returns whether the given node is a direct child of a JSX node.
* In particular, it aims to detect numbers used as prop values in JSX tags.
* Example: <input maxLength={10} />
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
* @returns {boolean} true if the node is a JSX number
*/
function isJSXNumber(fullNumberNode) {
return fullNumberNode.parent.type.indexOf("JSX") === 0;
}
/**
* Returns whether the given node is used as an array index.
* Value must coerce to a valid array index name: "0", "1", "2" ... "4294967294".
*
* All other values, like "-1", "2.5", or "4294967295", are just "normal" object properties,
* which can be created and accessed on an array in addition to the array index properties,
* but they don't affect array's length and are not considered by methods such as .map(), .forEach() etc.
*
* The maximum array length by the specification is 2 ** 32 - 1 = 4294967295,
* thus the maximum valid index is 2 ** 32 - 2 = 4294967294.
*
* All notations are allowed, as long as the value coerces to one of "0", "1", "2" ... "4294967294".
*
* Valid examples:
* a[0], a[1], a[1.2e1], a[0xAB], a[0n], a[1n]
* a[-0] (same as a[0] because -0 coerces to "0")
* a[-0n] (-0n evaluates to 0n)
*
* Invalid examples:
* a[-1], a[-0xAB], a[-1n], a[2.5], a[1.23e1], a[12e-1]
* a[4294967295] (above the max index, it's an access to a regular property a["4294967295"])
* a[999999999999999999999] (even if it wasn't above the max index, it would be a["1e+21"])
* a[1e310] (same as a["Infinity"])
* @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
* @param {bigint|number} value Value expressed by the fullNumberNode
* @returns {boolean} true if the node is a valid array index
*/
function isArrayIndex(fullNumberNode, value) {
const parent = fullNumberNode.parent;
return (
parent.type === "MemberExpression" &&
parent.property === fullNumberNode &&
(Number.isInteger(value) || typeof value === "bigint") &&
value >= 0 &&
value < MAX_ARRAY_LENGTH
);
}
return {
Literal(node) {
if (!astUtils.isNumericLiteral(node)) {
return;
}
let fullNumberNode;
let value;
let raw;
// Treat unary minus as a part of the number
if (
node.parent.type === "UnaryExpression" &&
node.parent.operator === "-"
) {
fullNumberNode = node.parent;
value = -node.value;
raw = `-${node.raw}`;
} else {
fullNumberNode = node;
value = node.value;
raw = node.raw;
}
const parent = fullNumberNode.parent;
// Always allow radix arguments and JSX props
if (
isIgnoredValue(value) ||
(ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
(ignoreClassFieldInitialValues &&
isClassFieldInitialValue(fullNumberNode)) ||
isParseIntRadix(fullNumberNode) ||
isJSXNumber(fullNumberNode) ||
(ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))
) {
return;
}
if (parent.type === "VariableDeclarator") {
if (enforceConst && parent.parent.kind !== "const") {
context.report({
node: fullNumberNode,
messageId: "useConst",
});
}
} else if (
!okTypes.includes(parent.type) ||
(parent.type === "AssignmentExpression" &&
parent.left.type === "Identifier")
) {
context.report({
node: fullNumberNode,
messageId: "noMagic",
data: {
raw,
},
});
}
},
};
},
};
Mini Shell