@angular-wave/angular.ts 0.1.3 → 0.1.5

package/src/core/q/q.js

@@ -1,5 +1,4 @@
 import {
-  forEach,
   minErr,
   isUndefined,
   isFunction,
@@ -10,19 +9,34 @@ import {
   isPromiseLike,
 } from "../../shared/utils";
 
+/**
+ * @typedef {Object} QService
+ * @property {function():Deferred<any>} defer
+ * @property {function(any?):QPromise<any>} all
+ * @property {function(any?):any} resolve
+ * @property {function(any):any} reject
+ */
+
+/**
+ * @typedef {Object} PromiseState
+ * @property {?number} status
+ * @property {PromiseResolvables[]} [pending]
+ * @property {boolean} processScheduled
+ * @property {any} [value]
+ * @property {boolean} pur
+ */
+
+/**
+ * @typedef {Object} PromiseResolvables
+ * @property {any} result
+ * @property {function(any):any} onFulfilled
+ * @property {function(any):any} onRejected
+ */
+
 /**
  * @template T
  * @typedef {Object} QPromise
- * @property {function(
- *   ((value: T) => (PromiseLike<never>|PromiseLike<T>|T))|null,
- *   ((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null,
- *   ((state: any) => any)=
- * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
- * @property {function(
- *   ((value: T) => (QPromise<never>|QPromise<T>|T))|null,
- *   ((reason: any) => (QPromise<never>|QPromise<never>|never))|null,
- *   ((state: any) => any)
- * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
+ * @property {function(any,any?): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
  * @property {function(((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
  * @property {function(((reason: any) => (QPromise<never>|QPromise<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
  * @property {function(Array.<QPromise<T>>): QPromise<T>} all
@@ -40,9 +54,12 @@ import {
  * @property {QPromise<T>} promise - The promise associated with this deferred object.
  */
 
-export function $QProvider() {
-  let errorOnUnhandledRejections = true;
-  this.$get = [
+export class $QProvider {
+  constructor() {
+    this.errorOn = true;
+  }
+
+  $get = [
     "$rootScope",
     "$exceptionHandler",
     /**
@@ -59,7 +76,7 @@ export function $QProvider() {
           );
         },
         $exceptionHandler,
-        errorOnUnhandledRejections,
+        this.errorOn,
       );
     },
   ];
@@ -72,38 +89,40 @@ export function $QProvider() {
    * @returns {boolean|$QProvider} Current value when called without a new value or self for
    *    chaining otherwise.
    */
-  this.errorOnUnhandledRejections = function (value) {
+  errorOnUnhandledRejections(value) {
     if (isDefined(value)) {
-      errorOnUnhandledRejections = value;
+      this.errorOn = value;
       return this;
     }
-    return errorOnUnhandledRejections;
-  };
+    return this.errorOn;
+  }
 }
 
-export function $$QProvider() {
-  let errorOnUnhandledRejections = true;
-  this.$get = [
-    "$browser",
+export class $$QProvider {
+  constructor() {
+    this.errorOn = true;
+  }
+
+  $get = [
     "$exceptionHandler",
-    function ($browser, $exceptionHandler) {
+    function ($exceptionHandler) {
       return qFactory(
         (callback) => {
-          $browser.defer(callback);
+          window.setTimeout(callback);
         },
         $exceptionHandler,
-        errorOnUnhandledRejections,
+        this.errorOn,
       );
     },
   ];
 
-  this.errorOnUnhandledRejections = function (value) {
+  errorOnUnhandledRejections(value) {
     if (isDefined(value)) {
-      errorOnUnhandledRejections = value;
+      this.errorOn = value;
       return this;
     }
-    return errorOnUnhandledRejections;
-  };
+    return this.errorOn;
+  }
 }
 
 /**
@@ -119,53 +138,48 @@ export function $$QProvider() {
 function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
   const $qMinErr = minErr("$q");
   let queueSize = 0;
-  const checkQueue = [];
-
   /**
-   * Creates a `Deferred` object which represents a task which will finish in the future.
-   *
-   * @returns {Deferred} Returns a new instance of deferred.
+   * @type {PromiseState[]}
    */
-  function defer() {
-    return new Deferred();
-  }
+  const checkQueue = [];
 
-  function Deferred() {
-    const promise = (this.promise = new QPromise());
-    // Non prototype methods necessary to support unbound execution :/
-    this.resolve = function (val) {
-      resolvePromise(promise, val);
-    };
-    this.reject = function (reason) {
-      rejectPromise(promise, reason);
-    };
-    this.notify = function (progress) {
-      notifyPromise(promise, progress);
-    };
+  class Deferred {
+    constructor() {
+      this.promise = new QPromise();
+      this.resolve = (val) => resolvePromise(this.promise, val);
+      this.reject = (reason) => rejectPromise(this.promise, reason);
+    }
   }
 
   class QPromise {
     constructor() {
-      this.$$state = { status: 0 };
+      /** @type {PromiseState} */
+      this.$$state = {
+        status: 0,
+        pending: undefined,
+        processScheduled: false,
+        pur: false,
+      };
     }
 
-    then(onFulfilled, onRejected, progressBack) {
-      if (
-        isUndefined(onFulfilled) &&
-        isUndefined(onRejected) &&
-        isUndefined(progressBack)
-      ) {
+    /**
+     * Calls one of the success or error callbacks asynchronously as soon as the result is available.
+     * @param {*} onFulfilled
+     * @param {*} onRejected
+     * @returns
+     */
+    then(onFulfilled, onRejected) {
+      if (isUndefined(onFulfilled) && isUndefined(onRejected)) {
         return this;
       }
       const result = new QPromise();
 
       this.$$state.pending = this.$$state.pending || [];
-      this.$$state.pending.push([
-        result,
-        onFulfilled,
-        onRejected,
-        progressBack,
-      ]);
+      this.$$state.pending.push({
+        result: result,
+        onFulfilled: onFulfilled,
+        onRejected: onRejected,
+      });
       if (this.$$state.status > 0) scheduleProcessQueue(this.$$state);
 
       return result;
@@ -175,28 +189,29 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
       return this.then(null, callback);
     }
 
-    finally(callback, progressBack) {
+    finally(callback) {
       return this.then(
         (value) => handleCallback(value, resolve, callback),
         (error) => handleCallback(error, reject, callback),
-        progressBack,
       );
     }
   }
 
+  /**
+   * @param {PromiseState} state
+   */
   function processQueue(state) {
-    let fn;
-    let promise;
-    let pending;
-
-    pending = state.pending;
     state.processScheduled = false;
-    state.pending = undefined;
     try {
-      for (let i = 0, ii = pending.length; i < ii; ++i) {
-        markQStateExceptionHandled(state);
-        promise = pending[i][0];
-        fn = pending[i][state.status];
+      for (let i = 0, ii = state.pending.length; i < ii; ++i) {
+        state.pur = true;
+        const promise = state.pending[i].result;
+        let fn;
+        if (state.status === 1) {
+          fn = state.pending[i].onFulfilled;
+        } else {
+          fn = state.pending[i].onRejected;
+        }
         try {
           if (isFunction(fn)) {
             resolvePromise(promise, fn(state.value));
@@ -207,10 +222,6 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
           }
         } catch (e) {
           rejectPromise(promise, e);
-          // This error is explicitly marked for being passed to the $exceptionHandler
-          if (e && e.$$passToExceptionHandler === true) {
-            exceptionHandler(e);
-          }
         }
       }
     } finally {
@@ -218,6 +229,7 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
       if (errorOnUnhandledRejections && queueSize === 0) {
         nextTick(processChecks);
       }
+      state.pending = undefined;
     }
   }
 
@@ -225,7 +237,7 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     while (!queueSize && checkQueue.length) {
       const toCheck = checkQueue.shift();
       if (!isStateExceptionHandled(toCheck)) {
-        markQStateExceptionHandled(toCheck);
+        toCheck.pur = true;
         const errorMessage = `Possibly unhandled rejection: ${toDebugString(toCheck.value)}`;
         if (isError(toCheck.value)) {
           exceptionHandler(toCheck.value, errorMessage);
@@ -236,6 +248,9 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     }
   }
 
+  /**
+   * @param {PromiseState} state
+   */
   function scheduleProcessQueue(state) {
     if (
       errorOnUnhandledRejections &&
@@ -256,6 +271,11 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     });
   }
 
+  /**
+   * @param {QPromise} promise
+   * @param {*} val
+   * @returns
+   */
   function resolvePromise(promise, val) {
     if (promise.$$state.status) return;
     if (val === promise) {
@@ -272,6 +292,11 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     }
   }
 
+  /**
+   *
+   * @param {QPromise} promise
+   * @param {*} val
+   */
   function $$resolve(promise, val) {
     let then;
     let done = false;
@@ -279,7 +304,7 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
       if (isObject(val) || isFunction(val)) then = val.then;
       if (isFunction(then)) {
         promise.$$state.status = -1;
-        then.call(val, doResolve, doReject, doNotify);
+        then.call(val, doResolve, doReject);
       } else {
         promise.$$state.value = val;
         promise.$$state.status = 1;
@@ -299,45 +324,29 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
       done = true;
       $$reject(promise, val);
     }
-    function doNotify(progress) {
-      notifyPromise(promise, progress);
-    }
   }
 
+  /**
+   * @param {QPromise} promise
+   * @param {*} reason
+   * @returns
+   */
   function rejectPromise(promise, reason) {
     if (promise.$$state.status) return;
     $$reject(promise, reason);
   }
 
+  /**
+   * @param {QPromise} promise
+   * @param {*} reason
+   * @returns
+   */
   function $$reject(promise, reason) {
     promise.$$state.value = reason;
     promise.$$state.status = 2;
     scheduleProcessQueue(promise.$$state);
   }
 
-  function notifyPromise(promise, progress) {
-    const callbacks = promise.$$state.pending;
-
-    if (promise.$$state.status <= 0 && callbacks && callbacks.length) {
-      nextTick(() => {
-        let callback;
-        let result;
-        for (let i = 0, ii = callbacks.length; i < ii; i++) {
-          result = callbacks[i][0];
-          callback = callbacks[i][3];
-          try {
-            notifyPromise(
-              result,
-              isFunction(callback) ? callback(progress) : progress,
-            );
-          } catch (e) {
-            exceptionHandler(e);
-          }
-        }
-      });
-    }
-  }
-
   /**
    * Creates a promise that is resolved as rejected with the specified `reason`. This api should be
    * used to forward rejection in a chain of promises. If you are dealing with the last promise in
@@ -348,22 +357,6 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
    * a promise error callback and you want to forward the error to the promise derived from the
    * current promise, you have to "rethrow" the error by returning a rejection constructed via
    * `reject`.
-   *
-   * ```js
-   *   promiseB = promiseA.then(function(result) {
-   *     // success: do something and resolve promiseB
-   *     //          with the old or a new result
-   *     return result;
-   *   }, function(reason) {
-   *     // error: handle the error if possible and
-   *     //        resolve promiseB with newPromiseOrValue,
-   *     //        otherwise forward the rejection to promiseB
-   *     if (canHandle(reason)) {
-   *      // handle the error and recover
-   *      return newPromiseOrValue;
-   *     }
-   *     return $q.reject(reason);
-   *   });
    * ```
    *
    * @param {*} reason Constant, message, exception or an object representing the rejection reason.
@@ -396,27 +389,15 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
    * @param {*} value Value or a promise
    * @param {Function=} successCallback
    * @param {Function=} errorCallback
-   * @param {Function=} progressCallback
    * @returns {QPromise} Returns a promise of the passed value or promise
    */
 
-  function when(value, successCallback, errorCallback, progressCallback) {
+  function resolve(value, successCallback, errorCallback) {
     const result = new QPromise();
     resolvePromise(result, value);
-    return result.then(successCallback, errorCallback, progressCallback);
+    return result.then(successCallback, errorCallback);
   }
 
-  /**
-   * Alias of {@link when} to maintain naming consistency with ES6.
-   *
-   * @param {*} value Value or a promise
-   * @param {Function=} successCallback
-   * @param {Function=} errorCallback
-   * @param {Function=} progressCallback
-   * @returns {Promise} Returns a promise of the passed value or promise
-   */
-  let resolve = when;
-
   /**
    * Combines multiple promises into a single promise that is resolved when all of the input
    * promises are resolved.
@@ -433,9 +414,9 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     let counter = 0;
     const results = Array.isArray(promises) ? [] : {};
 
-    forEach(promises, (promise, key) => {
+    Object.entries(promises).forEach(([key, promise]) => {
       counter++;
-      when(promise).then(
+      resolve(promise).then(
         (value) => {
           results[key] = value;
           if (!--counter) resolvePromise(result, results);
@@ -463,10 +444,10 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
    */
 
   function race(promises) {
-    const deferred = defer();
+    const deferred = new Deferred();
 
-    forEach(promises, (promise) => {
-      when(promise).then(deferred.resolve, deferred.reject);
+    promises.forEach((promise) => {
+      resolve(promise).then(deferred.resolve, deferred.reject);
     });
 
     return deferred.promise;
@@ -486,26 +467,16 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
 
     const promise = new QPromise();
 
-    function resolveFn(value) {
-      resolvePromise(promise, value);
-    }
-
-    function rejectFn(reason) {
-      rejectPromise(promise, reason);
-    }
-
-    resolver(resolveFn, rejectFn);
+    resolver(
+      (value) => resolvePromise(promise, value),
+      (reason) => rejectPromise(promise, reason),
+    );
 
     return promise;
   }
 
-  // Let's make the instanceof operator work for promises, so that
-  // `new $q(fn) instanceof $q` would evaluate to true.
-  $Q.prototype = QPromise.prototype;
-
-  $Q.defer = defer;
+  $Q.defer = () => new Deferred();
   $Q.reject = reject;
-  $Q.when = when;
   $Q.resolve = resolve;
   $Q.all = all;
   $Q.race = race;
@@ -516,15 +487,13 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
 function isStateExceptionHandled(state) {
   return !!state.pur;
 }
-function markQStateExceptionHandled(state) {
-  state.pur = true;
-}
+
 export function markQExceptionHandled(q) {
   // Built-in `$q` promises will always have a `$$state` property. This check is to allow
   // overwriting `$q` with a different promise library (e.g. Bluebird + angular-bluebird-promises).
   // (Currently, this is the only method that might be called with a promise, even if it is not
   // created by the built-in `$q`.)
   if (q.$$state) {
-    markQStateExceptionHandled(q.$$state);
+    q.$$state.pur = true;
   }
 }

package/src/core/q/q.md

@@ -68,24 +68,6 @@
 
   ```
 
-- // for the purpose of this example let's assume that variables `$q` and `okToGreet`
-- // are available in the current lexical scope (they could have been injected or passed in).
--
-- function asyncGreet(name) {
--     let deferred = $q.defer();
--
--     setTimeout(function() {
--       deferred.notify('About to greet ' + name + '.');
--
--       if (okToGreet(name)) {
--         deferred.resolve('Hello, ' + name + '!');
--       } else {
--         deferred.reject('Greeting ' + name + ' is not allowed.');
--       }
--     }, 1000);
--
--     return deferred.promise;
-- }
 -
 - let promise = asyncGreet('Robin Hood');
 - promise.then(function(greeting) {