migrate to typescript-eslint

.eslintrc.json

@@ -6,25 +6,23 @@
     "jest/globals": true
   },
   "extends": [
-    "standard",
-    "prettier",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier/@typescript-eslint",
     "plugin:jest/recommended",
     "plugin:jest-formatting/recommended"
   ],
-  "plugins": [
-    "prettier",
-    "jest",
-    "jest-formatting"
-  ],
+  "plugins": ["@typescript-eslint", "jest", "jest-formatting"],
   "globals": {
     "Atomics": "readonly",
     "SharedArrayBuffer": "readonly"
   },
+  "parser": "@typescript-eslint/parser",
   "parserOptions": {
-    "ecmaVersion": 2018
+    "project": "./tsconfig.eslint.json"
   },
   "rules": {
-    "prettier/prettier": "error",
-    "no-var": "error"
+    "no-var": "error",
+    "@typescript-eslint/explicit-function-return-type": "off"
   }
 }

.gitignore

@@ -1,3 +1,6 @@
+# Output 
+dist
+
 # Logs
 logs
 *.log

.travis.yml

@@ -10,6 +10,12 @@ node_js:
 
 jobs:
   include:
+    - stage: build
+      node_js: lts/*
+      script: npm run build
+    - stage: test
+      node_js: lts/*
+      script: npm run test
     - stage: release
       if: branch = master AND type != pull_request
       node_js: lts/*

jest.config.js

@@ -1,5 +1,8 @@
 module.exports = {
-  testMatch: ['**/tests/**/*.js'],
+  testMatch: ['**/tests/**/*.test.ts'],
+  transform: {
+    '^.+\\.tsx?$': 'ts-jest',
+  },
   coverageThreshold: {
     global: {
       branches: 100,

lib/index.ts

@@ -0,0 +1,70 @@
+import awaitAsyncQuery from './rules/await-async-query';
+import awaitAsyncUtils from './rules/await-async-utils';
+import awaitFireEvent from './rules/await-fire-event';
+import consistentDataTestid from './rules/consistent-data-testid';
+import noAwaitSyncQuery from './rules/no-await-sync-query';
+import noDebug from './rules/no-debug';
+import noDomImport from './rules/no-dom-import';
+import noManualCleanup from './rules/no-manual-cleanup';
+import noWaitForEmptyCallback from './rules/no-wait-for-empty-callback';
+import preferExplicitAssert from './rules/prefer-explicit-assert';
+import preferPresenceQueries from './rules/prefer-presence-queries';
+import preferScreenQueries from './rules/prefer-screen-queries';
+import preferWaitFor from './rules/prefer-wait-for';
+
+const rules = {
+  'await-async-query': awaitAsyncQuery,
+  'await-async-utils': awaitAsyncUtils,
+  'await-fire-event': awaitFireEvent,
+  'consistent-data-testid': consistentDataTestid,
+  'no-await-sync-query': noAwaitSyncQuery,
+  'no-debug': noDebug,
+  'no-dom-import': noDomImport,
+  'no-manual-cleanup': noManualCleanup,
+  'no-wait-for-empty-callback': noWaitForEmptyCallback,
+  'prefer-explicit-assert': preferExplicitAssert,
+  'prefer-presence-queries': preferPresenceQueries,
+  'prefer-screen-queries': preferScreenQueries,
+  'prefer-wait-for': preferWaitFor,
+};
+
+const recommendedRules = {
+  'testing-library/await-async-query': 'error',
+  'testing-library/await-async-utils': 'error',
+  'testing-library/no-await-sync-query': 'error',
+};
+
+export = {
+  rules,
+  configs: {
+    recommended: {
+      plugins: ['testing-library'],
+      rules: recommendedRules,
+    },
+    angular: {
+      plugins: ['testing-library'],
+      rules: {
+        ...recommendedRules,
+        'testing-library/no-debug': 'warn',
+        'testing-library/no-dom-import': ['error', 'angular'],
+      },
+    },
+    react: {
+      plugins: ['testing-library'],
+      rules: {
+        ...recommendedRules,
+        'testing-library/no-debug': 'warn',
+        'testing-library/no-dom-import': ['error', 'react'],
+      },
+    },
+    vue: {
+      plugins: ['testing-library'],
+      rules: {
+        ...recommendedRules,
+        'testing-library/await-fire-event': 'error',
+        'testing-library/no-debug': 'warn',
+        'testing-library/no-dom-import': ['error', 'vue'],
+      },
+    },
+  },
+};

lib/node-utils.ts

@@ -0,0 +1,104 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+
+export function isCallExpression(
+  node: TSESTree.Node
+): node is TSESTree.CallExpression {
+  return node && node.type === 'CallExpression';
+}
+
+export function isAwaitExpression(
+  node: TSESTree.Node
+): node is TSESTree.AwaitExpression {
+  return node && node.type === 'AwaitExpression';
+}
+
+export function isIdentifier(node: TSESTree.Node): node is TSESTree.Identifier {
+  return node && node.type === 'Identifier';
+}
+
+export function isMemberExpression(
+  node: TSESTree.Node
+): node is TSESTree.MemberExpression {
+  return node && node.type === 'MemberExpression';
+}
+
+export function isLiteral(node: TSESTree.Node): node is TSESTree.Literal {
+  return node && node.type === 'Literal';
+}
+
+export function isImportSpecifier(
+  node: TSESTree.Node
+): node is TSESTree.ImportSpecifier {
+  return node && node.type === 'ImportSpecifier';
+}
+
+export function isImportDefaultSpecifier(
+  node: TSESTree.Node
+): node is TSESTree.ImportDefaultSpecifier {
+  return node && node.type === 'ImportDefaultSpecifier';
+}
+
+export function isBlockStatement(
+  node: TSESTree.Node
+): node is TSESTree.BlockStatement {
+  return node && node.type === 'BlockStatement';
+}
+
+export function isVariableDeclarator(
+  node: TSESTree.Node
+): node is TSESTree.VariableDeclarator {
+  return node && node.type === 'VariableDeclarator';
+}
+
+export function isObjectPattern(
+  node: TSESTree.Node
+): node is TSESTree.ObjectPattern {
+  return node && node.type === 'ObjectPattern';
+}
+
+export function isProperty(node: TSESTree.Node): node is TSESTree.Property {
+  return node && node.type === 'Property';
+}
+
+export function isJSXAttribute(
+  node: TSESTree.Node
+): node is TSESTree.JSXAttribute {
+  return node && node.type === 'JSXAttribute';
+}
+
+export function findClosestCallExpressionNode(
+  node: TSESTree.Node
+): TSESTree.CallExpression {
+  if (isCallExpression(node)) {
+    return node;
+  }
+
+  return findClosestCallExpressionNode(node.parent);
+}
+
+export function findClosestCallNode(
+  node: TSESTree.Node,
+  name: string
+): TSESTree.CallExpression {
+  if (!node.parent) {
+    return null;
+  }
+
+  if (
+    isCallExpression(node) &&
+    isIdentifier(node.callee) &&
+    node.callee.name === name
+  ) {
+    return node;
+  } else {
+    return findClosestCallNode(node.parent, name);
+  }
+}
+
+export function hasThenProperty(node: TSESTree.Node) {
+  return (
+    isMemberExpression(node) &&
+    isIdentifier(node.property) &&
+    node.property.name === 'then'
+  );
+}