@blumintinc/eslint-plugin-blumint 1.10.0 → 1.11.1

package/lib/rules/enforce-positive-naming.js

@@ -5,20 +5,22 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 // Common negative prefixes for boolean variables
 const BOOLEAN_NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
+// Words that contain negative prefixes but should be treated as valid
+const EXCEPTION_WORDS = ['interaction', 'interactions'];
 // Map of negative boolean terms to suggested positive alternatives
 const BOOLEAN_POSITIVE_ALTERNATIVES = {
     // Boolean prefixes
-    'isNot': ['is'],
-    'isUn': ['is'],
-    'isDis': ['is'],
-    'isIn': ['is'],
-    'isNon': ['is'],
-    'hasNo': ['has'],
-    'hasNot': ['has'],
-    'canNot': ['can'],
-    'shouldNot': ['should'],
-    'willNot': ['will'],
-    'doesNot': ['does'],
+    isNot: ['is'],
+    isUn: ['is'],
+    isDis: ['is'],
+    isIn: ['is'],
+    isNon: ['is'],
+    hasNo: ['has'],
+    hasNot: ['has'],
+    canNot: ['can'],
+    shouldNot: ['should'],
+    willNot: ['will'],
+    doesNot: ['does'],
 };
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
@@ -56,20 +58,52 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function hasBooleanNegativeNaming(name) {
             // Check for exact matches in our alternatives map first
             if (BOOLEAN_POSITIVE_ALTERNATIVES[name]) {
-                return { isNegative: true, alternatives: BOOLEAN_POSITIVE_ALTERNATIVES[name] };
+                return {
+                    isNegative: true,
+                    alternatives: BOOLEAN_POSITIVE_ALTERNATIVES[name],
+                };
             }
             // Check for negative prefixes in boolean-like variables
-            if (name.startsWith('is') || name.startsWith('has') || name.startsWith('can') ||
-                name.startsWith('should') || name.startsWith('will') || name.startsWith('does')) {
+            if (name.startsWith('is') ||
+                name.startsWith('has') ||
+                name.startsWith('can') ||
+                name.startsWith('should') ||
+                name.startsWith('will') ||
+                name.startsWith('does')) {
+                // Check if the name contains any exception words
+                for (const exceptionWord of EXCEPTION_WORDS) {
+                    const lowerCaseName = name.toLowerCase();
+                    if (lowerCaseName.includes(exceptionWord.toLowerCase())) {
+                        return { isNegative: false, alternatives: [] };
+                    }
+                }
                 for (const prefix of BOOLEAN_NEGATIVE_PREFIXES) {
                     // Check for patterns like isNot, hasNo, canNot, etc.
                     const prefixPatterns = [
-                        { pattern: new RegExp(`^is${prefix}`, 'i'), key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                        { pattern: new RegExp(`^has${prefix}`, 'i'), key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                        { pattern: new RegExp(`^can${prefix}`, 'i'), key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                        { pattern: new RegExp(`^should${prefix}`, 'i'), key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                        { pattern: new RegExp(`^will${prefix}`, 'i'), key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                        { pattern: new RegExp(`^does${prefix}`, 'i'), key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        {
+                            pattern: new RegExp(`^is${prefix}`, 'i'),
+                            key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
+                        {
+                            pattern: new RegExp(`^has${prefix}`, 'i'),
+                            key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
+                        {
+                            pattern: new RegExp(`^can${prefix}`, 'i'),
+                            key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
+                        {
+                            pattern: new RegExp(`^should${prefix}`, 'i'),
+                            key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
+                        {
+                            pattern: new RegExp(`^will${prefix}`, 'i'),
+                            key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
+                        {
+                            pattern: new RegExp(`^does${prefix}`, 'i'),
+                            key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                        },
                     ];
                     for (const { pattern, key } of prefixPatterns) {
                         if (pattern.test(name)) {
@@ -82,10 +116,16 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                             if (alternatives.length > 0) {
                                 // Suggest the positive version with the rest of the name
                                 const restOfName = name.replace(pattern, '');
-                                const suggestedAlternatives = alternatives.map(alt => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
-                                return { isNegative: true, alternatives: suggestedAlternatives };
+                                const suggestedAlternatives = alternatives.map((alt) => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
+                                return {
+                                    isNegative: true,
+                                    alternatives: suggestedAlternatives,
+                                };
                             }
-                            return { isNegative: true, alternatives: ['a positive alternative'] };
+                            return {
+                                isNegative: true,
+                                alternatives: ['a positive alternative'],
+                            };
                         }
                     }
                 }
@@ -118,9 +158,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             // Check if the node has a name that suggests it's a boolean
             if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
-                (node.name.startsWith('is') || node.name.startsWith('has') ||
-                    node.name.startsWith('can') || node.name.startsWith('should') ||
-                    node.name.startsWith('will') || node.name.startsWith('does'))) {
+                (node.name.startsWith('is') ||
+                    node.name.startsWith('has') ||
+                    node.name.startsWith('can') ||
+                    node.name.startsWith('should') ||
+                    node.name.startsWith('will') ||
+                    node.name.startsWith('does'))) {
                 return true;
             }
             return false;
@@ -238,7 +281,8 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                 return;
             // Only check boolean properties
             if (!isBooleanLike(node.key) &&
-                !(node.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword))
+                !(node.typeAnnotation?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSBooleanKeyword))
                 return;
             const propertyName = node.key.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);

package/lib/rules/enforce-props-argument-name.js

@@ -72,7 +72,15 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             if (typeName.endsWith('Props')) {
                 return null;
             }
-            const suffixes = ['Config', 'Settings', 'Options', 'Params', 'Parameters', 'Args', 'Arguments'];
+            const suffixes = [
+                'Config',
+                'Settings',
+                'Options',
+                'Params',
+                'Parameters',
+                'Args',
+                'Arguments',
+            ];
             for (const suffix of suffixes) {
                 if (typeName.endsWith(suffix)) {
                     return suffix;
@@ -96,13 +104,20 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             }
             const param = node.params[0];
             // Skip primitive parameters
-            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && (param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword ||
-                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNumberKeyword ||
-                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                param.typeAnnotation &&
+                (param.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSStringKeyword ||
+                    param.typeAnnotation.typeAnnotation.type ===
+                        utils_1.AST_NODE_TYPES.TSNumberKeyword ||
+                    param.typeAnnotation.typeAnnotation.type ===
+                        utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
                 return;
             }
             // Check if the parameter has a type annotation
-            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                param.typeAnnotation &&
+                param.typeAnnotation.typeAnnotation) {
                 const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
                 if (typeName) {
                     const nonPropsSuffix = hasNonPropsSuffix(typeName);
@@ -128,13 +143,20 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             }
             const param = constructor.params[0];
             // Skip primitive parameters
-            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && (param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword ||
-                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNumberKeyword ||
-                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                param.typeAnnotation &&
+                (param.typeAnnotation.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSStringKeyword ||
+                    param.typeAnnotation.typeAnnotation.type ===
+                        utils_1.AST_NODE_TYPES.TSNumberKeyword ||
+                    param.typeAnnotation.typeAnnotation.type ===
+                        utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
                 return;
             }
             // Check if the parameter has a type annotation
-            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                param.typeAnnotation &&
+                param.typeAnnotation.typeAnnotation) {
                 const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
                 if (typeName) {
                     const nonPropsSuffix = hasNonPropsSuffix(typeName);

package/lib/rules/enforce-realtimedb-path-utils.js

@@ -55,7 +55,8 @@ exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
             return false;
         }
         function isStringLiteralOrTemplate(node) {
-            return ((node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') ||
+            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') ||
                 node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
         function isUtilityFunction(node) {

package/lib/rules/enforce-singular-type-names.js

@@ -38,7 +38,10 @@ exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
             if (name.length < 3)
                 return false;
             // Skip checking if name ends with 'Props' or 'Params'
-            if (name.endsWith('Props') || name.endsWith('Params') || name.endsWith('Options') || name.endsWith('Settings'))
+            if (name.endsWith('Props') ||
+                name.endsWith('Params') ||
+                name.endsWith('Options') ||
+                name.endsWith('Settings'))
                 return false;
             // Skip checking if name is already singular according to pluralize
             if (pluralize.isSingular(name))

package/lib/rules/enforce-timestamp-now.js

@@ -51,8 +51,7 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
                         return true;
                     }
                     // Check if the argument is a variable reference to a Date object
-                    if (arg &&
-                        arg.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (arg && arg.type === utils_1.AST_NODE_TYPES.Identifier) {
                         // If it's a variable, we need to check if it's a Date that's being modified
                         // If it's modified, we shouldn't flag it
                         return false;
@@ -95,11 +94,11 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
         function isDateBeingModified(dateVar) {
             // Look through the scope to find if this variable is modified
             const scope = context.getScope();
-            const variable = scope.variables.find(v => v.name === dateVar);
+            const variable = scope.variables.find((v) => v.name === dateVar);
             if (!variable)
                 return false;
             // Check if any references to this variable are followed by property access and modification
-            return variable.references.some(ref => {
+            return variable.references.some((ref) => {
                 const id = ref.identifier;
                 const parent = id.parent;
                 // Check for patterns like dateVar.setDate(), dateVar.setHours(), etc.

package/lib/rules/enforce-verb-noun-naming.js

@@ -4608,7 +4608,9 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                 return true;
             }
             // Check for JSX assigned to variables then returned
-            if (text.includes('const ') && text.includes('<') && text.includes('return')) {
+            if (text.includes('const ') &&
+                text.includes('<') &&
+                text.includes('return')) {
                 return true;
             }
             return false;
@@ -4624,9 +4626,11 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
                 functionName = node.id.name;
             }
-            else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression || node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                 const parent = node.parent;
-                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                     functionName = parent.id.name;
                 }
             }
@@ -4644,20 +4648,26 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                         const parent = node.parent;
                         if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                             const id = parent.id;
-                            if (id.type === utils_1.AST_NODE_TYPES.Identifier && id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
-                                const typeText = context.getSourceCode().getText(id.typeAnnotation.typeAnnotation);
-                                return typeText.includes('React.') || typeText.includes('FC') || typeText.includes('FunctionComponent');
+                            if (id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                id.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+                                const typeText = context
+                                    .getSourceCode()
+                                    .getText(id.typeAnnotation.typeAnnotation);
+                                return (typeText.includes('React.') ||
+                                    typeText.includes('FC') ||
+                                    typeText.includes('FunctionComponent'));
                             }
                         }
                     }
                     return false;
                 })(),
                 // 5. Component name ends with "Unmemoized" (common React pattern)
-                functionName && functionName.endsWith('Unmemoized')
+                functionName && functionName.endsWith('Unmemoized'),
             ];
             // Consider it a React component if it matches at least 2 indicators
             // OR if it has the Unmemoized suffix (strong indicator of a React component)
-            return indicators.filter(Boolean).length >= 2 || (!!functionName && functionName.endsWith('Unmemoized'));
+            return (indicators.filter(Boolean).length >= 2 ||
+                (!!functionName && functionName.endsWith('Unmemoized')));
         }
         return {
             FunctionDeclaration(node) {

package/lib/rules/ensure-pointer-events-none.js

@@ -59,7 +59,8 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                 if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
                     propertyName = property.key.name;
                 }
-                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal && typeof property.key.value === 'string') {
+                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof property.key.value === 'string') {
                     propertyName = property.key.value;
                 }
                 // Get property value if it's a string literal
@@ -97,7 +98,9 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             const isAbsolutePositioned = absolutePositionedStyles.get(node) || false;
             const pointerEventsValue = stylesWithPointerEvents.get(node);
             // If this is a pseudo-element with absolute positioning but no pointer-events
-            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === undefined) {
+            if (isPseudoElement &&
+                isAbsolutePositioned &&
+                pointerEventsValue === undefined) {
                 context.report({
                     node,
                     messageId: 'missingPointerEventsNone',
@@ -113,11 +116,13 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                             return fixer.insertTextAfter(lastPropertyToken, `, pointerEvents: 'none'`);
                         }
                         return null;
-                    }
+                    },
                 });
             }
             // If this is a pseudo-element with absolute positioning and pointer-events: auto
-            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === 'auto') {
+            if (isPseudoElement &&
+                isAbsolutePositioned &&
+                pointerEventsValue === 'auto') {
                 // Don't report an error if pointer-events is explicitly set to 'auto'
                 // This is an intentional choice by the developer
             }
@@ -139,15 +144,17 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                 }
                 if (isStyledComponent) {
                     // For styled-components, we need to check the template content
-                    const template = node.quasi.quasis.map(q => q.value.raw).join('');
+                    const template = node.quasi.quasis.map((q) => q.value.raw).join('');
                     // Check if it contains a pseudo-element with position: absolute/fixed
                     if (hasPseudoElementSelector(template) &&
-                        (template.includes('position: absolute') || template.includes('position: fixed'))) {
+                        (template.includes('position: absolute') ||
+                            template.includes('position: fixed'))) {
                         // Check if it's missing pointer-events: none
-                        if (!template.includes('pointer-events: none') && !template.includes('pointer-events:none')) {
+                        if (!template.includes('pointer-events: none') &&
+                            !template.includes('pointer-events:none')) {
                             context.report({
                                 node,
-                                messageId: 'missingPointerEventsNone'
+                                messageId: 'missingPointerEventsNone',
                             });
                         }
                     }
@@ -155,7 +162,8 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             },
             // Process style objects in JSX
             JSXAttribute(node) {
-                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || node.name.name !== 'style')
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier ||
+                    node.name.name !== 'style')
                     return;
                 if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
                     node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
@@ -185,7 +193,8 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                 else if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
                     // Check for CSS-in-JS libraries like emotion's css() function
                     const callee = parent.callee;
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'css') {
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.name === 'css') {
                         isStyleObject = true;
                     }
                 }
@@ -204,7 +213,7 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                     processStyleObject(node.value);
                     checkStyleObject(node.value, node.key.value);
                 }
-            }
+            },
         };
     },
 });

package/lib/rules/extract-global-constants.js

@@ -54,10 +54,10 @@ function isMutableValue(node) {
         if (node.elements.length === 0)
             return true;
         // Arrays with spread elements are mutable
-        if (node.elements.some(element => !element || element.type === 'SpreadElement'))
+        if (node.elements.some((element) => !element || element.type === 'SpreadElement'))
             return true;
         // Arrays with non-immutable values are mutable
-        return node.elements.some(element => !isImmutableValue(element));
+        return node.elements.some((element) => !isImmutableValue(element));
     }
     // Check for new expressions (e.g., new Map(), new Set())
     if (node.type === 'NewExpression') {
@@ -83,7 +83,7 @@ function isMutableValue(node) {
                 'splice',
                 'reverse',
                 'sort',
-                'fill'
+                'fill',
             ];
             return mutatingMethods.includes(methodName);
         }
@@ -93,7 +93,8 @@ function isMutableValue(node) {
 function isNumericLiteral(node) {
     if (!node)
         return false;
-    return node.type === 'Literal' && typeof node.value === 'number';
+    return (node.type === 'Literal' &&
+        typeof node.value === 'number');
 }
 function isZeroOrOne(node) {
     if (!isNumericLiteral(node))
@@ -168,7 +169,10 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 // Check initialization
                 if (node.init && node.init.type === 'VariableDeclaration') {
                     for (const decl of node.init.declarations) {
-                        if (decl.init && isNumericLiteral(decl.init) && !isZeroOrOne(decl.init) && !isAsConstExpression(decl.init)) {
+                        if (decl.init &&
+                            isNumericLiteral(decl.init) &&
+                            !isZeroOrOne(decl.init) &&
+                            !isAsConstExpression(decl.init)) {
                             context.report({
                                 node: decl.init,
                                 messageId: 'requireAsConst',
@@ -181,7 +185,9 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 }
                 // Check test condition
                 if (node.test && node.test.type === 'BinaryExpression') {
-                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                    if (isNumericLiteral(node.test.right) &&
+                        !isZeroOrOne(node.test.right) &&
+                        !isAsConstExpression(node.test.right)) {
                         context.report({
                             node: node.test.right,
                             messageId: 'requireAsConst',
@@ -194,7 +200,10 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 // Check update expression
                 if (node.update) {
                     if (node.update.type === 'AssignmentExpression') {
-                        if (node.update.right && isNumericLiteral(node.update.right) && !isZeroOrOne(node.update.right) && !isAsConstExpression(node.update.right)) {
+                        if (node.update.right &&
+                            isNumericLiteral(node.update.right) &&
+                            !isZeroOrOne(node.update.right) &&
+                            !isAsConstExpression(node.update.right)) {
                             context.report({
                                 node: node.update.right,
                                 messageId: 'requireAsConst',
@@ -205,7 +214,9 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                         }
                     }
                     else if (node.update.type === 'BinaryExpression') {
-                        if (isNumericLiteral(node.update.right) && !isZeroOrOne(node.update.right) && !isAsConstExpression(node.update.right)) {
+                        if (isNumericLiteral(node.update.right) &&
+                            !isZeroOrOne(node.update.right) &&
+                            !isAsConstExpression(node.update.right)) {
                             context.report({
                                 node: node.update.right,
                                 messageId: 'requireAsConst',
@@ -220,7 +231,9 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
             WhileStatement(node) {
                 // Check test condition
                 if (node.test.type === 'BinaryExpression') {
-                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                    if (isNumericLiteral(node.test.right) &&
+                        !isZeroOrOne(node.test.right) &&
+                        !isAsConstExpression(node.test.right)) {
                         context.report({
                             node: node.test.right,
                             messageId: 'requireAsConst',
@@ -234,7 +247,9 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
             DoWhileStatement(node) {
                 // Check test condition
                 if (node.test.type === 'BinaryExpression') {
-                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                    if (isNumericLiteral(node.test.right) &&
+                        !isZeroOrOne(node.test.right) &&
+                        !isAsConstExpression(node.test.right)) {
                         context.report({
                             node: node.test.right,
                             messageId: 'requireAsConst',

package/lib/rules/fast-deep-equal-over-microdiff.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'useFastDeepEqual' | 'addFastDeepEqualImport';
+export declare const fastDeepEqualOverMicrodiff: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};