@angular-wave/angular.ts 0.1.2 → 0.1.4

package/src/router/transition/transition.js

@@ -13,7 +13,7 @@ import {
   flattenR,
   uniqR,
 } from "../../shared/common";
-import { isUndefined, isObject } from "../../shared/utils";
+import { isUndefined, isObject, assert } from "../../shared/utils";
 import { prop, propEq, val, is } from "../../shared/hof";
 import { TransitionHookPhase } from "./interface"; // has or is using
 import { TransitionHook } from "./transition-hook";
@@ -334,7 +334,7 @@ export class Transition {
     const targetNode = find(topath, (node) => {
       return node.state.name === stateName;
     });
-    console.assert(targetNode, `targetNode not found ${stateName}`);
+    assert(!!targetNode, `targetNode not found ${stateName}`);
 
     const resolveContext = new ResolveContext(topath);
     resolveContext.addResolvables([resolvable], targetNode.state);

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

@@ -14,8 +14,8 @@ import { isDefined, isString } from "../../shared/utils";
 import { Param, DefType } from "../params/param";
 import { joinNeighborsR, splitOnDelim } from "../../shared/strings";
 function quoteRegExp(str, param) {
-  let surroundPattern = ["", ""],
-    result = str.replace(/[\\\[\]\^$*+?.()|{}]/g, "\\$&");
+  let surroundPattern = ["", ""];
+  let result = str.replace(/[\\[\]^$*+?.()|{}]/g, "\\$&");
   if (!param) return result;
   switch (param.squash) {
     case false:
@@ -207,9 +207,9 @@ export class UrlMatcher {
     //    \\.                            - a backslash escape
     //    \{(?:[^{}\\]+|\\.)*\}          - a matched set of curly braces containing other atoms
     const placeholder =
-      /([:*])([\w\[\]]+)|\{([\w\[\]]+)(?:\:\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
+      /([:*])([\w[\]]+)|\{([\w[\]]+)(?::\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
     const searchPlaceholder =
-      /([:]?)([\w\[\].-]+)|\{([\w\[\].-]+)(?:\:\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
+      /([:]?)([\w[\].-]+)|\{([\w[\].-]+)(?::\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
     const patterns = [];
     let last = 0;
     let matchArray;

package/src/services/anchor-scroll.js

@@ -19,14 +19,16 @@ import {
  * @typedef {AnchorScrollFunction | AnchorScrollObject} AnchorScrollService
  */
 
-export function AnchorScrollProvider() {
-  let autoScrollingEnabled = true;
+export class AnchorScrollProvider {
+  constructor() {
+    this.autoScrollingEnabled = true;
+  }
 
-  this.disableAutoScrolling = () => {
-    autoScrollingEnabled = false;
-  };
+  disableAutoScrolling() {
+    this.autoScrollingEnabled = false;
+  }
 
-  this.$get = [
+  $get = [
     "$location",
     "$rootScope",
     /**
@@ -124,7 +126,7 @@ export function AnchorScrollProvider() {
 
       // does not scroll when user clicks on anchor link that is currently on
       // (no url change, no $location.hash() change), browser native does scroll
-      if (autoScrollingEnabled) {
+      if (this.autoScrollingEnabled) {
         $rootScope.$watch(
           () => $location.hash(),
           (newVal, oldVal) => {

package/src/services/browser.js

@@ -1,9 +1,6 @@
 import { JQLite } from "../shared/jqlite/jqlite";
 import { urlResolve } from "../core/url-utils/url-utils";
-import { isUndefined, equals } from "../shared/utils";
-
-// This variable should be used *only* inside the cacheState function.
-let lastCachedState = null;
+import { equals } from "../shared/utils";
 
 /**
  * Removes a trailing hash ('#') from the given URL if it exists.
@@ -20,266 +17,223 @@ export function trimEmptyHash(url) {
  */
 
 /**
- * @name $browser
- * @description
  * This object has two goals:
  *
  * - hide all the global state in the browser caused by the window object
  * - abstract away all the browser specific features and inconsistencies
- *
- *
- */
-
-/**
- * @param {import('../core/task-tracker-factory').TaskTracker} taskTracker
  */
-export function Browser(taskTracker) {
-  const self = this;
-  const pendingDeferIds = {};
-  /** @type {Array<UrlChangeListener>} */
-  const urlChangeListeners = [];
-  let urlChangeInit = false;
-
-  /// ///////////////////////////////////////////////////////////
-  // Task-tracking API
-  /// ///////////////////////////////////////////////////////////
-
-  // TODO(vojta): remove this temporary api
-  self.$$completeOutstandingRequest = taskTracker.completeTask;
-  self.$$incOutstandingRequestCount = taskTracker.incTaskCount;
-
-  // TODO(vojta): prefix this method with $$ ?
-  self.notifyWhenNoOutstandingRequests = taskTracker.notifyWhenNoPendingTasks;
+export class Browser {
+  /**
+   * @param {import('../core/task-tracker-factory').TaskTracker} taskTracker
+   */
+  constructor(taskTracker) {
+    /**
+     * @type {import('../core/task-tracker-factory').TaskTracker} taskTracker
+     */
+    this.taskTracker = taskTracker;
+    this.pendingDeferIds = {};
+    /** @type {Array<UrlChangeListener>} */
+    this.urlChangeListeners = [];
+    this.urlChangeInit = false;
+
+    /** @type {any} */
+    this.cachedState = null;
+    /** @type {any} */
+    this.lastHistoryState = null;
+    /** @type {string} */
+    this.lastBrowserUrl = window.location.href;
+    /** @type {JQLite} */
+    this.baseElement = JQLite(
+      Array.from(document.getElementsByTagName("base")),
+    );
+
+    // Task-tracking API
+    this.$$completeOutstandingRequest =
+      this.taskTracker.completeTask.bind(taskTracker);
+    this.$$incOutstandingRequestCount =
+      this.taskTracker.incTaskCount.bind(taskTracker);
+    this.notifyWhenNoOutstandingRequests =
+      this.taskTracker.notifyWhenNoPendingTasks.bind(taskTracker);
+
+    this.cacheState();
+  }
 
   /// ///////////////////////////////////////////////////////////
   // URL API
   /// ///////////////////////////////////////////////////////////
 
-  let cachedState;
-  let lastHistoryState;
-  let lastBrowserUrl = window.location.href;
-  const baseElement = JQLite(Array.from(document.getElementsByTagName("base")));
-
-  cacheState();
-
-  /**
-   * @name $browser#url
-   *
-   * @description
-   * GETTER:
-   * Without any argument, this method just returns current value of `location.href` (with a
-   * trailing `#` stripped of if the hash is empty).
-   *
-   * SETTER:
-   * With at least one argument, this method sets url to new value.
-   * If html5 history api supported, `pushState`/`replaceState` is used, otherwise
-   * `location.href`/`location.replace` is used.
-   * Returns its own instance to allow chaining.
-   *
-   * NOTE: this api is intended for use only by the `$location` service. Please use the
-   * {@link ng.$location $location service} to change url.
-   *
-   * @param {string=} url New url (when used as setter)
-   * @param {boolean=} replace Should new url replace current history record?
-   * @param {object=} state State object to use with `pushState`/`replaceState`
-   */
-  self.url = function (url, replace, state) {
-    // In modern browsers `history.state` is `null` by default; treating it separately
-    // from `undefined` would cause `$browser.url('/foo')` to change `history.state`
-    // to undefined via `pushState`. Instead, let's change `undefined` to `null` here.
-    if (isUndefined(state)) {
+  url(url, state) {
+    if (state === undefined) {
       state = null;
     }
 
     // setter
     if (url) {
-      // Normalize the inputted URL
       url = urlResolve(url).href;
 
-      // Don't change anything if previous and current URLs and states match. This also prevents
-      // IE<10 from getting into redirect loop when in LocationHashbangInHtml5Url mode.
-      // See https://github.com/angular/angular.js/commit/ffb2701
-      if (lastBrowserUrl === url && lastHistoryState === state) {
-        return self;
+      if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
+        return this;
       }
-      // const sameBase =
-      //   lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);
-      lastBrowserUrl = url;
-      lastHistoryState = state;
+
+      this.lastBrowserUrl = url;
+      this.lastHistoryState = state;
       history.pushState(state, "", url);
-      cacheState();
-      return self;
-      // getter
+      this.cacheState();
+      return this;
     }
-    // - pendingLocation is needed as browsers don't allow to read out
-    //   the new location.href if a reload happened or if there is a bug like in iOS 9 (see
-    //   https://openradar.appspot.com/22186109).
+
+    // getter
     return trimEmptyHash(window.location.href);
-  };
+  }
 
   /**
-   * @name $browser#state
+   * Returns the cached state.
    *
-   * @description
-   * This method is a getter.
-   *
-   * Return history.state or null if history.state is undefined.
-   *
-   * @returns {object} state
+   * @returns {any} The cached state.
    */
-  self.state = function () {
-    return cachedState;
-  };
+  state() {
+    return this.cachedState;
+  }
 
-  function cacheStateAndFireUrlChange() {
-    fireStateOrUrlChange();
+  /**
+   * Caches the current state and fires the URL change event.
+   *
+   * @private
+   */
+  cacheStateAndFireUrlChange() {
+    this.fireStateOrUrlChange();
   }
 
-  function cacheState() {
-    // This should be the only place in $browser where `history.state` is read.
-    cachedState = history.state;
-    cachedState = isUndefined(cachedState) ? null : cachedState;
+  /**
+   * Caches the current state.
+   *
+   * @private
+   */
+  cacheState() {
+    this.cachedState = history.state;
+    this.cachedState = this.cachedState === undefined ? null : this.cachedState;
 
-    // Prevent callbacks fo fire twice if both hashchange & popstate were fired.
-    if (equals(cachedState, lastCachedState)) {
-      cachedState = lastCachedState;
+    if (equals(this.cachedState, this.lastCachedState)) {
+      this.cachedState = this.lastCachedState;
     }
 
-    lastCachedState = cachedState;
-    lastHistoryState = cachedState;
+    this.lastCachedState = this.cachedState;
+    this.lastHistoryState = this.cachedState;
   }
 
-  function fireStateOrUrlChange() {
-    const prevLastHistoryState = lastHistoryState;
-    cacheState();
-
-    if (lastBrowserUrl === self.url() && prevLastHistoryState === cachedState) {
+  /**
+   * Fires the state or URL change event.
+   *
+   * @private
+   */
+  fireStateOrUrlChange() {
+    const prevLastHistoryState = this.lastHistoryState;
+    this.cacheState();
+
+    if (
+      this.lastBrowserUrl === this.url() &&
+      prevLastHistoryState === this.cachedState
+    ) {
       return;
     }
-    lastBrowserUrl = /** @type {string} */ (self.url());
-    lastHistoryState = cachedState;
-    urlChangeListeners.forEach((listener) => {
-      listener(trimEmptyHash(window.location.href), cachedState);
+
+    this.lastBrowserUrl = /** @type {string} */ (this.url());
+    this.lastHistoryState = this.cachedState;
+    this.urlChangeListeners.forEach((listener) => {
+      listener(trimEmptyHash(window.location.href), this.cachedState);
     });
   }
 
   /**
-   * Register callback function that will be called, when url changes.
-   *
-   * It's only called when the url is changed from outside of AngularJS:
-   * - user types different url into address bar
-   * - user clicks on history (forward/back) button
-   * - user clicks on a link
-   *
-   * It's not called when url is changed by $browser.url() method
-   *
-   * The listener gets called with new url as parameter.
-   *
-   * NOTE: this api is intended for use only by the $location service. Please use the
-   * {@link ng.$location $location service} to monitor url changes in AngularJS apps.
+   * Registers a callback to be called when the URL changes.
    *
-   * @param {UrlChangeListener} callback Listener function to be called when url changes.
-   * @return {UrlChangeListener} Returns the registered listener fn - handy if the fn is anonymous.
+   * @param {UrlChangeListener} callback - The callback function to register.
+   * @returns {UrlChangeListener} The registered callback function.
    */
-  self.onUrlChange = function (callback) {
-    // TODO(vojta): refactor to use node's syntax for events
-    if (!urlChangeInit) {
-      // We listen on both (hashchange/popstate) when available, as some browsers don't
-      // fire popstate when user changes the address bar and don't fire hashchange when url
-      // changed by push/replaceState
-
-      // html5 history api - popstate event
-      JQLite(window).on("popstate", cacheStateAndFireUrlChange);
-      // hashchange event
-      JQLite(window).on("hashchange", cacheStateAndFireUrlChange);
-
-      urlChangeInit = true;
+  onUrlChange(callback) {
+    if (!this.urlChangeInit) {
+      window.addEventListener(
+        "popstate",
+        this.cacheStateAndFireUrlChange.bind(this),
+      );
+      window.addEventListener(
+        "hashchange",
+        this.cacheStateAndFireUrlChange.bind(this),
+      );
+
+      this.urlChangeInit = true;
     }
 
-    urlChangeListeners.push(callback);
+    this.urlChangeListeners.push(callback);
     return callback;
-  };
+  }
 
-  /**
-   * Remove popstate and hashchange handler from window.
-   *
-   * NOTE: this api is intended for use only by $rootScope.
-   */
-  self.$$applicationDestroyed = function () {
-    JQLite(window).off("hashchange popstate", cacheStateAndFireUrlChange);
-  };
+  $$applicationDestroyed() {
+    window.removeEventListener(
+      "popstate",
+      this.cacheStateAndFireUrlChange.bind(this),
+    );
+    window.removeEventListener(
+      "hashchange",
+      this.cacheStateAndFireUrlChange.bind(this),
+    );
+  }
 
-  /**
-   * Checks whether the url has changed outside of AngularJS.
-   * Needs to be exported to be able to check for changes that have been done in sync,
-   * as hashchange/popstate events fire in async.
-   */
-  self.$$checkUrlChange = fireStateOrUrlChange;
+  $$checkUrlChange() {
+    this.fireStateOrUrlChange();
+  }
 
   /// ///////////////////////////////////////////////////////////
   // Misc API
   /// ///////////////////////////////////////////////////////////
 
   /**
-   * Returns current <base href>
-   * (always relative - without domain)
+   * Returns the base href of the document.
    *
-   * @returns {string} The current base href
+   * @returns {string} The base href.
    */
-  self.baseHref = function () {
-    const href = baseElement.attr("href");
+  baseHref() {
+    const href = this.baseElement.attr("href");
     return href ? href.replace(/^(https?:)?\/\/[^/]*/, "") : "";
-  };
+  }
 
   /**
-   * @param {function():any} fn A function, who's execution should be deferred.
-   * @param {number=} [delay=0] Number of milliseconds to defer the function execution.
-   * @param {string=} [taskType=DEFAULT_TASK_TYPE] The type of task that is deferred.
-   * @returns {number} DeferId that can be used to cancel the task via `$browser.cancel()`.
-   *
-   * Executes a fn asynchronously via `setTimeout(fn, delay)`.
-   *
-   * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
-   * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
-   * via `$browser.defer.flush()`.
+   * Defers a function to be executed after a delay.
    *
+   * @param {function(): any} fn - The function to defer.
+   * @param {number} [delay=0] - The delay in milliseconds before executing the function.
+   * @param {string} [taskType=this.taskTracker.DEFAULT_TASK_TYPE] - The type of task to track.
+   * @returns {number} The timeout ID associated with the deferred function.
    */
-  self.defer = function (fn, delay, taskType) {
+  defer(fn, delay = 0, taskType = this.taskTracker.DEFAULT_TASK_TYPE) {
     let timeoutId;
 
-    delay = delay || 0;
-    taskType = taskType || taskTracker.DEFAULT_TASK_TYPE;
-
-    taskTracker.incTaskCount(taskType);
+    this.taskTracker.incTaskCount(taskType);
     timeoutId = window.setTimeout(() => {
-      delete pendingDeferIds[timeoutId];
-      taskTracker.completeTask(fn, taskType);
+      delete this.pendingDeferIds[timeoutId];
+      this.taskTracker.completeTask(fn, taskType);
     }, delay);
-    pendingDeferIds[timeoutId] = taskType;
+    this.pendingDeferIds[timeoutId] = taskType;
 
     return timeoutId;
-  };
+  }
 
   /**
-   * @name $browser#cancel
-   *
-   * @description
-   * Cancels a deferred task identified with `deferId`.
+   * Cancels a deferred function.
    *
-   * @param {number} deferId Token returned by the `$browser.defer` function.
-   * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
-   *                    canceled.
+   * @param {number} deferId - The ID of the deferred function to cancel.
+   * @returns {boolean} True if the function was successfully canceled, false otherwise.
    */
-  self.cancel = function (deferId) {
-    if (Object.prototype.hasOwnProperty.call(pendingDeferIds, deferId)) {
-      const taskType = pendingDeferIds[deferId];
-      delete pendingDeferIds[deferId];
+  cancel(deferId) {
+    if (Object.prototype.hasOwnProperty.call(this.pendingDeferIds, deferId)) {
+      const taskType = this.pendingDeferIds[deferId];
+      delete this.pendingDeferIds[deferId];
       window.clearTimeout(deferId);
-      taskTracker.completeTask(() => {}, taskType);
+      this.taskTracker.completeTask(() => {}, taskType);
       return true;
     }
     return false;
-  };
+  }
 }
 
 /**
@@ -297,8 +251,6 @@ export class BrowserProvider {
      * @param {import('../core/task-tracker-factory').TaskTracker} $$taskTrackerFactory
      * @returns
      */
-    function ($$taskTrackerFactory) {
-      return new Browser($$taskTrackerFactory);
-    },
+    ($$taskTrackerFactory) => new Browser($$taskTrackerFactory),
   ];
 }

package/src/services/http/http.spec.js

@@ -1212,6 +1212,7 @@ describe("$http", function () {
         },
       );
     $rootScope.$apply();
+
     expect(response.xhrStatus).toBe("timeout");
   });
 

package/src/services/http-backend/http-backend.js

@@ -22,17 +22,16 @@ export function $HttpBackendProvider() {
      * @returns
      */
     function ($browser) {
-      return createHttpBackend($browser, $browser.defer);
+      return createHttpBackend($browser);
     },
   ];
 }
 
 /**
  * @param {import('../browser').Browser} $browser
- * @param {*} $browserDefer
  * @returns
  */
-export function createHttpBackend($browser, $browserDefer) {
+export function createHttpBackend($browser) {
   // TODO(vojta): fix the signature
   return function (
     method,
@@ -146,7 +145,7 @@ export function createHttpBackend($browser, $browserDefer) {
     // xhr.abort()                        abort (The xhr object is normally inaccessible, but
     //                                    can be exposed with the xhrFactory)
     if (timeout > 0) {
-      var timeoutId = $browserDefer(() => {
+      var timeoutId = $browser.defer(() => {
         timeoutRequest("timeout");
       }, timeout);
     } else if (isPromiseLike(timeout)) {

package/src/shared/common.js

@@ -1,10 +1,38 @@
 import { isDate, isFunction, isRegExp, isString } from "./utils";
 import { all, any, prop, curry } from "./hof";
 import { services } from "../router/common/coreservices";
-export const fromJson = JSON.parse.bind(JSON);
-export const toJson = JSON.stringify.bind(JSON);
-export const forEach = _forEach;
-export const equals = _equals;
+
+export function forEach(obj, cb, thisArg) {
+  if (Array.isArray(obj)) return obj.forEach(cb, thisArg);
+  Object.keys(obj).forEach((key) => cb(obj[key], key));
+}
+
+export function equals(o1, o2) {
+  if (o1 === o2) return true;
+  if (o1 === null || o2 === null) return false;
+  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+  const t1 = typeof o1,
+    t2 = typeof o2;
+  if (t1 !== t2 || t1 !== "object") return false;
+  const tup = [o1, o2];
+  if (all(Array.isArray)(tup)) return _arraysEq(o1, o2);
+  if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
+  if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
+  if (all(isFunction)(tup)) return true; // meh
+  const predicates = [isFunction, Array.isArray, isDate, isRegExp];
+  if (predicates.map(any).reduce((b, fn) => b || !!fn(tup), false))
+    return false;
+  const keys = {};
+
+  for (const key in o1) {
+    if (!equals(o1[key], o2[key])) return false;
+    keys[key] = true;
+  }
+  for (const key in o2) {
+    if (!keys[key]) return false;
+  }
+  return true;
+}
 /**
  * Builds proxy functions on the `to` object which pass through to the `from` object.
  *
@@ -438,41 +466,10 @@ export function copy(src, dest) {
   if (!dest) dest = {};
   return Object.assign(dest, src);
 }
-/** Naive forEach implementation works with Objects or Arrays */
-function _forEach(obj, cb, _this) {
-  if (Array.isArray(obj)) return obj.forEach(cb, _this);
-  Object.keys(obj).forEach((key) => cb(obj[key], key));
-}
 
-function _equals(o1, o2) {
-  if (o1 === o2) return true;
-  if (o1 === null || o2 === null) return false;
-  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
-  const t1 = typeof o1,
-    t2 = typeof o2;
-  if (t1 !== t2 || t1 !== "object") return false;
-  const tup = [o1, o2];
-  if (all(Array.isArray)(tup)) return _arraysEq(o1, o2);
-  if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
-  if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
-  if (all(isFunction)(tup)) return true; // meh
-  const predicates = [isFunction, Array.isArray, isDate, isRegExp];
-  if (predicates.map(any).reduce((b, fn) => b || !!fn(tup), false))
-    return false;
-  const keys = {};
-
-  for (const key in o1) {
-    if (!_equals(o1[key], o2[key])) return false;
-    keys[key] = true;
-  }
-  for (const key in o2) {
-    if (!keys[key]) return false;
-  }
-  return true;
-}
 function _arraysEq(a1, a2) {
   if (a1.length !== a2.length) return false;
-  return arrayTuples(a1, a2).reduce((b, t) => b && _equals(t[0], t[1]), true);
+  return arrayTuples(a1, a2).reduce((b, t) => b && equals(t[0], t[1]), true);
 }
 // issue #2676
 export const silenceUncaughtInPromise = (promise) =>

package/src/shared/hof.js

@@ -1,10 +1,3 @@
-/**
- * Higher order functions
- *
- * These utility functions are exported, but are subject to change without notice.
- *
- * @packageDocumentation
- */
 /**
  * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
  *
@@ -105,13 +98,6 @@ export const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
  */
 export const parse = (name) => pipe.apply(null, name.split(".").map(prop));
 
-/**
- * Given two functions that return truthy or falsey values, returns a function that returns truthy
- * if both functions return truthy for the given arguments
- */
-export function and(fn1, fn2) {
-  return (...args) => fn1.apply(null, args) && fn2.apply(null, args);
-}
 /**
  * Given two functions that return truthy or falsey values, returns a function that returns truthy
  * if at least one of the functions returns truthy for the given arguments