@angular-wave/angular.ts 0.4.4 → 0.4.5

package/src/core/on.spec.js

@@ -101,6 +101,7 @@ describe("ngOn* event binding", () => {
       $rootScope,
     );
     const cb = ($rootScope.cb = jasmine.createSpy("ng-on cb"));
+    $rootScope.$digest();
     element.triggerHandler("asdf");
     expect(cb).toHaveBeenCalled();
     expect(element.attr("asdf")).toBe("foo");
@@ -111,6 +112,7 @@ describe("ngOn* event binding", () => {
       $rootScope,
     );
     const cb = ($rootScope.cb = jasmine.createSpy("ng-on cb"));
+    $rootScope.$digest();
     element.triggerHandler("asdf");
     expect(cb).toHaveBeenCalled();
     expect(element.attr("asdf")).toBe("foo");
@@ -121,6 +123,7 @@ describe("ngOn* event binding", () => {
       $rootScope,
     );
     const cb = ($rootScope.cb = jasmine.createSpy("ng-on cb"));
+    $rootScope.$digest();
     element.triggerHandler("asdf");
     expect(cb).toHaveBeenCalled();
     expect(element[0].asdf).toBe(123);
@@ -194,6 +197,8 @@ describe("ngOn* event binding", () => {
   it("should correctly bind to kebab-cased event names", () => {
     const element = $compile('<span ng-on-foo-bar="cb()"></span>')($rootScope);
     const cb = ($rootScope.cb = jasmine.createSpy("ng-on cb"));
+    $rootScope.$digest();
+
     element.triggerHandler("foobar");
     element.triggerHandler("fooBar");
     expect(cb).not.toHaveBeenCalled();
@@ -205,6 +210,8 @@ describe("ngOn* event binding", () => {
   it("should correctly bind to camelCased event names", () => {
     const element = $compile('<span ng-on-foo_bar="cb()"></span>')($rootScope);
     const cb = ($rootScope.cb = jasmine.createSpy("ng-on cb"));
+    $rootScope.$digest();
+
     element.triggerHandler("foobar");
     element.triggerHandler("foo-bar");
     element.triggerHandler("foo-bar");

package/src/core/parse/interpreter.js

@@ -1,4 +1,4 @@
-import { isDefined, isFunction, isObject } from "../../shared/utils";
+import { isDefined } from "../../shared/utils";
 import { ASTType } from "./ast-type";
 
 export const PURITY_ABSOLUTE = 1;
@@ -66,7 +66,6 @@ export class ASTInterpreter {
     if (inputs) {
       fn.inputs = inputs;
     }
-    fn.decoratedNode = decoratedNode;
     return fn;
   }
 
@@ -135,10 +134,9 @@ export class ASTInterpreter {
           ? function (scope, locals, assign) {
               const values = [];
               for (let i = 0; i < args.length; ++i) {
-                const res = args[i](scope, locals, assign);
-                values.push(isFunction(res) ? res() : res);
+                values.push(args[i](scope, locals, assign));
               }
-              const value = () => right.apply(undefined, values);
+              const value = right.apply(undefined, values);
               return context
                 ? { context: undefined, name: undefined, value }
                 : value;
@@ -146,11 +144,10 @@ export class ASTInterpreter {
           : function (scope, locals, assign) {
               const rhs = right(scope, locals, assign);
               let value;
-              if (rhs.value != null && isFunction(rhs.value)) {
+              if (rhs.value != null) {
                 const values = [];
                 for (let i = 0; i < args.length; ++i) {
-                  const res = args[i](scope, locals, assign);
-                  values.push(isFunction(res) ? res() : res);
+                  values.push(args[i](scope, locals, assign));
                 }
                 value = rhs.value.apply(rhs.context, values);
               }
@@ -813,8 +810,8 @@ function assignableAST(ast) {
 }
 
 function plusFn(l, r) {
-  if (typeof l === "undefined" || isObject(l)) return r;
-  if (typeof r === "undefined" || isObject(r)) return l;
+  if (typeof l === "undefined") return r;
+  if (typeof r === "undefined") return l;
   return l + r;
 }
 

package/src/core/parse/parse.js

@@ -9,21 +9,11 @@ import { Parser } from "./parser/parser.js";
  * @property {boolean} constant - Indicates if the expression is constant.
  * @property {boolean} [isPure]
  * @property {boolean} oneTime
- * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
  * @property {function(import('../scope/scope').Scope, import('../scope/scope').WatchListener, boolean, CompiledExpression, string | ((scope:  import('../scope/scope').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
  * @property {any[]|Function} inputs
  * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
  */
 
-/**
- * @typedef {Object} CompiledExpressionHandlerMap
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {Map<string, Function>} keyMap - property keys to observe
- */
-
 /**
  * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
@@ -133,24 +123,14 @@ export function ParseProvider() {
           parsedExpression = parsedExpression.$$intercepted;
         }
 
-        let useInputs = false;
+        var useInputs = false;
 
-        const fn = function interceptedExpression(
-          scope,
-          locals,
-          assign,
-          inputs,
-        ) {
-          const value =
+        var fn = function interceptedExpression(scope, locals, assign, inputs) {
+          var value =
             useInputs && inputs
               ? inputs[0]
               : parsedExpression(scope, locals, assign, inputs);
-          // Do not invoke for getters
-          if (scope.getter) {
-            return;
-          }
-          const res = isFunction(value) ? value() : value;
-          return interceptorFn(res);
+          return interceptorFn(value);
         };
 
         // Maintain references to the interceptor/intercepted
@@ -161,7 +141,6 @@ export function ParseProvider() {
         fn.literal = parsedExpression.literal;
         fn.oneTime = parsedExpression.oneTime;
         fn.constant = parsedExpression.constant;
-        fn.decoratedNode = parsedExpression.decoratedNode;
 
         // Treat the interceptor like filters.
         // If it is not $stateful then only watch its inputs.
@@ -349,7 +328,7 @@ function oneTimeWatchDelegate(
     lastValue =
       useInputs && inputs ? inputs[0] : exp(scope, locals, assign, inputs);
     if (isDone(lastValue)) {
-      scope.$postUpdate(unwatchIfDone);
+      scope.$$postDigest(unwatchIfDone);
     }
     return post(lastValue);
   }

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);
       });