Breaking: Add support for TypeScript rules

Author: bmish

lib/utils.js

@@ -85,6 +85,23 @@ function isRuleTesterConstruction (node) {
 
 const INTERESTING_RULE_KEYS = new Set(['create', 'meta']);
 
+/**
+ * Collect properties from an object that have interesting key names into a new object
+ * @param {Node[]} properties
+ * @param {Set<String>} interestingKeys
+ * @returns Object
+ */
+function collectInterestingProperties (properties, interestingKeys) {
+  // eslint-disable-next-line unicorn/prefer-object-from-entries
+  return properties.reduce((parsedProps, prop) => {
+    const keyValue = module.exports.getKeyName(prop);
+    if (interestingKeys.has(keyValue)) {
+      parsedProps[keyValue] = prop.value;
+    }
+    return parsedProps;
+  }, {});
+}
+
 /**
  * Helper for `getRuleInfo`. Handles ESM rules.
  */
@@ -95,16 +112,27 @@ function getRuleExportsESM (ast) {
     // eslint-disable-next-line unicorn/prefer-object-from-entries
     .reduce((currentExports, node) => {
       if (node.type === 'ObjectExpression') {
-        // eslint-disable-next-line unicorn/prefer-object-from-entries
-        return node.properties.reduce((parsedProps, prop) => {
-          const keyValue = module.exports.getKeyName(prop);
-          if (INTERESTING_RULE_KEYS.has(keyValue)) {
-            parsedProps[keyValue] = prop.value;
-          }
-          return parsedProps;
-        }, {});
+        // Check `export default { create() {}, meta: {} }`
+        return collectInterestingProperties(node.properties, INTERESTING_RULE_KEYS);
       } else if (isNormalFunctionExpression(node)) {
+        // Check `export default function() {}`
         return { create: node, meta: null, isNewStyle: false };
+      } else if (
+        node.type === 'CallExpression' &&
+        node.arguments.length === 1 &&
+        node.arguments[0].type === 'ObjectExpression' &&
+        // Check various TypeScript rule helper formats.
+        (
+          // createESLintRule({ ... })
+          node.callee.type === 'Identifier' ||
+          // util.createRule({ ... })
+          (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.property.type === 'Identifier') ||
+          // ESLintUtils.RuleCreator(docsUrl)({ ... })
+          (node.callee.type === 'CallExpression' && node.callee.callee.type === 'MemberExpression' && node.callee.callee.object.type === 'Identifier' && node.callee.callee.property.type === 'Identifier')
+        )
+      ) {
+        // Check `export default someTypeScriptHelper({ create() {}, meta: {} });
+        return collectInterestingProperties(node.arguments[0].properties, INTERESTING_RULE_KEYS);
       }
       return currentExports;
     }, {});
@@ -136,14 +164,7 @@ function getRuleExportsCJS (ast) {
         } else if (node.right.type === 'ObjectExpression') {
           // Check `module.exports = { create: function () {}, meta: {} }`
 
-          // eslint-disable-next-line unicorn/prefer-object-from-entries
-          return node.right.properties.reduce((parsedProps, prop) => {
-            const keyValue = module.exports.getKeyName(prop);
-            if (INTERESTING_RULE_KEYS.has(keyValue)) {
-              parsedProps[keyValue] = prop.value;
-            }
-            return parsedProps;
-          }, {});
+          return collectInterestingProperties(node.right.properties, INTERESTING_RULE_KEYS);
         }
         return {};
       } else if (

tests/lib/utils.js

@@ -39,6 +39,12 @@ describe('utils', () => {
         'export const foo = { create() {} }',
         'export default { foo: {} }',
         'const foo = {}; export default foo',
+        'export default foo()({ create() {}, meta: {} });',
+        'export default foo().bar({ create() {}, meta: {} });',
+        'export default foo.bar.baz({ create() {}, meta: {} });',
+        'export default foo(123);',
+        'export default foo.bar(123);',
+        'export default foo.bar()(123);',
       ].forEach(noRuleCase => {
         it(`returns null for ${noRuleCase}`, () => {
           const ast = espree.parse(noRuleCase, { ecmaVersion: 8, range: true, sourceType: 'module' });
@@ -149,6 +155,26 @@ describe('utils', () => {
           meta: null,
           isNewStyle: false,
         },
+
+        // ESM + TypeScript helper
+        // Util function only
+        'export default createESLintRule({ create() {}, meta: {} })': {
+          create: { type: 'FunctionExpression' },
+          meta: { type: 'ObjectExpression' },
+          isNewStyle: true,
+        },
+        // Util function from util object
+        'export default util.createRule({ create() {}, meta: {} });': {
+          create: { type: 'FunctionExpression' },
+          meta: { type: 'ObjectExpression' },
+          isNewStyle: true,
+        },
+        // Util function from util object with additional doc URL argument
+        'export default ESLintUtils.RuleCreator(docsUrl)({ create() {}, meta: {} });': {
+          create: { type: 'FunctionExpression' },
+          meta: { type: 'ObjectExpression' },
+          isNewStyle: true,
+        },
       };
 
       Object.keys(CASES).forEach(ruleSource => {