@agilebot/eslint-plugin 0.2.1 → 0.2.3

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@agilebot/eslint-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Agilebot's ESLint plugin",
-  "main": "lib",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "license": "MIT",
   "keywords": [
     "eslint",
@@ -19,16 +20,17 @@
   "dependencies": {
     "@typescript-eslint/utils": "^7.6.0",
     "eslint-plugin-react": "^7.34.1",
-    "fast-glob": "^3.3.2",
-    "@agilebot/eslint-utils": "0.2.1"
+    "@agilebot/eslint-utils": "0.2.3"
   },
   "peerDependencies": {
     "eslint": "^7.0.0 || ^8.0.0"
   },
   "files": [
-    "lib"
+    "dist"
   ],
   "scripts": {
-    "lint": "eslint lib --fix"
+    "build": "rollup -c rollup.config.mjs && nr dts",
+    "dts": "tsc -p tsconfig.dts.json",
+    "lint": "eslint src --fix"
   }
 }

package/lib/index.js

@@ -1,43 +0,0 @@
-// @ts-check
-const path = require('node:path');
-const { globSync } = require('fast-glob');
-
-// List all rules in rules folder
-const rulesPath = path.join(__dirname, 'rules');
-const ruleFiles = globSync('**/*.js', {
-  cwd: rulesPath
-});
-
-/**
- * @type {import('eslint').Linter.RulesRecord}
- */
-const rules = {};
-ruleFiles.forEach(file => {
-  const { dir, name } = path.parse(file);
-  const ruleName = `${dir}/${name}`;
-  rules[ruleName] = require(path.join(rulesPath, file));
-});
-
-module.exports.rules = rules;
-
-module.exports.configs = {
-  recommended: {
-    plugins: ['@agilebot'],
-    rules: {
-      '@agilebot/react/prefer-named-property-access': 'error',
-      '@agilebot/react/hook-use-ref': 'warn',
-      '@agilebot/react/no-inline-styles': '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',
-      '@agilebot/others/no-unnecessary-template-literals': 'error'
-    },
-    settings: {
-      react: {
-        version: '18.0.0'
-      }
-    }
-  }
-};

package/lib/rules/import/enforce-icon-alias.js

@@ -1,42 +0,0 @@
-module.exports = {
-  meta: {
-    type: 'problem', // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: 'Enforce alias for @mui/icons-material imports',
-      recommended: true
-    },
-    fixable: 'code', // Or `code` or `whitespace`
-    schema: [] // Add a schema if the rule has options
-  },
-
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        if (
-          node.source.value !== '@mui/icons-material' &&
-          node.source.value !== 'mdi-material-ui'
-        ) {
-          return;
-        }
-
-        for (const specifier of node.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') {
-            return;
-          }
-
-          if (specifier.imported.name === specifier.local.name) {
-            context.report({
-              node,
-              message: `Import for ${node.source.value} should be aliased.`,
-              fix: fixer =>
-                fixer.replaceText(
-                  specifier,
-                  `${specifier.imported.name} as ${specifier.imported.name}Icon`
-                )
-            });
-          }
-        }
-      }
-    };
-  }
-};

package/lib/rules/import/monorepo.js

@@ -1,49 +0,0 @@
-const { getSetting } = require('../../util/settings');
-
-let warnedForMissingPrefix = false;
-
-module.exports = {
-  meta: {
-    type: 'problem', // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: 'Enforce import styles for monorepo',
-      recommended: true
-    },
-    fixable: 'code', // Or `code` or `whitespace`
-    schema: [] // Add a schema if the rule has options
-  },
-
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        const prefix = getSetting(context, 'monorepo-prefix');
-        if (!prefix) {
-          if (!warnedForMissingPrefix) {
-            // eslint-disable-next-line no-console -- this is a CLI tool
-            console.error('Warning: agilebot/monorepo-prefix is not set.');
-            warnedForMissingPrefix = true;
-          }
-          return;
-        }
-
-        if (!node.source.value.startsWith(prefix)) {
-          return;
-        }
-        const values = node.source.value.split('/');
-
-        if (values[2] === 'src') {
-          context.report({
-            node,
-            message: `Import for ${node.source.value} should not contains src folder.`,
-            fix: fixer => {
-              const correctedPath = values
-                .filter((_, index) => index !== 2)
-                .join('/');
-              return fixer.replaceText(node.source, `'${correctedPath}'`);
-            }
-          });
-        }
-      }
-    };
-  }
-};

