Chore: Upgrade deps to eslint 4 and typescript-parser 4

.eslintrc.yml

@@ -1,4 +1,7 @@
-extends: eslint
-env:
-  es6: true
-  node: true
+root: true
+
+plugins:
+    - node
+extends:
+    - "eslint"
+    - "plugin:node/recommended"

.npmrc

@@ -0,0 +1 @@
+package-lock = false

docs/rules/type-annotation-spacing.md

@@ -3,7 +3,7 @@
 Type annotations in TypeScript tend to have a very specific format, where the colon appears directly after the identifier or function, followed by a space, followed by the type. For example:
 
 ```ts
-var foo: string = "bar";
+let foo: string = "bar";
 
 function foo(a: string): string {
     // code
@@ -19,7 +19,7 @@ This rule aims to enforce specific spacing patterns around type annotations. As
 The following patterns are considered warnings:
 
 ```ts
-var foo:string = "bar";
+let foo:string = "bar";
 
 function foo(a : string):string {
     // code
@@ -29,7 +29,7 @@ function foo(a : string):string {
 The following patterns are not warnings:
 
 ```js
-var foo: string = "bar";
+let foo: string = "bar";
 
 function foo(a: string): string {
     // code

lib/index.js

@@ -8,8 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var requireIndex = require("requireindex"),
-    path = require("path");
+const requireIndex = require("requireindex");
+const path = require("path");
 
 //------------------------------------------------------------------------------
 // Plugin Definition

lib/rules/explicit-member-accessibility.js

@@ -17,7 +17,7 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
+    create(context) {
 
         //----------------------------------------------------------------------
         // Helpers
@@ -33,7 +33,7 @@ module.exports = {
             if (!methodDefinition.accessibility) {
                 context.report({
                     node: methodDefinition,
-                    message: "Missing accessibility modifier on method definition " + methodDefinition.key.name + "."
+                    message: `Missing accessibility modifier on method definition ${methodDefinition.key.name}.`
                 });
             }
         }
@@ -48,7 +48,7 @@ module.exports = {
             if (!classProperty.accessibility) {
                 context.report({
                     node: classProperty,
-                    message: "Missing accessibility modifier on class property " + classProperty.key.name + "."
+                    message: `Missing accessibility modifier on class property ${classProperty.key.name}.`
                 });
             }
         }

lib/rules/interface-name-prefix.js

@@ -21,8 +21,9 @@ module.exports = {
         ]
     },
 
-    create: function(context) {
-        var never = context.options[0] !== "always";
+    create(context) {
+        const never = context.options[0] !== "always";
+
         //----------------------------------------------------------------------
         // Helpers
         //----------------------------------------------------------------------
@@ -40,8 +41,9 @@ module.exports = {
             if (name.length === 0) {
                 return false;
             }
-            var first = name.charAt(0);
-            var second = name.charAt(1);
+            const first = name.charAt(0);
+            const second = name.charAt(1);
+
             if (second === "") {
                 return false;
             }
@@ -59,16 +61,16 @@ module.exports = {
          */
         function checkInterfacePrefix(interfaceNode) {
             if (never) {
-                if (isPrefixedWithI(interfaceNode.name.name)) {
+                if (isPrefixedWithI(interfaceNode.id.name)) {
                     context.report({
-                        node: interfaceNode.name,
+                        node: interfaceNode.id,
                         message: "Interface name must not be prefixed with \"I\""
                     });
                 }
             } else {
-                if (!isPrefixedWithI(interfaceNode.name.name)) {
+                if (!isPrefixedWithI(interfaceNode.id.name)) {
                     context.report({
-                        node: interfaceNode.name,
+                        node: interfaceNode.id,
                         message: "Interface name must be prefixed with \"I\""
                     });
                 }

lib/rules/no-angle-bracket-type-assertion.js

@@ -17,15 +17,15 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
+    create(context) {
 
-        var sourceCode = context.getSourceCode();
+        const sourceCode = context.getSourceCode();
 
         //----------------------------------------------------------------------
         // Public
         //----------------------------------------------------------------------
         return {
-            TSTypeAssertionExpression: function(node) {
+            TSTypeAssertionExpression(node) {
                 context.report({
                     node,
                     message: "Prefer 'as {{cast}}' instead of '<{{cast}}>' when doing type assertions",

lib/rules/no-explicit-any.js

@@ -17,7 +17,7 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
+    create(context) {
 
         //----------------------------------------------------------------------
         // Helpers

lib/rules/no-namespace.js

@@ -30,10 +30,10 @@ module.exports = {
         ]
     },
 
-    create: function(context) {
+    create(context) {
 
-        var allowDeclarations = context.options[0] ? context.options[0].allowDeclarations : false;
-        var allowDefinitionFiles = context.options[0] ? context.options[0].allowDefinitionFiles : false;
+        const allowDeclarations = context.options[0] ? context.options[0].allowDeclarations : false;
+        const allowDefinitionFiles = context.options[0] ? context.options[0].allowDefinitionFiles : false;
 
         //----------------------------------------------------------------------
         // Helpers
@@ -56,7 +56,8 @@ module.exports = {
          * @private
          */
         function isDeclaration(node) {
-            var hasDeclareModifier = (node.modifiers || []).filter(m => m.type === "TSDeclareKeyword").length > 0;
+            const hasDeclareModifier = (node.modifiers || []).filter(m => m.type === "TSDeclareKeyword").length > 0;
+
             return hasDeclareModifier && !isTypeScriptModuleDeclaration(node);
         }
 
@@ -66,15 +67,16 @@ module.exports = {
          * @private
          */
         function isDefinitionFile() {
-            var filename = context.getFilename();
+            const filename = context.getFilename();
+
             return filename ? filename.slice(-5).toLowerCase() === ".d.ts" : false;
         }
 
         //----------------------------------------------------------------------
         // Public
         //----------------------------------------------------------------------
         return {
-            TSModuleDeclaration: function(node) {
+            TSModuleDeclaration(node) {
                 if (isTypeScriptModuleDeclaration(node) ||
                     (allowDefinitionFiles && isDefinitionFile()) ||
                     (allowDeclarations && isDeclaration(node))) {

lib/rules/no-triple-slash-reference.js

@@ -17,9 +17,9 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
-        var referenceRegExp = /^\/\s*<reference/;
-        var sourceCode = context.getSourceCode();
+    create(context) {
+        const referenceRegExp = /^\/\s*<reference/;
+        const sourceCode = context.getSourceCode();
 
         //----------------------------------------------------------------------
         // Helpers
@@ -32,8 +32,9 @@ module.exports = {
          * @private
          */
         function checkTripleSlashReference(program) {
-            var leading = sourceCode.getComments(program).leading;
-            leading.forEach(function(comment) {
+            const leading = sourceCode.getComments(program).leading;
+
+            leading.forEach(comment => {
                 if (comment.type !== "Line") {
                     return;
                 }

lib/rules/no-unused-vars.js

@@ -8,15 +8,15 @@
  * Record that a particular variable has been used in code
  *
  * @param {Object} context The current rule context.
- * @param {String} name The name of the variable to mark as used.
- * @returns {Boolean} True if the variable was found and marked as used, false if not.
+ * @param {string} name The name of the variable to mark as used.
+ * @returns {boolean} True if the variable was found and marked as used, false if not.
  */
 function markVariableAsUsed(context, name) {
-    var scope = context.getScope();
-    var variables;
-    var i;
-    var len;
-    var found = false;
+    let scope = context.getScope();
+    let variables;
+    let i;
+    let len;
+    let found = false;
 
     // Special Node.js scope means we need to start one level deeper
     if (scope.type === "global") {
@@ -53,7 +53,7 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
+    create(context) {
 
         //----------------------------------------------------------------------
         // Helpers
@@ -69,21 +69,32 @@ module.exports = {
             if (!node.decorators || !node.decorators.length) {
                 return;
             }
-            node.decorators.forEach(function(decorator) {
+            node.decorators.forEach(decorator => {
+
                 /**
                  * Decorator
                  */
                 if (decorator.name) {
                     markVariableAsUsed(context, decorator.name);
                     return;
                 }
+
+                if (decorator.expression && decorator.expression.name) {
+                    markVariableAsUsed(context, decorator.expression.name);
+                    return;
+                }
+
                 /**
                  * Decorator Factory
                  */
                 if (decorator.callee && decorator.callee.name) {
                     markVariableAsUsed(context, decorator.callee.name);
-                    return;
                 }
+
+                if (decorator.expression && decorator.expression.callee && decorator.expression.callee.name) {
+                    markVariableAsUsed(context, decorator.expression.callee.name);
+                }
+
             });
         }
 
@@ -97,7 +108,7 @@ module.exports = {
             if (!node.implements || !node.implements.length) {
                 return;
             }
-            node.implements.forEach(function(implementedInterface) {
+            node.implements.forEach(implementedInterface => {
                 if (!implementedInterface || !implementedInterface.id || !implementedInterface.id.name) {
                     return;
                 }
@@ -110,32 +121,36 @@ module.exports = {
         //----------------------------------------------------------------------
         return {
             ClassProperty: markDecoratorsAsUsed,
-            ClassDeclaration: function(node) {
+            ClassDeclaration(node) {
                 markDecoratorsAsUsed(node);
                 markImplementedInterfacesAsUsed(node);
             },
-            MethodDefinition: function(node) {
+            MethodDefinition(node) {
+
                 /**
                  * Decorators are only supported on class methods, so exit early
                  * if the parent is not a ClassBody
                  */
                 const anc = context.getAncestors();
                 const tAnc = anc.length;
+
                 if (!tAnc || !anc[tAnc - 1] || anc[tAnc - 1].type !== "ClassBody") {
                     return;
                 }
+
                 /**
                  * Mark any of the method's own decorators as used
                  */
                 markDecoratorsAsUsed(node);
+
                 /**
                  * Mark any parameter decorators as used
                  */
                 if (!node.value || !node.value.params || !node.value.params.length) {
                     return;
                 }
                 node.value.params.forEach(markDecoratorsAsUsed);
-            },
+            }
         };
 
     }

lib/rules/prefer-namespace-keyword.js

@@ -18,9 +18,9 @@ module.exports = {
         schema: []
     },
 
-    create: function(context) {
+    create(context) {
 
-        var sourceCode = context.getSourceCode();
+        const sourceCode = context.getSourceCode();
 
         //----------------------------------------------------------------------
         // Helpers
@@ -53,8 +53,9 @@ module.exports = {
         // Public
         //----------------------------------------------------------------------
         return {
-            TSModuleDeclaration: function(node) {
-                var declaration = sourceCode.getText(node);
+            TSModuleDeclaration(node) {
+                const declaration = sourceCode.getText(node);
+
                 if (isTypeScriptModuleDeclaration(node) || /\bnamespace\b/.test(declaration)) {
                     return;
                 }
@@ -63,7 +64,8 @@ module.exports = {
                     node,
                     message: "Use namespace instead of module to declare custom TypeScript modules",
                     fix(fixer) {
-                        var start = getStartIndex(node);
+                        const start = getStartIndex(node);
+
                         return fixer.replaceTextRange([start, start + "module".length], "namespace");
                     }
                 });