@agilebot/eslint-plugin 0.8.0 → 0.8.1

package/LICENSE

@@ -1,9 +1,9 @@
-The MIT License (MIT)
-
-Copyright (c) 2024 Agilebot, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2024 Agilebot, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.js

@@ -1,11 +1,11 @@
-/**
- * @license @agilebot/eslint-plugin v0.8.0
- *
- * Copyright (c) Agilebot, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+/**
+ * @license @agilebot/eslint-plugin v0.8.1
+ *
+ * Copyright (c) Agilebot, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 'use strict';
 
 var utils = require('@typescript-eslint/utils');
@@ -38,9 +38,9 @@ const hasDocs = typeof ["enforce-mui-icon-alias","intl-id-missing","intl-id-pref
 ["enforce-mui-icon-alias","intl-id-missing","intl-id-prefix","intl-no-default","react-better-exhaustive-deps"] : [];
 const createRule = utils.ESLintUtils.RuleCreator(name => hasDocs.includes(name) ? "".concat(docBaseUrl).concat(name, ".md") : "".concat(docBaseUrl).concat(name, ".test.js"));
 
-const RULE_NAME$j = 'enforce-mui-icon-alias';
+const RULE_NAME$h = 'enforce-mui-icon-alias';
 var enforceMuiIconAlias = createRule({
-  name: RULE_NAME$j,
+  name: RULE_NAME$h,
   meta: {
     type: 'problem',
     docs: {
@@ -61,7 +61,7 @@ var enforceMuiIconAlias = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') {
+          if (specifier.type !== utils.AST_NODE_TYPES.ImportSpecifier) {
             return;
           }
           if (specifier.imported.name === specifier.local.name || !specifier.local.name.endsWith('Icon')) {
@@ -84,9 +84,9 @@ function getSetting(context, name) {
   return context.settings["agilebot/".concat(name)];
 }
 
-const RULE_NAME$i = 'import-monorepo';
+const RULE_NAME$g = 'import-monorepo';
 var importMonorepo = createRule({
-  name: RULE_NAME$i,
+  name: RULE_NAME$g,
   meta: {
     type: 'problem',
     docs: {
@@ -134,25 +134,25 @@ var importMonorepo = createRule({
 });
 
 function findFormatMessageAttrNode(node, attrName) {
-  if (node.type === 'CallExpression' && (node.callee.name === 'formatMessage' || node.callee.name === '$t') && node.arguments.length > 0 && node.arguments[0].properties) {
+  if (node.type === utils.AST_NODE_TYPES.CallExpression && (node.callee.name === 'formatMessage' || node.callee.name === '$t') && node.arguments.length > 0 && node.arguments[0].properties) {
     return node.arguments[0].properties.find(a => a.key && a.key.name === attrName);
   }
-  if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression' && (node.callee.object.name === 'intl' || node.callee.object.name && node.callee.object.name.endsWith('Intl')) && (node.callee.property.name === 'formatMessage' || node.callee.property.name === '$t')) {
+  if (node.type === utils.AST_NODE_TYPES.CallExpression && node.callee.type === utils.AST_NODE_TYPES.MemberExpression && (node.callee.object.name === 'intl' || node.callee.object.name && node.callee.object.name.endsWith('Intl')) && (node.callee.property.name === 'formatMessage' || node.callee.property.name === '$t')) {
     return node.arguments[0].properties.find(a => a.key && a.key.name === attrName);
   }
 }
 function findFormattedMessageAttrNode(node, attrName) {
-  if (node.type === 'JSXIdentifier' && node.name === 'FormattedMessage' && node.parent && node.parent.type === 'JSXOpeningElement') {
+  if (node.type === utils.AST_NODE_TYPES.JSXIdentifier && node.name === 'FormattedMessage' && node.parent && node.parent.type === utils.AST_NODE_TYPES.JSXOpeningElement) {
     return node.parent.attributes.find(a => a.name && a.name.name === attrName);
   }
 }
 function findAttrNodeInDefineMessages(node, attrName) {
-  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.parent && node.parent.parent.parent.parent && node.parent.parent.parent.parent.type === 'CallExpression' && node.parent.parent.parent.parent.callee.name === 'defineMessages') {
+  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.parent && node.parent.parent.parent.parent && node.parent.parent.parent.parent.type === utils.AST_NODE_TYPES.CallExpression && node.parent.parent.parent.parent.callee.name === 'defineMessages') {
     return node;
   }
 }
 function findAttrNodeInDefineMessage(node, attrName) {
-  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.type === 'CallExpression' && node.parent.parent.callee.name === 'defineMessage') {
+  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.type === utils.AST_NODE_TYPES.CallExpression && node.parent.parent.callee.name === 'defineMessage') {
     return node;
   }
 }
@@ -201,9 +201,9 @@ function getIntlIds(context) {
   return results;
 }
 
-const RULE_NAME$h = 'intl-id-missing';
+const RULE_NAME$f = 'intl-id-missing';
 var intlIdMissing = createRule({
-  name: RULE_NAME$h,
+  name: RULE_NAME$f,
   meta: {
     type: 'problem',
     docs: {
@@ -251,13 +251,13 @@ var intlIdMissing = createRule({
       }
     }
     function processAttrNode(node) {
-      if (node.value.type === 'Literal') {
+      if (node.value.type === utils.AST_NODE_TYPES.Literal) {
         return processLiteral(node.value);
       }
-      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value.expression);
       }
-      if (node.value.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value);
       }
       context.report({
@@ -291,9 +291,9 @@ var intlIdMissing = createRule({
   }
 });
 
-const RULE_NAME$g = 'intl-id-naming';
+const RULE_NAME$e = 'intl-id-naming';
 var intlIdNaming = createRule({
-  name: RULE_NAME$g,
+  name: RULE_NAME$e,
   meta: {
     type: 'problem',
     docs: {
@@ -353,13 +353,13 @@ var intlIdNaming = createRule({
       report(node, displayStr);
     }
     function processAttrNode(node) {
-      if (node.value.type === 'Literal') {
+      if (node.value.type === utils.AST_NODE_TYPES.Literal) {
         return processLiteral(node.value);
       }
-      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value.expression);
       }
-      if (node.value.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value);
       }
     }
@@ -386,9 +386,9 @@ var intlIdNaming = createRule({
   }
 });
 
-const RULE_NAME$f = 'intl-id-prefix';
+const RULE_NAME$d = 'intl-id-prefix';
 var intlIdPrefix = createRule({
-  name: RULE_NAME$f,
+  name: RULE_NAME$d,
   meta: {
     type: 'problem',
     docs: {
@@ -429,13 +429,13 @@ var intlIdPrefix = createRule({
       report(node, displayStr);
     }
     function processAttrNode(node) {
-      if (node.value.type === 'Literal') {
+      if (node.value.type === utils.AST_NODE_TYPES.Literal) {
         return processLiteral(node.value);
       }
-      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value.expression);
       }
-      if (node.value.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value);
       }
     }
@@ -462,10 +462,10 @@ var intlIdPrefix = createRule({
   }
 });
 
-const RULE_NAME$e = 'intl-id-unused';
+const RULE_NAME$c = 'intl-id-unused';
 const usedIds = new Map();
 var intlIdUnused = createRule({
-  name: RULE_NAME$e,
+  name: RULE_NAME$c,
   meta: {
     type: 'problem',
     docs: {
@@ -503,13 +503,13 @@ var intlIdUnused = createRule({
       if (isTemplateTranslated(re)) ;
     }
     function processAttrNode(node) {
-      if (node.value.type === 'Literal') {
+      if (node.value.type === utils.AST_NODE_TYPES.Literal) {
         return processLiteral(node.value);
       }
-      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value.expression);
       }
-      if (node.value.type === 'TemplateLiteral') {
+      if (node.value.type === utils.AST_NODE_TYPES.TemplateLiteral) {
         return processTemplateLiteral(node.value);
       }
     }
@@ -541,9 +541,9 @@ var intlIdUnused = createRule({
   }
 });
 
-const RULE_NAME$d = 'intl-no-default';
+const RULE_NAME$b = 'intl-no-default';
 var intlNoDefault = createRule({
-  name: RULE_NAME$d,
+  name: RULE_NAME$b,
   meta: {
     type: 'problem',
     docs: {
@@ -585,9 +585,9 @@ var intlNoDefault = createRule({
   }
 });
 
-const RULE_NAME$c = 'no-async-array-methods';
+const RULE_NAME$a = 'no-async-array-methods';
 var noAsyncArrayMethods = createRule({
-  name: RULE_NAME$c,
+  name: RULE_NAME$a,
   meta: {
     type: 'problem',
     docs: {
@@ -612,7 +612,7 @@ var noAsyncArrayMethods = createRule({
         }
         if (notAllowedArrayMethods.includes(callee.property.name)) {
           const functionArguments = node.expression.arguments.find(n => {
-            return ['ArrowFunctionExpression', 'FunctionExpression'].includes(n.type);
+            return [utils.AST_NODE_TYPES.ArrowFunctionExpression, utils.AST_NODE_TYPES.FunctionExpression].includes(n.type);
           });
           if (functionArguments && functionArguments.async) {
             context.report({
@@ -629,9 +629,9 @@ var noAsyncArrayMethods = createRule({
   }
 });
 
-const RULE_NAME$b = 'no-extends-error';
+const RULE_NAME$9 = 'no-extends-error';
 var noExtendsError = createRule({
-  name: RULE_NAME$b,
+  name: RULE_NAME$9,
   meta: {
     type: 'problem',
     docs: {
@@ -647,7 +647,7 @@ var noExtendsError = createRule({
   create(context) {
     return {
       ClassDeclaration(node) {
-        if (node.superClass && node.superClass.type === 'Identifier' && node.superClass.name === 'Error') {
+        if (node.superClass && node.superClass.type === utils.AST_NODE_TYPES.Identifier && node.superClass.name === 'Error') {
           context.report({
             node: node.superClass,
             messageId: 'noExtendsError'
@@ -658,9 +658,9 @@ var noExtendsError = createRule({
   }
 });
 
-const RULE_NAME$a = 'no-import-css';
+const RULE_NAME$8 = 'no-import-css';
 var noImportCss = createRule({
-  name: RULE_NAME$a,
+  name: RULE_NAME$8,
   meta: {
     type: 'problem',
     docs: {
@@ -691,9 +691,9 @@ var noImportCss = createRule({
   }
 });
 
-const RULE_NAME$9 = 'no-then-catch-finally';
+const RULE_NAME$7 = 'no-then-catch-finally';
 var noThenCatchFinally = createRule({
-  name: RULE_NAME$9,
+  name: RULE_NAME$7,
   meta: {
     type: 'suggestion',
     docs: {
@@ -731,7 +731,7 @@ var noThenCatchFinally = createRule({
       return node.property && (node.property.name === 'then' || node.property.name === 'catch' || node.property.name === 'finally');
     }
     return {
-      'CallExpression > MemberExpression.callee'(node) {
+      ["".concat(utils.AST_NODE_TYPES.CallExpression, " > ").concat(utils.AST_NODE_TYPES.MemberExpression, ".callee")]: node => {
         if (isTopLevelScoped(node)) {
           return;
         }
@@ -739,7 +739,7 @@ var noThenCatchFinally = createRule({
           return;
         }
         const callExpression = node.object;
-        if (callExpression.type === 'CallExpression' && callExpression.callee.type === 'Identifier' && restrictedFunctions.includes(callExpression.callee.name)) {
+        if (callExpression.type === utils.AST_NODE_TYPES.CallExpression && callExpression.callee.type === utils.AST_NODE_TYPES.Identifier && restrictedFunctions.includes(callExpression.callee.name)) {
           context.report({
             node: node.property,
             messageId: 'forbiddenThenCatchFinally',
@@ -753,9 +753,9 @@ var noThenCatchFinally = createRule({
   }
 });
 
-const RULE_NAME$8 = 'no-unnecessary-template-literals';
+const RULE_NAME$6 = 'no-unnecessary-template-literals';
 var noUnnecessaryTemplateLiterals = createRule({
-  name: RULE_NAME$8,
+  name: RULE_NAME$6,
   meta: {
     type: 'problem',
     docs: {
@@ -2055,9 +2055,9 @@ function isUseEffectEventIdentifier(node) {
 }
 
 const Components = require('eslint-plugin-react/lib/util/Components');
-const RULE_NAME$7 = 'react-hook-use-ref';
+const RULE_NAME$5 = 'react-hook-use-ref';
 var reactHookUseRef = createRule({
-  name: RULE_NAME$7,
+  name: RULE_NAME$5,
   meta: {
     type: 'suggestion',
     docs: {
@@ -2073,11 +2073,11 @@ var reactHookUseRef = createRule({
   defaultOptions: [],
   create: Components.detect((context, component, util) => ({
     CallExpression(node) {
-      const isImmediateReturn = node.parent && node.parent.type === 'ReturnStatement';
+      const isImmediateReturn = node.parent && node.parent.type === utils.AST_NODE_TYPES.ReturnStatement;
       if (isImmediateReturn || !util.isReactHookCall(node, ['useRef'])) {
         return;
       }
-      if (node.parent.id.type !== 'Identifier') {
+      if (node.parent.id.type !== utils.AST_NODE_TYPES.Identifier) {
         return;
       }
       const variable = node.parent.id.name;
@@ -2091,94 +2091,9 @@ var reactHookUseRef = createRule({
   }))
 });
 
-const RULE_NAME$6 = 'react-prefer-named-property-access';
-function* updateImportStatement(context, fixer, key) {
-  const sourceCode = context.sourceCode;
-  const importNode = sourceCode.ast.body.find(node => node.type === 'ImportDeclaration' && node.source.value === 'react');
-  if (!importNode) {
-    yield fixer.insertTextBefore(sourceCode.ast.body[0], "import { ".concat(key, " } from 'react';\n"));
-    return;
-  }
-  if (importNode.specifiers.length === 1 && importNode.specifiers[0].type === 'ImportDefaultSpecifier') {
-    yield fixer.insertTextAfter(importNode.specifiers[0], ", { ".concat(key, " }"));
-    return;
-  }
-  const alreadyImportedKeys = importNode.specifiers.filter(specifier => specifier.type === 'ImportSpecifier').map(specifier => specifier.imported.name);
-  if (alreadyImportedKeys.includes(key)) {
-    return;
-  }
-  yield fixer.insertTextAfter([...importNode.specifiers].pop(), ", ".concat(key));
-}
-var reactPreferNamedPropertyAccess = createRule({
-  name: RULE_NAME$6,
-  meta: {
-    type: 'problem',
-    fixable: 'code',
-    docs: {
-      description: 'Enforce importing each member of React namespace separately instead of accessing them through React namespace',
-      recommended: 'recommended'
-    },
-    messages: {
-      illegalReactPropertyAccess: 'Illegal React property access: {{name}}. Use named import instead.',
-      disallowImportReactEvent: 'Disallow importing React event types to avoid conflicts with global event types.'
-    },
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      TSQualifiedName(node) {
-        if ('name' in node.left && node.left.name !== 'React' || 'name' in node.right && node.right.name.endsWith('Event')) {
-          return;
-        }
-        context.report({
-          node,
-          messageId: 'illegalReactPropertyAccess',
-          data: {
-            name: node.right.name
-          },
-          *fix(fixer) {
-            yield fixer.replaceText(node, node.right.name);
-            yield* updateImportStatement(context, fixer, node.right.name);
-          }
-        });
-      },
-      MemberExpression(node) {
-        if (node.object.name !== 'React') {
-          return;
-        }
-        context.report({
-          node,
-          messageId: 'illegalReactPropertyAccess',
-          data: {
-            name: node.property.name
-          },
-          *fix(fixer) {
-            yield fixer.replaceText(node, node.property.name);
-            yield* updateImportStatement(context, fixer, node.property.name);
-          }
-        });
-      },
-      ImportDeclaration(node) {
-        if (node.source.value !== 'react' && node.source.value !== 'preact') {
-          return;
-        }
-        node.specifiers.forEach(specifier => {
-          if (specifier.type === 'ImportSpecifier' && specifier.imported.name && specifier.imported.name.endsWith('Event')) {
-            context.report({
-              node: specifier,
-              messageId: 'disallowImportReactEvent'
-            });
-          }
-        });
-      }
-    };
-  }
-});
-
-const RULE_NAME$5 = 'react-prefer-sx-prop';
+const RULE_NAME$4 = 'react-prefer-sx-prop';
 var reactPreferSxProp = createRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$4,
   meta: {
     type: 'problem',
     docs: {
@@ -2249,13 +2164,13 @@ var reactPreferSxProp = createRule({
 });
 
 function getBasicIdentifier(node) {
-  if (node.type === 'Identifier') {
+  if (node.type === utils.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === 'Literal') {
+  if (node.type === utils.AST_NODE_TYPES.Literal) {
     return node.value;
   }
-  if (node.type === 'TemplateLiteral') {
+  if (node.type === utils.AST_NODE_TYPES.TemplateLiteral) {
     if (node.expressions.length > 0) {
       return null;
     }
@@ -2265,15 +2180,15 @@ function getBasicIdentifier(node) {
 }
 function getBaseIdentifier(node) {
   switch (node.type) {
-    case 'Identifier':
+    case utils.AST_NODE_TYPES.Identifier:
       {
         return node;
       }
-    case 'CallExpression':
+    case utils.AST_NODE_TYPES.CallExpression:
       {
         return getBaseIdentifier(node.callee);
       }
-    case 'MemberExpression':
+    case utils.AST_NODE_TYPES.MemberExpression:
       {
         return getBaseIdentifier(node.object);
       }
@@ -2282,7 +2197,7 @@ function getBaseIdentifier(node) {
 }
 function getStyesObj(node) {
   const isMakeStyles = node.callee.name === 'makeStyles';
-  const isModernApi = node.callee.type === 'MemberExpression' && node.callee.property.name === 'create' && getBaseIdentifier(node.callee.object) && getBaseIdentifier(node.callee.object).name === 'tss';
+  const isModernApi = node.callee.type === utils.AST_NODE_TYPES.MemberExpression && node.callee.property.name === 'create' && getBaseIdentifier(node.callee.object) && getBaseIdentifier(node.callee.object).name === 'tss';
   if (!isMakeStyles && !isModernApi) {
     return;
   }
@@ -2298,21 +2213,21 @@ function getStyesObj(node) {
     return;
   }
   switch (styles.type) {
-    case 'ObjectExpression':
+    case utils.AST_NODE_TYPES.ObjectExpression:
       return styles;
-    case 'ArrowFunctionExpression':
+    case utils.AST_NODE_TYPES.ArrowFunctionExpression:
       {
         const {
           body
         } = styles;
         switch (body.type) {
-          case 'ObjectExpression':
+          case utils.AST_NODE_TYPES.ObjectExpression:
             return body;
-          case 'BlockStatement':
+          case utils.AST_NODE_TYPES.BlockStatement:
             {
               let stylesObj;
               body.body.forEach(bodyNode => {
-                if (bodyNode.type === 'ReturnStatement' && bodyNode.argument.type === 'ObjectExpression') {
+                if (bodyNode.type === utils.AST_NODE_TYPES.ReturnStatement && bodyNode.argument.type === utils.AST_NODE_TYPES.ObjectExpression) {
                   stylesObj = bodyNode.argument;
                 }
               });
@@ -2324,10 +2239,10 @@ function getStyesObj(node) {
   }
 }
 function loopStylesObj(node, callback) {
-  if (node && node.type === 'ObjectExpression') {
+  if (node && node.type === utils.AST_NODE_TYPES.ObjectExpression) {
     node.properties.forEach(property => {
-      if (property.type === 'Property' && property.value) {
-        if (property.value.type === 'ObjectExpression') {
+      if (property.type === utils.AST_NODE_TYPES.Property && property.value) {
+        if (property.value.type === utils.AST_NODE_TYPES.ObjectExpression) {
           loopStylesObj(property.value, callback);
         } else {
           callback(property.value);
@@ -2337,9 +2252,9 @@ function loopStylesObj(node, callback) {
   }
 }
 
-const RULE_NAME$4 = 'tss-class-naming';
+const RULE_NAME$3 = 'tss-class-naming';
 var tssClassNaming = createRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$3,
   meta: {
     type: 'problem',
     docs: {
@@ -2363,7 +2278,7 @@ var tssClassNaming = createRule({
           if (property.computed) {
             return;
           }
-          if (property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement') {
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === utils.AST_NODE_TYPES.SpreadElement) {
             return;
           }
           const className = property.key.value || property.key.name;
@@ -2533,9 +2448,9 @@ var colors = {
   yellowgreen: [154, 205, 50]
 };
 
-const RULE_NAME$3 = 'tss-no-color-name';
+const RULE_NAME$2 = 'tss-no-color-name';
 var tssNoColorName = createRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$2,
   meta: {
     type: 'suggestion',
     docs: {
@@ -2556,7 +2471,7 @@ var tssNoColorName = createRule({
           return;
         }
         function checkColorLiteral(value) {
-          if (value.type === 'Literal' && typeof value.value === 'string' && Object.keys(colors).includes(value.value.toLowerCase())) {
+          if (value.type === utils.AST_NODE_TYPES.Literal && typeof value.value === 'string' && Object.keys(colors).includes(value.value.toLowerCase())) {
             context.report({
               node: value,
               messageId: 'disallowColorName'
@@ -2569,9 +2484,9 @@ var tssNoColorName = createRule({
   }
 });
 
-const RULE_NAME$2 = 'tss-no-color-value';
+const RULE_NAME$1 = 'tss-no-color-value';
 var tssNoColorValue = createRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$1,
   meta: {
     type: 'problem',
     docs: {
@@ -2592,7 +2507,7 @@ var tssNoColorValue = createRule({
           return;
         }
         function checkColorLiteral(value) {
-          if (value.type === 'Literal' && typeof value.value === 'string') {
+          if (value.type === utils.AST_NODE_TYPES.Literal && typeof value.value === 'string') {
             const colorCodePattern = /#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|rgb\?\(\s*(\d{1,3}\s*,\s*){2}\d{1,3}(?:\s*,\s*\d*(?:\.\d+)?)?\s*\)/g;
             if (colorCodePattern.test(value.value)) {
               context.report({
@@ -2608,9 +2523,9 @@ var tssNoColorValue = createRule({
   }
 });
 
-const RULE_NAME$1 = 'tss-unused-classes';
+const RULE_NAME = 'tss-unused-classes';
 var tssUnusedClasses = createRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME,
   meta: {
     type: 'suggestion',
     docs: {
@@ -2636,14 +2551,14 @@ var tssUnusedClasses = createRule({
           if (property.computed) {
             return;
           }
-          if (property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement') {
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === utils.AST_NODE_TYPES.SpreadElement) {
             return;
           }
           definedClasses[property.key.value || property.key.name] = property;
         });
       },
       MemberExpression(node) {
-        if (node.object.type === 'Identifier' && node.object.name === 'classes') {
+        if (node.object.type === utils.AST_NODE_TYPES.Identifier && node.object.name === 'classes') {
           const whichClass = getBasicIdentifier(node.property);
           if (whichClass) {
             usedClasses[whichClass] = true;
@@ -2660,22 +2575,22 @@ var tssUnusedClasses = createRule({
         const {
           parent
         } = node;
-        if (parent.type !== 'MemberExpression') {
+        if (parent.type !== utils.AST_NODE_TYPES.MemberExpression) {
           return;
         }
         if (
         node.object.object &&
-        node.object.object.type !== 'ThisExpression') {
+        node.object.object.type !== utils.AST_NODE_TYPES.ThisExpression) {
           return;
         }
         const propsIdentifier = getBasicIdentifier(parent.object);
         if (propsIdentifier && propsIdentifier !== 'props') {
           return;
         }
-        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
+        if (!propsIdentifier && parent.object.type !== utils.AST_NODE_TYPES.MemberExpression) {
           return;
         }
-        if (parent.parent.type === 'MemberExpression') {
+        if (parent.parent.type === utils.AST_NODE_TYPES.MemberExpression) {
           return;
         }
         const parentClassIdentifier = getBasicIdentifier(parent.property);
@@ -2700,254 +2615,6 @@ var tssUnusedClasses = createRule({
   }
 });
 
-const RULE_NAME = 'var-naming';
-const reactGlobalFuncs = new Set(['createContext', 'forwardRef', 'lazy', 'memo', 'combineProviders']);
-const reactFCTypes = new Set(['FC', 'FunctionComponent', 'VFC', 'VoidFunctionComponent']);
-const defaultExcludeTypes = ['StoryObj', 'StoryFn'];
-const defaultExcludeNames = ['^(__dirname|__filename)$', '(.*)Event$'];
-var varNaming = createRule({
-  name: RULE_NAME,
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Enforce variable and function naming convention',
-      recommended: 'recommended'
-    },
-    schema: [{
-      type: 'object',
-      properties: {
-        funcFormat: {
-          type: 'array',
-          items: {
-            "enum": ['camelCase', 'PascalCase', 'UPPER_CASE']
-          }
-        },
-        varFormat: {
-          type: 'array',
-          items: {
-            "enum": ['camelCase', 'PascalCase', 'UPPER_CASE']
-          }
-        },
-        excludeNames: {
-          type: 'array',
-          items: {
-            type: 'string'
-          }
-        },
-        excludeFuncs: {
-          type: 'array',
-          items: {
-            type: 'string'
-          }
-        },
-        excludeTypes: {
-          type: 'array',
-          items: {
-            type: 'string'
-          }
-        }
-      }
-    }],
-    messages: {
-      invalidFuncNaming: 'Invalid function naming for non-React component, expected {{formats}}',
-      invalidReactFCNaming: 'Invalid naming convention for React functional component, expected PascalCase',
-      invalidVarNaming: 'Invalid variable naming, expected {{formats}}'
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (!context.options[0]) {
-      context.options[0] = {};
-    }
-    const funcFormat = context.options[0].funcFormat || ['camelCase'];
-    const varFormat = context.options[0].varFormat || ['camelCase', 'UPPER_CASE'];
-    let excludeNames = context.options[0].excludeNames || [];
-    excludeNames = [...defaultExcludeNames, ...excludeNames];
-    const excludeFuncs = context.options[0].excludeFuncs || [];
-    let excludeTypes = context.options[0].excludeTypes || [];
-    excludeTypes = [...defaultExcludeTypes, ...excludeTypes];
-    function validate(type, {
-      node,
-      name
-    }) {
-      let isPass = false;
-      let formats;
-      let messageId;
-      switch (type) {
-        case 'func':
-          formats = funcFormat;
-          messageId = 'invalidFuncNaming';
-          break;
-        case 'var':
-          formats = varFormat;
-          messageId = 'invalidVarNaming';
-          break;
-      }
-      for (const format of formats) {
-        switch (format) {
-          case 'camelCase':
-            if (eslintUtils.isCamelCase(name)) {
-              isPass = true;
-            }
-            break;
-          case 'PascalCase':
-            if (eslintUtils.isPascalCase(name)) {
-              isPass = true;
-            }
-            break;
-          case 'UPPER_CASE':
-            if (eslintUtils.isUpperCase(name)) {
-              isPass = true;
-            }
-            break;
-        }
-      }
-      if (!isPass) {
-        context.report({
-          node: node,
-          messageId: messageId,
-          data: {
-            formats: formats.join(', ')
-          }
-        });
-      }
-    }
-    function checkJSXElement(node) {
-      if (!node) {
-        return false;
-      }
-      if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
-        return true;
-      }
-      if (node.type === 'BlockStatement') {
-        for (const statement of node.body) {
-          if (statement.type === 'ReturnStatement') {
-            if (checkJSXElement(statement.argument)) {
-              return true;
-            }
-          } else if (checkJSXElement(statement)) {
-            return true;
-          }
-        }
-      }
-      if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
-        return checkJSXElement(node.body);
-      }
-      return false;
-    }
-    function getTypeReference(node) {
-      if (node.id.typeAnnotation && node.id.typeAnnotation.typeAnnotation) {
-        const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
-        if (typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName.type === 'Identifier') {
-          const typeName = typeAnnotation.typeName.name;
-          const typeNameLast = typeName.split('.').pop();
-          return typeNameLast;
-        }
-      }
-    }
-    return {
-      FunctionDeclaration(node) {
-        if (node.type === 'FunctionDeclaration' && node.id) {
-          const fnName = node.id.name;
-          const isReactComponent = checkJSXElement(node.body);
-          if (!isReactComponent) {
-            validate('func', {
-              node,
-              name: fnName
-            });
-          }
-        }
-      },
-      VariableDeclarator(node) {
-        if (node.id && node.init && ['FunctionExpression', 'ArrowFunctionExpression'].includes(node.init.type)) {
-          const fnName = node.id.name;
-          let isReactComponent = checkJSXElement(node.init.body);
-          const typeName = getTypeReference(node);
-          if (typeName && reactFCTypes.has(typeName)) {
-            isReactComponent = true;
-          }
-          if (!isReactComponent) {
-            validate('func', {
-              node,
-              name: fnName
-            });
-          }
-        } else if (node.id && node.init && node.init.type === 'LogicalExpression') {
-          const varName = node.id.name;
-          const parts = [node.init.left, node.init.right];
-          let partIsReactComponent = false;
-          for (const part of parts) {
-            if (['FunctionExpression', 'ArrowFunctionExpression'].includes(part.type)) {
-              const isReactComponent = checkJSXElement(part.body);
-              if (isReactComponent) {
-                partIsReactComponent = true;
-              }
-            }
-          }
-          if (!partIsReactComponent) {
-            validate('var', {
-              node,
-              name: varName
-            });
-          }
-        } else if (node.id) {
-          const varName = node.id.name;
-          for (const excludeRegex of excludeNames) {
-            if (new RegExp(excludeRegex).test(varName)) {
-              return;
-            }
-          }
-          const typeName = getTypeReference(node);
-          if (typeName) {
-            for (const excludeRegex of excludeTypes) {
-              if (new RegExp(excludeRegex).test(typeName)) {
-                return;
-              }
-            }
-          }
-          if (node.id.parent && node.id.parent.init) {
-            let calleeName;
-            let shouldCheckReact = false;
-            let initNode;
-            if (node.id.parent.init.type === 'CallExpression') {
-              initNode = node.id.parent.init;
-            } else if (node.id.parent.init.type === 'TSAsExpression' && node.id.parent.init.expression && node.id.parent.init.expression.callee) {
-              initNode = node.id.parent.init.expression;
-            }
-            if (initNode) {
-              shouldCheckReact = true;
-              if (initNode.callee.type === 'Identifier') {
-                calleeName = initNode.callee.name;
-              } else if (initNode.callee.type === 'MemberExpression') {
-                calleeName = initNode.callee.property.name;
-              }
-            }
-            if (calleeName) {
-              for (const excludeRegex of excludeFuncs) {
-                if (new RegExp(excludeRegex).test(calleeName)) {
-                  return;
-                }
-              }
-            }
-            if (shouldCheckReact) {
-              if (!calleeName) {
-                return;
-              }
-              if (reactGlobalFuncs.has(calleeName) || reactGlobalFuncs.has(calleeName.split('.').pop())) {
-                return;
-              }
-            }
-          }
-          validate('var', {
-            node,
-            name: varName
-          });
-        }
-      }
-    };
-  }
-});
-
 var ruleFiles = /*#__PURE__*/Object.freeze({
   __proto__: null,
   rules_enforce_mui_icon_alias: enforceMuiIconAlias,
@@ -2964,13 +2631,11 @@ var ruleFiles = /*#__PURE__*/Object.freeze({
   rules_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals,
   rules_react_better_exhaustive_deps: reactBetterExhaustiveDeps,
   rules_react_hook_use_ref: reactHookUseRef,
-  rules_react_prefer_named_property_access: reactPreferNamedPropertyAccess,
   rules_react_prefer_sx_prop: reactPreferSxProp,
   rules_tss_class_naming: tssClassNaming,
   rules_tss_no_color_name: tssNoColorName,
   rules_tss_no_color_value: tssNoColorValue,
-  rules_tss_unused_classes: tssUnusedClasses,
-  rules_var_naming: varNaming
+  rules_tss_unused_classes: tssUnusedClasses
 });
 
 const plugin = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilebot/eslint-plugin",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Agilebot's ESLint plugin",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,10 +18,9 @@
     "node": "^18.18.0 || >=20.0.0"
   },
   "dependencies": {
-    "@eslint/compat": "^1.2.7",
     "@typescript-eslint/utils": "~8.25.0",
     "eslint-plugin-react": "^7.37.2",
-    "@agilebot/eslint-utils": "0.8.0"
+    "@agilebot/eslint-utils": "0.8.1"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0"
@@ -33,7 +32,7 @@
     "@types/color-name": "^1.1.4",
     "@types/estree": "^1.0.5",
     "color-name": "^2.0.0",
-    "eslint-vitest-rule-tester": "^1.1.0",
+    "eslint-vitest-rule-tester": "^2.2.0",
     "typescript-eslint": "~8.25.0"
   },
   "scripts": {