@agilebot/eslint-plugin 0.8.0 → 0.8.2

package/dist/index.js

@@ -1,17 +1,18 @@
-/**
- * @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.2
+ *
+ * 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');
 var fs = require('node:fs');
 var path = require('node:path');
 var eslintUtils = require('@agilebot/eslint-utils');
+var Components = require('eslint-plugin-react/lib/util/Components.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -32,15 +33,16 @@ function _interopNamespaceDefault(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var Components__namespace = /*#__PURE__*/_interopNamespaceDefault(Components);
 
 const docBaseUrl = 'https://github.com/sh-agilebot/frontend-toolkit/blob/master/packages/eslint-plugin/src/rules/';
 const hasDocs = typeof ["enforce-mui-icon-alias","intl-id-missing","intl-id-prefix","intl-no-default","react-better-exhaustive-deps"] !== 'undefined' ?
 ["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 +63,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 +86,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 +136,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 +203,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 +253,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 +293,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 +355,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 +388,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 +431,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 +464,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 +505,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 +543,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 +587,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 +614,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 +631,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 +649,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 +660,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 +693,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 +733,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 +741,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 +755,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: {
@@ -2054,10 +2056,9 @@ function isUseEffectEventIdentifier(node) {
   return false;
 }
 
-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: {
@@ -2071,13 +2072,13 @@ var reactHookUseRef = createRule({
     }
   },
   defaultOptions: [],
-  create: Components.detect((context, component, util) => ({
+  create: Components__namespace["default"].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 +2092,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 +2165,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 +2181,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 +2198,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 +2214,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 +2240,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 +2253,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 +2279,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 +2449,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 +2472,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 +2485,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 +2508,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 +2524,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 +2552,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 +2576,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 +2616,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 +2632,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 = {