@agilebot/eslint-plugin 0.3.3 → 0.3.4

package/dist/index.d.ts

@@ -1,20 +1,10 @@
-declare namespace _default {
-    export { rules };
-    export namespace configs {
+export default plugin;
+declare namespace plugin {
+    let rules: import('eslint').Linter.RulesRecord;
+    namespace configs {
         namespace recommended {
             export let plugins: string[];
-            let rules_1: {
-                '@agilebot/no-unnecessary-template-literals': string;
-                '@agilebot/no-async-array-methods': string;
-                '@agilebot/react-prefer-named-property-access': string;
-                '@agilebot/react-hook-use-ref': string;
-                '@agilebot/react-prefer-sx-prop': string;
-                '@agilebot/tss-unused-classes': string;
-                '@agilebot/tss-no-color-value': string;
-                '@agilebot/tss-class-naming': string;
-                '@agilebot/import-enforce-icon-alias': string;
-                '@agilebot/import-monorepo': string;
-            };
+            let rules_1: import('eslint').Linter.RulesRecord;
             export { rules_1 as rules };
             export namespace settings {
                 namespace react {
@@ -24,8 +14,3 @@ declare namespace _default {
         }
     }
 }
-export default _default;
-/**
- * @type {import('eslint').Linter.RulesRecord}
- */
-declare const rules: import('eslint').Linter.RulesRecord;

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @license @agilebot/eslint-plugin v0.3.3
+ * @license @agilebot/eslint-plugin v0.3.4
  *
  * Copyright (c) Agilebot, Inc. and its affiliates.
  *
@@ -41,7 +41,10 @@ var enforceIconAlias = {
       recommended: true
     },
     fixable: 'code',
-    schema: []
+    schema: [],
+    messages: {
+      iconAlias: 'Import for {{ name }} should be aliased.'
+    }
   },
   create(context) {
     return {
@@ -59,7 +62,10 @@ var enforceIconAlias = {
           if (specifier.imported.name === specifier.local.name) {
             context.report({
               node,
-              message: `Import for ${node.source.value} should be aliased.`,
+              messageId: 'iconAlias',
+              data: {
+                name: node.source.value
+              },
               fix: fixer =>
                 fixer.replaceText(
                   specifier,
@@ -86,7 +92,10 @@ var monorepo = {
       recommended: true
     },
     fixable: 'code',
-    schema: []
+    schema: [],
+    messages: {
+      monorepoImport: 'Import for {{ module }} should not contains src folder.'
+    }
   },
   create(context) {
     return {
@@ -110,7 +119,10 @@ var monorepo = {
         if (values[2] === 'src') {
           context.report({
             node,
-            message: `Import for ${node.source.value} should not contains src folder.`,
+            messageId: 'monorepoImport',
+            data: {
+              module: node.source.value
+            },
             fix: fixer => {
               const correctedPath = values
                 .filter((_, index) => index !== 2)
@@ -240,8 +252,7 @@ var idMissing = {
   meta: {
     docs: {
       description: 'Validates intl message ids are in locale file',
-      category: 'Intl',
-      recommended: true
+      category: 'Intl'
     },
     fixable: undefined,
     schema: []
@@ -322,8 +333,7 @@ var idPrefix = {
   meta: {
     docs: {
       description: 'Validates intl message ids has correct prefixes',
-      category: 'Intl',
-      recommended: true
+      category: 'Intl'
     },
     fixable: undefined,
     schema: [
@@ -400,8 +410,7 @@ var idUnused = {
   meta: {
     docs: {
       description: 'Finds unused intl message ids in locale file',
-      category: 'Intl',
-      recommended: true
+      category: 'Intl'
     },
     fixable: undefined,
     schema: []
@@ -483,8 +492,7 @@ var noDefault = {
   meta: {
     docs: {
       description: 'Validates defaultMessage is not used with react-intl',
-      category: 'Intl',
-      recommended: true
+      category: 'Intl'
     },
     fixable: undefined,
     schema: []
@@ -521,387 +529,56 @@ var noDefault = {
   }
 };
 
-function getBasicIdentifier(node) {
-  if (node.type === 'Identifier') {
-    return node.name;
-  }
-  if (node.type === 'Literal') {
-    return node.value;
-  }
-  if (node.type === 'TemplateLiteral') {
-    if (node.expressions.length > 0) {
-      return null;
-    }
-    return node.quasis[0].value.raw;
-  }
-  return null;
-}
-function getBaseIdentifier(node) {
-  switch (node.type) {
-    case 'Identifier': {
-      return node;
-    }
-    case 'CallExpression': {
-      return getBaseIdentifier(node.callee);
-    }
-    case 'MemberExpression': {
-      return getBaseIdentifier(node.object);
-    }
-  }
-  return null;
-}
-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';
-  if (!isMakeStyles && !isModernApi) {
-    return;
-  }
-  const styles = (() => {
-    if (isMakeStyles) {
-      return node.parent.arguments[0];
-    }
-    if (isModernApi) {
-      return node.callee.parent.arguments[0];
-    }
-  })();
-  if (!styles) {
-    return;
-  }
-  switch (styles.type) {
-    case 'ObjectExpression':
-      return styles;
-    case 'ArrowFunctionExpression':
-      {
-        const { body } = styles;
-        switch (body.type) {
-          case 'ObjectExpression':
-            return body;
-          case 'BlockStatement': {
-            let stylesObj;
-            body.body.forEach(bodyNode => {
-              if (
-                bodyNode.type === 'ReturnStatement' &&
-                bodyNode.argument.type === 'ObjectExpression'
-              ) {
-                stylesObj = bodyNode.argument;
-              }
-            });
-            return stylesObj;
-          }
-        }
-      }
-      break;
-  }
-}
-
-var classNaming = {
-  meta: {
-    type: 'problem'
-  },
-  create: function rule(context) {
-    return {
-      CallExpression(node) {
-        const stylesObj = getStyesObj(node);
-        if (stylesObj === undefined) {
-          return;
-        }
-        stylesObj.properties.forEach(property => {
-          if (property.computed) {
-            return;
-          }
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
-            return;
-          }
-          const className = property.key.value || property.key.name;
-          if (!eslintUtils.isCamelCase(className)) {
-            context.report({
-              node: property,
-              message: `Class \`${className}\` must be camelCase in TSS.`
-            });
-          }
-        });
-      }
-    };
-  }
-};
-
-var noColorValue = {
+var betterExhaustiveDeps = {
   meta: {
-    type: 'problem',
+    type: 'suggestion',
     docs: {
       description:
-        'Enforce the use of color variables instead of color codes within TSS'
-    }
-  },
-  create: function (context) {
-    const parserOptions = context.parserOptions;
-    if (!parserOptions || !parserOptions.project) {
-      return {};
-    }
-    return {
-      CallExpression(node) {
-        const stylesObj = getStyesObj(node);
-        if (!stylesObj) {
-          return;
-        }
-        function checkColorLiteral(value) {
-          if (value.type === '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;
-            const isColorCode = colorCodePattern.test(value.value);
-            if (isColorCode) {
-              context.report({
-                node: value,
-                message: 'Use color variables instead of color codes in TSS.'
-              });
-            }
-          }
-        }
-        function loopStylesObj(obj) {
-          if (obj && obj.type === 'ObjectExpression') {
-            obj.properties.forEach(property => {
-              if (property.type === 'Property' && property.value) {
-                if (property.value.type === 'ObjectExpression') {
-                  loopStylesObj(property.value);
-                } else {
-                  checkColorLiteral(property.value);
+        'verifies the list of dependencies for Hooks like useEffect and similar',
+      url: 'https://github.com/facebook/react/issues/14920'
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        enableDangerousAutofixThisMayCauseInfiniteLoops: false,
+        properties: {
+          additionalHooks: {
+            type: 'string'
+          },
+          enableDangerousAutofixThisMayCauseInfiniteLoops: {
+            type: 'boolean'
+          },
+          staticHooks: {
+            type: 'object',
+            additionalProperties: {
+              oneOf: [
+                {
+                  type: 'boolean'
+                },
+                {
+                  type: 'array',
+                  items: {
+                    type: 'boolean'
+                  }
+                },
+                {
+                  type: 'object',
+                  additionalProperties: {
+                    type: 'boolean'
+                  }
                 }
-              }
-            });
+              ]
+            }
+          },
+          checkMemoizedVariableIsStatic: {
+            type: 'boolean'
           }
         }
-        loopStylesObj(stylesObj);
       }
-    };
-  }
-};
-
-var unusedClasses = {
-  meta: {
-    type: 'problem'
-  },
-  create: function rule(context) {
-    const usedClasses = {};
-    const definedClasses = {};
-    return {
-      CallExpression(node) {
-        const stylesObj = getStyesObj(node);
-        if (stylesObj === undefined) {
-          return;
-        }
-        stylesObj.properties.forEach(property => {
-          if (property.computed) {
-            return;
-          }
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
-            return;
-          }
-          definedClasses[property.key.value || property.key.name] = property;
-        });
-      },
-      MemberExpression(node) {
-        if (
-          node.object.type === 'Identifier' &&
-          node.object.name === 'classes'
-        ) {
-          const whichClass = getBasicIdentifier(node.property);
-          if (whichClass) {
-            usedClasses[whichClass] = true;
-          }
-          return;
-        }
-        const classIdentifier = getBasicIdentifier(node.property);
-        if (!classIdentifier) {
-          return;
-        }
-        if (classIdentifier !== 'classes') {
-          return;
-        }
-        const { parent } = node;
-        if (parent.type !== 'MemberExpression') {
-          return;
-        }
-        if (
-          node.object.object &&
-          node.object.object.type !== 'ThisExpression'
-        ) {
-          return;
-        }
-        const propsIdentifier = getBasicIdentifier(parent.object);
-        if (propsIdentifier && propsIdentifier !== 'props') {
-          return;
-        }
-        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
-          return;
-        }
-        if (parent.parent.type === 'MemberExpression') {
-          return;
-        }
-        const parentClassIdentifier = getBasicIdentifier(parent.property);
-        if (parentClassIdentifier) {
-          usedClasses[parentClassIdentifier] = true;
-        }
-      },
-      'Program:exit': () => {
-        Object.keys(definedClasses).forEach(definedClassKey => {
-          if (!usedClasses[definedClassKey]) {
-            context.report({
-              node: definedClasses[definedClassKey],
-              message: `Class \`${definedClassKey}\` is unused`
-            });
-          }
-        });
-      }
-    };
-  }
-};
-
-var noAsyncArrayMethods = {
-  meta: {
-    docs: {
-      description:
-        'No async callback for Array methods forEach, map, filter, reduce, some, every, etc.',
-      category: 'Array',
-      recommended: true
-    },
-    fixable: undefined,
-    schema: []
-  },
-  create: function (context) {
-    return {
-      ExpressionStatement: function (node) {
-        const notAllowedArrayMethods = [
-          'forEach',
-          'filter',
-          'some',
-          'every',
-          'map',
-          'reduce',
-          'reduceRight',
-          'flatMap',
-          'find',
-          'findIndex',
-          'findLast',
-          'findLastIndex'
-        ];
-        const { callee } = node.expression;
-        if (!callee || !callee.property || !callee.property.name) {
-          return;
-        }
-        if (notAllowedArrayMethods.includes(callee.property.name)) {
-          const functionArguments = node.expression.arguments.find(n => {
-            return ['ArrowFunctionExpression', 'FunctionExpression'].includes(
-              n.type
-            );
-          });
-          if (functionArguments && functionArguments.async) {
-            context.report({
-              node,
-              message: `No async function in method '${callee.property.name}'`
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-var noUnnecessaryTemplateLiterals = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Check if a template string contains only one ${}',
-      recommended: true
-    },
-    fixable: 'code',
-    schema: []
-  },
-  create(context) {
-    return {
-      TemplateLiteral(node) {
-        const code = context.sourceCode.getText(node);
-        if (
-          code.startsWith('`${') &&
-          code.endsWith('}`') &&
-          code.split('${').length === 2
-        ) {
-          context.report({
-            node,
-            message: 'Unnecessary template string with only one ${}.',
-            fix(fixer) {
-              return fixer.replaceText(
-                node,
-                code.substring(3, code.length - 2)
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
-var betterExhaustiveDeps = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'verifies the list of dependencies for Hooks like useEffect and similar',
-      recommended: true,
-      url: 'https://github.com/facebook/react/issues/14920'
-    },
-    fixable: 'code',
-    hasSuggestions: true,
-    schema: [
-      {
-        type: 'object',
-        additionalProperties: false,
-        enableDangerousAutofixThisMayCauseInfiniteLoops: false,
-        properties: {
-          additionalHooks: {
-            type: 'string'
-          },
-          enableDangerousAutofixThisMayCauseInfiniteLoops: {
-            type: 'boolean'
-          },
-          staticHooks: {
-            type: 'object',
-            additionalProperties: {
-              oneOf: [
-                {
-                  type: 'boolean'
-                },
-                {
-                  type: 'array',
-                  items: {
-                    type: 'boolean'
-                  }
-                },
-                {
-                  type: 'object',
-                  additionalProperties: {
-                    type: 'boolean'
-                  }
-                }
-              ]
-            }
-          },
-          checkMemoizedVariableIsStatic: {
-            type: 'boolean'
-          }
-        }
-      }
-    ]
+    ]
   },
   create(context) {
     const additionalHooks =
@@ -2394,7 +2071,7 @@ var hookUseRef = {
   meta: {
     docs: {
       description: 'Ensure naming of useRef hook value.',
-      recommended: false
+      recommended: true
     },
     schema: [],
     type: 'suggestion',
@@ -2455,7 +2132,8 @@ var preferNamedPropertyAccess = utils.ESLintUtils.RuleCreator.withoutDocs({
     fixable: 'code',
     docs: {
       description:
-        'Enforce importing each member of React namespace separately instead of accessing them through React namespace'
+        'Enforce importing each member of React namespace separately instead of accessing them through React namespace',
+      recommended: 'recommended'
     },
     messages: {
       illegalReactPropertyAccess:
@@ -2509,7 +2187,7 @@ var preferSxProp = {
     docs: {
       description: 'Prefer using sx prop instead of inline styles',
       category: 'Best Practices',
-      recommended: false
+      recommended: true
     },
     messages: {
       preferSxProp:
@@ -2582,55 +2260,458 @@ var preferSxProp = {
   }
 };
 
-var ruleFiles = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  rules_import_enforce_icon_alias: enforceIconAlias,
-  rules_import_monorepo: monorepo,
-  rules_intl_id_missing: idMissing,
-  rules_intl_id_prefix: idPrefix,
-  rules_intl_id_unused: idUnused,
-  rules_intl_no_default: noDefault,
-  rules_react_better_exhaustive_deps: betterExhaustiveDeps,
-  rules_react_hook_use_ref: hookUseRef,
-  rules_react_prefer_named_property_access: preferNamedPropertyAccess,
-  rules_react_prefer_sx_prop: preferSxProp,
-  rules_tss_class_naming: classNaming,
-  rules_tss_no_color_value: noColorValue,
-  rules_tss_unused_classes: unusedClasses,
-  rules_unprefixed_no_async_array_methods: noAsyncArrayMethods,
-  rules_unprefixed_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals
-});
-
-const rules = {};
-Object.keys(ruleFiles).forEach(key => {
-  const ruleKey = key.replace(/^rules_/, '').replace(/^unprefixed_/, '');
-  const finalKey = ruleKey.replace(/_/g, '-');
-  rules[finalKey] = ruleFiles[key];
-});
-var index = {
-  rules,
-  configs: {
-    recommended: {
-      plugins: ['@agilebot'],
-      rules: {
-        '@agilebot/no-unnecessary-template-literals': 'error',
-        '@agilebot/no-async-array-methods': 'error',
-        '@agilebot/react-prefer-named-property-access': 'error',
-        '@agilebot/react-hook-use-ref': 'warn',
-        '@agilebot/react-prefer-sx-prop': 'error',
-        '@agilebot/tss-unused-classes': 'warn',
-        '@agilebot/tss-no-color-value': 'error',
-        '@agilebot/tss-class-naming': 'error',
-        '@agilebot/import-enforce-icon-alias': 'error',
-        '@agilebot/import-monorepo': 'error'
-      },
-      settings: {
-        react: {
-          version: '18.0.0'
-        }
-      }
+function getBasicIdentifier(node) {
+  if (node.type === 'Identifier') {
+    return node.name;
+  }
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  if (node.type === 'TemplateLiteral') {
+    if (node.expressions.length > 0) {
+      return null;
     }
+    return node.quasis[0].value.raw;
   }
-};
+  return null;
+}
+function getBaseIdentifier(node) {
+  switch (node.type) {
+    case 'Identifier': {
+      return node;
+    }
+    case 'CallExpression': {
+      return getBaseIdentifier(node.callee);
+    }
+    case 'MemberExpression': {
+      return getBaseIdentifier(node.object);
+    }
+  }
+  return null;
+}
+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';
+  if (!isMakeStyles && !isModernApi) {
+    return;
+  }
+  const styles = (() => {
+    if (isMakeStyles) {
+      return node.parent.arguments[0];
+    }
+    if (isModernApi) {
+      return node.callee.parent.arguments[0];
+    }
+  })();
+  if (!styles) {
+    return;
+  }
+  switch (styles.type) {
+    case 'ObjectExpression':
+      return styles;
+    case 'ArrowFunctionExpression':
+      {
+        const { body } = styles;
+        switch (body.type) {
+          case 'ObjectExpression':
+            return body;
+          case 'BlockStatement': {
+            let stylesObj;
+            body.body.forEach(bodyNode => {
+              if (
+                bodyNode.type === 'ReturnStatement' &&
+                bodyNode.argument.type === 'ObjectExpression'
+              ) {
+                stylesObj = bodyNode.argument;
+              }
+            });
+            return stylesObj;
+          }
+        }
+      }
+      break;
+  }
+}
+
+var classNaming = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce camelCase class names in TSS',
+      category: 'Best Practices',
+      recommended: true
+    }
+  },
+  create: function rule(context) {
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            return;
+          }
+          const className = property.key.value || property.key.name;
+          if (!eslintUtils.isCamelCase(className)) {
+            context.report({
+              node: property,
+              message: `Class \`${className}\` must be camelCase in TSS.`
+            });
+          }
+        });
+      }
+    };
+  }
+};
+
+var noColorValue = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce the use of color variables instead of color codes within TSS',
+      recommended: true
+    }
+  },
+  create: function (context) {
+    const parserOptions = context.parserOptions;
+    if (!parserOptions || !parserOptions.project) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+        function checkColorLiteral(value) {
+          if (value.type === '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;
+            const isColorCode = colorCodePattern.test(value.value);
+            if (isColorCode) {
+              context.report({
+                node: value,
+                message: 'Use color variables instead of color codes in TSS.'
+              });
+            }
+          }
+        }
+        function loopStylesObj(obj) {
+          if (obj && obj.type === 'ObjectExpression') {
+            obj.properties.forEach(property => {
+              if (property.type === 'Property' && property.value) {
+                if (property.value.type === 'ObjectExpression') {
+                  loopStylesObj(property.value);
+                } else {
+                  checkColorLiteral(property.value);
+                }
+              }
+            });
+          }
+        }
+        loopStylesObj(stylesObj);
+      }
+    };
+  }
+};
+
+var unusedClasses = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unused classes in tss',
+      category: 'Best Practices',
+      recommended: true
+    }
+  },
+  create: function rule(context) {
+    const usedClasses = {};
+    const definedClasses = {};
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            return;
+          }
+          definedClasses[property.key.value || property.key.name] = property;
+        });
+      },
+      MemberExpression(node) {
+        if (
+          node.object.type === 'Identifier' &&
+          node.object.name === 'classes'
+        ) {
+          const whichClass = getBasicIdentifier(node.property);
+          if (whichClass) {
+            usedClasses[whichClass] = true;
+          }
+          return;
+        }
+        const classIdentifier = getBasicIdentifier(node.property);
+        if (!classIdentifier) {
+          return;
+        }
+        if (classIdentifier !== 'classes') {
+          return;
+        }
+        const { parent } = node;
+        if (parent.type !== 'MemberExpression') {
+          return;
+        }
+        if (
+          node.object.object &&
+          node.object.object.type !== 'ThisExpression'
+        ) {
+          return;
+        }
+        const propsIdentifier = getBasicIdentifier(parent.object);
+        if (propsIdentifier && propsIdentifier !== 'props') {
+          return;
+        }
+        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
+          return;
+        }
+        if (parent.parent.type === 'MemberExpression') {
+          return;
+        }
+        const parentClassIdentifier = getBasicIdentifier(parent.property);
+        if (parentClassIdentifier) {
+          usedClasses[parentClassIdentifier] = true;
+        }
+      },
+      'Program:exit': () => {
+        Object.keys(definedClasses).forEach(definedClassKey => {
+          if (!usedClasses[definedClassKey]) {
+            context.report({
+              node: definedClasses[definedClassKey],
+              message: `Class \`${definedClassKey}\` is unused`
+            });
+          }
+        });
+      }
+    };
+  }
+};
+
+var noAsyncArrayMethods = {
+  meta: {
+    docs: {
+      description:
+        'No async callback for Array methods forEach, map, filter, reduce, some, every, etc.',
+      category: 'Array',
+      recommended: true
+    },
+    fixable: undefined,
+    schema: []
+  },
+  create: function (context) {
+    return {
+      ExpressionStatement: function (node) {
+        const notAllowedArrayMethods = [
+          'forEach',
+          'filter',
+          'some',
+          'every',
+          'map',
+          'reduce',
+          'reduceRight',
+          'flatMap',
+          'find',
+          'findIndex',
+          'findLast',
+          'findLastIndex'
+        ];
+        const { callee } = node.expression;
+        if (!callee || !callee.property || !callee.property.name) {
+          return;
+        }
+        if (notAllowedArrayMethods.includes(callee.property.name)) {
+          const functionArguments = node.expression.arguments.find(n => {
+            return ['ArrowFunctionExpression', 'FunctionExpression'].includes(
+              n.type
+            );
+          });
+          if (functionArguments && functionArguments.async) {
+            context.report({
+              node,
+              message: `No async function in method '${callee.property.name}'`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+var noThenCatchFinally = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow the use of then()/catch()/finally() when invoking specific functions.'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          restrictedFunctions: {
+            type: 'array',
+            uniqueItems: true,
+            items: { type: 'string' }
+          }
+        }
+      }
+    ],
+    messages: {
+      forbiddenThenCatchFinally: `then()/catch()/finally() is forbidden when invoke {{ name }}().`
+    }
+  },
+  create(context) {
+    const configuration = context.options[0] || {};
+    const restrictedFunctions = configuration.restrictedFunctions || [];
+    function isTopLevelScoped() {
+      return context.getScope().block.type === 'Program';
+    }
+    function isThenCatchFinally(node) {
+      return (
+        node.property &&
+        (node.property.name === 'then' ||
+          node.property.name === 'catch' ||
+          node.property.name === 'finally')
+      );
+    }
+    return {
+      'CallExpression > MemberExpression.callee'(node) {
+        if (isTopLevelScoped()) {
+          return;
+        }
+        if (!isThenCatchFinally(node)) {
+          return;
+        }
+        const callExpression = node.object;
+        if (
+          callExpression.type === 'CallExpression' &&
+          callExpression.callee.type === 'Identifier' &&
+          restrictedFunctions.includes(callExpression.callee.name)
+        ) {
+          context.report({
+            node: node.property,
+            messageId: 'forbiddenThenCatchFinally',
+            data: {
+              name: callExpression.callee.name
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+var noUnnecessaryTemplateLiterals = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Check if a template string contains only one ${}',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      unnecessaryTemplateString:
+        'Unnecessary template string with only one ${}.'
+    }
+  },
+  create(context) {
+    return {
+      TemplateLiteral(node) {
+        const code = context.sourceCode.getText(node);
+        if (
+          code.startsWith('`${') &&
+          code.endsWith('}`') &&
+          code.split('${').length === 2
+        ) {
+          context.report({
+            node,
+            messageId: 'unnecessaryTemplateString',
+            fix(fixer) {
+              return fixer.replaceText(
+                node,
+                code.substring(3, code.length - 2)
+              );
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+var ruleFiles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  rules_import_enforce_icon_alias: enforceIconAlias,
+  rules_import_monorepo: monorepo,
+  rules_intl_id_missing: idMissing,
+  rules_intl_id_prefix: idPrefix,
+  rules_intl_id_unused: idUnused,
+  rules_intl_no_default: noDefault,
+  rules_react_better_exhaustive_deps: betterExhaustiveDeps,
+  rules_react_hook_use_ref: hookUseRef,
+  rules_react_prefer_named_property_access: preferNamedPropertyAccess,
+  rules_react_prefer_sx_prop: preferSxProp,
+  rules_tss_class_naming: classNaming,
+  rules_tss_no_color_value: noColorValue,
+  rules_tss_unused_classes: unusedClasses,
+  rules_unprefixed_no_async_array_methods: noAsyncArrayMethods,
+  rules_unprefixed_no_then_catch_finally: noThenCatchFinally,
+  rules_unprefixed_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals
+});
+
+const plugin = {
+  rules: {},
+  configs: {
+    recommended: {
+      plugins: ['@agilebot'],
+      rules: {},
+      settings: {
+        react: {
+          version: '18.0.0'
+        }
+      }
+    }
+  }
+};
+Object.keys(ruleFiles).forEach(key => {
+  const ruleKey = key.replace(/^rules_/, '').replace(/^unprefixed_/, '');
+  const finalKey = ruleKey.replace(/_/g, '-');
+  const rule = ruleFiles[key];
+  plugin.rules[finalKey] = rule;
+  if (rule.meta && rule.meta.docs && rule.meta.docs.recommended) {
+    plugin.configs.recommended.rules[`@agilebot/${finalKey}`] =
+      rule.meta.type === 'suggestion' ? 'warn' : 'error';
+  }
+});
 
-module.exports = index;
+module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilebot/eslint-plugin",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Agilebot's ESLint plugin",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "~7.7.0",
     "eslint-plugin-react": "^7.34.1",
-    "@agilebot/eslint-utils": "0.3.3"
+    "@agilebot/eslint-utils": "0.3.4"
   },
   "peerDependencies": {
     "eslint": "^7.0.0 || ^8.0.0"
@@ -29,7 +29,8 @@
     "dist"
   ],
   "devDependencies": {
-    "@types/estree": "^1.0.5"
+    "@types/estree": "^1.0.5",
+    "eslint-vitest-rule-tester": "^0.3.2"
   },
   "scripts": {
     "build": "rollup -c rollup.config.mjs && nr dts",