package/lib/rules/intl/id-missing.js

@@ -1,111 +0,0 @@
-const {
-  sortedTemplateElements,
-  templateLiteralDisplayStr,
-  findFormatMessageAttrNode,
-  findFormattedMessageAttrNode,
-  findAttrNodeInDefineMessages,
-  findAttrNodeInDefineMessage
-} = require('../../util/intl');
-const { getIntlIds } = require('../../util/translations');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Validates intl message ids are in locale file',
-      category: 'Intl',
-      recommended: true
-    },
-    fixable: null,
-    schema: []
-  },
-
-  create: function (context) {
-    const translatedIds = getIntlIds(context);
-    const translatedIdSet = new Set(translatedIds);
-
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-
-    function isLiteralTranslated(id) {
-      return translatedIdSet.has(id);
-    }
-
-    function isTemplateTranslated(re) {
-      return translatedIds.some(k => re.test(k));
-    }
-
-    function processLiteral(node) {
-      if (!isLiteralTranslated(node.value)) {
-        context.report({
-          node: node,
-          message: 'Missing id: ' + node.value
-        });
-      }
-    }
-
-    function processTemplateLiteral(node) {
-      const exStr = sortedTemplateElements(node)
-        .map(e => (!e.value ? '.*' : e.value.raw))
-        .join('');
-      const re = new RegExp(exStr);
-
-      if (!isTemplateTranslated(re)) {
-        context.report({
-          node: node,
-          message: 'Missing id pattern: ' + templateLiteralDisplayStr(node)
-        });
-      }
-    }
-
-    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);
-      }
-      context.report({
-        node: node,
-        message: 'Do not invoke intl by ' + node.value.type
-      });
-    }
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    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);
-        }
-      }
-    };
-  }
-};

package/lib/rules/intl/id-prefix.js

@@ -1,103 +0,0 @@
-const {
-  findFormatMessageAttrNode,
-  findFormattedMessageAttrNode,
-  findAttrNodeInDefineMessages,
-  findAttrNodeInDefineMessage,
-  templateLiteralDisplayStr
-} = require('../../util/intl');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Validates intl message ids has correct prefixes',
-      category: 'Intl',
-      recommended: true
-    },
-    fixable: null,
-    schema: [
-      {
-        type: 'array',
-        items: {
-          type: 'string'
-        }
-      }
-    ]
-  },
-
-  create: function (context) {
-    if (context.options[0].length === 0) {
-      throw new Error('Prefixes are required in settings');
-    }
-
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-
-    const hasPrefix = value =>
-      context.options[0].some(p => value.startsWith(p));
-
-    function report(node, value) {
-      if (!hasPrefix(value)) {
-        context.report({
-          node: node,
-          message: `Invalid id prefix: ${value}`
-        });
-      }
-    }
-
-    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);
-      }
-    }
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    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);
-        }
-      }
-    };
-  }
-};

package/lib/rules/intl/id-unused.js

@@ -1,123 +0,0 @@
-const path = require('node:path');
-const fs = require('node:fs');
-const {
-  sortedTemplateElements,
-  findFormatMessageAttrNode,
-  findFormattedMessageAttrNode,
-  findAttrNodeInDefineMessages,
-  findAttrNodeInDefineMessage
-} = require('../../util/intl');
-const { getIntlIds } = require('../../util/translations');
-const { getSetting } = require('../../util/settings');
-
-// 已经使用的id集合 key为项目目录，value为id集合Set
-const usedIds = new Map();
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Finds unused intl message ids in locale file',
-      category: 'Intl',
-      recommended: true
-    },
-    fixable: null,
-    schema: []
-  },
-
-  create: function (context) {
-    const projectRoot = getSetting(context, 'project-root');
-    if (!projectRoot) {
-      throw new Error('projectRoot must be set in this rule');
-    }
-    if (!usedIds.has(projectRoot)) {
-      usedIds.set(projectRoot, new Set());
-    }
-    const usedIdSet = usedIds.get(projectRoot);
-
-    const translatedIds = getIntlIds(context);
-    const translatedIdSet = new Set(translatedIds);
-
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-
-    function isLiteralTranslated(id) {
-      return translatedIdSet.has(id);
-    }
-
-    function isTemplateTranslated(re) {
-      return translatedIds.some(k => re.test(k));
-    }
-
-    function processLiteral(node) {
-      if (isLiteralTranslated(node.value)) {
-        // 将已使用的id加入usedIdSet
-        usedIdSet.add(node.value);
-      }
-    }
-
-    function processTemplateLiteral(node) {
-      const exStr = sortedTemplateElements(node)
-        .map(e => (!e.value ? '.*' : e.value.raw))
-        .join('');
-      const re = new RegExp(exStr);
-
-      if (isTemplateTranslated(re)) {
-        // TODO: 暂时没有这种情况
-      }
-    }
-
-    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);
-      }
-    }
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    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);
-        }
-      },
-      'Program:exit': function () {
-        // 将usedIdSet转为数组，然后与translatedIds取差集，即为未使用的id
-        const unusedIds = [...translatedIdSet].filter(id => !usedIdSet.has(id));
-        // 在项目目录下生成intl-unused.json
-        const jsonPath = path.join(projectRoot, 'intl-unused.json');
-        fs.writeFileSync(jsonPath, JSON.stringify(unusedIds, null, 2));
-      }
-    };
-  }
-};

