@angular-wave/angular.ts 0.1.3 → 0.1.5

package/src/core/q/q.spec.js

@@ -474,111 +474,6 @@ describe("q", () => {
     expect(rejectedSpy).toHaveBeenCalledWith("fail");
   });
 
-  it("can report progress", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.then(null, null, progressSpy);
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
-  });
-
-  it("can report progress many times", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.then(null, null, progressSpy);
-    d.notify("40%");
-    $rootScope.$apply();
-    d.notify("80%");
-    d.notify("100%");
-    $rootScope.$apply();
-    expect(progressSpy.calls.count()).toBe(3);
-  });
-
-  it("does not notify progress after being resolved", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.then(null, null, progressSpy);
-    d.resolve("ok");
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).not.toHaveBeenCalled();
-  });
-
-  it("does not notify progress after being rejected", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.then(null, null, progressSpy);
-    d.reject("fail");
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).not.toHaveBeenCalled();
-  });
-
-  it("can notify progress through chain", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise
-      .then(() => {})
-      .catch(() => {})
-      .then(null, null, progressSpy);
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
-  });
-
-  it("transforms progress through handlers", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise
-      .then(() => {})
-      .then(null, null, function (progress) {
-        return "***" + progress + "***";
-      })
-      .catch(() => {})
-      .then(null, null, progressSpy);
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("***working...***");
-  });
-
-  it("recovers from progressback exceptions", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    var fulfilledSpy = jasmine.createSpy();
-    d.promise.then(null, null, function (progress) {
-      throw "fail";
-    });
-    d.promise.then(fulfilledSpy, null, progressSpy);
-    d.notify("working...");
-    d.resolve("ok");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
-    expect(fulfilledSpy).toHaveBeenCalledWith("ok");
-  });
-
-  it("can notify progress through promise returned from handler", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.then(null, null, progressSpy);
-    var d2 = $q.defer();
-    // Resolve original with nested promise
-    d.resolve(d2.promise);
-    // Notify on the nested promise
-    d2.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
-  });
-
-  it("allows attaching progressback in finally", function () {
-    var d = $q.defer();
-    var progressSpy = jasmine.createSpy();
-    d.promise.finally(null, progressSpy);
-    d.notify("working...");
-    $rootScope.$apply();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
-  });
-
   it("can make an immediately rejected promise", function () {
     var fulfilledSpy = jasmine.createSpy();
     var rejectedSpy = jasmine.createSpy();
@@ -592,7 +487,7 @@ describe("q", () => {
   it("can make an immediately resolved promise", function () {
     var fulfilledSpy = jasmine.createSpy();
     var rejectedSpy = jasmine.createSpy();
-    var promise = $q.when("ok");
+    var promise = $q.resolve("ok");
     promise.then(fulfilledSpy, rejectedSpy);
     $rootScope.$apply();
     expect(fulfilledSpy).toHaveBeenCalledWith("ok");
@@ -602,7 +497,7 @@ describe("q", () => {
   it("can wrap a foreign promise", function () {
     var fulfilledSpy = jasmine.createSpy();
     var rejectedSpy = jasmine.createSpy();
-    var promise = $q.when({
+    var promise = $q.resolve({
       then: function (handler) {
         $rootScope.$evalAsync(function () {
           handler("ok");
@@ -618,15 +513,12 @@ describe("q", () => {
   it("takes callbacks directly when wrapping", function () {
     var fulfilledSpy = jasmine.createSpy();
     var rejectedSpy = jasmine.createSpy();
-    var progressSpy = jasmine.createSpy();
     var wrapped = $q.defer();
-    $q.when(wrapped.promise, fulfilledSpy, rejectedSpy, progressSpy);
-    wrapped.notify("working...");
+    $q.resolve(wrapped.promise, fulfilledSpy, rejectedSpy);
     wrapped.resolve("ok");
     $rootScope.$apply();
     expect(fulfilledSpy).toHaveBeenCalledWith("ok");
     expect(rejectedSpy).not.toHaveBeenCalled();
-    expect(progressSpy).toHaveBeenCalledWith("working...");
   });
 
   it("makes an immediately resolved promise with resolve", function () {
@@ -651,7 +543,7 @@ describe("all", function () {
   });
 
   it("can resolve an array of promises to array of results", function () {
-    var promise = $q.all([$q.when(1), $q.when(2), $q.when(3)]);
+    var promise = $q.all([$q.resolve(1), $q.resolve(2), $q.resolve(3)]);
     var fulfilledSpy = jasmine.createSpy();
     promise.then(fulfilledSpy);
     $rootScope.$apply();
@@ -659,7 +551,7 @@ describe("all", function () {
   });
 
   it("can resolve an object of promises to an object of results", function () {
-    var promise = $q.all({ a: $q.when(1), b: $q.when(2) });
+    var promise = $q.all({ a: $q.resolve(1), b: $q.resolve(2) });
     var fulfilledSpy = jasmine.createSpy();
     promise.then(fulfilledSpy);
     $rootScope.$apply();
@@ -683,7 +575,7 @@ describe("all", function () {
   });
 
   it("rejects when any of the promises rejects", function () {
-    var promise = $q.all([$q.when(1), $q.when(2), $q.reject("fail")]);
+    var promise = $q.all([$q.resolve(1), $q.resolve(2), $q.reject("fail")]);
     var fulfilledSpy = jasmine.createSpy();
     var rejectedSpy = jasmine.createSpy();
     promise.then(fulfilledSpy, rejectedSpy);
@@ -693,7 +585,7 @@ describe("all", function () {
   });
 
   it("wraps non-promises in the input collection", function () {
-    var promise = $q.all([$q.when(1), 2, 3]);
+    var promise = $q.all([$q.resolve(1), 2, 3]);
     var fulfilledSpy = jasmine.createSpy();
     promise.then(fulfilledSpy);
     $rootScope.$apply();
@@ -807,12 +699,12 @@ describe("all", function () {
       expect(typeof promise.finally).toBe("function");
     });
 
-    it("should support the instanceof operator", () => {
-      let promise = $q(() => {});
-      expect(promise instanceof $q).toBe(true);
-      promise = new $q(() => {});
-      expect(promise instanceof $q).toBe(true);
-    });
+    // it("should support the instanceof operator", () => {
+    //   let promise = $q(() => {});
+    //   expect(promise instanceof $q).toBe(true);
+    //   promise = new $q(() => {});
+    //   expect(promise instanceof $q).toBe(true);
+    // });
 
     // describe("resolve", () => {
     //   it("should fulfill the promise and execute all success callbacks in the registration order", () => {
@@ -2162,7 +2054,7 @@ describe("all", function () {
   // describe("when", () => {
   //   describe("resolution", () => {
   //     it("should call the success callback in the next turn when the value is a non-promise", () => {
-  //       q.when("hello", success(), error());
+  //       q.resolve("hello", success(), error());
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("success(hello)->hello");
@@ -2170,7 +2062,7 @@ describe("all", function () {
 
   //     it("should call the success callback in the next turn when the value is a resolved promise", () => {
   //       deferred.resolve("hello");
-  //       q.when(deferred.promise, success(), error());
+  //       q.resolve(deferred.promise, success(), error());
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("success(hello)->hello");
@@ -2178,14 +2070,14 @@ describe("all", function () {
 
   //     it("should call the errback in the next turn when the value is a rejected promise", () => {
   //       deferred.reject("nope");
-  //       q.when(deferred.promise, success(), error());
+  //       q.resolve(deferred.promise, success(), error());
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("error(nope)->reject(nope)");
   //     });
 
   //     it("should call the success callback after the original promise is resolved", () => {
-  //       q.when(deferred.promise, success(), error());
+  //       q.resolve(deferred.promise, success(), error());
   //       expect(logStr()).toBe("");
   //       expect(logStr()).toBe("");
   //       syncResolve(deferred, "hello");
@@ -2193,7 +2085,7 @@ describe("all", function () {
   //     });
 
   //     it("should call the errback after the original promise is rejected", () => {
-  //       q.when(deferred.promise, success(), error());
+  //       q.resolve(deferred.promise, success(), error());
   //       expect(logStr()).toBe("");
   //       expect(logStr()).toBe("");
   //       syncReject(deferred, "nope");
@@ -2203,7 +2095,7 @@ describe("all", function () {
 
   //   describe("notification", () => {
   //     it("should call the progressBack when the value is a promise and gets notified", () => {
-  //       q.when(deferred.promise, success(), error(), progress());
+  //       q.resolve(deferred.promise, success(), error(), progress());
   //       expect(logStr()).toBe("");
   //       syncNotify(deferred, "notification");
   //       expect(logStr()).toBe("progress(notification)->notification");
@@ -2219,14 +2111,14 @@ describe("all", function () {
 
   //   describe("optional callbacks", () => {
   //     it("should not require success callback and propagate resolution", () => {
-  //       q.when("hi", null, error()).then(success(2), error());
+  //       q.resolve("hi", null, error()).then(success(2), error());
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("success2(hi)->hi");
   //     });
 
   //     it("should not require success callback and propagate rejection", () => {
-  //       q.when(q.reject("sorry"), null, error(1)).then(success(), error(2));
+  //       q.resolve(q.reject("sorry"), null, error(1)).then(success(), error(2));
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe(
@@ -2235,21 +2127,21 @@ describe("all", function () {
   //     });
 
   //     it("should not require errback and propagate resolution", () => {
-  //       q.when("hi", success(1, "hello")).then(success(2), error());
+  //       q.resolve("hi", success(1, "hello")).then(success(2), error());
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("success1(hi)->hello; success2(hello)->hello");
   //     });
 
   //     it("should not require errback and propagate rejection", () => {
-  //       q.when(q.reject("sorry"), success()).then(success(2), error(2));
+  //       q.resolve(q.reject("sorry"), success()).then(success(2), error(2));
   //       expect(logStr()).toBe("");
   //       mockNextTick.flush();
   //       expect(logStr()).toBe("error2(sorry)->reject(sorry)");
   //     });
 
   //     it("should not require progressBack and propagate notification", () => {
-  //       q.when(deferred.promise).then(success(), error(), progress());
+  //       q.resolve(deferred.promise).then(success(), error(), progress());
   //       expect(logStr()).toBe("");
   //       syncNotify(deferred, "notification");
   //       expect(logStr()).toBe("progress(notification)->notification");
@@ -2261,7 +2153,7 @@ describe("all", function () {
   //       "should return a promise that can be resolved with a value returned from the success " +
   //         "callback",
   //       () => {
-  //         q.when("hello", success(1, "hi"), error()).then(success(2), error());
+  //         q.resolve("hello", success(1, "hi"), error()).then(success(2), error());
   //         mockNextTick.flush();
   //         expect(logStr()).toBe("success1(hello)->hi; success2(hi)->hi");
   //       },
@@ -2271,7 +2163,7 @@ describe("all", function () {
   //       "should return a promise that can be rejected with a rejected promise returned from the " +
   //         "success callback",
   //       () => {
-  //         q.when("hello", success(1, q.reject("sorry")), error()).then(
+  //         q.resolve("hello", success(1, q.reject("sorry")), error()).then(
   //           success(),
   //           error(2),
   //         );
@@ -2283,7 +2175,7 @@ describe("all", function () {
   //     );
 
   //     it("should return a promise that can be resolved with a value returned from the errback", () => {
-  //       q.when(q.reject("sorry"), success(), error(1, "hi")).then(
+  //       q.resolve(q.reject("sorry"), success(), error(1, "hi")).then(
   //         success(2),
   //         error(),
   //       );
@@ -2295,7 +2187,7 @@ describe("all", function () {
   //       "should return a promise that can be rejected with a rejected promise returned from the " +
   //         "errback",
   //       () => {
-  //         q.when(q.reject("sorry"), success(), error(1, q.reject("sigh"))).then(
+  //         q.resolve(q.reject("sorry"), success(), error(1, q.reject("sigh"))).then(
   //           success(),
   //           error(2),
   //         );
@@ -2311,7 +2203,7 @@ describe("all", function () {
   //         "callback",
   //       () => {
   //         const deferred2 = defer();
-  //         q.when("hi", success(1, deferred2.promise), error()).then(
+  //         q.resolve("hi", success(1, deferred2.promise), error()).then(
   //           success(2),
   //           error(),
   //         );
@@ -2329,7 +2221,7 @@ describe("all", function () {
   //         "callback",
   //       () => {
   //         const deferred2 = defer();
-  //         q.when(
+  //         q.resolve(
   //           q.reject("sorry"),
   //           success(),
   //           error(1, deferred2.promise),
@@ -2357,7 +2249,7 @@ describe("all", function () {
   //           },
   //         };
 
-  //         q.when(evilPromise, success(), error());
+  //         q.resolve(evilPromise, success(), error());
   //         expect(logStr()).toBe("");
   //         evilPromise.success("done");
   //         mockNextTick.flush(); // TODO(i) wrong queue, evil promise would be resolved outside of the
@@ -2384,7 +2276,7 @@ describe("all", function () {
   //           },
   //         };
 
-  //         q.when(evilPromise, success(), error());
+  //         q.resolve(evilPromise, success(), error());
   //         expect(logStr()).toBe("");
   //         evilPromise.error("failed");
   //         mockNextTick.flush();
@@ -2408,7 +2300,7 @@ describe("all", function () {
   //           },
   //         };
 
-  //         q.when(evilPromise, success(), error(), progress());
+  //         q.resolve(evilPromise, success(), error(), progress());
   //         expect(logStr()).toBe("");
   //         evilPromise.progress("notification");
   //         evilPromise.success("ok");
@@ -2761,7 +2653,7 @@ describe("all", function () {
   //   describe("in when", () => {
   //     it("should NOT log exceptions thrown in a success callback but reject the derived promise", () => {
   //       const success1 = success(1, "oops", true);
-  //       q.when("hi", success1, error())
+  //       q.resolve("hi", success1, error())
   //         .then(success(), error(2))
   //         .catch(() => {});
   //       mockNextTick.flush();
@@ -2772,7 +2664,7 @@ describe("all", function () {
   //     });
 
   //     it("should NOT log exceptions when a success callback returns rejected promise", () => {
-  //       q.when("hi", success(1, q.reject("rejected")))
+  //       q.resolve("hi", success(1, q.reject("rejected")))
   //         .then(success(2), error(2))
   //         .catch(() => {});
   //       mockNextTick.flush();
@@ -2784,7 +2676,7 @@ describe("all", function () {
 
   //     it("should NOT log exceptions thrown in a errback but reject the derived promise", () => {
   //       const error1 = error(1, "oops", true);
-  //       q.when(q.reject("sorry"), success(), error1)
+  //       q.resolve(q.reject("sorry"), success(), error1)
   //         .then(success(), error(2))
   //         .catch(() => {});
   //       mockNextTick.flush();
@@ -2795,7 +2687,7 @@ describe("all", function () {
   //     });
 
   //     it("should NOT log exceptions when an errback returns a rejected promise", () => {
-  //       q.when(q.reject("sorry"), success(), error(1, q.reject("rejected")))
+  //       q.resolve(q.reject("sorry"), success(), error(1, q.reject("rejected")))
   //         .then(success(2), error(2))
   //         .catch(() => {});
   //       mockNextTick.flush();

package/src/core/task-tracker-factory.js

@@ -1,122 +1,138 @@
-export function $$TaskTrackerFactoryProvider() {
-  this.$get = [
+export class $$TaskTrackerFactoryProvider {
+  $get = [
     "$log",
-    /** @param {import('../services/log').LogService} log */
+    /**
+     * Creates a new `TaskTracker` instance.
+     *
+     * @param {import('../services/log').LogService} log - The logging service.
+     * @returns {TaskTracker} A new `TaskTracker` instance.
+     */
     (log) => new TaskTracker(log),
   ];
 }
 
 /**
- * ! This is a private undocumented service !
+ * A factory function to create `TaskTracker` instances.
  *
- * @name $$taskTrackerFactory
- * @description
- * A function to create `TaskTracker` instances.
- *
- * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+ * A `TaskTracker` tracks pending tasks (grouped by type) and notifies interested
  * parties when all pending tasks (or tasks of a specific type) have been completed.
- * @param {import('../services/log').LogService} log
  */
-export function TaskTracker(log) {
-  const self = this;
-  const taskCounts = {};
-  const taskCallbacks = [];
-
-  const ALL_TASKS_TYPE = (self.ALL_TASKS_TYPE = "$$all$$");
-  const DEFAULT_TASK_TYPE = (self.DEFAULT_TASK_TYPE = "$$default$$");
-
+export class TaskTracker {
   /**
-   * Execute the specified function and decrement the appropriate `taskCounts` counter.
-   * If the counter reaches 0, all corresponding `taskCallbacks` are executed.
-   *
-   * @param {Function} fn - The function to execute.
-   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task that is being completed.
+   * @param {import('../services/log').LogService} log - The logging service.
    */
-  self.completeTask = completeTask;
+  constructor(log) {
+    /** @private */
+    this.log = log;
 
-  /**
-   * Increase the task count for the specified task type (or the default task type if non is
-   * specified).
-   *
-   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
-   */
-  self.incTaskCount = incTaskCount;
+    /** @private */
+    this.taskCounts = {};
+
+    /** @private */
+    this.taskCallbacks = [];
+
+    /**
+     * Special task types used for tracking all tasks and default tasks.
+     * @type {string}
+     */
+    this.ALL_TASKS_TYPE = "$$all$$";
+
+    /**
+     * Default task type.
+     * @type {string}
+     */
+    this.DEFAULT_TASK_TYPE = "$$default$$";
+  }
 
   /**
-   * Execute the specified callback when all pending tasks have been completed.
-   *
-   * If there are no pending tasks, the callback is executed immediately. You can optionally limit
-   * the tasks that will be waited for to a specific type, by passing a `taskType`.
+   * Completes a task and decrements the associated task counter.
+   * If the counter reaches 0, all corresponding callbacks are executed.
    *
-   * @param {function} callback - The function to call when there are no pending tasks.
-   * @param {string=} [taskType=ALL_TASKS_TYPE] - The type of tasks that will be waited for.
+   * @param {Function} fn - The function to execute when completing the task.
+   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task being completed.
    */
-  self.notifyWhenNoPendingTasks = notifyWhenNoPendingTasks;
-
-  function completeTask(fn, taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
-
+  completeTask(fn, taskType = this.DEFAULT_TASK_TYPE) {
     try {
       fn();
     } finally {
-      decTaskCount(taskType);
+      if (this.taskCounts[taskType]) {
+        this.taskCounts[taskType]--;
+        this.taskCounts[this.ALL_TASKS_TYPE]--;
+      }
 
-      const countForType = taskCounts[taskType];
-      const countForAll = taskCounts[ALL_TASKS_TYPE];
+      const countForType = this.taskCounts[taskType];
+      const countForAll = this.taskCounts[this.ALL_TASKS_TYPE];
 
-      // If at least one of the queues (`ALL_TASKS_TYPE` or `taskType`) is empty, run callbacks.
+      // If either the overall task queue or the specific task type queue is empty, run callbacks.
       if (!countForAll || !countForType) {
         const getNextCallback = !countForAll
-          ? getLastCallback
-          : getLastCallbackForType;
-        let nextCb;
+          ? this.getLastCallback.bind(this)
+          : () => this.getLastCallbackForType(taskType);
 
-        while ((nextCb = getNextCallback(taskType))) {
+        let nextCb;
+        while ((nextCb = getNextCallback())) {
           try {
             nextCb();
           } catch (e) {
-            log.error(e);
+            this.log.error(e);
           }
         }
       }
     }
   }
 
-  function decTaskCount(taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
-    if (taskCounts[taskType]) {
-      taskCounts[taskType]--;
-      taskCounts[ALL_TASKS_TYPE]--;
+  /**
+   * Increments the task count for the specified task type.
+   *
+   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
+   */
+  incTaskCount(taskType = this.DEFAULT_TASK_TYPE) {
+    this.taskCounts[taskType] = (this.taskCounts[taskType] || 0) + 1;
+    this.taskCounts[this.ALL_TASKS_TYPE] =
+      (this.taskCounts[this.ALL_TASKS_TYPE] || 0) + 1;
+  }
+
+  /**
+   * Registers a callback to be executed when all pending tasks of the specified type are completed.
+   * If there are no pending tasks of the specified type, the callback is executed immediately.
+   *
+   * @param {Function} callback - The function to execute when no pending tasks remain.
+   * @param {string} [taskType=this.ALL_TASKS_TYPE] - The type of tasks to wait for completion.
+   */
+  notifyWhenNoPendingTasks(callback, taskType = this.ALL_TASKS_TYPE) {
+    if (!this.taskCounts[taskType]) {
+      callback();
+    } else {
+      this.taskCallbacks.push({ type: taskType, cb: callback });
     }
   }
 
-  function getLastCallback() {
-    const cbInfo = taskCallbacks.pop();
-    return cbInfo && cbInfo.cb;
+  /**
+   * Retrieves and removes the last registered callback from the queue.
+   *
+   * @private
+   * @returns {Function|undefined} The last callback function or undefined if none exist.
+   */
+  getLastCallback() {
+    const cbInfo = this.taskCallbacks.pop();
+    return cbInfo ? cbInfo.cb : undefined;
   }
 
-  function getLastCallbackForType(taskType) {
-    for (let i = taskCallbacks.length - 1; i >= 0; --i) {
-      const cbInfo = taskCallbacks[i];
+  /**
+   * Retrieves and removes the last registered callback for the specified task type.
+   *
+   * @private
+   * @param {string} taskType - The type of task for which the callback was registered.
+   * @returns {Function|undefined} The last callback function for the task type, or undefined if none exist.
+   */
+  getLastCallbackForType(taskType) {
+    for (let i = this.taskCallbacks.length - 1; i >= 0; --i) {
+      const cbInfo = this.taskCallbacks[i];
       if (cbInfo.type === taskType) {
-        taskCallbacks.splice(i, 1);
+        this.taskCallbacks.splice(i, 1);
         return cbInfo.cb;
       }
     }
-  }
-
-  function incTaskCount(taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
-    taskCounts[taskType] = (taskCounts[taskType] || 0) + 1;
-    taskCounts[ALL_TASKS_TYPE] = (taskCounts[ALL_TASKS_TYPE] || 0) + 1;
-  }
-
-  function notifyWhenNoPendingTasks(callback, taskType) {
-    taskType = taskType || ALL_TASKS_TYPE;
-    if (!taskCounts[taskType]) {
-      callback();
-    } else {
-      taskCallbacks.push({ type: taskType, cb: callback });
-    }
+    return undefined;
   }
 }

package/src/directive/model/model.js

@@ -163,7 +163,7 @@ export class NgModelController {
     this.$$animate = $animate;
     this.$$timeout = $timeout;
     this.$$parse = $parse;
-    this.$$q = $q;
+    this.$q = $q;
     this.$$exceptionHandler = $exceptionHandler;
 
     this.$$hasNativeValidators = false;
@@ -650,7 +650,7 @@ export class NgModelController {
       if (!validatorPromises.length) {
         validationDone(true);
       } else {
-        that.$$q.all(validatorPromises).then(
+        that.$q.all(validatorPromises).then(
           () => {
             validationDone(allValid);
           },

package/src/router/common/coreservices.js

@@ -1,5 +1,6 @@
-const services = {
+export const services = {
+  /** @type {import("../../core/q/q").QService} */
   $q: undefined,
+  /** @type {import("../../core/di/internal-injector").InjectorService} */
   $injector: undefined,
 };
-export { services };

package/src/router/directives/state-directives.spec.js

@@ -1019,7 +1019,7 @@ describe("ngSrefActive", () => {
       name: "contacts.lazy.**",
       url: "/lazy",
       lazyLoad: () => {
-        return $q.when().then(() => {
+        return $q.resolve().then(() => {
           _stateProvider
             .state({ name: "contacts.lazy", abstract: true, url: "/lazy" })
             .state({ name: "contacts.lazy.s1", url: "/s1" })
@@ -1103,7 +1103,7 @@ describe("ngSrefActive", () => {
         name: "contacts.lazy.**",
         url: "/lazy",
         lazyLoad: () => {
-          return $q.when().then(() => {
+          return $q.resolve().then(() => {
             _stateProvider
               .state({ name: "contacts.lazy", abstract: true, url: "/lazy" })
               .state({ name: "contacts.lazy.s1", url: "/s1" })