Merge pull request #15 from Idicious/typescript-definitions

Author: kwolfy

package.json

@@ -1,15 +1,17 @@
 {
   "name": "webworker-promise",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Promise for webworkers",
   "module": "src/index.js",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
-    "prepublish": "npm run build; npm run dist",
+    "prepublish": "npm run build; npm run dist; npm run copy-types",
     "dist": "webpack",
     "build": "babel src --out-dir lib",
     "watch": "babel src --out-dir lib --watch",
     "test": "mocha ./test/*.test.js",
+    "copy-types": "cp src/*.d.ts lib",
     "coverage": "istanbul cover _mocha test/*.test.js"
   },
   "author": {

src/index.d.ts

@@ -0,0 +1,142 @@
+import NodeWorker = require("./node-worker");
+
+export = PromiseWorker;
+
+declare class PromiseWorker {
+  constructor(worker: Worker | NodeWorker);
+
+  /**
+   * Trigger the main worker function.
+   * The `onEvent` function is scoped to the 'emit' passed into the main function and is not triggered by global emits from the worker.
+   *
+   * @param message Data to send to worker
+   * @param transferableList List of transferables to send to worker
+   * @param onEvent Eventhandler for `emit` calls from the worker
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * registerWebworker((message) => {
+   *      return `Hello ${message}!`;
+   * });
+   *
+   * // main.js
+   * worker.postMessage('world').then((response) => {
+   *      console.log(response); // Hello world!
+   * })
+   * ```
+   */
+  postMessage(
+    message: any,
+    transferableList?: Transferable[],
+    onEvent?: (eventName: string, message: any) => void
+  ): Promise<any>;
+
+  /**
+   * Trigger an operation that is registered via the `operation` function in the worker.
+   * The 'onEvent' function is scoped to the 'emit' passed into the `operation` function and is not triggered by global emits from the worker.
+   *
+   * @param operationName Name of the operation
+   * @param message Data to send to worker
+   * @param transferableList List of transferables to send to worker
+   * @param onEvent Eventhandler for `emit` calls from the worker
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * registerWebworker().operation('greet', (message) => {
+   *      return `Hello ${message}!`;
+   * });
+   *
+   * // main.js
+   * worker.exec('greet', 'world').then((response) => {
+   *      console.log(response); // Hello world!
+   * })
+   * ```
+   */
+  exec(
+    operationName: string,
+    message?: any,
+    transferableList?: Transferable[],
+    onEvent?: (eventName: string, message: any) => void
+  ): Promise<any>;
+  /**
+   * Register an event handler that can be triggered via the `emit` command from the worker.
+   *
+   * @param eventName Name of the operation
+   * @param handler Event handler
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * const host = registerWebworker()
+   *  .on('add', (x, y) => {
+   *      host.emit('add:result', x + y);
+   *  });
+   *
+   * // main.js
+   * worker.on('add:result', (result) => {
+   *      console.log(result); // 3
+   * });
+   *
+   * worker.emit('add', 1, 2);
+   * ```
+   */
+  on(eventName: string, handler: (...args: any[]) => void): PromiseWorker;
+  /**
+   * Register an event handler that can be triggered via the `emit` command from the worker, will only be triggered once.
+   *
+   * @param eventName Name of the operation
+   * @param handler Event handler
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * const host = registerWebworker()
+   *  .once('add', (x, y) => {
+   *      host.emit('add:result', x + y);
+   *  });
+   *
+   * // main.js
+   * worker.once('add:result', (result) => {
+   *      console.log(result); // 3
+   * });
+   *
+   * // Will only have effect first call
+   * worker.emit('add', 1, 2);
+   * ```
+   */
+  once(eventName: string, handler: (...args: any[]) => void): PromiseWorker;
+  /**
+   * Emit an event to the worker that can be listened to via the `on` and `once` methods in the worker.
+   *
+   * @param eventName Name of the operation
+   * @param args Values to emit
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * const host = registerWebworker()
+   *  .on('add', (x, y) => {
+   *      host.emit('add:result', x + y);
+   *  });
+   *
+   * // main.js
+   * worker.on('add:result', (result) => {
+   *      console.log(result); // 3
+   * });
+   *
+   * worker.emit('add', 1, 2);
+   * ```
+   */
+  emit(eventName: string, ...args: any[]): void;
+  /**
+   * Disposes the underlying worker, future calls will have no effect
+   */
+  terminate(): void;
+}

src/node-worker.d.ts

@@ -0,0 +1,20 @@
+export = NodeWorker;
+
+/**
+ * You can use webworker-promise with nodejs using shim
+ *
+ * @example
+ *
+ * ```
+ * const WebworkerPromise = require('webworker-promise');
+ * const Worker = require('webworker-promise/lib/node-worker');
+ * const path = require('path');
+ *
+ * const workerPath = path.join(__dirname, './worker');
+ * const worker = new WebworkerPromise(new Worker(workerPath));
+ * ```
+ *
+ */
+declare class NodeWorker {
+  constructor(filePath: string);
+}

src/pool.d.ts

@@ -0,0 +1,104 @@
+import NodeWorker = require("./node-worker");
+
+export = WorkerPool;
+
+/**
+ * Dynamic pool for workers.
+ *
+ * Note: It's experimental feature, and api may be changed
+ *
+ * @example
+ *
+ * ```
+ * const pool = WorkerPool.create({
+ *      src: './test.worker.js',
+ *      // or
+ *      create: () => new Worker('./test.worker.js'),
+ *      maxThreads: 3, // optional, default is 2, max numbers of workers to create if necessary
+ *      maxConcurrentPerWorker: 1, // optional, default is 1
+ *  });
+ *
+ *  pool.postMessage('hello').then(() => {
+ *      console.log('result');
+ *  });
+ * ```
+ */
+declare class WorkerPool {
+  static create(
+    workerPoolOptions:
+      | WorkerPool.WorkerPoolSrcOptions
+      | WorkerPool.WorkerPoolCreateOptions
+  ): WorkerPool;
+  /**
+   * Trigger the main worker function.
+   * The 'onEvent' function is scoped to the 'emit' passed into the main function and is not triggered by global emits from the worker.
+   *
+   * @param message Data to send to worker
+   * @param transferableList List of transferables to send to worker
+   * @param onEvent Eventhandler for `emit` calls from the worker
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * registerWebworker((message) => {
+   *      return `Hello ${message}!`;
+   * });
+   *
+   * // main.js
+   * worker.postMessage('world').then((response) => {
+   *      console.log(response); // Hello world!
+   * })
+   * ```
+   */
+  postMessage(
+    message: any,
+    transferableList?: Transferable[],
+    onEvent?: (eventName: string, message: any) => void
+  ): Promise<any>;
+
+  /**
+   * Trigger an operation that is registered via the `operation` function in the worker.
+   * The 'onEvent' function is scoped to the 'emit' passed into the `operation` function and is not triggered by global emits from the worker.
+   *
+   * @param operationName Name of the operation
+   * @param message Data to send to worker
+   * @param transferableList List of transferables to send to worker
+   * @param onEvent Eventhandler for `emit` calls from the worker
+   *
+   * @example
+   *
+   * ```
+   * // worker.js
+   * registerWebworker().operation('greet', (message) => {
+   *      return `Hello ${message}!`;
+   * });
+   *
+   * // main.js
+   * worker.exec('greet', 'world').then((response) => {
+   *      console.log(response); // Hello world!
+   * })
+   * ```
+   */
+  exec(
+    operationName: string,
+    message?: any,
+    transferableList?: Transferable[],
+    onEvent?: (eventName: string, message: any) => void
+  ): Promise<any>;
+}
+
+declare namespace WorkerPool {
+  interface WorkerPoolSharedOptions {
+    maxThreads?: number;
+    maxConcurrentPerWorker?: number;
+  }
+
+  interface WorkerPoolSrcOptions extends WorkerPoolSharedOptions {
+    src: string;
+  }
+
+  interface WorkerPoolCreateOptions extends WorkerPoolSharedOptions {
+    create: () => Worker | NodeWorker;
+  }
+}