@angular-wave/angular.ts 0.4.4 → 0.4.5

package/src/core/interval/interval.spec.js

@@ -0,0 +1,280 @@
+import { Angular } from "../../loader";
+import { createInjector } from "../di/injector";
+import { wait } from "../../shared/test-utils";
+
+describe("$interval", () => {
+  let injector;
+  let $interval;
+  let $rootScope;
+  let errors;
+
+  beforeEach(() => {
+    errors = [];
+    window.angular = new Angular();
+    window.angular
+      .module("myModule", ["ng"])
+      .decorator("$exceptionHandler", () => {
+        return (exception) => {
+          errors.push(exception);
+        };
+      });
+    injector = createInjector(["myModule"]);
+
+    $interval = injector.get("$interval");
+    $rootScope = injector.get("$rootScope");
+  });
+
+  it("should run tasks repeatedly", async () => {
+    let counter = 0;
+    $interval(() => {
+      counter++;
+    }, 1);
+    expect(counter).toBe(0);
+    await wait(15);
+    expect(counter).toBeGreaterThanOrEqual(1);
+  });
+
+  it("should call $apply after each task is executed", (done) => {
+    const applySpy = spyOn($rootScope, "$apply").and.callThrough();
+
+    $interval(() => {}, 1);
+    expect(applySpy).not.toHaveBeenCalled();
+
+    setTimeout(() => {
+      expect(applySpy).toHaveBeenCalled();
+    }, 3);
+
+    applySpy.calls.reset();
+
+    $interval(() => {}, 1);
+    $interval(() => {}, 1);
+
+    setTimeout(() => {
+      expect(applySpy).toHaveBeenCalledTimes(3);
+      done();
+    }, 1);
+  });
+
+  it("should allow you to specify a number of iterations", async () => {
+    let counter = 0;
+    $interval(
+      () => {
+        counter++;
+      },
+      1,
+      2,
+    );
+
+    await wait(15);
+    expect(counter).toBe(2);
+  });
+
+  it("should allow you to specify a number of arguments", (done) => {
+    const task1 = jasmine.createSpy("task1");
+    const task2 = jasmine.createSpy("task2");
+    const task3 = jasmine.createSpy("task3");
+    $interval(task1, 1, 2, true, "Task1");
+    $interval(task2, 1, 2, true, "Task2");
+    $interval(task3, 1, 2, true, "I", "am", "a", "Task3", "spy");
+
+    setTimeout(() => {
+      expect(task1).toHaveBeenCalledWith("Task1");
+      expect(task2).toHaveBeenCalledWith("Task2");
+      expect(task3).toHaveBeenCalledWith("I", "am", "a", "Task3", "spy");
+    }, 1);
+
+    task1.calls.reset();
+    task2.calls.reset();
+    task3.calls.reset();
+
+    setTimeout(() => {
+      expect(task1).toHaveBeenCalledWith("Task1");
+      expect(task2).toHaveBeenCalledWith("Task2");
+      expect(task3).toHaveBeenCalledWith("I", "am", "a", "Task3", "spy");
+      done();
+    }, 1);
+  });
+
+  it("should return a promise which will be updated with the count on each iteration", async () => {
+    const log = [];
+    const promise = $interval(() => {
+      log.push("tick");
+    }, 1);
+
+    promise.then(
+      (value) => {
+        log.push(`promise success: ${value}`);
+      },
+      (err) => {
+        log.push(`promise error: ${err}`);
+      },
+      (note) => {
+        log.push(`promise update: ${note}`);
+      },
+    );
+    expect(log).toEqual([]);
+
+    await wait(5);
+    expect(log[0]).toEqual("tick");
+    expect(log[1]).toEqual("tick");
+  });
+
+  it("should return a promise which will be resolved after the specified number of iterations", async () => {
+    const log = [];
+    const promise = $interval(
+      () => {
+        log.push("tick");
+      },
+      1,
+      2,
+    );
+
+    promise.then(
+      (value) => {
+        log.push(`promise success: ${value}`);
+      },
+      (err) => {
+        log.push(`promise error: ${err}`);
+      },
+    );
+    expect(log).toEqual([]);
+    await wait(15);
+    expect(log).toEqual(["tick", "tick", "promise success: 2"]);
+  });
+
+  describe("exception handling", () => {
+    it("should delegate exception to the $exceptionHandler service", (done) => {
+      errors = [];
+      $interval(() => {
+        throw "Test Error";
+      }, 10);
+
+      setTimeout(() => {
+        expect(errors).toContain("Test Error");
+        done();
+      }, 20);
+    });
+
+    it("should call $apply even if an exception is thrown in callback", (done) => {
+      const applySpy = spyOn($rootScope, "$apply").and.callThrough();
+
+      $interval(() => {
+        throw "Test Error2";
+      }, 10);
+      expect(applySpy).not.toHaveBeenCalled();
+
+      setTimeout(() => {
+        expect(applySpy).toHaveBeenCalled();
+        done();
+      }, 11);
+    });
+  });
+
+  describe("cancel", () => {
+    it("should cancel tasks", (done) => {
+      const task1 = jasmine.createSpy("task1", 1);
+      const task2 = jasmine.createSpy("task2", 1);
+      const task3 = jasmine.createSpy("task3", 1);
+      let promise1;
+      let promise3;
+
+      promise1 = $interval(task1, 2);
+      $interval(task2, 1);
+      promise3 = $interval(task3, 3);
+
+      $interval.cancel(promise3);
+      $interval.cancel(promise1);
+      setTimeout(() => {
+        expect(task1).not.toHaveBeenCalled();
+        expect(task2).toHaveBeenCalled();
+        expect(task3).not.toHaveBeenCalled();
+        done();
+      }, 1);
+    });
+
+    it("should cancel the promise", (done) => {
+      const promise = $interval(() => {}, 1);
+      const log = [];
+      promise.then(
+        (value) => {
+          log.push(`promise success: ${value}`);
+        },
+        (err) => {
+          log.push(`promise error: ${err}`);
+        },
+      );
+      expect(log).toEqual([]);
+
+      setTimeout(() => {
+        $interval.cancel(promise);
+      }, 1);
+
+      setTimeout(() => {
+        $rootScope.$apply(); // For resolving the promise -
+        // necessary since q uses $rootScope.evalAsync.
+
+        expect(log).toEqual(["promise error: canceled"]);
+        done();
+      }, 2);
+    });
+
+    it("should return true if a task was successfully canceled", (done) => {
+      const task1 = jasmine.createSpy("task1");
+      const task2 = jasmine.createSpy("task2");
+      let promise1;
+      let promise2;
+
+      promise1 = $interval(task1, 1, 1);
+      setTimeout(() => {
+        promise2 = $interval(task2, 1, 1);
+
+        expect($interval.cancel(promise1)).toBe(false);
+        expect($interval.cancel(promise2)).toBe(true);
+        done();
+      }, 1);
+    });
+
+    it("should not throw an error when given an undefined promise", () => {
+      expect($interval.cancel()).toBe(false);
+    });
+
+    it("should throw an error when given a non-$interval promise", () => {
+      const promise = $interval(() => {}).then(() => {});
+      expect(() => {
+        $interval.cancel(promise);
+      }).toThrowError(/badprom/);
+    });
+
+    it("should not trigger digest when cancelled", () => {
+      const watchSpy = jasmine.createSpy("watchSpy");
+      $rootScope.$watch(watchSpy);
+
+      const t = $interval();
+      $interval.cancel(t);
+      expect(watchSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("$window delegation", () => {
+    it("should use $window.setInterval instead of the global function", () => {
+      const setIntervalSpy = spyOn(window, "setInterval");
+
+      $interval(() => {}, 1);
+      expect(setIntervalSpy).toHaveBeenCalled();
+    });
+
+    it("should use $window.clearInterval instead of the global function", (done) => {
+      const clearIntervalSpy = spyOn(window, "clearInterval");
+
+      $interval(() => {}, 1, 1);
+      setTimeout(() => {
+        expect(clearIntervalSpy).toHaveBeenCalled();
+
+        clearIntervalSpy.calls.reset();
+        $interval.cancel($interval(() => {}, 1));
+        expect(clearIntervalSpy).toHaveBeenCalled();
+        done();
+      }, 1);
+    });
+  });
+});

package/src/core/interval/interval.test.js

@@ -5,7 +5,7 @@ const TEST_URL = "src/core/interval/interval.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
-  await page.waitForTimeout(100);
+  await page.waitForTimeout(500);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/core/location/location.js

@@ -2,7 +2,6 @@ import { JQLite } from "../../shared/jqlite/jqlite";
 import { urlResolve } from "../url-utils/url-utils";
 import {
   encodeUriSegment,
-  isBoolean,
   isDefined,
   isNumber,
   isObject,
@@ -13,6 +12,7 @@ import {
   toInt,
   toKeyValue,
 } from "../../shared/utils";
+import { ScopePhase } from "../scope/scope";
 
 /**
  * @typedef {Object} DefaultPorts
@@ -329,7 +329,6 @@ export class Location {
     // so the modification window is narrow.
     this.$$state = isUndefined(state) ? null : state;
     this.$$urlUpdatedByLocation = true;
-
     return this;
   }
 
@@ -543,26 +542,28 @@ export class LocationHashbangUrl extends Location {
   }
 }
 
-export function LocationProvider() {
-  let hashPrefix = "!";
-  const html5Mode = {
-    enabled: false,
-    requireBase: true,
-    rewriteLinks: true,
-  };
+export class LocationProvider {
+  constructor() {
+    this.hashPrefixValue = "!";
+    this.html5ModeConfig = {
+      enabled: false,
+      requireBase: true,
+      rewriteLinks: true,
+    };
+  }
 
   /**
    * The default value for the prefix is `'!'`.
-   * @param {string=} prefix Prefix for hash part (containing path and search)
-   * @returns {*} current value if used as getter or itself (chaining) if used as setter
+   * @param {string=} prefix - Prefix for hash part (containing path and search)
+   * @returns {string|LocationProvider} current value if used as getter or itself (chaining) if used as setter
    */
-  this.hashPrefix = function (prefix) {
-    if (isDefined(prefix)) {
-      hashPrefix = prefix;
+  hashPrefix(prefix) {
+    if (typeof prefix !== "undefined") {
+      this.hashPrefixValue = prefix;
       return this;
     }
-    return hashPrefix;
-  };
+    return this.hashPrefixValue;
+  }
 
   /**
    * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
@@ -584,30 +585,29 @@ export function LocationProvider() {
    *
    * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
    */
-  this.html5Mode = function (mode) {
-    if (isBoolean(mode)) {
-      html5Mode.enabled = mode;
+  html5Mode(mode) {
+    if (typeof mode === "boolean") {
+      this.html5ModeConfig.enabled = mode;
       return this;
     }
-    if (isObject(mode)) {
-      if (isBoolean(mode.enabled)) {
-        html5Mode.enabled = mode.enabled;
-      }
 
-      if (isBoolean(mode.requireBase)) {
-        html5Mode.requireBase = mode.requireBase;
-      }
-
-      if (isBoolean(mode.rewriteLinks) || isString(mode.rewriteLinks)) {
-        html5Mode.rewriteLinks = mode.rewriteLinks;
+    if (typeof mode === "object") {
+      if (typeof mode.enabled === "boolean")
+        this.html5ModeConfig.enabled = mode.enabled;
+      if (typeof mode.requireBase === "boolean")
+        this.html5ModeConfig.requireBase = mode.requireBase;
+      if (
+        typeof mode.rewriteLinks === "boolean" ||
+        typeof mode.rewriteLinks === "string"
+      ) {
+        this.html5ModeConfig.rewriteLinks = mode.rewriteLinks;
       }
-
       return this;
     }
-    return html5Mode;
-  };
+    return this.html5ModeConfig;
+  }
 
-  this.$get = [
+  $get = [
     "$rootScope",
     "$browser",
     "$rootElement",
@@ -626,8 +626,8 @@ export function LocationProvider() {
       const initialUrl = /** @type {string} */ ($browser.url());
       let appBase;
 
-      if (html5Mode.enabled) {
-        if (!baseHref && html5Mode.requireBase) {
+      if (this.html5Mode.enabled) {
+        if (!baseHref && this.html5Mode.requireBase) {
           throw $locationMinErr(
             "nobase",
             "$location in HTML5 mode requires a <base> tag to be present!",
@@ -641,7 +641,11 @@ export function LocationProvider() {
       }
       const appBaseNoFile = stripFile(appBase);
 
-      $location = new LocationMode(appBase, appBaseNoFile, `#${hashPrefix}`);
+      $location = new LocationMode(
+        appBase,
+        appBaseNoFile,
+        `#${this.hashPrefix}`,
+      );
       $location.$$parseLinkUrl(initialUrl, initialUrl);
 
       $location.$$state = $browser.state();
@@ -668,7 +672,7 @@ export function LocationProvider() {
       }
 
       $rootElement.on("click", (event) => {
-        const { rewriteLinks } = html5Mode;
+        const { rewriteLinks } = this.html5Mode;
         // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
         // currently we open nice url link and redirect then
 
@@ -767,10 +771,11 @@ export function LocationProvider() {
             afterLocationChange(oldUrl, oldState);
           }
         });
+        if ($rootScope.$$phase === ScopePhase.NONE) $rootScope.$digest();
       });
 
       // update browser
-      $rootScope.$watch(() => {
+      function browserUpdate() {
         if (initializing || $location.$$urlUpdatedByLocation) {
           $location.$$urlUpdatedByLocation = false;
 
@@ -818,7 +823,9 @@ export function LocationProvider() {
 
         // we don't need to return anything because $evalAsync will make the digest loop dirty when
         // there is a change
-      });
+      }
+
+      setTimeout(() => browserUpdate());
 
       return $location;
 
@@ -830,6 +837,7 @@ export function LocationProvider() {
           $location.$$state,
           oldState,
         );
+        browserUpdate();
       }
     },
   ];

package/src/core/location/location.spec.js

@@ -785,7 +785,7 @@ describe("$location", () => {
   //         $browser,
   //         "url",
   //       ).and.callThrough();
-  //       ;
+  //       $rootScope.$digest();
   //       expect($browserUrl).not.toHaveBeenCalled();
   //     });
   //   });
@@ -815,7 +815,7 @@ describe("$location", () => {
   //         }
   //       });
   //       expect($browser.url()).toEqual("http://server/base/#!/home");
-  //       ;
+  //       $rootScope.$digest();
   //       expect(handlerCalled).toEqual(true);
   //       expect($browser.url()).toEqual("http://server/base/#!/");
   //     });
@@ -829,7 +829,7 @@ describe("$location", () => {
   //     });
   //     inject(($location, $browser, $rootScope) => {
   //       expect(() => {
-  //         ;
+  //         $rootScope.$digest();
   //       }).not.toThrow();
   //     });
   //   });
@@ -843,7 +843,7 @@ describe("$location", () => {
   //     });
   //     inject(($location, $browser, $rootScope) => {
   //       expect(() => {
-  //         ;
+  //         $rootScope.$digest();
   //       }).not.toThrow();
   //     });
   //   });
@@ -857,7 +857,7 @@ describe("$location", () => {
   //     });
   //     inject(($location, $browser, $rootScope) => {
   //       expect(() => {
-  //         ;
+  //         $rootScope.$digest();
   //       }).not.toThrow();
   //     });
   //   });
@@ -867,10 +867,10 @@ describe("$location", () => {
   //     initService({ html5Mode: true, supportHistory: true });
   //     mockUpBrowser({ initialUrl: "http://localhost:9876/", baseHref: "/" });
   //     inject(($location, $browser, $rootScope) => {
-  //       ;
+  //       $rootScope.$digest();
   //       $browser.url("http://localhost:9876/?q='");
   //       expect(() => {
-  //         ;
+  //         $rootScope.$digest();
   //       }).not.toThrow();
   //     });
   //   });
@@ -880,7 +880,7 @@ describe("$location", () => {
   //     initService({ html5Mode: true, supportHistory: true });
   //     mockUpBrowser({ initialUrl: "http://localhost:9876/", baseHref: "/" });
   //     inject(($window, $location, $browser, $rootScope) => {
-  //       ;
+  //       $rootScope.$digest();
   //       $window.location.href = "http://localhost:9876/?q='";
   //       expect(() => {
   //         JQLite($window).triggerHandler("popstate");
@@ -901,7 +901,7 @@ describe("$location", () => {
   //       $window,
   //     ) => {
   //       $location.url("baz");
-  //       ;
+  //       $rootScope.$digest();
 
   //       const originalUrl = $window.location.href;
 
@@ -931,7 +931,7 @@ describe("$location", () => {
   //       $window,
   //     ) => {
   //       $location.url("baz");
-  //       ;
+  //       $rootScope.$digest();
 
   //       $rootScope.$apply(() => {
   //         $rootScope.$evalAsync(() => {
@@ -969,7 +969,7 @@ describe("$location", () => {
 
   //         updatePathOnLocationChangeSuccessTo("/Home");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/Home");
   //         expect($location.path()).toEqual("/Home");
@@ -991,7 +991,7 @@ describe("$location", () => {
 
   //         updatePathOnLocationChangeSuccessTo("/");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/");
   //         expect($location.path()).toEqual("/");
@@ -1014,7 +1014,7 @@ describe("$location", () => {
   //         ).and.callThrough();
 
   //         updatePathOnLocationChangeSuccessTo("/Home");
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/Home");
   //         expect($location.path()).toEqual("/Home");
@@ -1037,7 +1037,7 @@ describe("$location", () => {
   //         ).and.callThrough();
 
   //         updatePathOnLocationChangeSuccessTo("/");
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/#!/");
   //         expect($location.path()).toEqual("/");
@@ -1059,7 +1059,7 @@ describe("$location", () => {
   //         const $location = $injector.get("$location");
   //         updatePathOnLocationChangeSuccessTo("/Home");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/Home");
   //         expect($location.path()).toEqual("/Home");
@@ -1079,7 +1079,7 @@ describe("$location", () => {
   //         const $location = $injector.get("$location");
   //         updatePathOnLocationChangeSuccessTo("/");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/");
   //         expect($location.path()).toEqual("/");
@@ -1099,7 +1099,7 @@ describe("$location", () => {
   //         const $location = $injector.get("$location");
   //         updatePathOnLocationChangeSuccessTo("/Home");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/Home");
   //         expect($location.path()).toEqual("/Home");
@@ -1119,7 +1119,7 @@ describe("$location", () => {
   //         const $location = $injector.get("$location");
   //         updatePathOnLocationChangeSuccessTo("/");
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($browser.url()).toEqual("http://server/app/");
   //         expect($location.path()).toEqual("/");
@@ -1140,7 +1140,7 @@ describe("$location", () => {
   //         const $location = $injector.get("$location");
   //         updatePathOnLocationChangeSuccessTo("/", { q: "'" });
 
-  //         ;
+  //         $rootScope.$digest();
 
   //         expect($location.path()).toEqual("/");
   //         expect($location.search()).toEqual({ q: "'" });
@@ -1200,7 +1200,7 @@ describe("$location", () => {
   //         }
   //       });
 
-  //       ;
+  //       $rootScope.$digest();
   //       expect($location.absUrl()).toBe(NEW_URL);
   //     });
   //   });
@@ -1299,7 +1299,7 @@ describe("$location", () => {
   //         },
   //       );
 
-  //       ;
+  //       $rootScope.$digest();
   //       expect($browser.url()).toBe("http://new.com/a/b#!/changed");
   //     });
   //   });
@@ -1310,7 +1310,7 @@ describe("$location", () => {
   //     inject(($rootScope, $browser, $location) => {
   //       $location.hash("test");
 
-  //       ;
+  //       $rootScope.$digest();
   //       expect($browser.url()).toBe("http://new.com/a/b##test");
   //     });
   //   });
@@ -1334,7 +1334,7 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://new.com/a/b/", baseHref: "/a/b/" });
   //     inject(($location, $rootScope, $window) => {
   //       $window.history.pushState({ b: 3 });
-  //       ;
+  //       $rootScope.$digest();
 
   //       expect($location.state()).toEqual({ b: 3 });
 
@@ -1343,7 +1343,7 @@ describe("$location", () => {
   //         null,
   //         `${$window.location.href}c?d=e#f`,
   //       );
-  //       ;
+  //       $rootScope.$digest();
 
   //       expect($location.path()).toBe("/c");
   //       expect($location.search()).toEqual({ d: "e" });
@@ -1358,10 +1358,10 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://server/app/", baseHref: "/app/" });
   //     inject(($rootScope, $injector, $window) => {
   //       const $location = $injector.get("$location");
-  //       ; // allow $location initialization to finish
+  //       $rootScope.$digest(); // allow $location initialization to finish
 
   //       $window.history.pushState({}, null, "http://server/app/Home?q='");
-  //       ;
+  //       $rootScope.$digest();
 
   //       expect($location.absUrl()).toEqual("http://server/app/Home?q='");
   //       expect($location.path()).toEqual("/Home");
@@ -1375,7 +1375,7 @@ describe("$location", () => {
   //     mockUpBrowser({ initialUrl: "http://server/app/", baseHref: "/app/" });
   //     inject(($rootScope, $injector, $window) => {
   //       const $location = $injector.get("$location");
-  //       ; // allow $location initialization to finish
+  //       $rootScope.$digest(); // allow $location initialization to finish
 
   //       $window.location.href = "http://server/app/Home?q='";
   //       JQLite($window).triggerHandler("popstate");