Add an optional callback to runAsync() to be notified when a check finished. (#30)

* Add an optional callback to runAsync() to be notified when a check finished.

Provide an option to raise notifications (e.g. node-notifier) after checking.

* added /dist

* Added a check befor accessing the msg property

* new /dist

* Refactoring, cleanup, removed pushResultWithWorker() and added as option to printResultWithWorker

+ fixed tslint issues
+ added to readme

* new /dist

* Fix duplicated output

* new /dist

Author: zigmo

README.md

@@ -45,6 +45,12 @@ var testAsync = TypeHelper({
 })
 
 testAsync.runAsync();
+/* or with optional callback
+testAsync.runAsync((errors: number) => {
+    // errors > 0 => notify
+});
+*/ 
+
 
 
 // Watch folder and use worker (uses internal watcher)

dist/commonjs/checker.js.map

@@ -6,8 +6,9 @@ export declare class TypeHelperClass {
     private monitor;
     private watchTimeout;
     private isWorkerInspectPreformed;
+    private workerCallback?;
     constructor(options: ITypeCheckerOptions);
-    runAsync(): void;
+    runAsync(callback?: (errors: number) => void): void;
     runSync(): number;
     runPromise(): Promise<number>;
     runWatch(pathToWatch: string): void;

dist/commonjs/index.d.ts

@@ -29,6 +29,7 @@ export interface IInternalTypeCheckerOptions extends ITypeCheckerOptions {
 export interface IWorkerOptions {
     type: WorkerCommand;
     options?: IInternalTypeCheckerOptions;
+    hasCallback?: boolean;
 }
 export declare enum WorkerCommand {
     inspectCode = 0,

dist/commonjs/index.js

@@ -16,7 +16,7 @@ export class TypeHelperClass {
     private monitor: any;
     private watchTimeout: NodeJS.Timer;
     private isWorkerInspectPreformed: boolean;
-
+    private workerCallback?: (errors: number) => void;
 
     constructor(options: ITypeCheckerOptions) {
         this.checker = new Checker();
@@ -59,11 +59,14 @@ export class TypeHelperClass {
      * Runs in own thread/works and quits
      *
      */
-    public runAsync(): void {
+    public runAsync(callback?: (errors: number) => void): void {
 
         // set options, add if it need to quit and run type
         let options: IInternalTypeCheckerOptions = Object.assign(this.options, { quit: true, type: TypecheckerRunType.async });
 
+        // set the worker callback
+        this.workerCallback = callback;
+
         // create thread
         this.createThread();
 
@@ -237,15 +240,12 @@ export class TypeHelperClass {
         if (this.isWorkerInspectPreformed) {
 
             // all well, lets preform printout
-            this.worker.send({ type: WorkerCommand.printResult });
+            this.worker.send({ type: WorkerCommand.printResult, hasCallback: this.workerCallback != null });
         } else {
             this.writeText('You can not run pront before you have inspected code first');
         }
     }
 
-
-
-
     /**
      * Creates thread/worker
      *
@@ -256,18 +256,22 @@ export class TypeHelperClass {
         this.worker = child.fork(path.join(__dirname, 'worker.js'), []);
 
         // listen for worker messages
-        this.worker.on('message', (err: any) => {
+        this.worker.on('message', (msg: any) => {
 
-            if (err === 'error') {
+            if (msg === 'error') {
 
                 // if error then exit
                 this.writeText('error typechecker');
                 process.exit(1);
             } else {
 
-                // if not error, then just kill worker
-                this.writeText('killing worker');
-                this.killWorker();
+                if (this.workerCallback && msg && typeof msg === 'object' && msg.type === 'result') {
+                    this.workerCallback(msg.result);
+                } else {
+                    // if not error, then just kill worker
+                    this.writeText('killing worker');
+                    this.killWorker();
+                }
             }
         });
     }