@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/core/q/q.js

@@ -1,49 +1,43 @@
+import {
+  forEach,
+  minErr,
+  isUndefined,
+  isFunction,
+  isObject,
+  isDefined,
+  isError,
+  toDebugString,
+  isPromiseLike,
+} from "../../shared/utils";
+
 /**
  * @template T
- * @typedef {Object} angular.QPromise
+ * @typedef {Object} QPromise
  * @property {function(
  *   ((value: T) => (PromiseLike<never>|PromiseLike<T>|T))|null,
  *   ((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null,
  *   ((state: any) => any)
- * ): angular.QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
+ * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
  * @property {function(
- *   ((value: T) => (angular.QPromise<never>|angular.QPromise<T>|T))|null,
- *   ((reason: any) => (angular.QPromise<never>|angular.QPromise<never>|never))|null,
+ *   ((value: T) => (QPromise<never>|QPromise<T>|T))|null,
+ *   ((reason: any) => (QPromise<never>|QPromise<never>|never))|null,
  *   ((state: any) => any)
- * ): angular.QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
- * @property {function(((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null): angular.QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
- * @property {function(((reason: any) => (angular.QPromise<never>|angular.QPromise<T>|T))|null): angular.QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
- * @property {function(function(): void): angular.QPromise<T>} finally - Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value.
+ * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
+ * @property {function(((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
+ * @property {function(((reason: any) => (QPromise<never>|QPromise<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
+ * @property {function(function(): void): QPromise<T>} finally - Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value.
+ * @property {number} [$$intervalId] - Internal id set by the $interval service for callback notifications
  */
 
 /**
  *@template T
- * @typedef {Object} angular.Deferred
- * @property {function(T|angular.QPromise<T>): void} resolve - Resolves the promise with a value or another promise.
+ * @typedef {Object} Deferred
+ * @property {function(T|QPromise<T>): void} resolve - Resolves the promise with a value or another promise.
  * @property {function(any): void} reject - Rejects the promise with a reason.
  * @property {function(any): void} notify - Provides a progress notification.
- * @property {angular.QPromise<T>} promise - The promise associated with this deferred object.
+ * @property {QPromise<T>} promise - The promise associated with this deferred object.
  */
 
