feat: use @typescript-eslint for TypeScript rules

Author: honzahovorka

environments/typescript/README.md

@@ -11,7 +11,7 @@ These configuration files are suitable to lint TypeScript code.
 You must install an ESLint-compatible TypeScript parser and add it to your _.eslintrc.js_ file:
 
 ```sh
-npm i -D typescript-eslint-parser@latest
+npm i -D @typescript-eslint/parser@latest
 ```
 
 In addition to using this ruleset, you should also choose one base ruleset depending on your target platform:
@@ -26,7 +26,8 @@ A full configuration for a TypeScript on Node.js project:
 'use strict'
 
 module.exports = {
-  parser: 'typescript-eslint-parser',
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
 
   extends: [
     '@strv/javascript/environments/nodejs/v10',

environments/typescript/recommended.js

@@ -26,7 +26,7 @@ module.exports = {
   },
 
   plugins: [
-    'typescript',
+    '@typescript-eslint',
   ],
 
   parserOptions: {
@@ -49,93 +49,98 @@ module.exports = {
 
     // Require that member overloads be consecutive
     // Grouping overloaded members together can improve readability of the code.
-    'typescript/adjacent-overload-signatures': 'warn',
+    '@typescript-eslint/adjacent-overload-signatures': 'warn',
 
     // Require PascalCased class and interface names
     // This rule aims to make it easy to differentiate classes from regular variables at a glance.
-    'typescript/class-name-casing': 'warn',
+    '@typescript-eslint/class-name-casing': 'warn',
 
     // Require explicit return types on functions and class methods
     // Explicit types for function return values makes it clear to any calling code what type is
     // returned. This ensures that the return value is assigned to a variable of the correct type;
     // or in the case where there is no return value, that the calling code doesn't try to use the
     // undefined value when it shouldn't.
-    'typescript/explicit-function-return-type': ['warn', {
+    '@typescript-eslint/explicit-function-return-type': ['warn', {
       allowExpressions: true,
     }],
 
     // Require explicit accessibility modifiers on class properties and methods
     // This rule aims to make code more readable and explicit about who can use which properties.
-    'typescript/explicit-member-accessibility': 'warn',
+    '@typescript-eslint/explicit-member-accessibility': 'warn',
 
     // Require that interface names be prefixed with I
     // It can be hard to differentiate between classes and interfaces. Prefixing interfaces with "I"
     // can help telling them apart at a glance.
-    'typescript/interface-name-prefix': ['warn', 'always'],
+    '@typescript-eslint/interface-name-prefix': ['warn', 'always'],
 
     // Require a specific member delimiter style for interfaces and type literals
     // This rule aims to standardise the way interface and type literal members are delimited.
-    'typescript/member-delimiter-style': ['warn', {
-      delimiter: 'none',
+    '@typescript-eslint/member-delimiter-style': ['warn', {
+      multiline: {
+        delimiter: 'none',
+      },
+      singleline: {
+        delimiter: 'comma',
+      },
     }],
 
     // Require a consistent member declaration order
     // A consistent ordering of fields, methods and constructors can make interfaces, type literals,
     // classes and class expressions easier to read, navigate and edit.
-    'typescript/member-ordering': 'warn',
+    '@typescript-eslint/member-ordering': 'warn',
 
     // Enforces the use of `as Type` assertions instead of `<Type>` assertions
     // This rule aims to standardise the use of type assertion style across the codebase.
-    'typescript/no-angle-bracket-type-assertion': 'warn',
+    '@typescript-eslint/no-angle-bracket-type-assertion': 'warn',
 
     // Disallow generic Array constructors
     // Use of the Array constructor to construct a new array is generally discouraged in favor of
     // array literal notation because of the single-argument pitfall and because the Array global
     // may be redefined.
-    'typescript/no-array-constructor': 'error',
+    '@typescript-eslint/no-array-constructor': 'error',
 
     // Disallow the declaration of empty interfaces
     // An empty interface is equivalent to its supertype. If the interface does not implement a
     // supertype, then the interface is equivalent to an empty object ({}). In both cases it can be
     // omitted.
-    'typescript/no-empty-interface': 'warn',
+    '@typescript-eslint/no-empty-interface': 'warn',
 
     // Disallows explicit type declarations for variables or parameters initialized to a number,
     // string, or boolean
     // This rule disallows explicit type declarations on parameters, variables and properties where
     // the type can be easily inferred from its value.
-    'typescript/no-explicit-any': 'warn',
+    '@typescript-eslint/no-explicit-any': 'warn',
 
 
     // Disallow the use of custom TypeScript modules and namespaces
     // Custom TypeScript modules (module foo {}) and namespaces (namespace foo {}) are considered
     // outdated ways to organize TypeScript code. ES2015 module syntax is now preferred
     // (import/export).
-    'typescript/no-namespace': 'error',
+    '@typescript-eslint/no-namespace': 'error',
 
     // Disallow non-null assertions using the ! postfix operator
     // Using non-null assertions cancels the benefits of the strict null-checking mode.
-    'typescript/no-non-null-assertion': 'warn',
+    '@typescript-eslint/no-non-null-assertion': 'warn',
 
     // Disallow the use of parameter properties in class constructors
     // This rule disallows the use of parameter properties in constructors, forcing the user to
     // explicitly declare all properties in the class.
-    'typescript/no-parameter-properties': 'warn',
+    '@typescript-eslint/no-parameter-properties': 'warn',
 
     // Disallow /// <reference path="" /> comments
     // Triple-slash reference directive comments should not be used anymore. Use import instead.
-    'typescript/no-triple-slash-reference': 'error',
+    '@typescript-eslint/no-triple-slash-reference': 'error',
 
     // Prevent TypeScript-specific constructs from being erroneously flagged as unused
     // This rule only has an effect when the no-unused-vars core rule is enabled. It ensures that
     // TypeScript-specific constructs, such as implemented interfaces, are not erroneously flagged
     // as unused.
-    'typescript/no-unused-vars': 'error',
+    '@typescript-eslint/no-unused-vars': 'error',
 
     // Disallow the use of variables before they are defined
     // This rule will warn when it encounters a reference to an identifier that has not yet been
     // declared.
-    'typescript/no-use-before-define': ['error', {
+    '@typescript-eslint/no-use-before-define': ['error', {
       functions: false,
       classes: false,
       typedefs: false,
@@ -144,18 +149,18 @@ module.exports = {
     // Disallows the use of require statements except in import statements
     // In other words, the use of forms such as var foo = require("foo") are banned. Instead use ES6
     // style imports or import foo = require("foo") imports.
-    'typescript/no-var-requires': 'error',
+    '@typescript-eslint/no-var-requires': 'error',
 
     // Require the use of the namespace keyword instead of the module keyword to declare custom
     // TypeScript modules
     // In an effort to prevent further confusion between custom TypeScript modules and the new
     // ES2015 modules, starting with TypeScript v1.5 the keyword namespace is now the preferred way
     // to declare custom TypeScript modules.
-    'typescript/prefer-namespace-keyword': 'warn',
+    '@typescript-eslint/prefer-namespace-keyword': 'warn',
 
     // Require consistent spacing around type annotations
     // This rule aims to enforce specific spacing patterns around type annotations and function
     // types in type literals.
-    'typescript/type-annotation-spacing': 'warn',
+    '@typescript-eslint/type-annotation-spacing': 'warn',
   },
 }