@angular-wave/angular.ts 0.4.2 → 0.4.4

package/src/core/prop.spec.js

@@ -34,13 +34,10 @@ fdescribe("ngProp*", () => {
     const element = $compile(
       '<button ng-prop-disabled="isDisabled">Button</button>',
     )($rootScope);
-    $rootScope.$digest();
     expect(element[0].disabled).toBe(false);
     $rootScope.isDisabled = true;
-    $rootScope.$digest();
     expect(element[0].disabled).toBe(true);
     $rootScope.isDisabled = false;
-    $rootScope.$digest();
     expect(element[0].disabled).toBe(false);
   });
 
@@ -50,33 +47,26 @@ fdescribe("ngProp*", () => {
     )($rootScope);
     expect(element[0].checked).toBe(false);
     $rootScope.isChecked = true;
-    $rootScope.$digest();
     expect(element[0].checked).toBe(true);
     $rootScope.isChecked = false;
-    $rootScope.$digest();
     expect(element[0].checked).toBe(false);
   });
 
   it("should bind string properties (title)", () => {
     const element = $compile('<span ng-prop-title="title" />')($rootScope);
     $rootScope.title = 123;
-    $rootScope.$digest();
     expect(element[0].title).toBe("123");
     $rootScope.title = "foobar";
-    $rootScope.$digest();
     expect(element[0].title).toBe("foobar");
   });
 
   it("should bind variable type properties", () => {
     const element = $compile('<span ng-prop-asdf="asdf" />')($rootScope);
     $rootScope.asdf = 123;
-    $rootScope.$digest();
     expect(element[0].asdf).toBe(123);
     $rootScope.asdf = "foobar";
-    $rootScope.$digest();
     expect(element[0].asdf).toBe("foobar");
     $rootScope.asdf = true;
-    $rootScope.$digest();
     expect(element[0].asdf).toBe(true);
   });
 
@@ -85,31 +75,24 @@ fdescribe("ngProp*", () => {
     const element = $compile('<span ng-prop-text="myText" />')($rootScope);
     // Initialize to truthy value
     $rootScope.myText = "abc";
-    $rootScope.$digest();
     expect(element[0].text).toBe("abc");
 
     // Assert various falsey values get assigned to the property
     $rootScope.myText = "";
-    $rootScope.$digest();
     expect(element[0].text).toBe("");
     $rootScope.myText = 0;
-    $rootScope.$digest();
     expect(element[0].text).toBe(0);
     $rootScope.myText = false;
-    $rootScope.$digest();
     expect(element[0].text).toBe(false);
     $rootScope.myText = undefined;
-    $rootScope.$digest();
     expect(element[0].text).toBeUndefined();
     $rootScope.myText = null;
-    $rootScope.$digest();
     expect(element[0].text).toBe(null);
   });
 
   it("should directly map special properties (class)", () => {
     const element = $compile('<span ng-prop-class="myText" />')($rootScope);
     $rootScope.myText = "abc";
-    $rootScope.$digest();
     expect(element[0].class).toBe("abc");
     expect(element[0]).not.toHaveClass("abc");
   });
@@ -117,7 +100,6 @@ fdescribe("ngProp*", () => {
   it("should support mixed case using underscore-separated names", () => {
     const element = $compile('<span ng-prop-a_bcd_e="value" />')($rootScope);
     $rootScope.value = 123;
-    $rootScope.$digest();
     expect(element[0].aBcdE).toBe(123);
   });
 
@@ -136,7 +118,6 @@ fdescribe("ngProp*", () => {
     const element = $compile("<a ng-prop-href=\"'test/' + value\"></a>")(
       $rootScope,
     );
-    $rootScope.$digest();
     expect(element[0].href).toMatch(/\/test\/test$/);
   });
 
@@ -158,7 +139,6 @@ fdescribe("ngProp*", () => {
       $rootScope,
     );
     $rootScope.asdf = 123;
-    $rootScope.$digest();
     expect(element[0].asdf).toBe(123);
     expect(element.attr("asdf")).toBe("foo");
   });
@@ -168,7 +148,6 @@ fdescribe("ngProp*", () => {
       $rootScope,
     );
     $rootScope.asdf = 123;
-    $rootScope.$digest();
     expect(element[0].asdf).toBe(123);
     expect(element.attr("asdf")).toBe("foo");
   });
@@ -278,7 +257,6 @@ fdescribe("ngProp*", () => {
       // Some browsers complain if you try to write `javascript:` into an `img[src]`
       // So for the test use something different
       $rootScope.testUrl = $sce.trustAsMediaUrl("someuntrustedthing:foo();");
-      $rootScope.$digest();
       expect(element[0].src).toEqual("someuntrustedthing:foo();");
     });
 
