@angular-wave/angular.ts 0.4.4 → 0.4.5

package/src/core/controller/controller.js

@@ -112,7 +112,6 @@ export class ControllerProvider {
           instance = Object.create(controllerPrototype || null);
 
           if (identifier) {
-            instance["$controllerIdentifier"] = identifier;
             this.addIdentifier(
               locals,
               identifier,
@@ -135,7 +134,6 @@ export class ControllerProvider {
             ) {
               instance = result;
               if (identifier) {
-                instance["$controllerIdentifier"] = identifier;
                 this.addIdentifier(
                   locals,
                   identifier,

package/src/core/di/injector.md

@@ -28,7 +28,7 @@
 - // use the type inference to auto inject arguments, or use implicit injection
 - $injector.invoke(function($rootScope, $compile, $document) {
 -     $compile($document)($rootScope);
--     ;
+-     $rootScope.$digest();
 - });
 - ```
 

package/src/core/di/injector.spec.js

@@ -1410,6 +1410,7 @@ describe("directive", () => {
     injector.loadNewModules(["a"]);
     injector.invoke(($compile, $rootScope) => {
       const elem = $compile("<div a-directive></div>")($rootScope); // compile and link
+      $rootScope.$digest();
       expect(elem.text()).toEqual("test directive");
       elem.remove();
     });
@@ -1423,6 +1424,7 @@ describe("directive", () => {
     injector.loadNewModules(["a"]);
     injector.invoke(($compile, $rootScope) => {
       const elem = $compile("<div a-directive></div>")($rootScope); // compile and link
+      $rootScope.$digest();
       expect(elem.text()).toEqual("test directive");
       elem.remove();
     });

package/src/core/di/internal-injector.js

@@ -114,8 +114,7 @@ class AbstractInjector {
 
     if (isClass(/** @type {string} */ (fn))) {
       args.unshift(null);
-      const res = new (Function.prototype.bind.apply(fn, args))();
-      return res;
+      return new (Function.prototype.bind.apply(fn, args))();
     } else {
       return /** @type {Function} */ (fn).apply(self, args);
     }

package/src/core/interpolate/interpolate.js

@@ -332,25 +332,13 @@ export class InterpolateProvider {
           };
 
           return extend(
-            (context, cb) => {
+            (context) => {
               let i = 0;
               const ii = expressions.length;
               const values = new Array(ii);
+
               try {
                 for (; i < ii; i++) {
-                  if (cb) {
-                    const watchProp = expressions[i].trim();
-                    console.log(watchProp);
-                    context.$watch(watchProp, () => {
-                      let vals = new Array(ii);
-                      let j = 0;
-                      for (; j < ii; j++) {
-                        vals[j] = parseFns[j](context);
-                      }
-                      cb(compute(vals));
-                    });
-                  }
-
                   values[i] = parseFns[i](context);
                 }
 
@@ -360,13 +348,12 @@ export class InterpolateProvider {
               }
             },
             {
-              // Most likely we would need to register watches during interpolation
               // all of these properties are undocumented for now
               exp: text, // just for compatibility with regular watchers created via $watch
               expressions,
               $$watchDelegate(scope, listener) {
                 let lastValue;
-                return scope.$watch(
+                return scope.$watchGroup(
                   parseFns,
                   function interpolateFnWatcher(values, oldValues) {
                     const currValue = compute(values);

package/src/core/interpolate/interpolate.spec.js

@@ -1,6 +1,5 @@
 import { createInjector } from "../di/injector";
 import { Angular } from "../../loader";
-import { wait } from "../../shared/test-utils";
 
 describe("$interpolate", () => {
   let $interpolate, $injector, $rootScope, $sce;
@@ -235,22 +234,18 @@ describe("$interpolate", () => {
       expect(calls.pop()).toBeUndefined();
     });
 
-    // TODO these tests shoudl be revereds
-    // Calling interpolation with scope should CREATE watches on scope
-    it("should stop watching strings with no expressions after first execution", async () => {
+    it("should stop watching strings with no expressions after first execution", () => {
       const spy = jasmine.createSpy();
-      $rootScope.$watch($interpolate("foo")(), spy);
-      $rootScope.foo = "foo";
-      await wait();
-      expect(spy).toHaveBeenCalledWith("foo", undefined, $rootScope);
+      $rootScope.$watch($interpolate("foo"), spy);
+      $rootScope.$digest();
+      expect(spy).toHaveBeenCalledWith("foo", "foo", $rootScope);
       expect(spy).toHaveBeenCalledTimes(1);
     });
 
     it("should stop watching strings with only constant expressions after first execution", () => {
       const spy = jasmine.createSpy();
-      let res = $interpolate("foo {{42}}")($rootScope);
-      $rootScope.$watch(res, spy);
-
+      $rootScope.$watch($interpolate("foo {{42}}"), spy);
+      $rootScope.$digest();
       expect(spy).toHaveBeenCalledWith("foo 42", "foo 42", $rootScope);
       expect(spy).toHaveBeenCalledTimes(1);
     });
@@ -269,12 +264,18 @@ describe("$interpolate", () => {
       expect(interp.$$watchDelegate).toBeDefined();
     });
 
-    it("correctly returns new value", async () => {
+    it("correctly returns new and old value when watched", function () {
       const interp = $interpolate("{{expr}}");
-      $rootScope.$watch("expr", () => {});
+      const listenerSpy = jasmine.createSpy();
+      $rootScope.$watch(interp, listenerSpy);
       $rootScope.expr = 42;
-      await wait();
-      expect(interp($rootScope)).toEqual("42");
+      $rootScope.$apply();
+      expect(listenerSpy.calls.mostRecent().args[0]).toEqual("42");
+      expect(listenerSpy.calls.mostRecent().args[1]).toEqual("42");
+      $rootScope.expr++;
+      $rootScope.$apply();
+      expect(listenerSpy.calls.mostRecent().args[0]).toEqual("43");
+      expect(listenerSpy.calls.mostRecent().args[1]).toEqual("42");
     });
 
     it("should support escaping interpolation signs", () => {
@@ -398,61 +399,6 @@ describe("$interpolate", () => {
     });
   });
 
-  describe("interpolation callbacks", () => {
-    it("does not require a callback", async () => {
-      let text;
-      $rootScope.expr = 42;
-      const interp = $interpolate("{{expr}}");
-
-      text = interp($rootScope);
-
-      expect(text).toEqual("42");
-    });
-
-    it("correctly invokes callback when interpolated value changes", async () => {
-      let counter = 0;
-
-      const interp = $interpolate("{{expr}}");
-
-      interp($rootScope, (val) => {
-        counter++;
-      });
-
-      $rootScope.expr = 42;
-      await wait();
-      expect(counter).toEqual(1);
-
-      $rootScope.expr++;
-      await wait();
-      expect(counter).toEqual(2);
-    });
-
-    it("returns currently interpolated text", async () => {
-      let text;
-      $rootScope.expr = 42;
-      const interp = $interpolate("{{expr}}");
-
-      text = interp($rootScope, (val) => {
-        text = val;
-      });
-
-      expect(text).toEqual("42");
-    });
-
-    it("invokes callback with newly interpolated text", async () => {
-      let text;
-      const interp = $interpolate("{{expr}}");
-
-      interp($rootScope, (val) => {
-        text = val;
-      });
-
-      $rootScope.expr = 42;
-      await wait();
-      expect(text).toEqual("42");
-    });
-  });
-
   describe("interpolating in a trusted context", () => {
     let sce;
 

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

@@ -0,0 +1,50 @@
+import { isDefined, sliceArgs } from "../../shared/utils";
+
+export function $IntervalFactoryProvider() {
+  this.$get = [
+    "$q",
+    "$rootScope",
+    /**
+     * @param {*} $q
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @returns
+     */
+    function ($q, $rootScope) {
+      return function intervalFactory(setIntervalFn, clearIntervalFn) {
+        return function intervalFn(fn, delay, count) {
+          const hasParams = arguments.length > 4;
+          const args = hasParams ? sliceArgs(arguments, 4) : [];
+          let iteration = 0;
+          const deferred = $q.defer();
+          const { promise } = deferred;
+
+          count = isDefined(count) ? count : 0;
+
+          function callback() {
+            if (!hasParams) {
+              fn(iteration);
+            } else {
+              fn.apply(null, args);
+            }
+          }
+
+          function tick() {
+            $rootScope.$evalAsync(callback);
+
+            iteration++;
+
+            if (count > 0 && iteration >= count) {
+              deferred.resolve(iteration);
+              clearIntervalFn(promise.$$intervalId);
+            }
+            $rootScope.$apply();
+          }
+
+          promise.$$intervalId = setIntervalFn(tick, delay, deferred);
+
+          return promise;
+        };
+      };
+    },
+  ];
+}

package/src/core/interval/interval.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/interval/interval.spec.js"></script>
+  </head>
+  <body>
+    <div id="dummy"></div>
+  </body>
+</html>

package/src/core/interval/interval.js

@@ -0,0 +1,77 @@
+import { markQExceptionHandled } from "../q/q";
+import { minErr } from "../../shared/utils";
+
+const $intervalMinErr = minErr("$interval");
+
+/**
+ * @typedef {number} IntervalId
+ * Interval ID which uniquely identifies the interval and can be used to cancel it
+ */
+
+/**
+ * @type {Map<IntervalId, import("../q/q").Deferred<any>>}
+ */
+const intervals = new Map();
+
+export function IntervalProvider() {
+  this.$get = [
+    "$$intervalFactory",
+    // TODO Add type
+    function ($$intervalFactory) {
+      /**
+       * @param {TimerHandler} tick
+       * @param {number} delay
+       * @param {import("../q/q").Deferred<any>} deferred
+       * @returns {IntervalId} - This method returns an interval ID which uniquely identifies the interval
+       */
+      function setIntervalFn(tick, delay, deferred) {
+        const id = window.setInterval(tick, delay);
+        intervals.set(id, deferred);
+        return id;
+      }
+
+      /**s
+       * @param {IntervalId} id
+       */
+      function clearIntervalFn(id) {
+        window.clearInterval(id);
+        intervals.delete(id);
+      }
+
+      const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
+
+      /**
+       * Cancels a task associated with the `promise`.
+       *
+       * @param {!import("../q/q").QPromise<any>} promise returned by the `$interval` function.
+       * @returns {boolean} Returns `true` if the task was successfully canceled.
+       */
+      interval.cancel = function (promise) {
+        if (!promise) return false;
+
+        if (!Object.prototype.hasOwnProperty.call(promise, "$$intervalId")) {
+          throw $intervalMinErr(
+            "badprom",
+            "`$interval.cancel()` called with a promise that was not generated by `$interval()`.",
+          );
+        }
+
+        if (!intervals.has(promise.$$intervalId)) {
+          return false;
+        }
+
+        const id = promise.$$intervalId;
+        const deferred = intervals.get(id);
+
+        // Interval cancels should not report an unhandled promise.
+        markQExceptionHandled(deferred.promise);
+        deferred.reject("canceled");
+        clearIntervalFn(id);
+
+        return true;
+      };
+
+      return interval;
+    },
+  ];
+}

package/src/core/interval/interval.md

@@ -0,0 +1,123 @@
+/**
+_ @ngdoc service
+_ @name $interval
+       *
+       * @description
+       * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
+       * milliseconds.
+       *
+       * The return value of registering an interval function is a promise. This promise will be
+       * notified upon each tick of the interval, and will be resolved after `count` iterations, or
+       * run indefinitely if `count` is not defined. The value of the notification will be the
+       * number of iterations that have run.
+       * To cancel an interval, call `$interval.cancel(promise)`.
+       *
+       * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
+       * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
+_ time.
+_
+_ <div class="alert alert-warning">
+_ **Note\*_: Intervals created by this service must be explicitly destroyed when you are finished
+_ with them. In particular they are not automatically destroyed when a controller's scope or a
+_ directive's element are destroyed.
+_ You should take this into consideration and make sure to always cancel the interval at the
+_ appropriate moment. See the example below for more details on how and when to do this.
+_ </div> \*
+_ @param {function()} fn A function that should be called repeatedly. If no additional arguments
+_ are passed (see below), the function is called with the current iteration count.
+_ @param {number} delay Number of milliseconds between each function call.
+_ @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
+_ indefinitely.
+_ @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+_ will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+_ @param {..._=} Pass additional parameters to the executed function.
+_ @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete. \*
+_ @example
+_ <example module="intervalExample" name="interval-service">
+_ <file name="index.html">
+_ <script>
+_ angular.module('intervalExample', [])
+_ .controller('ExampleController', ['$scope', '$interval',
+
+- function($scope, $interval) {
+- $scope.format = 'M/d/yy h:mm:ss a';
+- $scope.blood_1 = 100;
+- $scope.blood_2 = 120;
+-
+- let stop;
+- $scope.fight = function() {
+- // Don't start a new fight if we are already fighting
+- if ( angular.isDefined(stop) ) return;
+-
+- stop = $interval(function() {
+- if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+- $scope.blood_1 = $scope.blood_1 - 3;
+- $scope.blood_2 = $scope.blood_2 - 4;
+- } else {
+- $scope.stopFight();
+- }
+- }, 100);
+- };
+-
+- $scope.stopFight = function() {
+- if (angular.isDefined(stop)) {
+- $interval.cancel(stop);
+- stop = undefined;
+- }
+- };
+-
+- $scope.resetFight = function() {
+- $scope.blood_1 = 100;
+- $scope.blood_2 = 120;
+- };
+-
+- $scope.$on('$destroy', function() {
+- // Make sure that the interval is destroyed too
+- $scope.stopFight();
+- });
+- }])
+  _ // Register the 'myCurrentTime' directive factory method.
+  _ // We inject $interval and dateFilter service since the factory method is DI.
+       *       .directive('myCurrentTime', ['$interval', 'dateFilter',
+  _ function($interval, dateFilter) {
+  _ // return the directive link function. (compile function not needed)
+  _ return function(scope, element, attrs) {
+  _ let format, // date format
+  _ stopTime; // so that we can cancel the time updates
+  _
+  _ // used to update the UI
+  _ function updateTime() {
+  _ element.text(dateFilter(new Date(), format));
+  _ } \*
+  _ // watch the expression, and update the UI on change.
+  _ scope.$watch(attrs.myCurrentTime, function(value) {
+       *               format = value;
+       *               updateTime();
+       *             });
+       *
+       *             stopTime = $interval(updateTime, 1000);
+       *
+       *             // listen on DOM destroy (removal) event, and cancel the next UI update
+       *             // to prevent updating time after the DOM element was removed.
+       *             element.on('$destroy', function() {
+  _ $interval.cancel(stopTime);
+  _ });
+  _ }
+  _ }]);
+  _ </script>
+  _
+  _ <div>
+  _ <div ng-controller="ExampleController">
+  _ <label>Date format: <input ng-model="format"></label> <hr/>
+  _ Current time is: <span my-current-time="format"></span>
+  _ <hr/>
+  _ Blood 1 : <font color='red'>{{blood_1}}</font>
+  _ Blood 2 : <font color='red'>{{blood_2}}</font>
+  _ <button type="button" data-ng-click="fight()">Fight</button>
+  _ <button type="button" data-ng-click="stopFight()">StopFight</button>
+  _ <button type="button" data-ng-click="resetFight()">resetFight</button>
+  _ </div>
+  _ </div> \*
+  _ </file>
+  _ </example>
+  \*/