Update tslint to version 4.0.1 🚀 (#233)

* chore(package): update tslint to version 4.0.1

https://greenkeeper.io/

* chore: use shared standard tslint configuration

Author: greenkeeperio-bot

.travis.yml

@@ -8,11 +8,15 @@ matrix:
 branches:
   only:
     - master
+    - /^greenkeeper-.*$/
 notifications:
   email:
     on_success: never
 cache:
   directories:
   - node_modules
 
+before_script: 'npm run linter'
+script: 'npm run test'
 after_script: 'npm run coverage'
+

package.json

@@ -12,6 +12,7 @@
     "index.d.ts"
   ],
   "scripts": {
+    "linter": "tslint --project ./tsconfig.json --type-check",
     "start": "npm test",
     "clean": "rimraf dist",
     "prebuild": "npm run clean",
@@ -35,6 +36,7 @@
   },
   "license": "MIT",
   "devDependencies": {
+    "@knisterpeter/standard-tslint": "1.0.2",
     "@types/chalk": "0.4.31",
     "@types/diff": "0.0.31",
     "@types/node": "6.0.46",
@@ -55,7 +57,7 @@
     "rimraf": "2.5.4",
     "source-map-support": "0.4.6",
     "standard-version": "3.0.0",
-    "tslint": "4.0.0",
+    "tslint": "4.0.1",
     "typescript": "2.0.10"
   },
   "dependencies": {

src/analyzer.ts

@@ -1,9 +1,10 @@
 import * as ASTQ from 'astq';
 
-import { InstanceOfResolver } from './index';
 import { IPropTypes, IProp } from './deprecated';
+import { InstanceOfResolver } from './index';
 
-interface IASTNode {
+type IASTNode = ASTNode;
+interface ASTNode {
   type: string;
   loc: Object;
   [name: string]: any;
@@ -30,13 +31,14 @@ export function parsePropTypes(node: any, instanceOfResolver?: InstanceOfResolve
 
 function getOptionalDocumentation(propertyNode: any): string {
   return (((propertyNode.leadingComments || []) as any[])
-    .filter(comment => comment.type == 'CommentBlock')[0] || {})
+    .filter(comment => comment.type === 'CommentBlock')[0] || {})
     .value;
 }
 
 /**
  * @internal
  */
+// tslint:disable:next-line cyclomatic-complexity
 export function getTypeFromPropType(node: IASTNode, instanceOfResolver = defaultInstanceOfResolver): IProp {
   const result: IProp = {
     type: 'any',
@@ -91,14 +93,14 @@ export function getTypeFromPropType(node: IASTNode, instanceOfResolver = default
 }
 
 function isNode(obj: IASTNode): boolean {
-  return obj && typeof obj.type != 'undefined' && typeof obj.loc != 'undefined';
+  return obj && typeof obj.type !== 'undefined' && typeof obj.loc !== 'undefined';
 }
 
 function getReactPropTypeFromExpression(node: any, instanceOfResolver: InstanceOfResolver): any {
-  if (node.type == 'MemberExpression' && node.object.type == 'MemberExpression'
-      && node.object.object.name == 'React' && node.object.property.name == 'PropTypes') {
+  if (node.type === 'MemberExpression' && node.object.type === 'MemberExpression'
+      && node.object.object.name === 'React' && node.object.property.name === 'PropTypes') {
     return node.property;
-  } else if (node.type == 'CallExpression') {
+  } else if (node.type === 'CallExpression') {
     const callType = getReactPropTypeFromExpression(node.callee, instanceOfResolver);
     switch (callType.name) {
       case 'instanceOf':
@@ -111,7 +113,7 @@ function getReactPropTypeFromExpression(node: any, instanceOfResolver: InstanceO
         const arrayType = getTypeFromPropType(node.arguments[0], instanceOfResolver);
         return {
           name: 'array',
-          arrayType: arrayType.type,
+          arrayType: arrayType.type
         };
       case 'oneOfType':
         const unionTypes = node.arguments[0].elements.map((element: IASTNode) =>
@@ -126,7 +128,7 @@ function getReactPropTypeFromExpression(node: any, instanceOfResolver: InstanceO
 }
 
 function isRequiredPropType(node: any, instanceOfResolver: InstanceOfResolver): any {
-  const isRequired = node.type == 'MemberExpression' && node.property.name == 'isRequired';
+  const isRequired = node.type === 'MemberExpression' && node.property.name === 'isRequired';
   return {
     isRequired,
     type: getReactPropTypeFromExpression(isRequired ? node.object : node, instanceOfResolver)

src/deprecated.ts

@@ -1,13 +1,15 @@
 import * as ASTQ from 'astq';
-import { IOptions, InstanceOfResolver } from './index';
-import { Generator } from './generator';
+
 import { parsePropTypes } from './analyzer';
+import { Generator } from './generator';
+import { IOptions, InstanceOfResolver } from './index';
 
 export enum ExportType {
   default,
   named
 }
 
+// tslint:disable:next-line interface-name
 export interface IProp {
   type: string;
   optional: boolean;
@@ -16,6 +18,7 @@ export interface IProp {
   documentation?: string;
 }
 
+// tslint:disable:next-line interface-name
 export interface IPropTypes {
   [name: string]: IProp;
 }
@@ -64,6 +67,7 @@ export interface IParsingResult {
   propTypes: IPropTypes;
 }
 
+// tslint:disable:next-line cyclomatic-complexity
 function parseAst(ast: any, instanceOfResolver?: InstanceOfResolver): IParsingResult {
   let exportType: ExportType|undefined;
   let functionname: string|undefined;

src/generator.ts

@@ -92,7 +92,7 @@ export class Generator {
   public exportDeclaration(exportType: ExportType, fn: () => void): void {
     this.indent();
     this.code += 'export ';
-    if (exportType == ExportType.default) {
+    if (exportType === ExportType.default) {
       this.code += 'default ';
     }
     fn();

src/index.ts

@@ -1,5 +1,5 @@
-import * as fs from 'fs';
 import * as babylon from 'babylon';
+import * as fs from 'fs';
 import * as getStdin from 'get-stdin';
 
 import { generateTypings } from './deprecated';
@@ -10,7 +10,9 @@ export interface InstanceOfResolver {
   (name: string): string|undefined;
 };
 
-export interface IOptions {
+// the IOptions is for backward compatibility
+export type IOptions  = Options;
+export interface Options {
 
   /**
    * Resolves type names to import paths.

src/types.ts

@@ -34,6 +34,7 @@ export function get(astq: ASTQ, propertyAst: any, propTypesName: string|undefine
   };
 }
 
+// tslint:disable:next-line cyclomatic-complexity
 function getSimpleType(astq: ASTQ, propertyAst: any, propTypesName: string|undefined): TypeDeclaration|undefined {
   const [required, simpleTypeName] = getSimpleTypeName(astq, propertyAst, propTypesName);
   switch (simpleTypeName) {
@@ -79,6 +80,7 @@ function getComplexType(astq: ASTQ, propertyAst: any, propTypesName: string|unde
       const typeDecl = get(astq, typeAst.arguments[0], propTypesName);
       return getTypeDeclaration(dom.create.array(typeDecl.type), !required);
     case 'oneOf':
+      // tslint:disable:next-line comment-format
       // FIXME: This should better be a real enum
       const enumEntries = getEnumValues(typeAst.arguments[0].elements);
       return getTypeDeclaration(dom.create.union(enumEntries as dom.Type[]), !required);
@@ -90,7 +92,7 @@ function getComplexType(astq: ASTQ, propertyAst: any, propTypesName: string|unde
       });
       return getTypeDeclaration(dom.create.objectType(entries), !required);
   }
-return undefined;
+  return undefined;
 }
 
 function isRequired(astq: ASTQ, propertyAst: any): [boolean, any] {
@@ -128,6 +130,7 @@ function getComplexTypeName(astq: ASTQ, propertyAst: any,
 
 function getEnumValues(oneOfTypes: any[]): any[] {
   return oneOfTypes.map((element: any) => {
+    // tslint:disable:next-line comment-format
     // FIXME: This are not named references!
     if (element.type === 'StringLiteral') {
       return dom.create.namedTypeReference(`'${element.value}'`);

src/typings.ts

@@ -22,7 +22,7 @@ export function createTypings(moduleName: string|null, ast: any,
   }
   if (importStatements.length > 0) {
     importStatements.forEach(importStatement => {
-      if (importStatement.name == undefined) {
+      if (importStatement.name === undefined) {
         m.members.push(dom.create.importDefault(importStatement.local, importStatement.path));
       } else {
         throw new Error('Named imports are currently unsupported');
@@ -34,28 +34,7 @@ export function createTypings(moduleName: string|null, ast: any,
     const propTypes = getPropTypesFromAssignment(astq, ast, componentName) ||
       getPropTypesFromStaticAttribute(astq, ast, componentName);
     if (exportType) {
-      const classComponent = isClassComponent(astq, ast, componentName, reactComponentName);
-
-      const interf = dom.create.interface(`${componentName}Props`);
-      interf.flags = dom.DeclarationFlags.Export;
-      if (propTypes) {
-        createPropTypeTypings(interf, astq, propTypes, propTypesName);
-      }
-      if (propTypes || classComponent) {
-        m.members.push(interf);
-      }
-
-      if (classComponent) {
-        const classDecl = dom.create.class(componentName);
-        classDecl.baseType = dom.create.interface(`React.Component<${interf.name}, any>`);
-        classDecl.flags = exportType;
-        m.members.push(classDecl);
-      } else {
-        const funcDelc = dom.create.function(componentName, propTypes ? [dom.create.parameter('props', interf)] : [],
-          dom.create.namedTypeReference('JSX.Element'));
-        funcDelc.flags = exportType;
-        m.members.push(funcDelc);
-      }
+      createExportedTypes(m, astq, ast, componentName, reactComponentName, propTypes, propTypesName, exportType);
     }
   });
 
@@ -68,6 +47,33 @@ export function createTypings(moduleName: string|null, ast: any,
   }
 };
 
+function createExportedTypes(m: dom.ModuleDeclaration, astq: ASTQ, ast: any, componentName: string,
+    reactComponentName: string|undefined, propTypes: any, propTypesName: string|undefined,
+      exportType: dom.DeclarationFlags): void {
+  const classComponent = isClassComponent(astq, ast, componentName, reactComponentName);
+
+  const interf = dom.create.interface(`${componentName}Props`);
+  interf.flags = dom.DeclarationFlags.Export;
+  if (propTypes) {
+    createPropTypeTypings(interf, astq, propTypes, propTypesName);
+  }
+  if (propTypes || classComponent) {
+    m.members.push(interf);
+  }
+
+  if (classComponent) {
+    const classDecl = dom.create.class(componentName);
+    classDecl.baseType = dom.create.interface(`React.Component<${interf.name}, any>`);
+    classDecl.flags = exportType;
+    m.members.push(classDecl);
+  } else {
+    const funcDelc = dom.create.function(componentName, propTypes ? [dom.create.parameter('props', interf)] : [],
+      dom.create.namedTypeReference('JSX.Element'));
+    funcDelc.flags = exportType;
+    m.members.push(funcDelc);
+  }
+}
+
 function createPropTypeTypings(interf: dom.InterfaceDeclaration, astq: ASTQ, propTypes: any,
     propTypesName: string|undefined): void {
   const res = astq.query(propTypes, `

tests/parse-prop-types-test.ts

@@ -1,7 +1,7 @@
 import test from 'ava';
 
-import { IProp } from '../src/deprecated';
 import { getTypeFromPropType } from '../src/analyzer';
+import { IProp } from '../src/deprecated';
 
 const instanceOfResolver = (): any => undefined;
 const reactPropTypesMemberExpression: any = {

tests/parsing-test.ts

@@ -1,9 +1,9 @@
 import test, { ContextualTestContext } from 'ava';
 
-import * as fs from 'fs';
-import * as path from 'path';
 import * as chalk from 'chalk';
 import * as diff from 'diff';
+import * as fs from 'fs';
+import * as path from 'path';
 
 import * as react2dts from '../src/index';