update jaasync and add timeout option to scan

package.json

@@ -37,15 +37,15 @@
   "license": "MIT",
   "dependencies": {
     "core-decorators": "^0.20.0",
-    "jaasync": "^0.10.1"
+    "jaasync": "^0.11.0"
   },
   "devDependencies": {
     "@types/jasmine": "^3.3.0",
     "@types/node": "^10.17.3",
     "jasmine": "^3.3.0",
     "jasmine-spec-reporter": "^7.0.0",
     "tslint": "^6.1.3",
-    "typedoc": "^0.23.0",
+    "typedoc": "0.23.0-beta.5",
     "typescript": "^4.7.4"
   }
 }

src/scanner.ts

@@ -107,7 +107,7 @@ export class Scanner<TResult> implements CancelablePromise<TResult> {
     return this._promise.finally(onfinally);
   }
 
-  public cancel(reason?: string): boolean {
+  public cancel(reason?: string|Error): boolean {
     if(this.settle()) {
       this._promise.reject(reason);
       return true;

src/strongbus.ts

@@ -1,6 +1,6 @@
 
 import {autobind} from 'core-decorators';
-import {CancelablePromise, cancelable} from 'jaasync';
+import {CancelablePromise, cancelable, timeout} from 'jaasync';
 
 import {Scanner} from './scanner';
 import {StrongbusLogger} from './strongbusLogger';
@@ -267,32 +267,47 @@ export class Bus<TEventMap extends Events.EventMap = Events.EventMap> implements
    * @param params.evaluator - an evaluation function that should check for a certain state
    * and may resolve or reject the scan based on the state.
    * @param params.trigger - event or events that should trigger evaluator
+   * @param {boolean} [params.pool=true] - attempt to pool scanners that can be resolved by the same evaluator and trigger; default is `true`
+   * @param {integer} [params.timeout] - cancel the scan after `params.timeout` milliseconds. Values `<= 0` are ignored. If configured, will disable pooling regardles of `params.pool`'s value
    * @param {boolean} [params.eager=true] - should `params.evaluator` be called immediately; default is `true`.
    * This eliminates the following anti-pattern:
    * ```
    * if(!someCondition) {
    *  await this.scan({evaluator: evaluateSomeCondition, trigger: ...});
    * }
    * ```
-   * @param {boolean} [params.pool=true] - attempt to pool scanners that can be resolved by the same evaluator and trigger; default is `true`
    */
   public scan<TEvaluator extends Scanner.Evaluator<any, TEventMap>>(
     params: {
       evaluator: TEvaluator;
       trigger: Events.Listenable<EventKeys<TEventMap>>;
       eager?: boolean;
       pool?: boolean;
+      timeout?: number;
   }): CancelablePromise<TEvaluator extends Scanner.Evaluator<infer U, TEventMap> ? U : any> {
 
     type TReturnType = TEvaluator extends Scanner.Evaluator<infer U, TEventMap> ? U : any;
 
-    if(params.pool === false) {
+    if(params.timeout && params.timeout > 0) {
+      const scanner = new Scanner<TReturnType>(params);
+      scanner.scan<TEventMap>(this, params.trigger);
+      // tslint:disable-next-line:prefer-object-spread
+      return Object.assign(
+        timeout(scanner, {ms: params.timeout, cancelUnderlyingPromiseOnTimeout: true}),
+        {
+          [INTERNAL_PROMISE]: scanner,
+          cancel: (err: any) => scanner.cancel(err)
+        }
+      );
+    } else if(params.pool === false) {
       const scanner = new Scanner<TReturnType>(params);
       scanner.scan<TEventMap>(this, params.trigger);
+      // tslint:disable-next-line:prefer-object-spread
       return Object.assign(
-        cancelable(() => scanner),
+        scanner,
         {[INTERNAL_PROMISE]: scanner}
       );
+
     }
 
     /*