chore: update to typescript 2.8 (#584)

* chore: update to typescript 2.8

Migrate to TypeScript 2.8 and open the version range.

Author: mgechev

package-lock.json

@@ -86,7 +86,7 @@
     "rxjs-compat": "^6.0.0",
     "ts-node": "1.2.2",
     "tslint": "^5.0.0",
-    "typescript": "2.4.0",
+    "typescript": "^2.8.0",
     "zone.js": "^0.8.20"
   },
   "peerDependencies": {

package.json

@@ -19,6 +19,7 @@ import {
   decoratorArgument
 } from '../util/astQuery';
 import { getTemplate, getInlineStyle } from '../util/ngQuery';
+import { maybeNodeArray } from '../util/utils';
 
 const normalizeTransformed = (t: CodeWithSourceMap) => {
   if (!t.map) {
@@ -36,17 +37,17 @@ export class MetadataReader {
   }
 
   read(d: ts.ClassDeclaration): DirectiveMetadata {
-    let componentMetadata = unwrapFirst(
-      (d.decorators || ([] as ts.Decorator[])).map((dec: ts.Decorator) => {
+    const componentMetadata = unwrapFirst(
+      maybeNodeArray(d.decorators).map((dec: ts.Decorator) => {
         return Maybe.lift(dec)
           .bind(callExpression)
           .bind(withIdentifier('Component'))
           .fmap(() => this.readComponentMetadata(d, dec));
       })
     );
 
-    let directiveMetadata = unwrapFirst(
-      (d.decorators || ([] as ts.Decorator[])).map((dec: ts.Decorator) =>
+    const directiveMetadata = unwrapFirst(
+      maybeNodeArray(d.decorators).map((dec: ts.Decorator) =>
         Maybe.lift(dec)
           .bind(callExpression)
           .bind(withIdentifier('Directive'))

src/angular/metadataReader.ts

@@ -18,7 +18,7 @@ import { ngWalkerFactoryUtils } from './ngWalkerFactoryUtils';
 import { Config } from './config';
 
 import { logger } from '../util/logger';
-import { getDecoratorName } from '../util/utils';
+import { getDecoratorName, maybeNodeArray } from '../util/utils';
 
 const getDecoratorStringArgs = (decorator: ts.Decorator) => {
   let baseExpr = <any>decorator.expression || {};
@@ -59,17 +59,17 @@ export class NgWalker extends Lint.RuleWalker {
     } else if (metadata instanceof DirectiveMetadata) {
       this.visitNgDirective(metadata);
     }
-    (<ts.Decorator[]>declaration.decorators || []).forEach(this.visitClassDecorator.bind(this));
+    maybeNodeArray(<ts.NodeArray<ts.Decorator>>declaration.decorators).forEach(this.visitClassDecorator.bind(this));
     super.visitClassDeclaration(declaration);
   }
 
   visitMethodDeclaration(method: ts.MethodDeclaration) {
-    (<ts.Decorator[]>method.decorators || []).forEach(this.visitMethodDecorator.bind(this));
+    maybeNodeArray(<ts.NodeArray<ts.Decorator>>method.decorators).forEach(this.visitMethodDecorator.bind(this));
     super.visitMethodDeclaration(method);
   }
 
   visitPropertyDeclaration(prop: ts.PropertyDeclaration) {
-    (<ts.Decorator[]>prop.decorators || []).forEach(this.visitPropertyDecorator.bind(this));
+    maybeNodeArray(<ts.NodeArray<ts.Decorator>>prop.decorators).forEach(this.visitPropertyDecorator.bind(this));
     super.visitPropertyDeclaration(prop);
   }
 
@@ -227,10 +227,10 @@ export class NgWalker extends Lint.RuleWalker {
     }
     const sf = ts.createSourceFile(path, `\`${content}\``, ts.ScriptTarget.ES5);
     const original = sf.getFullText;
-    sf.getFullText = function() {
+    sf.getFullText = () => {
       const text = original.apply(sf);
       return text.substring(1, text.length - 1);
-    }.bind(sf);
+    };
     return sf;
   }
 }

src/angular/ngWalker.ts

@@ -18,7 +18,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
   static FAILURE_STRING = 'Call expressions are not allowed in templates except in output handlers.';
 
-  apply(sourceFile: ts.SourceFile) {
+  apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
     const walkerConfig: NgWalkerConfig = {
       templateVisitorCtrl: TemplateVisitor,
       expressionVisitorCtrl: ExpressionVisitor

src/noTemplateCallExpressionRule.ts

@@ -36,7 +36,7 @@ class DirectiveMetadataWalker extends Lint.RuleWalker {
   }
 
   visitClassDeclaration(node: ts.ClassDeclaration) {
-    (<ts.Decorator[]>node.decorators || []).forEach(this.validateDecorator.bind(this, node.name.text));
+    (<ts.NodeArray<ts.Decorator>>node.decorators).forEach(this.validateDecorator.bind(this, node.name.text));
     super.visitClassDeclaration(node);
   }
 

src/propertyDecoratorBase.ts

@@ -103,7 +103,9 @@ export class SelectorValidatorWalker extends Lint.RuleWalker {
   }
 
   visitClassDeclaration(node: ts.ClassDeclaration) {
-    (<ts.Decorator[]>node.decorators || []).forEach(this.validateDecorator.bind(this, node.name.text));
+    if (node.decorators) {
+      (<ts.NodeArray<ts.Decorator>>node.decorators).forEach(this.validateDecorator.bind(this, node.name.text));
+    }
     super.visitClassDeclaration(node);
   }
 

src/selectorNameBase.ts

@@ -2,6 +2,7 @@ import * as Lint from 'tslint';
 import * as ts from 'typescript';
 import { sprintf } from 'sprintf-js';
 import SyntaxKind = require('./util/syntaxKind');
+import { maybeNodeArray } from './util/utils';
 
 const getInterfaceName = (t: any) => {
   if (t.expression && t.expression.name) {
@@ -32,9 +33,9 @@ export class Rule extends Lint.Rules.AbstractRule {
 export class ClassMetadataWalker extends Lint.RuleWalker {
   visitClassDeclaration(node: ts.ClassDeclaration) {
     if (this.hasIPipeTransform(node)) {
-      let decorators = <any[]>node.decorators || [];
-      let className: string = node.name.text;
-      let pipes: Array<string> = decorators
+      const decorators = maybeNodeArray(<ts.NodeArray<any>>node.decorators);
+      const className: string = node.name.text;
+      const pipes: Array<string> = decorators
         .map(d => (<any>d.expression).text || ((<any>d.expression).expression || {}).text)
         .filter(t => t === 'Pipe');
       if (pipes.length === 0) {

src/usePipeDecoratorRule.ts

@@ -53,7 +53,10 @@ export function getInitializer(p: ts.ObjectLiteralElement): Maybe<ts.Expression>
   return Maybe.lift(isPropertyAssignment(p) && isIdentifier(p.name) ? p.initializer : undefined);
 }
 
-export function getStringInitializerFromProperty(propertyName: string, ps: ts.ObjectLiteralElement[]): Maybe<WithStringInitializer> {
+export function getStringInitializerFromProperty(
+  propertyName: string,
+  ps: ts.NodeArray<ts.ObjectLiteralElement>
+): Maybe<WithStringInitializer> {
   const property = ps.find(p => isProperty(propertyName, p));
   return (
     getInitializer(property)

src/util/astQuery.ts

@@ -44,7 +44,7 @@ export const getDecoratorName = (decorator: ts.Decorator) => {
 };
 
 export const getComponentDecorator = (declaration: ts.ClassDeclaration) => {
-  return (<ts.Decorator[]>declaration.decorators || [])
+  return ([].slice.apply(declaration.decorators) || [])
     .filter((d: any) => {
       if (
         !(<ts.CallExpression>d.expression).arguments ||
@@ -60,3 +60,10 @@ export const getComponentDecorator = (declaration: ts.ClassDeclaration) => {
     })
     .pop();
 };
+
+export const maybeNodeArray = <T extends ts.Node>(nodes: ts.NodeArray<T>): ReadonlyArray<T> => {
+  if (!nodes) {
+    return [];
+  }
+  return nodes;
+};