@angular-wave/angular.ts 0.4.4 → 0.4.6

package/src/core/parse/parse.spec.js

@@ -10,7 +10,6 @@ import {
 import { createInjector } from "../di/injector.js";
 import { ASTType } from "./ast-type.js";
 import { Angular } from "../../loader.js";
-import { wait } from "../../shared/test-utils.js";
 
 describe("parser", () => {
   let $rootScope;
@@ -930,51 +929,52 @@ describe("parser", () => {
       expect($parse("::foo")).toBe($parse("::foo"));
     });
 
-    it("should not affect calling the parseFn directly", async () => {
-      $rootScope.$watch("::foo");
+    it("should not affect calling the parseFn directly", () => {
+      const fn = $parse("::foo");
+      $rootScope.$watch(fn);
 
       $rootScope.foo = "bar";
-      expect($rootScope.$$watchersCount).toBe(1);
-      expect($rootScope.foo).toEqual("bar");
+      expect($rootScope.$$watchers.length).toBe(1);
+      expect(fn($rootScope)).toEqual("bar");
 
-      await wait();
-      expect($rootScope.$$watchersCount).toBe(0);
-      expect($rootScope.foo).toEqual("bar");
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(0);
+      expect(fn($rootScope)).toEqual("bar");
 
       $rootScope.foo = "man";
-      await wait();
-      expect($rootScope.$$watchersCount).toBe(0);
-      expect($rootScope.foo).toEqual("man");
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(0);
+      expect(fn($rootScope)).toEqual("man");
 
       $rootScope.foo = "shell";
-      await wait();
-      expect($rootScope.$$watchersCount).toBe(0);
-      expect($rootScope.foo).toEqual("shell");
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(0);
+      expect(fn($rootScope)).toEqual("shell");
     });
 
-    it("should stay stable once the value defined", async () => {
-      $rootScope.$watch("::foo", (value, old) => {
+    it("should stay stable once the value defined", () => {
+      const fn = $parse("::foo");
+      $rootScope.$watch(fn, (value, old) => {
         if (value !== old) logs.push(value);
       });
-      expect(logs.length).toEqual(0);
 
-      expect($rootScope.$$watchersCount).toBe(1);
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(1);
 
       $rootScope.foo = "bar";
-      await wait();
-
-      expect($rootScope.$$watchersCount).toBe(0);
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(0);
       expect(logs[0]).toEqual("bar");
 
       $rootScope.foo = "man";
-      await wait();
-
-      expect($rootScope.$$watchersCount).toBe(0);
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(0);
       expect(logs.length).toEqual(1);
     });
 
-    it("should have a stable value if at the end of a $digest it has a defined value", async () => {
-      $rootScope.$watch("::foo", (value, old) => {
+    it("should have a stable value if at the end of a $digest it has a defined value", () => {
+      const fn = $parse("::foo");
+      $rootScope.$watch(fn, (value, old) => {
         if (value !== old) logs.push(value);
       });
       $rootScope.$watch("foo", () => {
@@ -984,37 +984,35 @@ describe("parser", () => {
       });
 
       $rootScope.foo = "bar";
-      await wait();
-
-      expect($rootScope.$$watchersCount).toBe(1);
-      expect(logs[0]).toEqual("bar");
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(2);
+      expect(logs[0]).toBeUndefined();
 
       $rootScope.foo = "man";
-      await wait();
-      expect($rootScope.$$watchersCount).toBe(1);
-      expect(logs[0]).toEqual("bar");
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(1);
+      expect(logs[1]).toEqual("man");
 
       $rootScope.foo = "shell";
-
-      await wait();
-      expect($rootScope.$$watchersCount).toBe(1);
-      expect(logs.length).toEqual(1);
+      $rootScope.$digest();
+      expect($rootScope.$$watchers.length).toBe(1);
+      expect(logs.length).toEqual(2);
     });
 
-    it("should not throw if the stable value is `null`", async () => {
-      $rootScope.$watch("::foo");
+    it("should not throw if the stable value is `null`", () => {
+      const fn = $parse("::foo");
+      $rootScope.$watch(fn);
       $rootScope.foo = null;
-      await wait();
-
+      $rootScope.$digest();
       $rootScope.foo = "foo";
-
-      await wait();
-      expect($rootScope.foo).toEqual("foo");
+      $rootScope.$digest();
+      expect(fn()).toEqual(undefined);
     });
 
-    xit("should invoke a stateless filter", async () => {
+    it("should invoke a stateless filter once when the parsed expression has an interceptor", () => {
       const countFilter = jasmine.createSpy();
-      countFilter.and.callThrough();
+      const interceptor = jasmine.createSpy();
+      countFilter.and.returnValue(1);
       createInjector([
         "ng",
         function ($filterProvider) {
@@ -1024,15 +1022,12 @@ describe("parser", () => {
         scope = _$rootScope_;
         $parse = _$parse_;
       });
-      scope.count = 0;
+
       scope.foo = function () {
-        scope.count++;
-        return scope.count;
+        return 1;
       };
-      // todo investiage our function stategy
-      scope.$watch("::foo() | count");
-
-      await wait();
+      scope.$watch($parse(":: foo() | count", interceptor));
+      scope.$digest();
       expect(countFilter.calls.count()).toBe(1);
     });
   });
@@ -1051,34 +1046,38 @@ describe("parser", () => {
           logs = [];
         });
 
-        fit("should only become stable when all the properties of an object have defined values", async () => {
-          $rootScope.$watch("::{foo: foo, bar: bar}", (value) => {
-            logs.push(value);
-          });
+        it("should only become stable when all the properties of an object have defined values", () => {
+          const fn = $parse("::{foo: foo, bar: bar}");
+          $rootScope.$watch(
+            fn,
+            (value) => {
+              logs.push(value);
+            },
+            isDeep,
+          );
 
           expect(logs).toEqual([]);
-          expect($rootScope.$$watchersCount).toBe(1);
-
-          // $rootScope.$digest();
-          // expect($rootScope.$$watchersCount).toBe(1);
-          // expect(logs[0]).toEqual({ foo: undefined, bar: undefined });
-
-          // $rootScope.foo = "foo";
-          // await wait();
-          // $rootScope.$digest();
-          // expect($rootScope.$$watchersCount).toBe(1);
-          //expect(logs[0]).toEqual({ foo: undefined, bar: undefined });
-
-          // $rootScope.foo = "foobar";
-          // $rootScope.bar = "bar";
-          // $rootScope.$digest();
-          // expect($rootScope.$$watchersCount).toBe(0);
-          // expect(logs[2]).toEqual({ foo: "foobar", bar: "bar" });
-
-          // $rootScope.foo = "baz";
-          // $rootScope.$digest();
-          // expect($rootScope.$$watchersCount).toBe(0);
-          // expect(logs[3]).toBeUndefined();
+          expect($rootScope.$$watchers.length).toBe(1);
+
+          $rootScope.$digest();
+          expect($rootScope.$$watchers.length).toBe(1);
+          expect(logs[0]).toEqual({ foo: undefined, bar: undefined });
+
+          $rootScope.foo = "foo";
+          $rootScope.$digest();
+          expect($rootScope.$$watchers.length).toBe(1);
+          expect(logs[0]).toEqual({ foo: undefined, bar: undefined });
+
+          $rootScope.foo = "foobar";
+          $rootScope.bar = "bar";
+          $rootScope.$digest();
+          expect($rootScope.$$watchers.length).toBe(0);
+          expect(logs[2]).toEqual({ foo: "foobar", bar: "bar" });
+
+          $rootScope.foo = "baz";
+          $rootScope.$digest();
+          expect($rootScope.$$watchers.length).toBe(0);
+          expect(logs[3]).toBeUndefined();
         });
 
         it("should only become stable when all the elements of an array have defined values", () => {
@@ -1092,26 +1091,26 @@ describe("parser", () => {
           );
 
           expect(logs.length).toEqual(0);
-          expect($rootScope.$$watchersCount).toBe(1);
+          expect($rootScope.$$watchers.length).toBe(1);
 
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(1);
+          expect($rootScope.$$watchers.length).toBe(1);
           expect(logs[0]).toEqual([undefined, undefined]);
 
           $rootScope.foo = "foo";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(1);
+          expect($rootScope.$$watchers.length).toBe(1);
           expect(logs[1]).toEqual(["foo", undefined]);
 
           $rootScope.foo = "foobar";
           $rootScope.bar = "bar";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(0);
+          expect($rootScope.$$watchers.length).toBe(0);
           expect(logs[2]).toEqual(["foobar", "bar"]);
 
           $rootScope.foo = "baz";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(0);
+          expect($rootScope.$$watchers.length).toBe(0);
           expect(logs[3]).toBeUndefined();
         });
 
@@ -1132,18 +1131,18 @@ describe("parser", () => {
 
           $rootScope.foo = "bar";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(2);
+          expect($rootScope.$$watchers.length).toBe(2);
           expect(logs[0]).toEqual(["bar"]);
           expect(logs[1]).toEqual([undefined]);
 
           $rootScope.foo = "baz";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(1);
+          expect($rootScope.$$watchers.length).toBe(1);
           expect(logs[2]).toEqual(["baz"]);
 
           $rootScope.bar = "qux";
           $rootScope.$digest();
-          expect($rootScope.$$watchersCount).toBe(1);
+          expect($rootScope.$$watchers.length).toBe(1);
           expect(logs[3]).toBeUndefined();
         });
       });
@@ -1495,7 +1494,7 @@ describe("parser", () => {
         expect(watcherCalls).toBe(1);
       });
 
-      it("should not be reevaluated in literals", async () => {
+      it("should not be reevaluated in literals", () => {
         let filterCalls = 0;
         filterProvider.register(
           "foo",
@@ -1505,21 +1504,18 @@ describe("parser", () => {
           }),
         );
 
+        scope.date = new Date(1234567890123);
+
         let watcherCalls = 0;
         scope.$watch("[(date | foo)]", (input) => {
           watcherCalls++;
         });
 
-        scope.date = new Date(1234567890123);
-
-        await wait();
-
+        scope.$digest();
         expect(filterCalls).toBe(1);
         expect(watcherCalls).toBe(1);
 
-        scope.date = new Date(1234567890124);
-
-        await wait();
+        scope.$digest();
         expect(filterCalls).toBe(1);
         expect(watcherCalls).toBe(1);
       });

package/src/core/prop.spec.js

@@ -34,10 +34,13 @@ 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);
   });
 
@@ -47,26 +50,33 @@ 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);
   });
 
@@ -75,24 +85,31 @@ 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");
   });
@@ -100,6 +117,7 @@ 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);
   });
 
@@ -118,6 +136,7 @@ fdescribe("ngProp*", () => {
     const element = $compile("<a ng-prop-href=\"'test/' + value\"></a>")(
       $rootScope,
     );
+    $rootScope.$digest();
     expect(element[0].href).toMatch(/\/test\/test$/);
   });
 
@@ -139,6 +158,7 @@ fdescribe("ngProp*", () => {
       $rootScope,
     );
     $rootScope.asdf = 123;
+    $rootScope.$digest();
     expect(element[0].asdf).toBe(123);
     expect(element.attr("asdf")).toBe("foo");
   });
@@ -148,6 +168,7 @@ fdescribe("ngProp*", () => {
       $rootScope,
     );
     $rootScope.asdf = 123;
+    $rootScope.$digest();
     expect(element[0].asdf).toBe(123);
     expect(element.attr("asdf")).toBe("foo");
   });
@@ -257,6 +278,7 @@ 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();");
     });
 
@@ -308,27 +330,33 @@ 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()");
     });
 
@@ -383,9 +411,16 @@ 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();
     });
   });
 
@@ -603,6 +638,7 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = '<div onclick="">hello</div>';
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -611,8 +647,10 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = "hello";
+        $rootScope.$digest();
         expect(element.html()).toEqual("hello");
         $rootScope.html = "goodbye";
+        $rootScope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
 
@@ -622,9 +660,11 @@ 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");
       });
     });
