npm - @angular-wave/angular.ts - Versions diffs - 0.1.4 → 0.1.5 - Mend

@angular-wave/angular.ts 0.1.4 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (749) hide show

package/package.json CHANGED Viewed

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/animations/animate-css.html CHANGED Viewed

@@ -49,7 +49,13 @@
     </style>
   </head>
   <body ng-app="test">
-    <div class="{{bool}}">{{bool}}</div>
+    <div ng-if="bool" id="data-animate" class="fade" data-animate="true">
+      Fade me in out
+    </div>
+    <div ng-if="bool" id="animate" class="fade" animate="true">
+      Fade me in out
+    </div>
+    <div ng-if="bool" id="no-animate" class="fade">Fade me in out</div>
     <button ng-click="bool=true">Fade In!</button>
     <button ng-click="bool=false">Fade Out!</button>
   </body>

package/src/core/compile/compile.js CHANGED Viewed

@@ -155,7 +155,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
       directive.require || (directive.controller && directive.name);
     if (!Array.isArray(require) && isObject(require)) {
-      forEach(require, (value, key) => {
+      Object.entries(require).forEach(([key, value]) => {
         const match = value.match(REQUIRE_PREFIX_REGEXP);
         const name = value.substring(match[0].length);
         if (!name) require[key] = match[0] + key;
@@ -207,7 +207,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
            */
           function ($injector, $exceptionHandler) {
             const directives = [];
-            forEach(hasDirectives[name], (directiveFactory, index) => {
+            hasDirectives[name].forEach((directiveFactory, index) => {
               try {
                 let directive = $injector.invoke(directiveFactory);
                 if (isFunction(directive)) {
@@ -323,7 +323,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
       };
       // Copy annotations (starting with $) over to the DDO
-      forEach(options, (val, key) => {
+      Object.entries(options).forEach(([key, val]) => {
         if (key.charAt(0) === "$") ddo[key] = val;
       });
@@ -461,7 +461,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
    */
   (function registerNativePropertyContexts() {
     function registerContext(ctx, values) {
-      forEach(values, (v) => {
+      values.forEach((v) => {
         PROP_CONTEXTS[v.toLowerCase()] = ctx;
       });
     }
@@ -1257,7 +1257,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           childLinkFn,
           scope,
           linkNode,
-          $rootElement,
+          _,
           boundTranscludeFn,
         ) {
           let i;

package/src/core/interval/interval-factory.js CHANGED Viewed

@@ -40,7 +40,8 @@ export function $$IntervalFactoryProvider() {
             } else {
               $rootScope.$evalAsync(callback);
             }
-            deferred.notify(iteration++);
+            iteration++;
             if (count > 0 && iteration >= count) {
               deferred.resolve(iteration);

package/src/core/interval/interval.spec.js CHANGED Viewed

@@ -141,9 +141,7 @@ describe("$interval", () => {
     await wait(5);
     expect(log[0]).toEqual("tick");
-    expect(log[1]).toEqual("promise update: 0");
-    expect(log[2]).toEqual("tick");
-    expect(log[3]).toEqual("promise update: 1");
+    expect(log[1]).toEqual("tick");
   });
   it("should return a promise which will be resolved after the specified number of iterations", async () => {
@@ -163,19 +161,10 @@ describe("$interval", () => {
       (err) => {
         log.push(`promise error: ${err}`);
       },
-      (note) => {
-        log.push(`promise update: ${note}`);
-      },
     );
     expect(log).toEqual([]);
     await wait(15);
-    expect(log).toEqual([
-      "tick",
-      "promise update: 0",
-      "tick",
-      "promise update: 1",
-      "promise success: 2",
-    ]);
+    expect(log).toEqual(["tick", "tick", "promise success: 2"]);
   });
   describe("exception handling", () => {
@@ -204,29 +193,6 @@ describe("$interval", () => {
         done();
       }, 11);
     });
-    it("should still update the interval promise when an exception is thrown", (done) => {
-      const promise = $interval(() => {
-        errors = [];
-        throw "Some Error";
-      }, 102);
-      promise.then(
-        (value) => {
-          errors.push(`promise success: ${value}`);
-        },
-        (err) => {
-          errors.push(`promise error: ${err}`);
-        },
-        (note) => {
-          errors.push(`promise update: ${note}`);
-        },
-      );
-      setTimeout(() => {
-        expect(errors[1]).toEqual("promise update: 0");
-        done();
-      }, 102);
-    });
   });
   describe("cancel", () => {
@@ -261,9 +227,6 @@ describe("$interval", () => {
         (err) => {
           log.push(`promise error: ${err}`);
         },
-        (note) => {
-          log.push(`promise update: ${note}`);
-        },
       );
       expect(log).toEqual([]);
@@ -275,7 +238,7 @@ describe("$interval", () => {
         $rootScope.$apply(); // For resolving the promise -
         // necessary since q uses $rootScope.evalAsync.
-        expect(log).toEqual(["promise update: 0", "promise error: canceled"]);
+        expect(log).toEqual(["promise error: canceled"]);
         done();
       }, 2);
     });

package/src/core/q/q.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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) {