@angular-wave/angular.ts 0.0.66 → 0.0.68

package/src/router/params/param.js

@@ -86,47 +86,6 @@ function getReplace(config, arrayMode, isOptional, squash) {
   ).concat(replace);
 }
 export class Param {
-  static values(params, values = {}) {
-    const paramValues = {};
-    for (const param of params) {
-      paramValues[param.id] = param.value(values[param.id]);
-    }
-    return paramValues;
-  }
-  /**
-   * Finds [[Param]] objects which have different param values
-   *
-   * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
-   *
-   * @param params: The list of Param objects to filter
-   * @param values1: The first set of parameter values
-   * @param values2: the second set of parameter values
-   *
-   * @returns any Param objects whose values were different between values1 and values2
-   */
-  static changed(params, values1 = {}, values2 = {}) {
-    return params.filter(
-      (param) => !param.type.equals(values1[param.id], values2[param.id]),
-    );
-  }
-  /**
-   * Checks if two param value objects are equal (for a set of [[Param]] objects)
-   *
-   * @param params The list of [[Param]] objects to check
-   * @param values1 The first set of param values
-   * @param values2 The second set of param values
-   *
-   * @returns true if the param values in values1 and values2 are equal
-   */
-  static equals(params, values1 = {}, values2 = {}) {
-    return Param.changed(params, values1, values2).length === 0;
-  }
-  /** Returns true if a the parameter values are valid, according to the Param definitions */
-  static validates(params, values = {}) {
-    return params
-      .map((param) => param.validates(values[param.id]))
-      .reduce(allTrueR, true);
-  }
   constructor(id, type, location, urlConfig, state) {
     const config = getParamDeclaration(id, location, state);
     type = getType(config, type, location, id, urlConfig.paramTypes);
@@ -157,20 +116,19 @@ export class Param {
       const arrayParamNomenclature = id.match(/\[\]$/) ? { array: true } : {};
       return Object.assign(arrayDefaults, arrayParamNomenclature, config).array;
     }
-    Object.assign(this, {
-      id,
-      type,
-      location,
-      isOptional,
-      dynamic,
-      raw,
-      squash,
-      replace,
-      inherit,
-      array: arrayMode,
-      config,
-    });
+    this.isOptional = isOptional;
+    this.type = type;
+    this.location = location;
+    this.id = id;
+    this.dynamic = dynamic;
+    this.raw = raw;
+    this.squash = squash;
+    this.replace = replace;
+    this.inherit = inherit;
+    this.array = arrayMode;
+    this.config = config;
   }
+
   isDefaultValue(value) {
     return this.isOptional && this.type.equals(this.value(), value);
   }
@@ -227,4 +185,46 @@ export class Param {
   toString() {
     return `{Param:${this.id} ${this.type} squash: '${this.squash}' optional: ${this.isOptional}}`;
   }
+
+  static values(params, values = {}) {
+    const paramValues = {};
+    for (const param of params) {
+      paramValues[param.id] = param.value(values[param.id]);
+    }
+    return paramValues;
+  }
+  /**
+   * Finds [[Param]] objects which have different param values
+   *
+   * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
+   *
+   * @param params: The list of Param objects to filter
+   * @param values1: The first set of parameter values
+   * @param values2: the second set of parameter values
+   *
+   * @returns any Param objects whose values were different between values1 and values2
+   */
+  static changed(params, values1 = {}, values2 = {}) {
+    return params.filter(
+      (param) => !param.type.equals(values1[param.id], values2[param.id]),
+    );
+  }
+  /**
+   * Checks if two param value objects are equal (for a set of [[Param]] objects)
+   *
+   * @param params The list of [[Param]] objects to check
+   * @param values1 The first set of param values
+   * @param values2 The second set of param values
+   *
+   * @returns true if the param values in values1 and values2 are equal
+   */
+  static equals(params, values1 = {}, values2 = {}) {
+    return Param.changed(params, values1, values2).length === 0;
+  }
+  /** Returns true if a the parameter values are valid, according to the Param definitions */
+  static validates(params, values = {}) {
+    return params
+      .map((param) => param.validates(values[param.id]))
+      .reduce(allTrueR, true);
+  }
 }

package/src/router/path/path-utils.js

@@ -74,6 +74,7 @@ export class PathUtils {
    */
   static inheritParams(fromPath, toPath, toKeys = []) {
     function nodeParamVals(path, state) {
+      /** @type {PathNode} */
       const node = find(path, propEq("state", state));
       return Object.assign({}, node && node.paramValues);
     }

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

@@ -17,9 +17,7 @@ const parseUrl = (url) => {
   const root = url.charAt(0) === "^";
   return { val: root ? url.substring(1) : url, root };
 };
-function nameBuilder(state) {
-  return state.name;
-}
+
 function selfBuilder(state) {
   state.self.$$state = () => state;
   return state.self;
@@ -250,7 +248,7 @@ export class StateBuilder {
       return matcher.find(self.parentName(state)) || root();
     }
     this.builders = {
-      name: [nameBuilder],
+      name: [(state) => state.name],
       self: [selfBuilder],
       parent: [parentBuilder],
       data: [dataBuilder],

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

@@ -190,7 +190,7 @@ export class StateService {
 
   /**
    *
-   * @param {angular.Ng1StateDeclaration} definition
+   * @param {any} definition
    */
   state(definition) {
     if (!definition.name) {

package/src/router/state-provider.js

@@ -155,7 +155,7 @@ export class StateProvider {
 
   /**
    *
-   * @param {angular.Ng1StateDeclaration} definition
+   * @param {*} definition
    * @returns {StateProvider}
    */
   state(definition) {

package/src/router/template-factory.js

@@ -27,10 +27,10 @@ export class TemplateFactory {
     "$q",
     "$injector",
     /**
-     * @param {angular.IHttpService} $http
-     * @param {angular.ITemplateCacheService} $templateCache
-     * @param {angular.ITemplateRequestService} $templateRequest
-     * @param {angular.IQService} $q
+     * @param {any} $http
+     * @param {any} $templateCache
+     * @param {any} $templateRequest
+     * @param {any} $q
      * @param {import("../core/di/internal-injector").InjectorService} $injector
      * @returns
      */
@@ -59,9 +59,9 @@ export class TemplateFactory {
    * The following properties are search in the specified order, and the first one
    * that is defined is used to create the template:
    *
-   * @param {angular.Ng1ViewDeclaration} config
+   * @param {any} config
    * @param {any} params  Parameters to pass to the template function.
-   * @param {angular.ResolveContext} context The resolve context associated with the template's view
+   * @param {import("./resolve/resolve-context").ResolveContext} context The resolve context associated with the template's view
    *
    * @return {string|object}  The template html as a string, or a promise for
    * that string,or `null` if no template is configured.
@@ -105,7 +105,7 @@ export class TemplateFactory {
    * Creates a template from a string or a function returning a string.
    *
    * @param {string | Function} template html template as a string or function that returns an html template as a string.
-   * @param {angular.RawParams} [params] Parameters to pass to the template function.
+   * @param {any} [params] Parameters to pass to the template function.
    *
    * @return {string|object} The template html as a string, or a promise for that
    * string.
@@ -142,7 +142,7 @@ export class TemplateFactory {
    *
    * @param {import('../types').Injectable<any>} provider Function to invoke via `locals`
    * @param {Function} injectFn a function used to invoke the template provider
-   * @param {angular.ResolveContext} context
+   * @param {import("./resolve/resolve-context").ResolveContext} context
    * @return {string|Promise.<string>} The template html as a string, or a promise
    * for that string.
    */
@@ -173,8 +173,8 @@ export class TemplateFactory {
    * It analyses the component's bindings, then constructs a template that instantiates the component.
    * The template wires input and output bindings to resolves or from the parent component.
    *
-   * @param {angular.IAugmentedJQuery} ngView {object} The parent ui-view (for binding outputs to callbacks)
-   * @param {angular.ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
+   * @param {any} ngView {object} The parent ui-view (for binding outputs to callbacks)
+   * @param {import("./resolve/resolve-context").ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
    * @param {string} component {string} Component's name in camel case.
    * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
    * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".

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

@@ -92,6 +92,13 @@ export class UrlService {
     "$location",
     "$browser",
     "$rootScope",
+    /**
+     *
+     * @param {import('../../core/location/location').Location} $location
+     * @param {import('../../services/browser').Browser} $browser
+     * @param {import('../../core/scope/scope').Scope} $rootScope
+     * @returns
+     */
     ($location, $browser, $rootScope) => {
       this.$location = $location;
       this.$browser = $browser;
@@ -159,11 +166,11 @@ export class UrlService {
    * locationServices.url("/some/path?query=value#anchor", true);
    * ```
    *
-   * @param {string} newUrl The new value for the URL.
+   * @param {string} [newUrl] The new value for the URL.
    *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
    *               It should not include the protocol, site, port, or base path of an absolute HREF.
-   * @param {boolean} replace When true, replaces the current history entry (instead of appending it) with this new url
-   * @param {any} state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+   * @param {boolean} [replace] When true, replaces the current history entry (instead of appending it) with this new url
+   * @param {any} [state] The history's state object, i.e., pushState (if the LocationServices implementation supports it)
    *
    * @return the url (after potentially being processed)
    */
@@ -231,7 +238,7 @@ export class UrlService {
       hash: this.hash(),
     };
     /**
-     * @type {MatchResult}
+     * @type {*}
      */
     const best = this.match(url);
     const applyResult = pattern([

package/src/services/anchor-scroll.js

@@ -18,13 +18,11 @@ export function AnchorScrollProvider() {
     "$rootScope",
     /**
      *
-     * @param {angular.IRootScopeService} $location
-     * @param {*} $rootScope
+     * @param {import('../core/location/location').Location} $location
+     * @param {import('../core/scope/scope').Scope} $rootScope
      * @returns
      */
     function ($location, $rootScope) {
-      const { document } = window;
-
       // Helper function to get first anchor from a NodeList
       // (using `Array#some()` instead of `angular#forEach()` since it's more performant
       //  and working in all supported browsers.)
@@ -117,7 +115,7 @@ export function AnchorScrollProvider() {
             if (newVal === oldVal && newVal === "") return;
 
             const action = () => $rootScope.$evalAsync(scroll);
-            if (window.document.readyState === "complete") {
+            if (document.readyState === "complete") {
               // Force the action to be run async for consistent behavior
               // from the action's point of view
               // i.e. it will definitely not be in a $apply

package/src/services/browser.js

@@ -291,8 +291,6 @@ export function Browser(taskTracker) {
 }
 
 /**
- * @typedef {import('../types').ServiceProvider} angular.BrowserProvider
- * @description
  * This object has two goals:
  *
  * - hide all the global state in the browser caused by the window object
@@ -300,13 +298,8 @@ export function Browser(taskTracker) {
  *
  * Remove this in the future
  */
-
-/**
- * @constructor
- * @this {angular.BrowserProvider}
- */
-export function BrowserProvider() {
-  this.$get = [
+export class BrowserProvider {
+  $get = [
     "$$taskTrackerFactory",
     /**
      * @param {import('../core/task-tracker-factory').TaskTracker} $$taskTrackerFactory

package/src/services/cache-factory.js

@@ -1,72 +1,5 @@
 import { extend, forEach, isUndefined, minErr } from "../shared/utils";
 
-/**
- * @ngdoc service
- * @name $cacheFactory
- * 
- *
- * @description
- * Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to
- * them.
- *
- * ```js
- *
- *  let cache = $cacheFactory('cacheId');
- *  expect($cacheFactory.get('cacheId')).toBe(cache);
- *  expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
- *
- *  cache.put("key", "value");
- *  cache.put("another key", "another value");
- *
- *  // We've specified no options on creation
- *  expect(cache.info()).toEqual({id: 'cacheId', size: 2});
- *
- * ```
- *
- *
- * @example
-   <example module="cacheExampleApp" name="cache-factory">
-     <file name="index.html">
-       <div ng-controller="CacheController">
-         <input ng-model="newCacheKey" placeholder="Key">
-         <input ng-model="newCacheValue" placeholder="Value">
-         <button ng-click="put(newCacheKey, newCacheValue)">Cache</button>
-
-         <p ng-if="keys.length">Cached Values</p>
-         <div ng-repeat="key in keys">
-           <span ng-bind="key"></span>
-           <span>: </span>
-           <b ng-bind="cache.get(key)"></b>
-         </div>
-
-         <p>Cache Info</p>
-         <div ng-repeat="(key, value) in cache.info()">
-           <span ng-bind="key"></span>
-           <span>: </span>
-           <b ng-bind="value"></b>
-         </div>
-       </div>
-     </file>
-     <file name="script.js">
-       angular.module('cacheExampleApp', []).
-         controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {
-           $scope.keys = [];
-           $scope.cache = $cacheFactory('cacheId');
-           $scope.put = function(key, value) {
-             if (angular.isUndefined($scope.cache.get(key))) {
-               $scope.keys.push(key);
-             }
-             $scope.cache.put(key, angular.isUndefined(value) ? null : value);
-           };
-         }]);
-     </file>
-     <file name="style.css">
-       p {
-         margin: 10px 0 3px;
-       }
-     </file>
-   </example>
- */
 export function CacheFactoryProvider() {
   this.$get = function () {
     const caches = {};

package/src/services/cache-factory.md

@@ -0,0 +1,75 @@
+/\*\*
+
+- @ngdoc service
+- @name $cacheFactory
+-
+-
+- @description
+- Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to
+- them.
+-
+- ```js
+
+  ```
+
+-
+- let cache = $cacheFactory('cacheId');
+- expect($cacheFactory.get('cacheId')).toBe(cache);
+- expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
+-
+- cache.put("key", "value");
+- cache.put("another key", "another value");
+-
+- // We've specified no options on creation
+- expect(cache.info()).toEqual({id: 'cacheId', size: 2});
+-
+- ```
+
+  ```
+
+-
+-
+- @example
+  <example module="cacheExampleApp" name="cache-factory">
+  <file name="index.html">
+  <div ng-controller="CacheController">
+  <input ng-model="newCacheKey" placeholder="Key">
+  <input ng-model="newCacheValue" placeholder="Value">
+  <button ng-click="put(newCacheKey, newCacheValue)">Cache</button>
+
+          <p ng-if="keys.length">Cached Values</p>
+          <div ng-repeat="key in keys">
+            <span ng-bind="key"></span>
+            <span>: </span>
+            <b ng-bind="cache.get(key)"></b>
+          </div>
+
+          <p>Cache Info</p>
+          <div ng-repeat="(key, value) in cache.info()">
+            <span ng-bind="key"></span>
+            <span>: </span>
+            <b ng-bind="value"></b>
+          </div>
+        </div>
+      </file>
+      <file name="script.js">
+        angular.module('cacheExampleApp', []).
+          controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {
+            $scope.keys = [];
+            $scope.cache = $cacheFactory('cacheId');
+            $scope.put = function(key, value) {
+              if (angular.isUndefined($scope.cache.get(key))) {
+                $scope.keys.push(key);
+              }
+              $scope.cache.put(key, angular.isUndefined(value) ? null : value);
+            };
+          }]);
+      </file>
+      <file name="style.css">
+        p {
+          margin: 10px 0 3px;
+        }
+      </file>
+
+    </example>
+  */

package/src/services/cookie-reader.js

@@ -1,67 +1,48 @@
 import { isUndefined } from "../shared/utils";
 
+let lastCookies = {};
+let lastCookieString = "";
+
 /**
- *
- * @description
- * This is a private service for reading cookies used by $http and ngCookies
- *
- * @return {Object} a key/value map of the current cookies
+ * @returns {Object<String, String>} List of all cookies
  */
-export function $$CookieReader() {
-  const rawDocument = window.document;
-  let lastCookies = {};
-  let lastCookieString = "";
-
-  function safeGetCookie(rawDocument) {
-    try {
-      return rawDocument.cookie || "";
-    } catch (e) {
-      return "";
-    }
-  }
-
-  function safeDecodeURIComponent(str) {
-    try {
-      return decodeURIComponent(str);
-    } catch (e) {
-      return str;
-    }
-  }
-
-  return function () {
-    let cookieArray;
-    let cookie;
-    let i;
-    let index;
-    let name;
-    const currentCookieString = safeGetCookie(rawDocument);
+export function getCookies() {
+  let cookieArray;
+  let cookie;
+  let i;
+  let index;
+  let name;
+  const currentCookieString = window.document.cookie;
 
-    if (currentCookieString !== lastCookieString) {
-      lastCookieString = currentCookieString;
-      cookieArray = lastCookieString.split("; ");
-      lastCookies = {};
+  if (currentCookieString !== lastCookieString) {
+    lastCookieString = currentCookieString;
+    cookieArray = lastCookieString.split("; ");
+    lastCookies = {};
 
-      for (i = 0; i < cookieArray.length; i++) {
-        cookie = cookieArray[i];
-        index = cookie.indexOf("=");
-        if (index > 0) {
-          // ignore nameless cookies
-          name = safeDecodeURIComponent(cookie.substring(0, index));
-          // the first value that is seen for a cookie is the most
-          // specific one.  values for the same cookie name that
-          // follow are for less specific paths.
-          if (isUndefined(lastCookies[name])) {
-            lastCookies[name] = safeDecodeURIComponent(
-              cookie.substring(index + 1),
-            );
-          }
+    for (i = 0; i < cookieArray.length; i++) {
+      cookie = cookieArray[i];
+      index = cookie.indexOf("=");
+      if (index > 0) {
+        // ignore nameless cookies
+        name = safeDecodeURIComponent(cookie.substring(0, index));
+        // the first value that is seen for a cookie is the most
+        // specific one.  values for the same cookie name that
+        // follow are for less specific paths.
+        if (isUndefined(lastCookies[name])) {
+          lastCookies[name] = safeDecodeURIComponent(
+            cookie.substring(index + 1),
+          );
         }
       }
     }
-    return lastCookies;
-  };
+  }
+  return lastCookies;
 }
 
-export function CookieReaderProvider() {
-  this.$get = $$CookieReader;
+function safeDecodeURIComponent(str) {
+  try {
+    return decodeURIComponent(str);
+  } catch (e) {
+    return str;
+  }
 }