@@ -330,33 +308,27 @@ fdescribe("ngProp*", () => {
     it("should NOT require trusted values for trusted URI values", () => {
       $rootScope.testUrl = "http://example.com/image.png"; // `http` is trusted
       let element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("http://example.com/image.png");
 
       element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("http://example.com/image.png");
     });
 
     it("should accept trusted values for non-trusted URI values", () => {
       $rootScope.testUrl = $sce.trustAsUrl("javascript:foo()"); // `javascript` is not trusted
       let element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("javascript:foo()");
 
       element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("javascript:foo()");
     });
 
     it("should sanitize non-trusted values", () => {
       $rootScope.testUrl = "javascript:foo()"; // `javascript` is not trusted
       let element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("unsafe:javascript:foo()");
 
       element = $compile('<a ng-prop-href="testUrl"></a>')($rootScope);
-      $rootScope.$digest();
       expect(element[0].href).toEqual("unsafe:javascript:foo()");
     });
 
@@ -411,16 +383,9 @@ fdescribe("ngProp*", () => {
           "<foo ng-prop-href=\"'http://example.com/' + testUrl\"></foo><foo ng-prop-href=\"::'http://example.com/' + testUrl\"></foo>",
       )($rootScope);
       $rootScope.testUrl = [1];
-      $rootScope.$digest();
-
       $rootScope.testUrl = [];
-      $rootScope.$digest();
-
       $rootScope.testUrl = { a: "b" };
-      $rootScope.$digest();
-
       $rootScope.testUrl = {};
-      $rootScope.$digest();
     });
   });
 
@@ -638,7 +603,6 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = '<div onclick="">hello</div>';
-        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -647,10 +611,8 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = "hello";
-        $rootScope.$digest();
         expect(element.html()).toEqual("hello");
         $rootScope.html = "goodbye";
-        $rootScope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
 
@@ -660,11 +622,9 @@ fdescribe("ngProp*", () => {
         );
         $rootScope.html = '<div onclick="">hello</div>';
         expect($rootScope.$$watchers.length).toEqual(1);
-        $rootScope.$digest();
         expect(element.text()).toEqual("hello");
         expect($rootScope.$$watchers.length).toEqual(0);
         $rootScope.html = '<div onclick="">hello</div>';
-        $rootScope.$digest();
         expect(element.text()).toEqual("hello");
       });
     });
