@angular-wave/angular.ts 0.0.33 → 0.0.35

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/core/root-scope.js

@@ -21,6 +21,13 @@ export const ScopePhase = {
   DIGEST: 2,
 };
 
+/**
+ * @typedef {Object} AsyncQueueTask
+ * @property {Scope} scope
+ * @property {Function} fn
+ * @property {Object} locals
+ */
+
 /**
  *
  * The default number of `$digest` iterations the scope should attempt to execute before giving up and
@@ -34,6 +41,8 @@ export const ScopePhase = {
 export const TTL = 10;
 
 const $rootScopeMinErr = minErr("$rootScope");
+
+/** @type {AsyncQueueTask[]} */
 const $$asyncQueue = [];
 const $$postDigestQueue = [];
 const $$applyAsyncQueue = [];
@@ -122,9 +131,9 @@ export function getQueues() {
   };
 }
 
-/**
- * @type {angular.IScope}
- */
+// /**
+//  * @type {angular.Scope}
+//  */
 class Scope {
   constructor() {
     /**
@@ -136,35 +145,68 @@ class Scope {
     this.$$phase = ScopePhase.NONE;
 
     /**
-     * @type {?angular.IScope} Reference to the parent scope.
+     * @type {?Scope} Reference to the parent scope.
      */
     this.$parent = null;
 
     /**
-     * @type {?angular.IScope}
+     * @type {?Scope}
      */
     this.$root = this;
 
-    this.$$watchers = null;
+    /** @type {Array} */
+    this.$$watchers = [];
+
+    /**
+     * @type {number}
+     */
+    this.$$digestWatchIndex = -1;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$nextSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$prevSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childHead = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childTail = null;
+
+    /** @type {boolean} */
     this.$$destroyed = false;
+
+    // TODO use maps
+    /** @type {boolean} */
     this.$$suspended = false;
+
+    // TODO use maps
+    /** @type {object} */
     this.$$listeners = {};
+
+    /** @type {object} */
     this.$$listenerCount = {};
+
+    /** @type {number} */
     this.$$watchersCount = 0;
     this.$$isolateBindings = null;
 
     /**
-     * @type {Scope}
+     * @type {?Scope}
      */
     this.$$ChildScope = null;
   }
 
   /**
-   * @description
    * Creates a new child {@link Scope}.
    *
    * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event.
@@ -179,24 +221,25 @@ class Scope {
    *         When creating widgets, it is useful for the widget to not accidentally read parent
    *         state.
    *
-   * @param {?angular.IScope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+   * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
    *                              of the newly created scope. Defaults to `this` scope if not provided.
    *                              This is used when creating a transclude scope to correctly place it
    *                              in the scope hierarchy while maintaining the correct prototypical
    *                              inheritance.
    *
-   * @returns {angular.IScope} The newly created child scope.
+   * @returns {Scope} The newly created child scope.
    *
    */
   $new(isolate, parent) {
+    /** @type {Scope} */
     let child;
     if (isolate) {
       child = new Scope();
-      child.$root = this.$root;
+      child.$root = rootScope;
     } else {
       child = Object.create(this);
       child.$id = nextUid();
-      child.$$watchers = null;
+      child.$$watchers = [];
       child.$$nextSibling = null;
       child.$$childHead = null;
       child.$$childTail = null;
@@ -206,6 +249,7 @@ class Scope {
       child.$$ChildScope = null;
       child.$$suspended = false;
     }
+
     child.$parent = parent || this;
     child.$$prevSibling = child.$parent.$$childTail;
     if (child.$parent.$$childHead) {
@@ -222,9 +266,13 @@ class Scope {
     // when the parent scope is destroyed.
     // The listener needs to be added after the parent is set
     if (isolate || parent !== this) {
-      child.$on("$destroy", ($event) => {
-        $event.currentScope.$$destroyed = true;
-      });
+      child.$on(
+        "$destroy",
+        /** @param {angular.IAngularEvent} $event */
+        ($event) => {
+          $event.currentScope.$$destroyed = true;
+        },
+      );
     }
     return child;
   }
@@ -352,8 +400,7 @@ class Scope {
     if (get.$$watchDelegate) {
       return get.$$watchDelegate(this, fn, objectEquality, get, watchExp);
     }
-    const scope = this;
-    let array = scope.$$watchers;
+
     const watcher = {
       fn,
       last: initWatchVal,
@@ -364,23 +411,21 @@ class Scope {
 
     lastDirtyWatch = null;
 
-    if (!array) {
-      array = scope.$$watchers = [];
-      array.$$digestWatchIndex = -1;
+    if (this.$$watchers.length == 0) {
+      this.$$digestWatchIndex = -1;
     }
     // we use unshift since we use a while loop in $digest for speed.
     // the while loop reads in reverse order.
-    array.unshift(watcher);
-    array.$$digestWatchIndex++;
+    this.$$watchers.unshift(watcher);
+    this.$$digestWatchIndex++;
     this.incrementWatchersCount(1);
-    const self = this;
 
-    return function deregisterWatch() {
-      const index = arrayRemove(array, watcher);
+    return () => {
+      const index = arrayRemove(this.$$watchers, watcher);
       if (index >= 0) {
-        self.incrementWatchersCount(-1);
-        if (index < array.$$digestWatchIndex) {
-          array.$$digestWatchIndex--;
+        this.incrementWatchersCount(-1);
+        if (index < this.$$digestWatchIndex) {
+          this.$$digestWatchIndex--;
         }
       }
       lastDirtyWatch = null;
@@ -715,7 +760,7 @@ class Scope {
     let ttl = TTL;
     let next;
     /**
-     * @type {angular.IScope}
+     * @type {Scope}
      */
     let current;
     const target = $$asyncQueue.length ? this.$root : this;
@@ -731,7 +776,7 @@ class Scope {
     if (this === this.$root && applyAsyncId !== null) {
       // If this is the root scope, and $applyAsync has scheduled a deferred $apply(), then
       // cancel the scheduled $apply and flush the queue of expressions to be evaluated.
-      $browser.defer.cancel(applyAsyncId);
+      $browser.cancel(applyAsyncId);
       flushApplyAsync();
       applyAsyncId = null;
     }
@@ -765,10 +810,10 @@ class Scope {
         // "traverse the scopes" loop
         if ((watchers = !current.$$suspended && current.$$watchers)) {
           // process our watches
-          watchers.$$digestWatchIndex = watchers.length;
-          while (watchers.$$digestWatchIndex--) {
+          current.$$digestWatchIndex = watchers.length;
+          while (current.$$digestWatchIndex--) {
             try {
-              watch = watchers[watchers.$$digestWatchIndex];
+              watch = watchers[current.$$digestWatchIndex];
               // Most common watches are on primitives, in which case we can short
               // circuit it with === operator, only when === fails do we use .equals
               if (watch) {
@@ -1072,7 +1117,7 @@ class Scope {
      expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
  * ```
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularJS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with the current `scope` parameter.
@@ -1180,7 +1225,7 @@ class Scope {
  *    expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
  *
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularJS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with current `scope` parameter.
@@ -1261,7 +1306,7 @@ class Scope {
    *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
    *
    * @param {string} name Event name to listen on.
-   * @param {function(event, ...args)} listener Function to call when the event is emitted.
+   * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {

package/src/core/timeout.js

@@ -103,7 +103,7 @@ export function $timeout($rootScope, $browser, $q, $$q, $exceptionHandler) {
     deferred.reject("canceled");
     delete deferreds[id];
 
-    return $browser.defer.cancel(id);
+    return $browser.cancel(id);
   };
 
   return timeout;

package/src/directive/input.js

@@ -727,7 +727,7 @@ function baseInputType(scope, element, attr, ctrl, $browser) {
 
   let listener = function (ev) {
     if (timeout) {
-      $browser.defer.cancel(timeout);
+      $browser.cancel(timeout);
       timeout = null;
     }
     if (composing) return;

package/src/router/services.js

@@ -6,7 +6,6 @@
  *
  * The optional [[$resolve]] service is also documented here.
  *
- * @preferred @publicapi @module ng1
  */
 import { services } from "./common/coreservices";
 import { unnestR } from "../shared/common";

package/src/services/browser.js

@@ -243,7 +243,7 @@ export function Browser($log, $$taskTrackerFactory) {
    * @param {function()} fn A function, who's execution should be deferred.
    * @param {number=} [delay=0] Number of milliseconds to defer the function execution.
    * @param {string=} [taskType=DEFAULT_TASK_TYPE] The type of task that is deferred.
-   * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
+   * @returns {*} DeferId that can be used to cancel the task via `$browser.cancel()`.
    *
    * @description
    * Executes a fn asynchronously via `setTimeout(fn, delay)`.
@@ -270,7 +270,7 @@ export function Browser($log, $$taskTrackerFactory) {
   };
 
   /**
-   * @name $browser#defer.cancel
+   * @name $browser#cancel
    *
    * @description
    * Cancels a deferred task identified with `deferId`.
@@ -279,7 +279,7 @@ export function Browser($log, $$taskTrackerFactory) {
    * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
    *                    canceled.
    */
-  self.defer.cancel = function (deferId) {
+  self.cancel = function (deferId) {
     if (Object.prototype.hasOwnProperty.call(pendingDeferIds, deferId)) {
       const taskType = pendingDeferIds[deferId];
       delete pendingDeferIds[deferId];

package/src/services/http.js

@@ -1,3 +1,4 @@
+import { ScopePhase } from "../core/root-scope";
 import { urlIsAllowedOriginFactory } from "../core/urlUtils";
 import {
   minErr,

package/test/core/parse.spec.js

@@ -3486,6 +3486,19 @@ describe("parser", () => {
   });
 
   describe("with primitive input", () => {
+    beforeEach(() => {
+      createInjector([
+        "ng",
+        function ($filterProvider) {
+          filterProvider = $filterProvider;
+        },
+      ]).invoke((_$rootScope_, _$parse_) => {
+        scope = _$rootScope_;
+        $parse = _$parse_;
+      });
+      logs = [];
+    });
+
     it("should not be reevaluated when passed literals", () => {
       let filterCalls = 0;
       filterProvider.register(

package/test/core/scope.spec.js

@@ -2630,7 +2630,7 @@ describe("Scope", function () {
       const scope = $rootScope.$new();
       let id = scope.$applyAsync('x = "CODE ORANGE"');
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect(scope.x).toBe("CODE ORANGE");
         expect($rootScope.x).toBeUndefined();
@@ -2644,8 +2644,8 @@ describe("Scope", function () {
       let id1 = $rootScope.$applyAsync('x.push("expr1")');
       let id2 = $rootScope.$applyAsync('x.push("expr2")');
 
-      $browser.defer.cancel(id1);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id1);
+      $browser.cancel(id2);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2660,7 +2660,7 @@ describe("Scope", function () {
         expect($browser.deferredFns.length).toBe(0);
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2672,7 +2672,7 @@ describe("Scope", function () {
         throw "OOPS";
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       expect(logs).toEqual([]);
       setTimeout(() => expect(logs[0]).toEqual("OOPS"));
     });
@@ -2683,14 +2683,14 @@ describe("Scope", function () {
       });
       let id2 = $rootScope.$applyAsync('x = "All good!"');
 
-      $browser.defer.cancel(id);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id);
+      $browser.cancel(id2);
       setTimeout(() => expect($rootScope.x).toBe("All good!"));
       expect($rootScope.x).toBeUndefined();
     });
 
     it("should be cancelled if a $rootScope digest occurs before the next tick", () => {
-      const cancel = spyOn($browser.defer, "cancel").and.callThrough();
+      const cancel = spyOn($browser, "cancel").and.callThrough();
       const expression = jasmine.createSpy("expr");
 
       $rootScope.$applyAsync(expression);

package/test/core/timeout.spec.js

@@ -325,7 +325,7 @@ describe("$timeout", () => {
     });
 
     it("should forget references to relevant deferred", () => {
-      // $browser.defer.cancel is only called on cancel if the deferred object is still referenced
+      // $browser.cancel is only called on cancel if the deferred object is still referenced
       const cancelSpy = spyOn($browser.defer, "cancel").and.callThrough();
 
       const promise = $timeout(() => {}, 0, false);