@angular-wave/angular.ts 0.4.4 → 0.4.6

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
@@ -42,6 +42,8 @@ export class Location {
    * @param {string} appBaseNoFile application base URL stripped of any filename
    */
   constructor(appBase, appBaseNoFile) {
+    const parsedUrl = urlResolve(appBase);
+
     /** @type {string} */
     this.appBase = appBase;
 
@@ -67,16 +69,17 @@ export class Location {
     this.$$replace = false;
 
     /** @type {import('../url-utils/url-utils').HttpProtocol} */
-    this.$$protocol = undefined;
+    this.$$protocol = parsedUrl.protocol;
 
     /** @type {string} */
-    this.$$host = undefined;
+    this.$$host = parsedUrl.hostname;
 
     /**
      * The port, without ":"
      * @type {number}
      */
-    this.$$port = undefined;
+    this.$$port =
+      toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
 
     /**
      * The pathname, beginning with "/"
@@ -329,7 +332,6 @@ export class Location {
     // so the modification window is narrow.
     this.$$state = isUndefined(state) ? null : state;
     this.$$urlUpdatedByLocation = true;
-
     return this;
   }
 
@@ -360,7 +362,6 @@ export class LocationHtml5Url extends Location {
     super(appBase, appBaseNoFile);
     this.$$html5 = true;
     this.basePrefix = basePrefix || "";
-    parseAbsoluteUrl(appBase, this);
   }
 
   /**
@@ -443,10 +444,7 @@ export class LocationHtml5Url extends Location {
 export class LocationHashbangUrl extends Location {
   constructor(appBase, appBaseNoFile, hashPrefix) {
     super(appBase, appBaseNoFile);
-    this.appBase = appBase;
-    this.appBaseNoFile = appBaseNoFile;
     this.hashPrefix = hashPrefix;
-    parseAbsoluteUrl(appBase, this);
   }
 
   /**
@@ -543,26 +541,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 +584,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 +625,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 +640,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 +671,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 +770,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 +822,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 +836,7 @@ export function LocationProvider() {
           $location.$$state,
           oldState,
         );
+        browserUpdate();
       }
     },
   ];
@@ -882,19 +889,6 @@ function normalizePath(pathValue, searchValue, hashValue) {
   return path + (search ? `?${search}` : "") + hash;
 }
 
-/**
- * @param {string} absoluteUrl
- * @param {Location} locationObj
- */
-function parseAbsoluteUrl(absoluteUrl, locationObj) {
-  const parsedUrl = urlResolve(absoluteUrl);
-
-  locationObj.$$protocol = parsedUrl.protocol;
-  locationObj.$$host = parsedUrl.hostname;
-  locationObj.$$port =
-    toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
-}
-
 function parseAppUrl(url, locationObj, html5Mode) {
   if (/^\s*[\\/]{2,}/.test(url)) {
     throw $locationMinErr("badpath", 'Invalid url "{0}".', url);