@agilebot/eslint-plugin 0.3.7 → 0.3.8

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @license @agilebot/eslint-plugin v0.3.7
+ * @license @agilebot/eslint-plugin v0.3.8
  *
  * Copyright (c) Agilebot, Inc. and its affiliates.
  *
@@ -8,9 +8,9 @@
  */
 'use strict';
 
+var eslintUtils = require('@agilebot/eslint-utils');
 var fs = require('node:fs');
 var path = require('node:path');
-var eslintUtils = require('@agilebot/eslint-utils');
 var utils = require('@typescript-eslint/utils');
 
 function _interopNamespaceDefault(e) {
@@ -72,6 +72,123 @@ var enforceMuiIconAlias = {
   }
 };
 
+var funcNaming = {
+  meta: {
+    docs: {
+      description: 'Enforce function naming convention'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        format: {
+          "enum": ['camelCase', 'PascalCase']
+        }
+      }
+    }],
+    messages: {
+      invalidFuncNaming: 'Invalid function naming for non-React component, expected {{format}}',
+      invalidReactFCNaming: 'Invalid naming convention for React functional component, expected PascalCase'
+    }
+  },
+  create(context) {
+    if (!context.options[0]) {
+      throw new Error('Missing options');
+    }
+    const format = context.options[0].format;
+    function validate({
+      node,
+      fnName
+    }) {
+      let isPass;
+      switch (format) {
+        case 'camelCase':
+          if (!eslintUtils.isCamelCase(fnName)) {
+            isPass = false;
+          }
+          break;
+        case 'PascalCase':
+          if (!eslintUtils.isPascalCase(fnName)) {
+            isPass = false;
+          }
+          break;
+      }
+      if (isPass === false) {
+        context.report({
+          node: node,
+          messageId: 'invalidFuncNaming',
+          data: {
+            format
+          }
+        });
+      }
+    }
+    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;
+    }
+    return {
+      MethodDefinition(node) {
+        if (node.kind === 'method') ;
+      },
+      FunctionDeclaration(node) {
+        if (node.type === 'FunctionDeclaration' && node.id) {
+          const fnName = node.id.name;
+          const isReactComponent = checkJSXElement(node.body);
+          if (!isReactComponent) {
+            validate({
+              node,
+              fnName
+            });
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init && ['FunctionExpression', 'ArrowFunctionExpression'].includes(node.init.type)) {
+          const fnName = node.id.name;
+          let isReactComponent = checkJSXElement(node.init.body);
+          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;
+              if (['FC', 'React.FC', 'FunctionComponent', 'React.FunctionComponent'].includes(typeName)) {
+                isReactComponent = true;
+              }
+            }
+          }
+          if (!isReactComponent) {
+            validate({
+              node,
+              fnName
+            });
+          }
+        }
+      },
+      Property(node) {
+        if (node.value.type === 'FunctionExpression') ;
+      }
+    };
+  }
+};
+
 function getSetting(context, name) {
   return context.settings["agilebot/".concat(name)];
 }
@@ -2511,6 +2628,7 @@ var tssUnusedClasses = {
 var ruleFiles = /*#__PURE__*/Object.freeze({
   __proto__: null,
   rules_enforce_mui_icon_alias: enforceMuiIconAlias,
+  rules_func_naming: funcNaming,
   rules_import_monorepo: importMonorepo,
   rules_intl_id_missing: intlIdMissing,
   rules_intl_id_naming: intlIdNaming,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilebot/eslint-plugin",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "Agilebot's ESLint plugin",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "~7.9.0",
     "eslint-plugin-react": "^7.34.1",
-    "@agilebot/eslint-utils": "0.3.7"
+    "@agilebot/eslint-utils": "0.3.8"
   },
   "peerDependencies": {
     "eslint": "^7.0.0 || ^8.0.0"