@angular-wave/angular.ts 0.0.67 → 0.0.68

package/package.json

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.0.67",
+  "version": "0.0.68",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

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

@@ -6,7 +6,14 @@ export function $$IntervalFactoryProvider() {
     "$q",
     "$$q",
     "$rootScope",
-    // TODO Add types
+    /**
+     *
+     * @param {import('../../services/browser').Browser} $browser
+     * @param {*} $q
+     * @param {*} $$q
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @returns
+     */
     function ($browser, $q, $$q, $rootScope) {
       return function intervalFactory(setIntervalFn, clearIntervalFn) {
         return function intervalFn(fn, delay, count, invokeApply) {

package/src/core/interval/interval.js

@@ -3,32 +3,47 @@ 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) {
-      const intervals = {};
-      const setIntervalFn = function (tick, delay, deferred) {
+      /**
+       * @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[id] = deferred;
+        intervals.set(id, deferred);
         return id;
-      };
-      const clearIntervalFn = function (id) {
+      }
+
+      /**s
+       * @param {IntervalId} id
+       */
+      function clearIntervalFn(id) {
         window.clearInterval(id);
-        delete intervals[id];
-      };
+        intervals.delete(id);
+      }
 
       const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
 
       /**
-       * @ngdoc method
-       * @name $interval#cancel
-       *
-       * @description
        * Cancels a task associated with the `promise`.
        *
-       * @param {Promise=} promise returned by the `$interval` function.
+       * @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) {
@@ -41,13 +56,12 @@ export function $IntervalProvider() {
           );
         }
 
-        if (
-          !Object.prototype.hasOwnProperty.call(intervals, promise.$$intervalId)
-        )
+        if (!intervals.has(promise.$$intervalId)) {
           return false;
+        }
 
         const id = promise.$$intervalId;
-        const deferred = intervals[id];
+        const deferred = intervals.get(id);
 
         // Interval cancels should not report an unhandled promise.
         markQExceptionHandled(deferred.promise);