@angular-wave/angular.ts 0.1.3 → 0.1.5

package/src/router/directives/view-directive.js

@@ -470,7 +470,7 @@ function registerControllerCallbacks(
       let promise;
       const ids = (trans[cacheProp] = trans[cacheProp] || {});
       if (!prevTruthyAnswer(trans)) {
-        promise = $q.when(controllerInstance.uiCanExit(trans));
+        promise = $q.resolve(controllerInstance.uiCanExit(trans));
         promise.then((val) => (ids[id] = val !== false));
       }
       return promise;

package/src/router/hooks/lazy-load.js

@@ -89,7 +89,7 @@ export function lazyLoadState(transition, state, stateRegistry) {
       return services.$q.reject(err);
     };
     promise = lazyLoadFn["_promise"] = services.$q
-      .when(lazyLoadFn(transition, state))
+      .resolve(lazyLoadFn(transition, state))
       .then(updateStateRegistry)
       .then(success, error);
   }

package/src/router/hooks/redirect-to.js

@@ -27,7 +27,7 @@ export const registerRedirectToHook = (transitionService, stateService) => {
         );
     }
     if (isFunction(redirect)) {
-      return services.$q.when(redirect(trans)).then(handleResult);
+      return services.$q.resolve(redirect(trans)).then(handleResult);
     }
     return handleResult(redirect);
   };

package/src/router/hooks/views.js

@@ -12,7 +12,7 @@ const loadEnteringViews = (transition) => {
   const enteringViews = transition.views("entering");
   if (!enteringViews.length) return;
   return $q
-    .all(enteringViews.map((view) => $q.when(view.load())))
+    .all(enteringViews.map((view) => $q.resolve(view.load())))
     .then(() => {});
 };
 export const registerLoadEnteringViews = (transitionService) =>

package/src/router/resolve/resolvable.js

