@agilebot/eslint-plugin 0.1.5 → 0.2.0

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

@@ -1,97 +1,103 @@
-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);
-      }
-    };
-  }
-};
+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,117 +1,123 @@
-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));
-      }
-    };
-  }
-};
+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,57 +1,63 @@
-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);
-      }
-    };
-  }
-};
+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 +1,38 @@
-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)
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-};
+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)
+              );
+            }
+          });
+        }
+      }
+    };
+  }
+};