@agilebot/eslint-plugin 0.3.6 → 0.3.8

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export default plugin;
+import * as eslint from 'eslint';
+
 declare namespace plugin {
-    let rules: import('eslint').Linter.RulesRecord;
+    let rules: eslint.Linter.RulesRecord;
     namespace configs {
         namespace recommended {
             export let plugins: string[];
-            let rules_1: import('eslint').Linter.RulesRecord;
+            let rules_1: eslint.Linter.RulesRecord;
             export { rules_1 as rules };
             export namespace settings {
                 namespace react {
@@ -14,3 +15,5 @@ declare namespace plugin {
         }
     }
 }
+
+export { plugin as default };

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @license @agilebot/eslint-plugin v0.3.6
+ * @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,11 +72,136 @@ 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)];
 }
 
-let warnedForMissingPrefix = false;
+const warned = new Set();
+function warnOnce(message) {
+  if (warned.has(message)) {
+    return;
+  }
+  warned.add(message);
+  console.warn("Warning: ".concat(message));
+}
+
 var importMonorepo = {
   meta: {
     type: 'problem',
@@ -95,10 +220,7 @@ var importMonorepo = {
       ImportDeclaration(node) {
         let prefix = getSetting(context, 'monorepo-scope');
         if (!prefix) {
-          if (!warnedForMissingPrefix) {
-            console.error('Warning: agilebot/monorepo-scope is not set.');
-            warnedForMissingPrefix = true;
-          }
+          warnOnce('agilebot/monorepo-scope is not set.');
           return;
         }
         prefix = "".concat(prefix, "/");
@@ -269,6 +391,98 @@ var intlIdMissing = {
   }
 };
 
+var intlIdNaming = {
+  meta: {
+    docs: {
+      description: 'Validates intl message ids naming convention',
+      category: 'Intl'
+    },
+    fixable: undefined,
+    schema: [{
+      type: 'object',
+      properties: {
+        format: {
+          "enum": ['camelCase', 'PascalCase']
+        }
+      }
+    }],
+    messages: {
+      invalidIdNaming: "Invalid id naming, expected {{format}}"
+    }
+  },
+  create: function (context) {
+    if (!context.options[0]) {
+      throw new Error('Missing options');
+    }
+    const format = context.options[0].format;
+    function report(node, value) {
+      const values = value.split('.');
+      let isPass;
+      for (const v of values) {
+        switch (format) {
+          case 'camelCase':
+            if (!eslintUtils.isCamelCase(v)) {
+              isPass = false;
+            }
+            break;
+          case 'PascalCase':
+            if (!eslintUtils.isPascalCase(v)) {
+              isPass = false;
+            }
+            break;
+        }
+      }
+      if (isPass === false) {
+        context.report({
+          node: node,
+          messageId: 'invalidIdNaming',
+          data: {
+            format
+          }
+        });
+      }
+    }
+    function processLiteral(node) {
+      report(node, node.value);
+    }
+    function processTemplateLiteral(node) {
+      const displayStr = templateLiteralDisplayStr(node);
+      report(node, displayStr);
+    }
+    function processAttrNode(node) {
+      if (node.value.type === 'Literal') {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+};
+
 var intlIdPrefix = {
   meta: {
     docs: {
@@ -2414,8 +2628,10 @@ 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,
   rules_intl_id_prefix: intlIdPrefix,
   rules_intl_id_unused: intlIdUnused,
   rules_intl_no_default: intlNoDefault,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilebot/eslint-plugin",
-  "version": "0.3.6",
+  "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.6"
+    "@agilebot/eslint-utils": "0.3.8"
   },
   "peerDependencies": {
     "eslint": "^7.0.0 || ^8.0.0"
@@ -35,8 +35,7 @@
     "eslint-vitest-rule-tester": "^0.3.2"
   },
   "scripts": {
-    "build": "rollup -c rollup.config.mjs && nr dts",
-    "dts": "tsc -p tsconfig.dts.json",
+    "build": "rollup -c rollup.config.mjs",
     "lint": "eslint src --fix"
   }
 }