@@ -648,7 +688,9 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = '<div onclick="">hello</div>';
-        expect(() => {}).toThrowError(/unsafe/);
+        expect(() => {
+          $rootScope.$digest();
+        }).toThrowError(/unsafe/);
       });
 
       it("should NOT set html for wrongly typed values", () => {
@@ -656,7 +698,9 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = $sce.trustAsCss('<div onclick="">hello</div>');
-        expect(() => {}).toThrowError(/unsafe/);
+        expect(() => {
+          $rootScope.$digest();
+        }).toThrowError(/unsafe/);
       });
 
       it("should set html for trusted values", () => {
@@ -664,6 +708,7 @@ fdescribe("ngProp*", () => {
           $rootScope,
         );
         $rootScope.html = $sce.trustAsHtml('<div onclick="">hello</div>');
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -672,8 +717,10 @@ 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");
       });
 
@@ -687,6 +734,7 @@ fdescribe("ngProp*", () => {
         $rootScope.getHtml = function () {
           return $sce.trustAsHtml('<div onclick="">hello</div>');
         };
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -727,8 +775,10 @@ 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");
       });
     });
@@ -738,18 +788,24 @@ 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(() => {}).toThrowError(/unsafe/);
+      expect(() => {
+        $rootScope.$digest();
+      }).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(() => {}).toThrowError(/unsafe/);
+      expect(() => {
+        $rootScope.$digest();
+      }).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/q/q.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularTS Test Runner</title>
+
+    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
+    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
+    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
+    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
+    <script type="module" src="/src/core/q/q.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>