@angular-wave/angular.ts 0.0.67 → 0.0.68

package/src/core/location/location.md

@@ -0,0 +1,114 @@
+/\*\*
+
+- The $location service parses the URL in the browser address bar (based on the
+- [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
+- available to your application. Changes to the URL in the address bar are reflected into
+- $location service and changes to $location are reflected into the browser address bar.
+-
+- **The $location service:**
+-
+- - Exposes the current URL in the browser address bar, so you can
+- - Watch and observe the URL.
+- - Change the URL.
+- - Synchronizes the URL with the browser when the user
+- - Changes the address bar.
+- - Clicks the back or forward button (or clicks a History link).
+- - Clicks on a link.
+- - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
+-
+- For more information see {@link guide/$location Developer Guide: Using $location}
+  \*/
+
+/\*\*
+
+- Use the `$locationProvider` to configure how the application deep linking paths are stored.
+  \*/
+
+/\*\*
+
+- @ngdoc event
+- @name $location#$locationChangeStart
+- @eventType broadcast on root scope
+- @description
+- Broadcasted before a URL will change.
+-
+- This change can be prevented by calling
+- `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
+- details about event object. Upon successful change
+- {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
+-
+- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+- the browser supports the HTML5 History API.
+-
+- @param {Object} angularEvent Synthetic event object.
+- @param {string} newUrl New URL
+- @param {string=} oldUrl URL that was before it was changed.
+- @param {string=} newState New history state object
+- @param {string=} oldState History state object that was before it was changed.
+  \*/
+
+/\*\*
+
+- @ngdoc event
+- @name $location#$locationChangeSuccess
+- @eventType broadcast on root scope
+- @description
+- Broadcasted after a URL was changed.
+-
+- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+- the browser supports the HTML5 History API.
+-
+- @param {Object} angularEvent Synthetic event object.
+- @param {string} newUrl New URL
+- @param {string=} oldUrl URL that was before it was changed.
+- @param {string=} newState New history state object
+- @param {string=} oldState History state object that was before it was changed.
+  \*/
+
+  /\*\*
+
+  - This method is getter / setter.
+  -
+  - Return search part (as object) of current URL when called without any parameter.
+  -
+  - Change search part when called with parameter and return `$location`.
+  -
+  -
+  - ```js
+
+    ```
+
+  - // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
+  - let searchObject = $location.search();
+  - // => {foo: 'bar', baz: 'xoxo'}
+  -
+  - // set foo to 'yipee'
+  - $location.search('foo', 'yipee');
+  - // $location.search() => {foo: 'yipee', baz: 'xoxo'}
+  - ```
+
+    ```
+
+  -
+  - @param {string|Object} search New search params - string or hash object.
+  -
+  - When called with a single argument the method acts as a setter, setting the `search` component
+  - of `$location` to the specified value.
+  -
+  - If the argument is a hash object containing an array of values, these values will be encoded
+  - as duplicate search parameters in the URL.
+  -
+  - @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue`
+  - will override only a single search property.
+  -
+  - If `paramValue` is an array, it will override the property of the `search` component of
+  - `$location` specified via the first argument.
+  -
+  - If `paramValue` is `null`, the property specified via the first argument will be deleted.
+  -
+  - If `paramValue` is `true`, the property specified via the first argument will be added with no
+  - value nor trailing equal sign.
+  -
+  - @return {Object} If called with no arguments returns the parsed `search` object. If called with
+  - one or more arguments returns `$location` object itself.
+    \*/

package/src/core/location/location.spec.js

@@ -2,7 +2,6 @@ import {
   LocationHtml5Url,
   LocationHashbangUrl,
   $LocationProvider,
-  LocationHashbangInHtml5Url,
 } from "./location";
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
@@ -464,6 +463,7 @@ describe("$location", () => {
           .hash("abcd")
           .state({ a: 2 })
           .search("bar", "baz");
+
         expect(locationUrl.path()).toEqual("/foo");
         expect(locationUrl.state()).toEqual({ a: 2 });
         expect(locationUrl.search() && locationUrl.search().bar).toBe("baz");
@@ -3310,81 +3310,6 @@ describe("$location", () => {
     });
   });
 
-  describe("LocationHashbangInHtml5Url", () => {
-    /* global LocationHashbangInHtml5Url: false */
-    let locationUrl;
-    let locationIndexUrl;
-
-    beforeEach(() => {
-      locationUrl = new LocationHashbangInHtml5Url(
-        "http://server/pre/",
-        "http://server/pre/",
-        "#!",
-      );
-      locationIndexUrl = new LocationHashbangInHtml5Url(
-        "http://server/pre/index.html",
-        "http://server/pre/",
-        "#!",
-      );
-    });
-
-    it("should rewrite URL", () => {
-      expect(parseLinkAndReturn(locationUrl, "http://other")).toEqual(
-        undefined,
-      );
-      expect(parseLinkAndReturn(locationUrl, "http://server/pre")).toEqual(
-        "http://server/pre/#!",
-      );
-      expect(parseLinkAndReturn(locationUrl, "http://server/pre/")).toEqual(
-        "http://server/pre/#!",
-      );
-      expect(
-        parseLinkAndReturn(locationUrl, "http://server/pre/otherPath"),
-      ).toEqual("http://server/pre/#!/otherPath");
-      // Note: relies on the previous state!
-      expect(
-        parseLinkAndReturn(locationUrl, "someIgnoredAbsoluteHref", "#test"),
-      ).toEqual("http://server/pre/#!/otherPath#test");
-
-      expect(parseLinkAndReturn(locationIndexUrl, "http://server/pre")).toEqual(
-        "http://server/pre/index.html#!",
-      );
-      expect(
-        parseLinkAndReturn(locationIndexUrl, "http://server/pre/"),
-      ).toEqual(undefined);
-      expect(
-        parseLinkAndReturn(locationIndexUrl, "http://server/pre/otherPath"),
-      ).toEqual("http://server/pre/index.html#!/otherPath");
-      // Note: relies on the previous state!
-      expect(
-        parseLinkAndReturn(
-          locationIndexUrl,
-          "someIgnoredAbsoluteHref",
-          "#test",
-        ),
-      ).toEqual("http://server/pre/index.html#!/otherPath#test");
-    });
-
-    it("should throw on url(urlString, stateObject)", () => {
-      expectThrowOnStateChange(locationUrl);
-    });
-
-    // it("should not throw when base path is another domain", () => {
-    //   initService({ html5Mode: true, hashPrefix: "!", supportHistory: true });
-    //   inject(
-    //     initBrowser({
-    //       url: "http://domain.com/base/",
-    //       basePath: "http://otherdomain.com/base/",
-    //     }),
-    //     ($location) => {
-    //       expect(() => {
-    //         $location.absUrl();
-    //       }).not.toThrow();
-    //     },
-    //   );
-    // });
-  });
-
   // function mockUpBrowser(options) {
   //   module(($windowProvider, $browserProvider) => {
   //     let browser;

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

package/src/directive/options/options.js

@@ -11,161 +11,6 @@ import {
 
 const ngOptionsMinErr = minErr("ngOptions");
 
-/**
- * @ngdoc directive
- * @name ngOptions
- * @restrict A
- *
- * @description
- *
- * The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
- * elements for the `<select>` element using the array or object obtained by evaluating the
- * `ngOptions` comprehension expression.
- *
- * In many cases, {@link ng.directive:ngRepeat ngRepeat} can be used on `<option>` elements instead of
- * `ngOptions` to achieve a similar result. However, `ngOptions` provides some benefits:
- * - more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
- * comprehension expression
- * - reduced memory consumption by not creating a new scope for each repeated instance
- * - increased render speed by creating the options in a documentFragment instead of individually
- *
- * When an item in the `<select>` menu is selected, the array element or object property
- * represented by the selected option will be bound to the model identified by the `ngModel`
- * directive.
- *
- * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
- * be nested into the `<select>` element. This element will then represent the `null` or "not selected"
- * option. See example below for demonstration.
- *
- * ## Complex Models (objects or collections)
- *
- * By default, `ngModel` watches the model by reference, not value. This is important to know when
- * binding the select to a model that is an object or a collection.
- *
- * One issue occurs if you want to preselect an option. For example, if you set
- * the model to an object that is equal to an object in your collection, `ngOptions` won't be able to set the selection,
- * because the objects are not identical. So by default, you should always reference the item in your collection
- * for preselections, e.g.: `$scope.selected = $scope.collection[3]`.
- *
- * Another solution is to use a `track by` clause, because then `ngOptions` will track the identity
- * of the item not by reference, but by the result of the `track by` expression. For example, if your
- * collection items have an id property, you would `track by item.id`.
- *
- * A different issue with objects or collections is that ngModel won't detect if an object property or
- * a collection item changes. For that reason, `ngOptions` additionally watches the model using
- * `$watchCollection`, when the expression contains a `track by` clause or the the select has the `multiple` attribute.
- * This allows ngOptions to trigger a re-rendering of the options even if the actual object/collection
- * has not changed identity, but only a property on the object or an item in the collection changes.
- *
- * Note that `$watchCollection` does a shallow comparison of the properties of the object (or the items in the collection
- * if the model is an array). This means that changing a property deeper than the first level inside the
- * object/collection will not trigger a re-rendering.
- *
- * ## `select` **`as`**
- *
- * Using `select` **`as`** will bind the result of the `select` expression to the model, but
- * the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
- * or property name (for object data sources) of the value within the collection. If a **`track by`** expression
- * is used, the result of that expression will be set as the value of the `option` and `select` elements.
- *
- *
- * ### `select` **`as`** and **`track by`**
- *
- * <div class="alert alert-warning">
- * Be careful when using `select` **`as`** and **`track by`** in the same expression.
- * </div>
- *
- * Given this array of items on the $scope:
- *
- * ```js
- * $scope.items = [{
- *   id: 1,
- *   label: 'aLabel',
- *   subItem: { name: 'aSubItem' }
- * }, {
- *   id: 2,
- *   label: 'bLabel',
- *   subItem: { name: 'bSubItem' }
- * }];
- * ```
- *
- * This will work:
- *
- * ```html
- * <select ng-options="item as item.label for item in items track by item.id" ng-model="selected"></select>
- * ```
- * ```js
- * $scope.selected = $scope.items[0];
- * ```
- *
- * but this will not work:
- *
- * ```html
- * <select ng-options="item.subItem as item.label for item in items track by item.id" ng-model="selected"></select>
- * ```
- * ```js
- * $scope.selected = $scope.items[0].subItem;
- * ```
- *
- * In both examples, the **`track by`** expression is applied successfully to each `item` in the
- * `items` array. Because the selected option has been set programmatically in the controller, the
- * **`track by`** expression is also applied to the `ngModel` value. In the first example, the
- * `ngModel` value is `items[0]` and the **`track by`** expression evaluates to `items[0].id` with
- * no issue. In the second example, the `ngModel` value is `items[0].subItem` and the **`track by`**
- * expression evaluates to `items[0].subItem.id` (which is undefined). As a result, the model value
- * is not matched against any `<option>` and the `<select>` appears as having no selected value.
- *
- *
- * @param {string} ngModel Assignable AngularJS expression to data-bind to.
- * @param {comprehension_expression} ngOptions in one of the following forms:
- *
- *   * for array data sources:
- *     * `label` **`for`** `value` **`in`** `array`
- *     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
- *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
- *     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array`
- *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
- *     * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
- *     * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
- *        (for including a filter with `track by`)
- *   * for object data sources:
- *     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
- *     * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
- *     * `label` **`disable when`** `disable` **`for (`**`key`**`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`group by`** `group`
- *         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
- *     * `select` **`as`** `label` **`disable when`** `disable`
- *         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
- *
- * Where:
- *
- *   * `array` / `object`: an expression which evaluates to an array / object to iterate over.
- *   * `value`: local variable which will refer to each item in the `array` or each property value
- *      of `object` during iteration.
- *   * `key`: local variable which will refer to a property name in `object` during iteration.
- *   * `label`: The result of this expression will be the label for `<option>` element. The
- *     `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
- *   * `select`: The result of this expression will be bound to the model of the parent `<select>`
- *      element. If not specified, `select` expression will default to `value`.
- *   * `group`: The result of this expression will be used to group options using the `<optgroup>`
- *      DOM element.
- *   * `disable`: The result of this expression will be used to disable the rendered `<option>`
- *      element. Return `true` to disable.
- *   * `trackexpr`: Used when working with an array of objects. The result of this expression will be
- *      used to identify the objects in the array. The `trackexpr` will most likely refer to the
- *     `value` variable (e.g. `value.propertyName`). With this the selection is preserved
- *      even when the options are recreated (e.g. reloaded from the server).
- * @param {string=} name Property name of the form under which the control is published.
- * @param {string=} required The control is considered valid only if value is entered.
- * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
- *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
- *    `required` when you want to data-bind to the `required` attribute.
- * @param {string=} ngAttrSize sets the size of the select element dynamically. Uses the
- * {@link guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes ngAttr} directive.
- *
- */
-
 const NG_OPTIONS_REGEXP =
   /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([$\w][$\w]*)|(?:\(\s*([$\w][$\w]*)\s*,\s*([$\w][$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/;
 // 1: value expression (valueFn)
@@ -618,7 +463,8 @@ export const ngOptionsDirective = [
 
               // Update the label on the group element
               // "null" is special cased because of Safari
-              groupElement.label =
+              /** @type {HTMLOptGroupElement} */
+              (groupElement).label =
                 option.group === null ? "null" : option.group;
 
               // Store it for use later