package/lib/rules/intl/no-default.js

@@ -1,63 +0,0 @@
-const {
-  findFormatMessageAttrNode,
-  findFormattedMessageAttrNode,
-  findAttrNodeInDefineMessages,
-  findAttrNodeInDefineMessage
-} = require('../../util/intl');
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Validates defaultMessage is not used with react-intl',
-      category: 'Intl',
-      recommended: true
-    },
-    fixable: null,
-    schema: []
-  },
-
-  create: function (context) {
-    // ----------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------
-
-    function processAttrNode(node) {
-      context.report({
-        node: node,
-        message: 'Do not use defaultMessage'
-      });
-    }
-
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    return {
-      JSXIdentifier: function (node) {
-        const attrNode = findFormattedMessageAttrNode(node, 'defaultMessage');
-        if (attrNode) {
-          return processAttrNode(attrNode);
-        }
-      },
-      CallExpression: function (node) {
-        const attrNode = findFormatMessageAttrNode(node, 'defaultMessage');
-        if (attrNode) {
-          return processAttrNode(attrNode);
-        }
-      },
-      Property: function (node) {
-        const attrNode =
-          findAttrNodeInDefineMessages(node, 'defaultMessage') ||
-          findAttrNodeInDefineMessage(node, 'defaultMessage');
-
-        if (attrNode) {
-          return processAttrNode(attrNode);
-        }
-      }
-    };
-  }
-};

package/lib/rules/others/no-unnecessary-template-literals.js

@@ -1,38 +0,0 @@
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Check if a template string contains only one ${}',
-      recommended: true
-    },
-    fixable: 'code', // Or `code` or `whitespace`
-    schema: [] // Add a schema if the rule has options
-  },
-
-  create(context) {
-    return {
-      TemplateLiteral(node) {
-        // Get the entire source code of the template string
-        const code = context.getSourceCode().getText(node);
-        // Check if the template string contains only one `${}`
-        if (
-          code.startsWith('`${') &&
-          code.endsWith('}`') &&
-          code.split('${').length === 2
-        ) {
-          context.report({
-            node,
-            message: 'Unnecessary template string with only one ${}.',
-            fix(fixer) {
-              // Replace the entire template string with the content inside ${}
-              return fixer.replaceText(
-                node,
-                code.substring(3, code.length - 2)
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-};

package/lib/rules/react/hook-use-ref.js

@@ -1,35 +0,0 @@
-const Components = require('eslint-plugin-react/lib/util/Components');
-
-module.exports = {
-  meta: {
-    docs: {
-      description: 'Ensure naming of useRef hook value.',
-      recommended: false
-    },
-    schema: [],
-    type: 'suggestion',
-    hasSuggestions: true
-  },
-
-  create: Components.detect((context, component, util) => ({
-    CallExpression(node) {
-      const isImmediateReturn =
-        node.parent && node.parent.type === 'ReturnStatement';
-
-      if (isImmediateReturn || !util.isReactHookCall(node, ['useRef'])) {
-        return;
-      }
-      if (node.parent.id.type !== 'Identifier') {
-        return;
-      }
-      const variable = node.parent.id.name;
-
-      if (!variable.endsWith('Ref')) {
-        context.report({
-          node: node,
-          message: 'useRef call is not end with "Ref"'
-        });
-      }
-    }
-  }))
-};