@@ -34,7 +34,7 @@ export class Resolvable {
       this.deps = deps || [];
       this.data = data;
       this.resolved = data !== undefined;
-      this.promise = this.resolved ? services.$q.when(this.data) : undefined;
+      this.promise = this.resolved ? services.$q.resolve(this.data) : undefined;
     } else if (
       isObject(arg1) &&
       arg1.token &&
@@ -90,7 +90,7 @@ export class Resolvable {
     };
     // Sets the promise property first, then getsResolvableDependencies in the context of the promise chain. Always waits one tick.
     return (this.promise = $q
-      .when()
+      .resolve()
       .then(getResolvableDependencies)
       .then(invokeResolveFn)
       .then(customAsyncPolicy)

package/src/router/resolve/resolve-context.js

@@ -7,7 +7,7 @@ import { PathUtils } from "../path/path-utils";
 import { stringify } from "../../shared/strings";
 import { isUndefined } from "../../shared/utils";
 
-export let resolvePolicies = {
+export const resolvePolicies = {
   when: {
     LAZY: "LAZY",
     EAGER: "EAGER",
@@ -18,10 +18,8 @@ export let resolvePolicies = {
   },
 };
 
-const whens = resolvePolicies.when;
-const ALL_WHENS = [whens.EAGER, whens.LAZY];
-const EAGER_WHENS = [whens.EAGER];
-export const NATIVE_INJECTOR_TOKEN = "Native Injector";
+const ALL_WHENS = [resolvePolicies.when.EAGER, resolvePolicies.when.LAZY];
+const EAGER_WHENS = [resolvePolicies.when.EAGER];
 /**
  * Encapsulates Dependency Injection for a path of nodes
  *
@@ -198,7 +196,7 @@ class UIInjectorImpl {
     return services.$injector.get(token);
   }
   getAsync(token) {
-    return services.$q.when(services.$injector.get(token));
+    return services.$q.resolve(services.$injector.get(token));
   }
   getNative(token) {
     return services.$injector.get(token);

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

@@ -208,7 +208,7 @@ export class StateService {
    *
    * Invokes the [[onInvalid]] callbacks, in natural order.
    * Each callback's return value is checked in sequence until one of them returns an instance of TargetState.
-   * The results of the callbacks are wrapped in $q.when(), so the callbacks may return promises.
+   * The results of the callbacks are wrapped in $q.resolve(), so the callbacks may return promises.
    *
    * If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.
    *
@@ -248,7 +248,7 @@ export class StateService {
       const nextCallback = callbackQueue.dequeue();
       if (nextCallback === undefined)
         return Rejection.invalid(toState.error()).toPromise();
-      const callbackResult = services.$q.when(
+      const callbackResult = services.$q.resolve(
         nextCallback(toState, fromState, injector),
       );
       return callbackResult
@@ -463,7 +463,7 @@ export class StateService {
         if (error.type === RejectType.IGNORED) {
           isLatest && this.urlService.update();
           // Consider ignored `Transition.run()` as a successful `transitionTo`
-          return services.$q.when(this.globals.current);
+          return services.$q.resolve(this.globals.current);
         }
         const detail = error.detail;
         if (
@@ -667,6 +667,7 @@ export class StateService {
   defaultErrorHandler(handler) {
     return (this._defaultErrorHandler = handler || this._defaultErrorHandler);
   }
+
   get(stateOrName, base) {
     const reg = this.stateRegistry;
     if (arguments.length === 0) return reg.get();

package/src/router/state/views.js

@@ -122,10 +122,10 @@ export class Ng1ViewConfig {
       {},
     );
     const promises = {
-      template: $q.when(
+      template: $q.resolve(
         this.factory.fromConfig(this.viewDecl, params, context),
       ),
-      controller: $q.when(this.getController(context)),
+      controller: $q.resolve(this.getController(context)),
     };
     return $q.all(promises).then((results) => {
       trace.traceViewServiceEvent("Loaded", this);

package/src/router/template-factory.js

@@ -69,9 +69,9 @@ export class TemplateFactory {
   fromConfig(config, params, context) {
     const defaultTemplate = "<ui-view></ui-view>";
     const asTemplate = (result) =>
-      this.$q.when(result).then((str) => ({ template: str }));
+      this.$q.resolve(result).then((str) => ({ template: str }));
     const asComponent = (result) =>
-      this.$q.when(result).then((str) => ({ component: str }));
+      this.$q.resolve(result).then((str) => ({ component: str }));
 
     const getConfigType = (config) => {
       if (isDefined(config.template)) return "template";

package/src/router/transition/transition-hook.js

@@ -37,7 +37,7 @@ export class TransitionHook {
     // Chain the next hook off the previous
     const createHookChainR = (prev, nextHook) =>
       prev.then(() => nextHook.invokeHook());
-    return hooks.reduce(createHookChainR, waitFor || services.$q.when());
+    return hooks.reduce(createHookChainR, waitFor || services.$q.resolve());
   }
   /**
    * Invokes all the provided TransitionHooks, in order.

package/src/router/transition/transition.js

@@ -619,7 +619,7 @@ export class Transition {
       // Wait to build the RUN hook chain until the BEFORE hooks are done
       // This allows a BEFORE hook to dynamically add additional RUN hooks via the Transition object.
       const allRunHooks = getHooksFor(TransitionHookPhase.RUN);
-      const done = () => services.$q.when(undefined);
+      const done = () => services.$q.resolve(undefined);
       return TransitionHook.invokeHooks(allRunHooks, done);
     };
     const startTransition = () => {
@@ -628,7 +628,7 @@ export class Transition {
       globals.transition = this;
       globals.transitionHistory.enqueue(this);
       trace.traceTransitionStart(this);
-      return services.$q.when(undefined);
+      return services.$q.resolve(undefined);
     };
     const allBeforeHooks = getHooksFor(TransitionHookPhase.BEFORE);
     TransitionHook.invokeHooks(allBeforeHooks, startTransition)

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

@@ -937,7 +937,7 @@ describe("$http", function () {
           return {
             request: function (config) {
               config.params.intercepted = true;
-              return $q.when(config);
+              return $q.resolve(config);
             },
           };
         });
@@ -1212,6 +1212,7 @@ describe("$http", function () {
         },
       );
     $rootScope.$apply();
+
     expect(response.xhrStatus).toBe("timeout");
   });