@angular-wave/angular.ts 0.0.26 → 0.0.28

package/src/router/url/url-service.js

@@ -1,21 +1,21 @@
-import { isString } from "../../shared/utils";
+import { isDefined, isObject, isString } from "../../shared/utils";
 import { is, pattern } from "../../shared/hof";
 import { UrlRules } from "./url-rules";
 import { UrlConfig } from "./url-config";
 import { TargetState } from "../state/target-state";
+import { removeFrom } from "../../shared/common";
+
 /**
  * API for URL management
  */
 export class UrlService {
   /**
-   *
-   * @param {import('../router').UIRouter} router
+   * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor(router) {
-    /**
-     * @type {import('../router').UIRouter}
-     */
-    this.router = router;
+  constructor($locationProvider, urlRuleFactory, stateService) {
+    this.stateService = stateService;
+
+    this.$locationProvider = $locationProvider;
 
     /** @type {boolean} */
     this.interceptDeferred = false;
@@ -25,69 +25,15 @@ export class UrlService {
      * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
-    this.rules = new UrlRules(this.router);
+    this.rules = new UrlRules(urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
      * @type {UrlConfig}
      */
-    this.config = new UrlConfig(this.router);
-    // Delegate these calls to the current LocationServices implementation
-    /**
-     * Gets the current url, or updates the url
-     *
-     * ### Getting the current URL
-     *
-     * When no arguments are passed, returns the current URL.
-     * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
-     *
-     * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
-     * have a base HREF prepended ([[PushStateLocationServices]]).
-     *
-     * The raw URL in the browser might be:
-     *
-     * ```
-     * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
-     * ```
-     *
-     * or
-     *
-     * ```
-     * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
-     * ```
-     *
-     * then this method returns:
-     *
-     * ```
-     * /internal/path/123?param1=foo#anchor
-     * ```
-     *
-     *
-     * #### Example:
-     * ```js
-     * locationServices.url(); // "/some/path?query=value#anchor"
-     * ```
-     *
-     * ### Updating the URL
-     *
-     * When `newurl` arguments is provided, changes the URL to reflect `newurl`
-     *
-     * #### Example:
-     * ```js
-     * locationServices.url("/some/path?query=value#anchor", true);
-     * ```
-     *
-     * @param {string} newurl The new value for the URL.
-     *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
-     *               It should not include the protocol, site, port, or base path of an absolute HREF.
-     * @param {boolean} replace When true, replaces the current history entry (instead of appending it) with this new url
-     * @param {any} state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
-     *
-     * @return the url (after potentially being processed)
-     */
-    this.url = (newurl, replace, state) =>
-      this.router.locationService.url(newurl, replace, state);
+    this.config = new UrlConfig();
+
     /**
      * Gets the path part of the current url
      *
@@ -95,7 +41,7 @@ export class UrlService {
      *
      * @return the path portion of the url
      */
-    this.path = () => this.router.locationService.path();
+    this.path = () => this.$location.path();
     /**
      * Gets the search part of the current url as an object
      *
@@ -103,7 +49,7 @@ export class UrlService {
      *
      * @return the search (query) portion of the url, as an object
      */
-    this.search = () => this.router.locationService.search();
+    this.search = () => this.$location.search();
     /**
      * Gets the hash part of the current url
      *
@@ -111,30 +57,103 @@ export class UrlService {
      *
      * @return the hash (anchor) portion of the url
      */
-    this.hash = () => this.router.locationService.hash();
-    /**
-     * @internal
-     *
-     * Registers a low level url change handler
-     *
-     * Note: Because this is a low level handler, it's not recommended for general use.
-     *
-     * #### Example:
-     * ```js
-     * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
-     * ```
-     *
-     * @param callback a function that will be called when the url is changing
-     * @return a function that de-registers the callback
-     */
-    this.onChange = (callback) =>
-      this.router.locationService.onChange(callback);
+    this.hash = () => this.$location.hash();
+
+    this._urlListeners = [];
+  }
+
+  html5Mode() {
+    let html5Mode = this.$locationProvider.html5Mode();
+    html5Mode = isObject(html5Mode) ? html5Mode.enabled : html5Mode;
+    return html5Mode && typeof history !== "undefined";
   }
 
-  dispose() {
-    this.listen(false);
-    this.rules.dispose();
+  baseHref() {
+    return (
+      this._baseHref ||
+      (this._baseHref = this.$browser.baseHref() || window.location.pathname)
+    );
   }
+
+  /**
+   * Gets the current url, or updates the url
+   *
+   * ### Getting the current URL
+   *
+   * When no arguments are passed, returns the current URL.
+   * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+   *
+   * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+   * have a base HREF prepended ([[PushStateLocationServices]]).
+   *
+   * The raw URL in the browser might be:
+   *
+   * ```
+   * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * or
+   *
+   * ```
+   * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * then this method returns:
+   *
+   * ```
+   * /internal/path/123?param1=foo#anchor
+   * ```
+   *
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url(); // "/some/path?query=value#anchor"
+   * ```
+   *
+   * ### Updating the URL
+   *
+   * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url("/some/path?query=value#anchor", true);
+   * ```
+   *
+   * @param {string} newUrl The new value for the URL.
+   *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
+   *               It should not include the protocol, site, port, or base path of an absolute HREF.
+   * @param {boolean} replace When true, replaces the current history entry (instead of appending it) with this new url
+   * @param {any} state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+   *
+   * @return the url (after potentially being processed)
+   */
+  url(newUrl, replace = false, state) {
+    if (isDefined(newUrl)) this.$location.url(newUrl);
+    if (replace) this.$location.replace();
+    if (state) this.$location.state(state);
+    return this.$location.url();
+  }
+
+  /**
+   * @internal
+   *
+   * Registers a low level url change handler
+   *
+   * Note: Because this is a low level handler, it's not recommended for general use.
+   *
+   * #### Example:
+   * ```js
+   * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
+   * ```
+   *
+   * @param callback a function that will be called when the url is changing
+   * @return a function that de-registers the callback
+   */
+  onChange(callback) {
+    this._urlListeners.push(callback);
+    return () => removeFrom(this._urlListeners)(callback);
+  }
+
   /**
    * Gets the current URL parts
    *
@@ -165,15 +184,18 @@ export class UrlService {
    */
   sync(evt) {
     if (evt && evt.defaultPrevented) return;
-    const { urlService, stateService } = this.router;
+    const stateService = this.stateService;
     const url = {
-      path: urlService.path(),
-      search: urlService.search(),
-      hash: urlService.hash(),
+      path: this.path(),
+      search: this.search(),
+      hash: this.hash(),
     };
+    /**
+     * @type {angular.MatchResult}
+     */
     const best = this.match(url);
     const applyResult = pattern([
-      [isString, (newurl) => urlService.url(newurl, true)],
+      [isString, (newurl) => this.url(newurl, true)],
       [
         TargetState.isDef,
         (def) => stateService.go(def.state, def.params, def.options),
@@ -184,7 +206,8 @@ export class UrlService {
           stateService.go(target.state(), target.params(), target.options()),
       ],
     ]);
-    applyResult(best && best.rule.handler(best.match, url, this.router));
+
+    applyResult(best && best.rule.handler(best.match, url));
   }
   /**
    * Starts or stops listening for URL changes
@@ -214,8 +237,7 @@ export class UrlService {
       delete this._stopListeningFn;
     } else {
       return (this._stopListeningFn =
-        this._stopListeningFn ||
-        this.router.urlService.onChange((evt) => this.sync(evt)));
+        this._stopListeningFn || this.onChange((evt) => this.sync(evt)));
     }
   }
   /**
@@ -251,13 +273,18 @@ export class UrlService {
    *
    * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
    * Return the result as a [[MatchResult]].
+   * @returns {angular.MatchResult}
    */
   match(url) {
     url = Object.assign({ path: "", search: {}, hash: "" }, url);
     const rules = this.rules.rules();
     // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined
+    /**
+     *
+     * @param {import("./url-rule").BaseUrlRule} rule
+     */
     const checkRule = (rule) => {
-      const match = rule.match(url, this.router);
+      const match = rule.match(url);
       return match && { match, rule, weight: rule.matchPriority(match) };
     };
     // The rules are pre-sorted.
@@ -275,4 +302,14 @@ export class UrlService {
     }
     return best;
   }
+
+  _runtimeServices($rootScope, $location, $browser) {
+    /** @type {angular.ILocationService} */
+    this.$location = $location;
+    this.$browser = $browser;
+    // Bind $locationChangeSuccess to the listeners registered in LocationService.onChange
+    $rootScope.$on("$locationChangeSuccess", (evt) =>
+      this._urlListeners.forEach((fn) => fn(evt)),
+    );
+  }
 }

package/src/router/view/view.js

@@ -26,9 +26,9 @@ import { trace } from "../common/trace";
  */
 export class ViewService {
   /**
-   * @param {import('../router').UIRouter} router
+   * @param {number} $id
    */
-  constructor(router) {
+  constructor($id) {
     this._uiViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
@@ -37,7 +37,7 @@ export class ViewService {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
       _registeredUIView: (id) =>
-        find(this._uiViews, (view) => `${router.$id}.${view.id}` === id),
+        find(this._uiViews, (view) => `${$id}.${view.id}` === id),
       _registeredUIViews: () => this._uiViews,
       _activeViewConfigs: () => this._viewConfigs,
       _onSync: (listener) => {

package/src/shared/hof.js

@@ -77,7 +77,7 @@ export function compose() {
  * let piped = pipe(f,g,h);
  * then, piped is: h(g(f(x)))
  */
-export function pipe(...funcs) {
+export function pipe() {
   return compose.apply(null, [].slice.call(arguments).reverse());
 }
 /**

package/test/angular.spec.js

@@ -48,6 +48,7 @@ describe("angular", () => {
 
   afterEach(() => {
     dealoc(element);
+    jqLite.CACHE.clear();
   });
 
   describe("case", () => {

package/test/aria/aria.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../src/injector";
 import { publishExternalAPI } from "../../src/public";
-import { dealoc } from "../../src/jqLite";
+import { dealoc, jqLite } from "../../src/jqLite";
 
 describe("$aria", () => {
   let scope;
@@ -17,6 +17,7 @@ describe("$aria", () => {
 
   afterEach(() => {
     dealoc(element);
+    jqLite.CACHE.clear();
   });
 
   describe("with `ngAriaDisable`", () => {

package/test/core/interval.spec.js

@@ -71,7 +71,7 @@ describe("$interval", () => {
 
     $interval(notifySpy, 1, 1, false);
 
-    await wait(10);
+    await wait(100);
     expect(notifySpy).toHaveBeenCalled();
     expect(evalAsyncSpy).not.toHaveBeenCalled();
     expect(digestSpy).not.toHaveBeenCalled();

package/test/core/pubsub.spec.js

@@ -0,0 +1,314 @@
+import { PubSub } from "../../src/core/pubsub";
+
+describe("PubSub", function () {
+  let pubsub;
+  let asyncPubsub;
+
+  beforeEach(function () {
+    pubsub = new PubSub();
+    asyncPubsub = new PubSub(true);
+  });
+
+  afterEach(function () {
+    asyncPubsub.dispose();
+    pubsub.dispose();
+  });
+
+  it("should create a PubSub instance", function () {
+    expect(pubsub).not.toBeNull();
+    expect(pubsub instanceof PubSub).toBe(true);
+  });
+
+  it("should dispose of the PubSub instance", function () {
+    expect(pubsub.isDisposed()).toBe(false);
+    pubsub.dispose();
+    expect(pubsub.isDisposed()).toBe(true);
+  });
+
+  it("should subscribe and unsubscribe correctly", function () {
+    function foo1() {}
+    function bar1() {}
+    function foo2() {}
+    function bar2() {}
+
+    expect(pubsub.getCount("foo")).toBe(0);
+    expect(pubsub.getCount("bar")).toBe(0);
+
+    pubsub.subscribe("foo", foo1);
+    expect(pubsub.getCount("foo")).toBe(1);
+    expect(pubsub.getCount("bar")).toBe(0);
+
+    pubsub.subscribe("bar", bar1);
+    expect(pubsub.getCount("foo")).toBe(1);
+    expect(pubsub.getCount("bar")).toBe(1);
+
+    pubsub.subscribe("foo", foo2);
+    expect(pubsub.getCount("foo")).toBe(2);
+    expect(pubsub.getCount("bar")).toBe(1);
+
+    pubsub.subscribe("bar", bar2);
+    expect(pubsub.getCount("foo")).toBe(2);
+    expect(pubsub.getCount("bar")).toBe(2);
+
+    expect(pubsub.unsubscribe("foo", foo1)).toBe(true);
+    expect(pubsub.getCount("foo")).toBe(1);
+    expect(pubsub.getCount("bar")).toBe(2);
+
+    expect(pubsub.unsubscribe("foo", foo2)).toBe(true);
+    expect(pubsub.getCount("foo")).toBe(0);
+    expect(pubsub.getCount("bar")).toBe(2);
+
+    expect(pubsub.unsubscribe("bar", bar1)).toBe(true);
+    expect(pubsub.getCount("foo")).toBe(0);
+    expect(pubsub.getCount("bar")).toBe(1);
+
+    expect(pubsub.unsubscribe("bar", bar2)).toBe(true);
+    expect(pubsub.getCount("foo")).toBe(0);
+    expect(pubsub.getCount("bar")).toBe(0);
+
+    expect(pubsub.unsubscribe("baz", foo1)).toBe(false);
+    expect(pubsub.unsubscribe("foo", () => {})).toBe(false);
+  });
+
+  it("should subscribe and unsubscribe with context correctly", function () {
+    function foo() {}
+    function bar() {}
+
+    const contextA = {};
+    const contextB = {};
+
+    expect(pubsub.getCount("X")).toBe(0);
+
+    pubsub.subscribe("X", foo, contextA);
+    expect(pubsub.getCount("X")).toBe(1);
+
+    pubsub.subscribe("X", bar);
+    expect(pubsub.getCount("X")).toBe(2);
+
+    pubsub.subscribe("X", bar, contextB);
+    expect(pubsub.getCount("X")).toBe(3);
+
+    expect(pubsub.unsubscribe("X", foo, contextB)).toBe(false);
+
+    expect(pubsub.unsubscribe("X", foo, contextA)).toBe(true);
+    expect(pubsub.getCount("X")).toBe(2);
+
+    expect(pubsub.unsubscribe("X", bar)).toBe(true);
+    expect(pubsub.getCount("X")).toBe(1);
+
+    expect(pubsub.unsubscribe("X", bar, contextB)).toBe(true);
+    expect(pubsub.getCount("X")).toBe(0);
+  });
+
+  it("should subscribe once correctly", function () {
+    let called;
+    let context;
+
+    called = false;
+    pubsub.subscribeOnce("someTopic", () => {
+      called = true;
+    });
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(called).toBe(false);
+
+    pubsub.publish("someTopic");
+    expect(pubsub.getCount("someTopic")).toBe(0);
+    expect(called).toBe(true);
+
+    context = { called: false };
+    pubsub.subscribeOnce(
+      "someTopic",
+      function () {
+        this.called = true;
+      },
+      context,
+    );
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(context.called).toBe(false);
+
+    pubsub.publish("someTopic");
+    expect(pubsub.getCount("someTopic")).toBe(0);
+    expect(context.called).toBe(true);
+
+    context = { called: false, value: 0 };
+    pubsub.subscribeOnce(
+      "someTopic",
+      function (value) {
+        this.called = true;
+        this.value = value;
+      },
+      context,
+    );
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(context.called).toBe(false);
+    expect(context.value).toBe(0);
+
+    pubsub.publish("someTopic", 17);
+    expect(pubsub.getCount("someTopic")).toBe(0);
+    expect(context.called).toBe(true);
+    expect(context.value).toBe(17);
+  });
+
+  it("should async subscribe once correctly", function (done) {
+    let callCount = 0;
+    asyncPubsub.subscribeOnce("someTopic", () => {
+      callCount++;
+    });
+    expect(asyncPubsub.getCount("someTopic")).toBe(1);
+
+    asyncPubsub.publish("someTopic");
+    asyncPubsub.publish("someTopic");
+
+    setTimeout(() => {
+      expect(asyncPubsub.getCount("someTopic")).toBe(0);
+      expect(callCount).toBe(1);
+      done();
+    }, 0);
+  });
+
+  it("should async subscribe once with context correctly", function (done) {
+    const context = { callCount: 0 };
+    asyncPubsub.subscribeOnce(
+      "someTopic",
+      function () {
+        this.callCount++;
+      },
+      context,
+    );
+    expect(asyncPubsub.getCount("someTopic")).toBe(1);
+
+    asyncPubsub.publish("someTopic");
+    asyncPubsub.publish("someTopic");
+
+    setTimeout(() => {
+      expect(asyncPubsub.getCount("someTopic")).toBe(0);
+      expect(context.callCount).toBe(1);
+      done();
+    }, 0);
+  });
+
+  it("should async subscribe once with context and value correctly", function (done) {
+    const context = { callCount: 0, value: 0 };
+    asyncPubsub.subscribeOnce(
+      "someTopic",
+      function (value) {
+        this.callCount++;
+        this.value = value;
+      },
+      context,
+    );
+    expect(asyncPubsub.getCount("someTopic")).toBe(1);
+
+    asyncPubsub.publish("someTopic", 17);
+    asyncPubsub.publish("someTopic", 42);
+
+    setTimeout(() => {
+      expect(asyncPubsub.getCount("someTopic")).toBe(0);
+      expect(context.callCount).toBe(1);
+      expect(context.value).toBe(17);
+      done();
+    }, 0);
+  });
+
+  it("should subscribe once with bound function correctly", function () {
+    const context = { called: false, value: 0 };
+
+    function subscriber(value) {
+      this.called = true;
+      this.value = value;
+    }
+
+    pubsub.subscribeOnce("someTopic", subscriber.bind(context));
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(context.called).toBe(false);
+    expect(context.value).toBe(0);
+
+    pubsub.publish("someTopic", 17);
+    expect(pubsub.getCount("someTopic")).toBe(0);
+    expect(context.called).toBe(true);
+    expect(context.value).toBe(17);
+  });
+
+  it("should subscribe once with partial function correctly", function () {
+    let called = false;
+    let value = 0;
+
+    function subscriber(hasBeenCalled, newValue) {
+      called = hasBeenCalled;
+      value = newValue;
+    }
+
+    pubsub.subscribeOnce("someTopic", subscriber.bind(null, true));
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(called).toBe(false);
+    expect(value).toBe(0);
+
+    pubsub.publish("someTopic", 17);
+    expect(pubsub.getCount("someTopic")).toBe(0);
+    expect(called).toBe(true);
+    expect(value).toBe(17);
+  });
+
+  it("should handle self resubscribe correctly", function () {
+    let value = null;
+
+    function resubscribe(iteration, newValue) {
+      pubsub.subscribeOnce("someTopic", resubscribe.bind(null, iteration + 1));
+      value = `${newValue}:${iteration}`;
+    }
+
+    pubsub.subscribeOnce("someTopic", resubscribe.bind(null, 0));
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(value).toBeNull();
+
+    pubsub.publish("someTopic", "foo");
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(value).toBe("foo:0");
+
+    pubsub.publish("someTopic", "bar");
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(value).toBe("bar:1");
+
+    pubsub.publish("someTopic", "baz");
+    expect(pubsub.getCount("someTopic")).toBe(1);
+    expect(value).toBe("baz:2");
+  });
+
+  it("should handle async self resubscribe correctly", function (done) {
+    let value = null;
+
+    function resubscribe(iteration, newValue) {
+      asyncPubsub.subscribeOnce(
+        "someTopic",
+        resubscribe.bind(null, iteration + 1),
+      );
+      value = `${newValue}:${iteration}`;
+    }
+
+    asyncPubsub.subscribeOnce("someTopic", resubscribe.bind(null, 0));
+    expect(asyncPubsub.getCount("someTopic")).toBe(1);
+    expect(value).toBeNull();
+
+    asyncPubsub.publish("someTopic", "foo");
+
+    setTimeout(() => {
+      expect(asyncPubsub.getCount("someTopic")).toBe(1);
+      expect(value).toBe("foo:0");
+
+      asyncPubsub.publish("someTopic", "bar");
+
+      setTimeout(() => {
+        expect(asyncPubsub.getCount("someTopic")).toBe(1);
+        expect(value).toBe("bar:1");
+
+        asyncPubsub.publish("someTopic", "baz");
+
+        setTimeout(() => {
+          expect(asyncPubsub.getCount("someTopic")).toBe(1);
+          expect(value).toBe("baz:2");
+          done();
+        }, 0);
+      }, 0);
+    }, 0);
+  });
+});