Update package name, update and lock clang-format and tslint versions, and format all source files …

lib/main.ts

 import * as dartStyle from 'dart-style';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
 import * as base from './base';
 import {ImportSummary, TranspilerBase} from './base';
 import DeclarationTranspiler from './declaration';
 import {FacadeConverter} from './facade_converter';
 import * as merge from './merge';
@@ skipping 102 matching lines @@
     this.declarationTranspiler.setTypeChecker(program.getTypeChecker());
 
     // Only write files that were explicitly passed in.
     let fileSet: {[s: string]: boolean} = {};
     fileNames.forEach((f) => fileSet[f] = true);
     let sourceFiles = program.getSourceFiles().filter((sourceFile) => fileSet[sourceFile.fileName]);
 
     this.errors = [];
 
     let sourceFileMap: {[s: string]: ts.SourceFile} = {};
-    sourceFiles.forEach((f: ts.SourceFile) => { sourceFileMap[f.fileName] = f; });
+    sourceFiles.forEach((f: ts.SourceFile) => {
+      sourceFileMap[f.fileName] = f;
+    });
 
     // Check for global module export declarations and propogate them to all modules they export.
     sourceFiles.forEach((f: ts.SourceFile) => {
       f.statements.forEach((n: ts.Node) => {
         if (n.kind !== ts.SyntaxKind.GlobalModuleExportDeclaration) return;
         // This is the name we are interested in for Dart purposes until Dart supports AMD module
         // loaders. This module name should all be reflected by all modules exported by this
         // library as we need to specify a global module location for every Dart library.
         let globalModuleName = base.ident((n as ts.GlobalModuleExportDeclaration).name);
         f.moduleName = globalModuleName;
@@ skipping 58 matching lines @@
     let compilerHost: ts.CompilerHost = {
       getSourceFile: (sourceName, languageVersion) => {
         let sourcePath = sourceName;
         if (sourceName === defaultLibFileName) {
           sourcePath = ts.getDefaultLibFilePath(COMPILER_OPTIONS);
         }
         if (!fs.existsSync(sourcePath)) return undefined;
         let contents = fs.readFileSync(sourcePath, 'UTF-8');
         return ts.createSourceFile(sourceName, contents, COMPILER_OPTIONS.target, true);
       },
-      writeFile(name, text, writeByteOrderMark) { fs.writeFile(name, text); },
+      writeFile(name, text, writeByteOrderMark) {
+        fs.writeFile(name, text);
+      },
       fileExists: (filename) => fs.existsSync(filename),
       readFile: (filename) => fs.readFileSync(filename, 'utf-8'),
       getDefaultLibFileName: () => defaultLibFileName,
       useCaseSensitiveFileNames: () => true,
       getCanonicalFileName: (filename) => filename,
       getCurrentDirectory: () => '',
       getNewLine: () => '\n',
     };
     compilerHost.resolveModuleNames = getModuleResolver(compilerHost);
     return compilerHost;
   }
 
   // Visible for testing.
   getOutputPath(filePath: string, destinationRoot: string): string {
     let relative = this.getDartFileName(filePath);
     return this.normalizeSlashes(path.join(destinationRoot, relative));
   }
 
-  public pushContext(context: OutputContext) { this.outputStack.push(this.outputs[context]); }
+  public pushContext(context: OutputContext) {
+    this.outputStack.push(this.outputs[context]);
+  }
 
   public popContext() {
     if (this.outputStack.length === 0) {
       this.reportError(null, 'Attempting to pop output stack when already empty');
     }
     this.outputStack.pop();
   }
 
   private translate(sourceFile: ts.SourceFile): string {
     this.currentFile = sourceFile;
@@ skipping 107 matching lines @@
     filePath = filePath.replace(/([^/]+)\/index.dart$/, '$1.dart');
     return this.getRelativeFileName(filePath);
   }
 
   isJsModuleFile(): boolean {
     // Treat files as being part of js modules if they match the node module file naming convention
     // of module_name/index.js.
     return !('/' + this.currentFile.fileName).match(/\/index\.(js|es6|d\.ts|ts)$/);
   }
 
-  private get currentOutput(): Output { return this.outputStack[this.outputStack.length - 1]; }
+  private get currentOutput(): Output {
+    return this.outputStack[this.outputStack.length - 1];
+  }
 
-  emit(s: string) { this.currentOutput.emit(s); }
-  emitNoSpace(s: string) { this.currentOutput.emitNoSpace(s); }
-  maybeLineBreak() { return this.currentOutput.maybeLineBreak(); }
-  enterCodeComment() { return this.currentOutput.enterCodeComment(); }
-  exitCodeComment() { return this.currentOutput.exitCodeComment(); }
+  emit(s: string) {
+    this.currentOutput.emit(s);
+  }
+  emitNoSpace(s: string) {
+    this.currentOutput.emitNoSpace(s);
+  }
+  maybeLineBreak() {
+    return this.currentOutput.maybeLineBreak();
+  }
+  enterCodeComment() {
+    return this.currentOutput.enterCodeComment();
+  }
+  exitCodeComment() {
+    return this.currentOutput.exitCodeComment();
+  }
 
-  enterTypeArgument() { this.typeArgumentDepth++; }
-  exitTypeArgument() { this.typeArgumentDepth--; }
-  get insideTypeArgument(): boolean { return this.typeArgumentDepth > 0; }
+  enterTypeArgument() {
+    this.typeArgumentDepth++;
+  }
+  exitTypeArgument() {
+    this.typeArgumentDepth--;
+  }
+  get insideTypeArgument(): boolean {
+    return this.typeArgumentDepth > 0;
+  }
 
-  emitType(s: string, comment: string) { return this.currentOutput.emitType(s, comment); }
-  get insideCodeComment() { return this.currentOutput.insideCodeComment; }
+  emitType(s: string, comment: string) {
+    return this.currentOutput.emitType(s, comment);
+  }
+  get insideCodeComment() {
+    return this.currentOutput.insideCodeComment;
+  }
 
   reportError(n: ts.Node, message: string) {
     let file = n.getSourceFile() || this.currentFile;
     let fileName = this.getRelativeFileName(file.fileName);
     let start = n.getStart(file);
     let pos = file.getLineAndCharacterOfPosition(start);
     // Line and character are 0-based.
     let fullMessage = `${fileName}:${pos.line + 1}:${pos.character + 1}: ${message}`;
     if (this.options.failFast) throw new Error(fullMessage);
     this.errors.push(fullMessage);
@@ skipping 25 matching lines @@
 
     for (let i = 0; i < this.transpilers.length; i++) {
       if (this.transpilers[i].visitNode(node)) return;
     }
 
     this.reportError(
         node,
         'Unsupported node type ' + (<any>ts).SyntaxKind[node.kind] + ': ' + node.getFullText());
   }
 
-  private normalizeSlashes(path: string) { return path.replace(/\\/g, '/'); }
+  private normalizeSlashes(path: string) {
+    return path.replace(/\\/g, '/');
+  }
 
   private translateComment(comment: string): string {
     let rawComment = comment;
     comment = comment.replace(/\{@link ([^\}]+)\}/g, '[$1]');
 
     // Remove the following tags and following comments till end of line.
     comment = comment.replace(/@param.*$/gm, '');
     comment = comment.replace(/@throws.*$/gm, '');
     comment = comment.replace(/@return.*$/gm, '');
 
@@ skipping 146 matching lines @@
   try {
     let transpiler = new Transpiler(args);
     if (args.destination) console.error('Transpiling', args._, 'to', args.destination);
     transpiler.transpile(args._, args.destination);
   } catch (e) {
     if (e.name !== 'DartFacadeError') throw e;
     console.error(e.message);
     process.exit(1);
   }
 }