@angular-wave/angular.ts 0.1.3 → 0.1.4

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/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

package/types/core/task-tracker-factory.d.ts

@@ -1,57 +1,68 @@
-export function $$TaskTrackerFactoryProvider(): void;
 export class $$TaskTrackerFactoryProvider {
     $get: (string | ((log: import("../services/log").LogService) => TaskTracker))[];
 }
 /**
- * ! This is a private undocumented service !
+ * A factory function to create `TaskTracker` instances.
  *
- * @name $$taskTrackerFactory
- * @description
- * A function to create `TaskTracker` instances.
- *
- * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+ * A `TaskTracker` tracks pending tasks (grouped by type) and notifies interested
  * parties when all pending tasks (or tasks of a specific type) have been completed.
- * @param {import('../services/log').LogService} log
  */
-export function TaskTracker(log: import("../services/log").LogService): void;
 export class TaskTracker {
     /**
-     * ! This is a private undocumented service !
-     *
-     * @name $$taskTrackerFactory
-     * @description
-     * A function to create `TaskTracker` instances.
-     *
-     * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
-     * parties when all pending tasks (or tasks of a specific type) have been completed.
-     * @param {import('../services/log').LogService} log
+     * @param {import('../services/log').LogService} log - The logging service.
      */
     constructor(log: import("../services/log").LogService);
+    /** @private */
+    private log;
+    /** @private */
+    private taskCounts;
+    /** @private */
+    private taskCallbacks;
+    /**
+     * Special task types used for tracking all tasks and default tasks.
+     * @type {string}
+     */
     ALL_TASKS_TYPE: string;
+    /**
+     * Default task type.
+     * @type {string}
+     */
     DEFAULT_TASK_TYPE: string;
     /**
-     * Execute the specified function and decrement the appropriate `taskCounts` counter.
-     * If the counter reaches 0, all corresponding `taskCallbacks` are executed.
+     * Completes a task and decrements the associated task counter.
+     * If the counter reaches 0, all corresponding callbacks are executed.
+     *
+     * @param {Function} fn - The function to execute when completing the task.
+     * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task being completed.
+     */
+    completeTask(fn: Function, taskType?: string): void;
+    /**
+     * Increments the task count for the specified task type.
      *
-     * @param {Function} fn - The function to execute.
-     * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task that is being completed.
+     * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
      */
-    completeTask: (fn: any, taskType: any) => void;
+    incTaskCount(taskType?: string): void;
     /**
-     * Increase the task count for the specified task type (or the default task type if non is
-     * specified).
+     * Registers a callback to be executed when all pending tasks of the specified type are completed.
+     * If there are no pending tasks of the specified type, the callback is executed immediately.
      *
-     * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
+     * @param {Function} callback - The function to execute when no pending tasks remain.
+     * @param {string} [taskType=this.ALL_TASKS_TYPE] - The type of tasks to wait for completion.
      */
-    incTaskCount: (taskType: any) => void;
+    notifyWhenNoPendingTasks(callback: Function, taskType?: string): void;
     /**
-     * Execute the specified callback when all pending tasks have been completed.
+     * Retrieves and removes the last registered callback from the queue.
      *
-     * If there are no pending tasks, the callback is executed immediately. You can optionally limit
-     * the tasks that will be waited for to a specific type, by passing a `taskType`.
+     * @private
+     * @returns {Function|undefined} The last callback function or undefined if none exist.
+     */
+    private getLastCallback;
+    /**
+     * Retrieves and removes the last registered callback for the specified task type.
      *
-     * @param {function} callback - The function to call when there are no pending tasks.
-     * @param {string=} [taskType=ALL_TASKS_TYPE] - The type of tasks that will be waited for.
+     * @private
+     * @param {string} taskType - The type of task for which the callback was registered.
+     * @returns {Function|undefined} The last callback function for the task type, or undefined if none exist.
      */
-    notifyWhenNoPendingTasks: (callback: any, taskType: any) => void;
+    private getLastCallbackForType;
 }

package/types/loader.d.ts

@@ -74,7 +74,6 @@ export class Angular {
      * @returns {any} InjectorService - Returns the newly created injector for this app.
      */
     bootstrap(element: string | Element | Document, modules?: Array<string | any>, config?: AngularBootstrapConfig): any;
-    resumeBootstrap(extraModules: any): any;
     /**
      *
      * @param {any[]} modules
@@ -82,6 +81,7 @@ export class Angular {
      * @returns {import("./core/di/internal-injector").InjectorService}
      */
     injector(modules: any[], strictDi: boolean | null): import("./core/di/internal-injector").InjectorService;
+    resumeBootstrap(extraModules: any): any;
     /**
      * @param {Element|Document} element
      */

package/types/router/url/url-service.d.ts

@@ -58,8 +58,8 @@ export class UrlService {
     _urlListeners: any[];
     $get: (string | (($location: import("../../core/location/location").Location, $browser: import("../../services/browser").Browser, $rootScope: import("../../core/scope/scope").Scope) => this))[];
     html5Mode(): boolean;
-    baseHref(): string;
-    _baseHref: string;
+    baseHref(): any;
+    _baseHref: any;
     /**
      * Gets the current url, or updates the url
      *