fix(core): update

ts/index.ts

@@ -1,5 +1,4 @@
-export * from './smartspawn.classes.thread';
-export * from './smartspawn.classes.threadfunction';
 export * from './smartspawn.classes.threadsimple';
-export * from './smartspawn.classes.pool';
 export * from './smartspawn.wrap';
+
+export * from 'threads';

ts/smartspawn.classes.cluster.ts

@@ -1,6 +0,0 @@
-// ==============
-// This file handles clustering of nodejs programs
-// ==============
-import * as plugins from './smartspawn.plugins';
-
-export class Cluster {}

ts/smartspawn.classes.pool.ts

@@ -1,13 +0,0 @@
-import * as plugins from './smartspawn.plugins';
-
-export class Pool {
-  pool;
-
-  // the constructor for pool
-  constructor() {
-    this.pool = new plugins.threads.Pool();
-  }
-  run(workerPathArg: string) {
-    return this.pool.run(workerPathArg);
-  }
-}

ts/smartspawn.classes.thread.ts

@@ -1,85 +0,0 @@
-import * as plugins from './smartspawn.plugins';
-import * as paths from './smartspawn.paths';
-import * as smartpromise from '@pushrocks/smartpromise';
-
-import { Pool } from './smartspawn.classes.pool';
-import { startSpawnWrap, endSpawnWrap } from './smartspawn.wrap';
-
-export let workerBasePath: string = null;
-
-export const setWorkerBasePath = (basePathArg: string) => {
-  workerBasePath = basePathArg;
-  plugins.threads.config.set({
-    basepath: {
-      node: workerBasePath
-    }
-  });
-};
-
-export class Thread {
-  thread;
-  workerPath: string;
-  running: boolean = false;
-  assignedPool: Pool = null;
-  constructor(filePathArg: string) {
-    this.workerPath = filePathArg;
-  }
-
-  /**
-   * sends a message to the spawned process
-   * spawns it and keeps running
-   */
-  send<T>(message: any): Promise<T> {
-    let done = smartpromise.defer<T>();
-    this._checkSpawn();
-    this.thread.send(message);
-    this.thread.on('message', (message: T) => {
-      done.resolve(message);
-    });
-    this.thread.on('done', (job, message: T) => {
-      done.resolve(message);
-    });
-    this.thread.on('error', err => {
-      done.reject(err);
-    });
-    return done.promise;
-  }
-
-  /**
-   * sends a command once and then kills the child process
-   */
-  sendOnce<T>(message): Promise<T> {
-    let done = smartpromise.defer<T>();
-    this.send<T>(message).then(message => {
-      done.resolve(message);
-      this.kill();
-    });
-    return done.promise;
-  }
-
-  /**
-   * kills the thread
-   */
-  kill() {
-    this.thread.kill();
-    this.running = false;
-  }
-
-  assignToPool(poolArg: Pool) {
-    this.assignedPool = poolArg;
-  }
-
-  enableTypeScript() {
-    // TODO:
-  }
-
-  private _checkSpawn() {
-    if (!this.running && !this.assignedPool) {
-      this.running = true;
-      this.thread = plugins.threads.spawn(this.workerPath);
-    } else if (!this.running && this.assignedPool) {
-      this.running = true;
-      this.thread = this.assignedPool.run(this.workerPath);
-    }
-  }
-}

ts/smartspawn.classes.threadfunction.ts

@@ -1,33 +0,0 @@
-import * as plugins from './smartspawn.plugins';
-import * as smartpromise from '@pushrocks/smartpromise';
-
-export interface IThreadFunction {
-  (input, done): void;
-}
-
-export class ThreadFunction {
-  thread;
-  constructor(functionArg: IThreadFunction) {
-    this.thread = plugins.threads.spawn(functionArg);
-  }
-
-  /**
-   * sends a message to the spawned process
-   */
-  send<T>(message: any): Promise<T> {
-    let done = smartpromise.defer<T>();
-    this.thread
-      .send(message)
-      .on('message', (message: T) => {
-        done.resolve(message);
-      })
-      .on('error', err => {
-        done.reject(err);
-      });
-    return done.promise;
-  }
-
-  kill() {
-    this.thread.kill();
-  }
-}

ts/smartspawn.classes.threadsimple.ts

@@ -2,13 +2,11 @@ import * as plugins from './smartspawn.plugins';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as childProcess from 'child_process';
 
-import { workerBasePath } from './smartspawn.classes.thread';
-
 export class ThreadSimple {
-  workerPath: string;
-  threadChildProcess: childProcess.ChildProcess;
-  forkOptions: childProcess.ForkOptions;
-  argvArgs: string[];
+  public workerPath: string;
+  public threadChildProcess: childProcess.ChildProcess;
+  public forkOptions: childProcess.ForkOptions;
+  public argvArgs: string[];
   constructor(
     filePathArg: string,
     argvArgs: string[] = [],
@@ -19,17 +17,13 @@ export class ThreadSimple {
     this.argvArgs = argvArgs;
   }
 
-  run() {
-    let done = smartpromise.defer<childProcess.ChildProcess>();
-    let forkPath = (() => {
-      if (workerBasePath) {
-        return plugins.path.join(workerBasePath, this.workerPath);
-      } else {
-        return this.workerPath;
-      }
-    })();
+  public async start() {
+    const forkPath = this.workerPath;
     this.threadChildProcess = childProcess.fork(forkPath, this.argvArgs, this.forkOptions);
-    done.resolve(this.threadChildProcess);
-    return done.promise;
+    return this.threadChildProcess;
+  }
+
+  public async stop() {
+    this.threadChildProcess.kill();
   }
 }

ts/smartspawn.wrap.ts

@@ -3,8 +3,8 @@ import * as spawnWrap from 'spawn-wrap';
 let unwrap: any = null;
 
 export const startSpawnWrap = (filePath: string, cliArgs: string[] = [], envArgs: any = {}) => {
-  let spawnArray = [filePath];
-  for (let cliArg of cliArgs) {
+  const spawnArray = [filePath];
+  for (const cliArg of cliArgs) {
     spawnArray.push(cliArg);
   }
   unwrap = spawnWrap(spawnArray, envArgs);