fixup! chore: min node version, dep updates and ts-loader in test matrix

Author: SimonSchick

.travis.yml

@@ -1,5 +1,6 @@
 language: node_js
 node_js:
+ - '6'
  - '8'
 install:
  - yarn install

package.json

@@ -37,7 +37,7 @@
     "webpack-plugin"
   ],
   "engines": {
-    "node": ">=8.9.0"
+    "node": ">=6.11.5"
   },
   "author": "Piotr Oleś <[email protected]>",
   "contributors": [

src/CancellationToken.ts

@@ -10,32 +10,32 @@ interface CancellationTokenData {
 }
 
 export class CancellationToken {
-  isCancelled: boolean;
-  cancellationFileName: string;
-  lastCancellationCheckTime: number;
+  private isCancelled: boolean;
+  private cancellationFileName: string;
+  private lastCancellationCheckTime: number;
   constructor(cancellationFileName?: string, isCancelled?: boolean) {
     this.isCancelled = !!isCancelled;
     this.cancellationFileName =
       cancellationFileName || crypto.randomBytes(64).toString('hex');
     this.lastCancellationCheckTime = 0;
   }
 
-  static createFromJSON(json: CancellationTokenData) {
+  public static createFromJSON(json: CancellationTokenData) {
     return new CancellationToken(json.cancellationFileName, json.isCancelled);
   }
 
-  toJSON() {
+  public toJSON() {
     return {
       cancellationFileName: this.cancellationFileName,
       isCancelled: this.isCancelled
     };
   }
 
-  getCancellationFilePath() {
+  public getCancellationFilePath() {
     return path.join(os.tmpdir(), this.cancellationFileName);
   }
 
-  isCancellationRequested() {
+  public isCancellationRequested() {
     if (this.isCancelled) {
       return true;
     }
@@ -52,18 +52,18 @@ export class CancellationToken {
     return this.isCancelled;
   }
 
-  throwIfCancellationRequested() {
+  public throwIfCancellationRequested() {
     if (this.isCancellationRequested()) {
       throw new ts.OperationCanceledException();
     }
   }
 
-  requestCancellation() {
+  public requestCancellation() {
     fs.writeFileSync(this.getCancellationFilePath(), '');
     this.isCancelled = true;
   }
 
-  cleanupCancellation() {
+  public cleanupCancellation() {
     if (this.isCancelled && fs.existsSync(this.getCancellationFilePath())) {
       fs.unlinkSync(this.getCancellationFilePath());
       this.isCancelled = false;

src/FilesRegister.ts

@@ -8,64 +8,63 @@ export interface DataShape {
 }
 
 export class FilesRegister {
-  files: { [filePath: string]: { mtime?: number; data: DataShape } };
-  dataFactory: (_data?: DataShape) => DataShape; // It doesn't seem that the _data parameter is ever used?
+  private files: { [filePath: string]: { mtime?: number; data: DataShape } };
 
-  constructor(dataFactory: (_data?: DataShape) => DataShape) {
+  constructor(private dataFactory: (_data?: DataShape) => DataShape) {
     this.files = {};
     this.dataFactory = dataFactory;
   }
 
-  keys() {
+  public keys() {
     return Object.keys(this.files);
   }
 
-  add(filePath: string) {
+  public add(filePath: string) {
     this.files[filePath] = {
       mtime: undefined,
       data: this.dataFactory(undefined)
     };
   }
 
-  remove(filePath: string) {
+  public remove(filePath: string) {
     if (this.has(filePath)) {
       delete this.files[filePath];
     }
   }
 
-  has(filePath: string) {
+  public has(filePath: string) {
     return this.files.hasOwnProperty(filePath);
   }
 
-  get(filePath: string) {
+  public get(filePath: string) {
     if (!this.has(filePath)) {
       throw new Error('File "' + filePath + '" not found in register.');
     }
 
     return this.files[filePath];
   }
 
-  ensure(filePath: string) {
+  public ensure(filePath: string) {
     if (!this.has(filePath)) {
       this.add(filePath);
     }
   }
 
-  getData(filePath: string) {
+  public getData(filePath: string) {
     return this.get(filePath).data;
   }
 
-  mutateData(filePath: string, mutator: (data: DataShape) => void) {
+  public mutateData(filePath: string, mutator: (data: DataShape) => void) {
     this.ensure(filePath);
 
     mutator(this.files[filePath].data);
   }
 
-  getMtime(filePath: string) {
+  public getMtime(filePath: string) {
     return this.get(filePath).mtime;
   }
 
-  setMtime(filePath: string, mtime: number) {
+  public setMtime(filePath: string, mtime: number) {
     this.ensure(filePath);
 
     if (this.files[filePath].mtime !== mtime) {

src/FilesWatcher.ts

@@ -2,22 +2,19 @@ import * as chokidar from 'chokidar';
 import * as path from 'path';
 
 export class FilesWatcher {
-  watchPaths: string[];
-  watchExtensions: string[];
-  watchers: chokidar.FSWatcher[];
-  listeners: { [eventName: string]: Function[] };
-  constructor(watchPaths: string[], watchExtensions: string[]) {
-    this.watchPaths = watchPaths;
+  private watchers: chokidar.FSWatcher[];
+  private listeners: { [eventName: string]: Function[] };
+  constructor(private watchPaths: string[], private watchExtensions: string[]) {
     this.watchExtensions = watchExtensions;
     this.watchers = [];
     this.listeners = {};
   }
 
-  isFileSupported(filePath: string) {
+  public isFileSupported(filePath: string) {
     return this.watchExtensions.indexOf(path.extname(filePath)) !== -1;
   }
 
-  watch() {
+  public watch() {
     if (this.isWatching()) {
       throw new Error('Cannot watch again - already watching.');
     }
@@ -42,27 +39,27 @@ export class FilesWatcher {
     });
   }
 
-  isWatchingFile(filePath: string) {
+  public isWatchingFile(filePath: string) {
     return (
       this.isWatching() &&
       this.isFileSupported(filePath) &&
       this.watchPaths.some(watchPath => filePath.startsWith(watchPath))
     );
   }
 
-  isWatching() {
+  public isWatching() {
     return this.watchers.length > 0;
   }
 
-  on(event: string, listener: Function) {
+  public on(event: string, listener: Function) {
     if (!this.listeners[event]) {
       this.listeners[event] = [];
     }
 
     this.listeners[event].push(listener);
   }
 
-  off(event: string, listener: Function) {
+  public off(event: string, listener: Function) {
     if (this.listeners[event]) {
       this.listeners[event] = this.listeners[event].filter(
         oldListener => oldListener !== listener

src/IncrementalChecker.ts

@@ -20,60 +20,39 @@ interface ConfigurationFile extends Configuration.IConfigurationFile {
 }
 
 export class IncrementalChecker {
-  programConfigFile: string;
-  compilerOptions: object;
-  linterConfigFile: string | false;
-  linterAutoFix: boolean;
-  watchPaths: string[];
-  workNumber: number;
-  workDivision: number;
-  checkSyntacticErrors: boolean;
-  files: FilesRegister;
-
-  linter?: Linter;
-  linterConfig?: ConfigurationFile;
-  linterExclusions: minimatch.IMinimatch[];
-
-  program?: ts.Program;
-  programConfig?: ts.ParsedCommandLine;
-  watcher?: FilesWatcher;
-
-  vue: boolean;
+  // it's shared between compilations
+  private files = new FilesRegister(() => ({
+    // data shape
+    source: undefined,
+    linted: false,
+    lints: []
+  }));
+
+  private linter?: Linter;
+  private linterConfig?: ConfigurationFile;
+
+  // Use empty array of exclusions in general to avoid having
+  // to check of its existence later on.
+  private linterExclusions: minimatch.IMinimatch[] = [];
+
+  private program?: ts.Program;
+  private programConfig?: ts.ParsedCommandLine;
+  private watcher?: FilesWatcher;
 
   constructor(
-    programConfigFile: string,
-    compilerOptions: object,
-    linterConfigFile: string | false,
-    linterAutoFix: boolean,
-    watchPaths: string[],
-    workNumber: number,
-    workDivision: number,
-    checkSyntacticErrors: boolean,
-    vue: boolean
+    private programConfigFile: string,
+    private compilerOptions: object,
+    private linterConfigFile: string | false,
+    private linterAutoFix: boolean,
+    private watchPaths: string[],
+    private workNumber: number = 0,
+    private workDivision: number = 1,
+    private checkSyntacticErrors: boolean = false,
+    private vue: boolean = false,
   ) {
-    this.programConfigFile = programConfigFile;
-    this.compilerOptions = compilerOptions;
-    this.linterConfigFile = linterConfigFile;
-    this.linterAutoFix = linterAutoFix;
-    this.watchPaths = watchPaths;
-    this.workNumber = workNumber || 0;
-    this.workDivision = workDivision || 1;
-    this.checkSyntacticErrors = checkSyntacticErrors || false;
-    this.vue = vue || false;
-    // Use empty array of exclusions in general to avoid having
-    // to check of its existence later on.
-    this.linterExclusions = [];
-
-    // it's shared between compilations
-    this.files = new FilesRegister(() => ({
-      // data shape
-      source: undefined,
-      linted: false,
-      lints: []
-    }));
   }
 
-  static loadProgramConfig(configFile: string, compilerOptions: object) {
+  public static loadProgramConfig(configFile: string, compilerOptions: object) {
     const tsconfig = ts.readConfigFile(configFile, ts.sys.readFile).config;
 
     tsconfig.compilerOptions = tsconfig.compilerOptions || {};
@@ -91,15 +70,15 @@ export class IncrementalChecker {
     return parsed;
   }
 
-  static loadLinterConfig(configFile: string): ConfigurationFile {
+  private static loadLinterConfig(configFile: string): ConfigurationFile {
     const tslint = require('tslint');
 
     return tslint.Configuration.loadConfigurationFromPath(
       configFile
     ) as ConfigurationFile;
   }
 
-  static createProgram(
+  private static createProgram(
     programConfig: ts.ParsedCommandLine,
     files: FilesRegister,
     watcher: FilesWatcher,
@@ -139,17 +118,17 @@ export class IncrementalChecker {
     );
   }
 
-  createLinter(program: ts.Program) {
+  private createLinter(program: ts.Program) {
     const tslint = require('tslint');
 
     return new tslint.Linter({ fix: this.linterAutoFix }, program);
   }
 
-  hasLinter(): boolean {
+  public hasLinter(): boolean {
     return !!this.linter;
   }
 
-  static isFileExcluded(
+  public static isFileExcluded(
     filePath: string,
     linterExclusions: minimatch.IMinimatch[]
   ): boolean {
@@ -159,7 +138,7 @@ export class IncrementalChecker {
     );
   }
 
-  nextIteration() {
+  public nextIteration() {
     if (!this.watcher) {
       const watchExtensions = this.vue
         ? ['.ts', '.tsx', '.vue']
@@ -202,7 +181,7 @@ export class IncrementalChecker {
     }
   }
 
-  loadVueProgram() {
+  private loadVueProgram() {
     this.programConfig =
       this.programConfig ||
       VueProgram.loadProgramConfig(
@@ -219,7 +198,7 @@ export class IncrementalChecker {
     );
   }
 
-  loadDefaultProgram() {
+  private loadDefaultProgram() {
     this.programConfig =
       this.programConfig ||
       IncrementalChecker.loadProgramConfig(
@@ -235,7 +214,7 @@ export class IncrementalChecker {
     );
   }
 
-  getDiagnostics(cancellationToken: CancellationToken) {
+  public getDiagnostics(cancellationToken: CancellationToken) {
     const { program } = this;
     if (!program) {
       throw new Error('Invoked called before program initialized');
@@ -277,7 +256,7 @@ export class IncrementalChecker {
     );
   }
 
-  getLints(cancellationToken: CancellationToken) {
+  public getLints(cancellationToken: CancellationToken) {
     if (!this.linter) {
       throw new Error('Cannot get lints - checker has no linter.');
     }