-import {
-  forEach,
-  minErr,
-  isUndefined,
-  isFunction,
-  isObject,
-  isDefined,
-  isError,
-  toDebugString,
-  isPromiseLike,
-} from "../../shared/utils";
-
-/**
- * @ngdoc provider
- * @name $qProvider
- *
- *
- * @description
- */
 export function $QProvider() {
   let errorOnUnhandledRejections = true;
   this.$get = [
@@ -51,14 +45,16 @@ export function $QProvider() {
     "$exceptionHandler",
     /**
      *
-     * @param {*} $rootScope
+     * @param {import('../scope/scope').Scope} $rootScope
      * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
      * @returns
      */
     function ($rootScope, $exceptionHandler) {
       return qFactory(
         (callback) => {
-          $rootScope.$evalAsync(callback);
+          $rootScope.$evalAsync(
+            /** @type {function(function):any} */ (callback),
+          );
         },
         $exceptionHandler,
         errorOnUnhandledRejections,
@@ -129,11 +125,6 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
   const checkQueue = [];
 
   /**
-   * @ngdoc method
-   * @name ng.$q#defer
-   * @kind function
-   *
-   * @description
    * Creates a `Deferred` object which represents a task which will finish in the future.
    *
    * @returns {Deferred} Returns a new instance of deferred.
@@ -156,38 +147,45 @@ function qFactory(nextTick, exceptionHandler, errorOnUnhandledRejections) {
     };
   }
 
-  function QPromise() {
-    this.$$state = { status: 0 };
-  }
-
-  QPromise.prototype.then = function (onFulfilled, onRejected, progressBack) {
-    if (
-      isUndefined(onFulfilled) &&
-      isUndefined(onRejected) &&
-      isUndefined(progressBack)
-    ) {
-      return this;
+  class QPromise {
+    constructor() {
+      this.$$state = { status: 0 };
     }
-    const result = new QPromise();
-
-    this.$$state.pending = this.$$state.pending || [];
-    this.$$state.pending.push([result, onFulfilled, onRejected, progressBack]);
-    if (this.$$state.status > 0) scheduleProcessQueue(this.$$state);
 
-    return result;
-  };
+    then(onFulfilled, onRejected, progressBack) {
+      if (
+        isUndefined(onFulfilled) &&
+        isUndefined(onRejected) &&
+        isUndefined(progressBack)
+      ) {
+        return this;
+      }
+      const result = new QPromise();
+
+      this.$$state.pending = this.$$state.pending || [];
+      this.$$state.pending.push([
+        result,
+        onFulfilled,
+        onRejected,
+        progressBack,
+      ]);
+      if (this.$$state.status > 0) scheduleProcessQueue(this.$$state);
+
+      return result;
+    }
 
-  QPromise.prototype.catch = function (callback) {
-    return this.then(null, callback);
-  };
+    catch(callback) {
+      return this.then(null, callback);
+    }
 
-  QPromise.prototype.finally = function (callback, progressBack) {
-    return this.then(
-      (value) => handleCallback(value, resolve, callback),
-      (error) => handleCallback(error, reject, callback),
-      progressBack,
-    );
-  };
+    finally(callback, progressBack) {
+      return this.then(
+        (value) => handleCallback(value, resolve, callback),
+        (error) => handleCallback(error, reject, callback),
+        progressBack,
+      );
+    }
+  }
 
   function processQueue(state) {
     let fn;

package/src/core/sce/sce.js

@@ -46,9 +46,7 @@ export const SCE_CONTEXTS = {
 // http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
 // Prereq: s is a string.
 export function escapeForRegexp(s) {
-  return s
-    .replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, "\\$1")
-    .replace(/\x08/g, "\\x08");
+  return s.replace(/([-()[\]{}+?*.$^|,:#<!\\])/g, "\\$1");
 }
 
 export function adjustMatcher(matcher) {

package/src/core/scope/scope.js

@@ -392,7 +392,7 @@ export class Scope {
  *
  *    - `string`: Evaluated as {@link guide/expression expression}
  *    - `function(scope)`: called with current `scope` as a parameter.
- * @param {WatchListener} listener
+ * @param {WatchListener} [listener]
  * @param {boolean=} [objectEquality=false] Compare for object equality using {@link angular.equals} instead of
  *     comparing for reference equality.
  * @returns {function()} Returns a deregistration function for this listener.
@@ -1155,7 +1155,7 @@ export class Scope {
    * will be scheduled. However, it is encouraged to always call code that changes the model
    * from within an `$apply` call. That includes code evaluated via `$evalAsync`.
    *
-   * @param {(string|function())=} expr An AngularTS expression to be executed.
+   * @param {(string|function(any):any)=} expr An AngularTS expression to be executed.
    *
    *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
    *    - `function(scope)`: execute the function with the current `scope` parameter.
@@ -1187,9 +1187,6 @@ export class Scope {
     return id;
   }
 
-  /**
-   * @private
-   */
   $$postDigest(fn) {
     $$postDigestQueue.push(fn);
   }

package/src/core/timeout/timeout.js

@@ -3,128 +3,127 @@ import { isDefined, isFunction, minErr, sliceArgs } from "../../shared/utils";
 
 const $timeoutMinErr = minErr("$timeout");
 
-/**
- *
- * @param {*} $rootScope
- * @param {*} $browser
- * @param {*} $q
- * @param {*} $$q
- * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
- * @returns
- */
-export function $timeout($rootScope, $browser, $q, $$q, $exceptionHandler) {
-  const deferreds = {};
-
-  /**
-   * @ngdoc service
-   * @name $timeout
-   *
-   * @description
-   * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
-   * block and delegates any exceptions to
-   * {@link ng.$exceptionHandler $exceptionHandler} service.
-   *
-   * The return value of calling `$timeout` is a promise, which will be resolved when
-   * the delay has passed and the timeout function, if provided, is executed.
-   *
-   * To cancel a timeout request, call `$timeout.cancel(promise)`.
-   *
-   * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
-   * synchronously flush the queue of deferred functions.
-   *
-   * If you only want a promise that will be resolved after some specified delay
-   * then you can call `$timeout` without the `fn` function.
-   *
-   * @param {function()=} fn A function, whose execution should be delayed.
-   * @param {number=} [delay=0] Delay in milliseconds.
-   * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
-   *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
-   * @param {...*=} Pass additional parameters to the executed function.
-   * @returns {Promise} Promise that will be resolved when the timeout is reached. The promise
-   *   will be resolved with the return value of the `fn` function.
-   *
-   */
-  function timeout(fn, delay, invokeApply) {
-    if (!isFunction(fn)) {
-      invokeApply = delay;
-      delay = fn;
-      fn = () => {};
-    }
-
-    const args = sliceArgs(arguments, 3);
-    const skipApply = isDefined(invokeApply) && !invokeApply;
-    const deferred = (skipApply ? $$q : $q).defer();
-    const { promise } = deferred;
-    let timeoutId;
+export function $TimeoutProvider() {
+  this.$get = [
+    "$rootScope",
+    "$browser",
+    "$q",
+    "$$q",
+    "$exceptionHandler",
+    /**
+     *
+     * @param {import('../scope/scope').Scope} $rootScope
+     * @param {import('../../services/browser').Browser} $browser
+     * @param {*} $q
+     * @param {*} $$q
+     * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
+     * @returns
+     */
+    function ($rootScope, $browser, $q, $$q, $exceptionHandler) {
+      const deferreds = {};
 
-    timeoutId = $browser.defer(
-      () => {
-        try {
-          deferred.resolve(fn.apply(null, args));
-        } catch (e) {
-          deferred.reject(e);
-          $exceptionHandler(e);
-        } finally {
-          delete deferreds[promise.$$timeoutId];
+      /**
+       * @ngdoc service
+       * @name $timeout
+       *
+       * @description
+       * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
+       * block and delegates any exceptions to
+       * {@link ng.$exceptionHandler $exceptionHandler} service.
+       *
+       * The return value of calling `$timeout` is a promise, which will be resolved when
+       * the delay has passed and the timeout function, if provided, is executed.
+       *
+       * To cancel a timeout request, call `$timeout.cancel(promise)`.
+       *
+       * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
+       * synchronously flush the queue of deferred functions.
+       *
+       * If you only want a promise that will be resolved after some specified delay
+       * then you can call `$timeout` without the `fn` function.
+       *
+       * @param {function()=} fn A function, whose execution should be delayed.
+       * @param {number=} [delay=0] Delay in milliseconds.
+       * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+       *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+       * @returns {Promise} Promise that will be resolved when the timeout is reached. The promise
+       *   will be resolved with the return value of the `fn` function.
+       *
+       */
+      function timeout(fn, delay, invokeApply = true) {
+        if (!isFunction(fn)) {
+          invokeApply = delay;
+          delay = fn;
+          fn = () => {};
         }
 
-        if (!skipApply) $rootScope.$apply();
-      },
-      delay,
-      "$timeout",
-    );
+        const args = sliceArgs(arguments, 3);
+        const skipApply = isDefined(invokeApply) && !invokeApply;
+        const deferred = (skipApply ? $$q : $q).defer();
+        const { promise } = deferred;
+        let timeoutId;
 
-    promise.$$timeoutId = timeoutId;
-    deferreds[timeoutId] = deferred;
+        timeoutId = $browser.defer(
+          () => {
+            try {
+              deferred.resolve(fn.apply(null, args));
+            } catch (e) {
+              deferred.reject(e);
+              $exceptionHandler(e);
+            } finally {
+              delete deferreds[promise.$$timeoutId];
+            }
 
-    return promise;
-  }
+            if (!skipApply) $rootScope.$apply();
+          },
+          delay,
+          "$timeout",
+        );
 
-  /**
-   * @ngdoc method
-   * @name $timeout#cancel
-   *
-   * @description
-   * Cancels a task associated with the `promise`. As a result of this, the promise will be
-   * resolved with a rejection.
-   *
-   * @param {Promise=} promise Promise returned by the `$timeout` function.
-   * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
-   *   canceled.
-   */
-  timeout.cancel = function (promise) {
-    if (!promise) return false;
+        promise.$$timeoutId = timeoutId;
+        deferreds[timeoutId] = deferred;
 
-    if (!Object.prototype.hasOwnProperty.call(promise, "$$timeoutId")) {
-      throw $timeoutMinErr(
-        "badprom",
-        "`$timeout.cancel()` called with a promise that was not generated by `$timeout()`.",
-      );
-    }
+        return promise;
+      }
 
-    if (!Object.prototype.hasOwnProperty.call(deferreds, promise.$$timeoutId))
-      return false;
-    const id = promise.$$timeoutId;
-    const deferred = deferreds[id];
+      /**
+       * @ngdoc method
+       * @name $timeout#cancel
+       *
+       * @description
+       * Cancels a task associated with the `promise`. As a result of this, the promise will be
+       * resolved with a rejection.
+       *
+       * @param {Promise=} promise Promise returned by the `$timeout` function.
+       * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+       *   canceled.
+       */
+      timeout.cancel = function (promise) {
+        if (!promise) return false;
 
-    // Timeout cancels should not report an unhandled promise.
-    markQExceptionHandled(deferred.promise);
-    deferred.reject("canceled");
-    delete deferreds[id];
+        if (!Object.prototype.hasOwnProperty.call(promise, "$$timeoutId")) {
+          throw $timeoutMinErr(
+            "badprom",
+            "`$timeout.cancel()` called with a promise that was not generated by `$timeout()`.",
+          );
+        }
 
-    return $browser.cancel(id);
-  };
+        if (
+          !Object.prototype.hasOwnProperty.call(deferreds, promise.$$timeoutId)
+        )
+          return false;
+        const id = promise.$$timeoutId;
+        const deferred = deferreds[id];
 
-  return timeout;
-}
+        // Timeout cancels should not report an unhandled promise.
+        markQExceptionHandled(deferred.promise);
+        deferred.reject("canceled");
+        delete deferreds[id];
 
-export function $TimeoutProvider() {
-  this.$get = [
-    "$rootScope",
-    "$browser",
-    "$q",
-    "$$q",
-    "$exceptionHandler",
-    $timeout,
+        return $browser.cancel(id);
+      };
+
+      return timeout;
+    },
   ];
 }

package/src/core/url-utils/url-utils.js

@@ -1,5 +1,10 @@
 import { isString } from "../../shared/utils";
 
+/**
+ * HTTP protocol
+ * @typedef {"http"|"https"} HttpProtocol
+ */
+
 // service.
 const urlParsingNode = window.document.createElement("a");
 const originUrl = urlResolve(window.location.href);