@@ -688,9 +648,7 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = '<div onclick="">hello</div>';
-        expect(() => {
-          $rootScope.$digest();
-        }).toThrowError(/unsafe/);
+        expect(() => {}).toThrowError(/unsafe/);
       });
 
       it("should NOT set html for wrongly typed values", () => {
@@ -698,9 +656,7 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = $sce.trustAsCss('<div onclick="">hello</div>');
-        expect(() => {
-          $rootScope.$digest();
-        }).toThrowError(/unsafe/);
+        expect(() => {}).toThrowError(/unsafe/);
       });
 
       it("should set html for trusted values", () => {
@@ -708,7 +664,6 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = $sce.trustAsHtml('<div onclick="">hello</div>');
-        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -717,10 +672,8 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = $sce.trustAsHtml("hello");
-        $rootScope.$digest();
         expect(element.html()).toEqual("hello");
         $rootScope.html = $sce.trustAsHtml("goodbye");
-        $rootScope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
 
@@ -734,7 +687,6 @@ fdescribe("ngProp*", () => {
         $rootScope.getHtml = function () {
           return $sce.trustAsHtml('<div onclick="">hello</div>');
         };
-        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -775,10 +727,8 @@ fdescribe("ngProp*", () => {
         $rootScope.getHtml = function () {
           return $sce.trustAsHtml(html);
         };
-        $rootScope.$digest();
         expect(element.html()).toEqual("hello");
         html = "goodbye";
-        $rootScope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
     });
@@ -788,24 +738,18 @@ fdescribe("ngProp*", () => {
     it("should NOT set style for untrusted values", () => {
       const element = $compile('<div ng-prop-style="style"></div>')($rootScope);
       $rootScope.style = "margin-left: 10px";
-      expect(() => {
-        $rootScope.$digest();
-      }).toThrowError(/unsafe/);
+      expect(() => {}).toThrowError(/unsafe/);
     });
 
     it("should NOT set style for wrongly typed values", () => {
       const element = $compile('<div ng-prop-style="style"></div>')($rootScope);
       $rootScope.style = $sce.trustAsHtml("margin-left: 10px");
-      expect(() => {
-        $rootScope.$digest();
-      }).toThrowError(/unsafe/);
+      expect(() => {}).toThrowError(/unsafe/);
     });
 
     it("should set style for trusted values", () => {
       const element = $compile('<div ng-prop-style="style"></div>')($rootScope);
       $rootScope.style = $sce.trustAsCss("margin-left: 10px");
-      $rootScope.$digest();
-
       expect(element[0].style["margin-left"]).toEqual("10px");
     });
   });

package/src/core/sce/sce.js

@@ -4,7 +4,6 @@ import {
   urlResolve,
 } from "./../url-utils/url-utils";
 import {
-  forEach,
   isFunction,
   isRegExp,
   isString,
@@ -731,7 +730,7 @@ export function SceProvider() {
       const { getTrusted } = sce;
       const { trustAs } = sce;
 
-      forEach(SCE_CONTEXTS, (enumValue, name) => {
+      Object.entries(SCE_CONTEXTS).forEach(([name, enumValue]) => {
         const lName = lowercase(name);
         sce[snakeToCamel(`parse_as_${lName}`)] = function (expr) {
           return parse(enumValue, expr);

package/src/core/sce/sce.spec.js

@@ -202,18 +202,14 @@ describe("SCE", () => {
         logs.push(`${value}`);
       });
 
-      $rootScope.$digest();
       expect(logs[0]).toEqual("undefined"); // initial listener call
 
       $rootScope.foo = $sce.trustAs($sce.HTML, "trustedValue");
       expect($rootScope.$$watchers.length).toBe(1);
-      $rootScope.$digest();
-
       expect($rootScope.$$watchers.length).toBe(0);
       expect(logs[1]).toEqual("trustedValue");
 
       $rootScope.foo = $sce.trustAs($sce.HTML, "anotherTrustedValue");
-      $rootScope.$digest();
       expect(logs[2]).toBeUndefined(); // watcher no longer active
     });
 
@@ -222,18 +218,14 @@ describe("SCE", () => {
         logs.push(`${value}`);
       });
 
-      $rootScope.$digest();
       expect(logs[0]).toEqual("undefined"); // initial listener call
 
       $rootScope.foo = $sce.trustAs($sce.URL, "trustedValue");
       expect($rootScope.$$watchers.length).toBe(1);
-      $rootScope.$digest();
-
       expect($rootScope.$$watchers.length).toBe(0);
       expect(logs[1]).toEqual("trustedValue");
 
       $rootScope.foo = $sce.trustAs($sce.URL, "anotherTrustedValue");
-      $rootScope.$digest();
       expect(logs[2]).toBeUndefined(); // watcher no longer active
     });
 

package/src/core/scope/scope.js

@@ -1,6 +1,5 @@
 import {
   concat,
-  forEach,
   minErr,
   nextUid,
   isFunction,
@@ -58,7 +57,7 @@ const $rootScopeMinErr = minErr("$rootScope");
 
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue = [];
-export const $$postDigestQueue = [];
+export const $postUpdateQueue = [];
 
 /**
  * @type {Function[]}
@@ -209,11 +208,6 @@ export class Scope {
     /** @type {number} */
     this.$$watchersCount = 0;
     this.$$isolateBindings = null;
-
-    /**
-     * @type {?Scope}
-     */
-    this.$$ChildScope = null;
   }
 
   /**
@@ -231,16 +225,11 @@ export class Scope {
    *         When creating widgets, it is useful for the widget to not accidentally read parent
    *         state.
    *
-   * @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 {Scope} The newly created child scope.
    *
    */
-  $new(isolate, parent) {
+  $new(isolate) {
     let child = isolate ? new Scope() : Object.create(this);
 
     if (isolate) {
@@ -255,11 +244,10 @@ export class Scope {
       child.$$listeners = new Map();
       child.$$listenerCount = {};
       child.$$watchersCount = 0;
-      child.$$ChildScope = null;
       child.$$suspended = false;
     }
 
-    child.$parent = parent || this;
+    child.$parent = this;
     child.$$prevSibling = child.$parent.$$childTail;
 
     if (child.$parent.$$childHead) {
@@ -271,7 +259,7 @@ export class Scope {
     }
 
     // Add a destroy listener if isolated or the parent differs from `this`
-    if (isolate || parent !== this) {
+    if (isolate) {
       child.$on("$destroy", ($event) => {
         $event.currentScope.$$destroyed = true;
       });
@@ -280,6 +268,49 @@ export class Scope {
     return child;
   }
 
+  /**
+   * Creates a transcluded scope
+   * @param {Scope} parent The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+   * of the newly created scope. This is used when creating a transclude scope to correctly place it
+   *  in the scope hierarchy while maintaining the correct prototypical inheritance.
+   *
+   * @returns {Scope} The newly created child scope.
+   *
+   */
+  $transcluded(parent) {
+    let child = Object.create(this);
+
+    // Initialize properties for a non-isolated child scope
+    child.$id = nextUid();
+    child.$$watchers = [];
+    child.$$nextSibling = null;
+    child.$$childHead = null;
+    child.$$childTail = null;
+    child.$$listeners = new Map();
+    child.$$listenerCount = {};
+    child.$$watchersCount = 0;
+    child.$$suspended = false;
+
+    child.$parent = parent || this;
+    child.$$prevSibling = child.$parent.$$childTail;
+
+    if (child.$parent.$$childHead) {
+      child.$parent.$$childTail.$$nextSibling = child;
+      child.$parent.$$childTail = child;
+    } else {
+      child.$parent.$$childHead = child;
+      child.$parent.$$childTail = child;
+    }
+
+    // Add a destroy listener if isolated or the parent differs from `this`
+    if (parent !== this) {
+      child.$on("$destroy", ($event) => {
+        $event.currentScope.$$destroyed = true;
+      });
+    }
+
+    return child;
+  }
   /**
  * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
  *
@@ -332,16 +363,16 @@ export class Scope {
      });
      expect(scope.counter).toEqual(0);
 
-     scope.$digest();
+     ;
      // the listener is always called during the first $digest loop after it was registered
      expect(scope.counter).toEqual(1);
 
-     scope.$digest();
+     ;
      // but now it will not be called unless the value changes
      expect(scope.counter).toEqual(1);
 
      scope.name = 'adam';
-     scope.$digest();
+     ;
      expect(scope.counter).toEqual(2);
 
      // Using a function as a watchExpression
@@ -363,12 +394,12 @@ export class Scope {
      expect(scope.foodCounter).toEqual(0);
 
      // Run the digest but since food has not changed count will still be zero
-     scope.$digest();
+     ;
      expect(scope.foodCounter).toEqual(0);
 
      // Update food and run digest.  Now the counter will increment
      food = 'cheeseburger';
-     scope.$digest();
+     ;
      expect(scope.foodCounter).toEqual(1);
 
  * ```
@@ -473,7 +504,7 @@ export class Scope {
       });
     }
 
-    forEach(watchExpressions, (expr, i) => {
+    Object.entries(watchExpressions).forEach(([i, expr]) => {
       const unwatchFn = self.$watch(expr, (value) => {
         newValues[i] = value;
         if (!changeReactionScheduled) {
@@ -675,7 +706,6 @@ export class Scope {
         }
       }
     }
-    // TODO: fix this type signature
     return this.$watch(changeDetector, $watchCollectionAction);
   }
 
@@ -711,16 +741,16 @@ export class Scope {
      });
      expect(scope.counter).toEqual(0);
 
-     scope.$digest();
+     ;
      // the listener is always called during the first $digest loop after it was registered
      expect(scope.counter).toEqual(1);
 
-     scope.$digest();
+     ;
      // but now it will not be called unless the value changes
      expect(scope.counter).toEqual(1);
 
      scope.name = 'adam';
-     scope.$digest();
+     ;
      expect(scope.counter).toEqual(2);
  * ```
  *
@@ -862,14 +892,14 @@ export class Scope {
     this.clearPhase();
 
     // postDigestQueuePosition isn't local here because this loop can be reentered recursively.
-    while (postDigestQueuePosition < $$postDigestQueue.length) {
+    while (postDigestQueuePosition < $postUpdateQueue.length) {
       try {
-        $$postDigestQueue[postDigestQueuePosition++]();
+        $postUpdateQueue[postDigestQueuePosition++]();
       } catch (e) {
         $exceptionHandler(e);
       }
     }
-    $$postDigestQueue.length = postDigestQueuePosition = 0;
+    $postUpdateQueue.length = postDigestQueuePosition = 0;
 
     // Check for changes to browser url that happened during the $digest
     // (for which no event is fired; e.g. via `history.pushState()`)
@@ -906,7 +936,7 @@ export class Scope {
    * Some of the things to consider are:
    *
    * * Any external event on a directive/component will not trigger a digest while the hosting
-   *   scope is suspended - even if the event handler calls `$apply()` or `$rootScope.$digest()`.
+   *   scope is suspended - even if the event handler calls `$apply()` or ``.
    * * Transcluded content exists on a scope that inherits from outside a directive but exists
    *   as a child of the directive's containing scope. If the containing scope is suspended the
    *   transcluded scope will also be suspended, even if the scope from which the transcluded
@@ -1120,8 +1150,8 @@ export class Scope {
     return id;
   }
 
-  $$postDigest(fn) {
-    $$postDigestQueue.push(fn);
+  $postUpdate(fn) {
+    $postUpdateQueue.push(fn);
   }
 
   /**