@angular-wave/angular.ts 0.2.1 → 0.2.3

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

@@ -56,11 +56,13 @@ export class ResolveContext {
       .filter((r) => r.token === token);
     return tail(matching);
   }
+
   /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
   getPolicy(resolvable) {
     const node = this.findNode(resolvable);
     return resolvable.getPolicy(node);
   }
+
   /**
    * Returns a ResolveContext that includes a portion of this one
    *
@@ -101,7 +103,7 @@ export class ResolveContext {
    *
    * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
    *
-   * @param newResolvables the new Resolvables
+   * @param {Resolvable[]} newResolvables the new Resolvables
    * @param state Used to find the node to put the resolvable on
    */
   addResolvables(newResolvables, state) {
@@ -115,9 +117,9 @@ export class ResolveContext {
   /**
    * Returns a promise for an array of resolved path Element promises
    *
-   * @param when
+   * @param {string} when
    * @param trans
-   * @returns {Promise<any>|any}
+   * @returns {import("../../core/q/q").QPromise<any>|any}
    */
   resolvePath(when = "LAZY", trans) {
     // This option determines which 'when' policy Resolvables we are about to fetch.
@@ -153,16 +155,21 @@ export class ResolveContext {
     // Wait for all the "WAIT" resolvables
     return services.$q.all(promises);
   }
+
   injector() {
     return this._injector || (this._injector = new UIInjectorImpl());
   }
+
   findNode(resolvable) {
     return find(this._path, (node) => node.resolvables.includes(resolvable));
   }
+
   /**
    * Gets the async dependencies of a Resolvable
    *
    * Given a Resolvable, returns its dependencies as a Resolvable[]
+   * @param {Resolvable} resolvable
+   * @returns {Resolvable[]}
    */
   getDependencies(resolvable) {
     const node = this.findNode(resolvable);
@@ -173,7 +180,7 @@ export class ResolveContext {
     const availableResolvables = subPath
       .reduce((acc, _node) => acc.concat(_node.resolvables), []) // all of subpath's resolvables
       .filter((res) => res !== resolvable); // filter out the `resolvable` argument
-    const getDependency = (token) => {
+    return resolvable.deps.map((token) => {
       const matching = availableResolvables.filter((r) => r.token === token);
       if (matching.length) return tail(matching);
       const fromInjector = services.$injector.get(token);
@@ -183,8 +190,7 @@ export class ResolveContext {
         );
       }
       return new Resolvable(token, () => fromInjector, [], fromInjector);
-    };
-    return resolvable.deps.map(getDependency);
+    });
   }
 }
 

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

@@ -1,10 +1,10 @@
 import {
   applyPairs,
   inherit,
-  mapObj,
   omit,
   tail,
   copy,
+  map,
 } from "../../shared/common";
 import { isDefined, isFunction, isString } from "../../shared/utils";
 import { stringify } from "../../shared/strings";
@@ -12,24 +12,27 @@ import { is, pattern, pipe, prop, val } from "../../shared/hof";
 import { Resolvable } from "../resolve/resolvable";
 import { services } from "../common/coreservices";
 import { annotate } from "../../core/di/injector";
-const parseUrl = (url) => {
+
+function parseUrl(url) {
   if (!isString(url)) return false;
   const root = url.charAt(0) === "^";
   return { val: root ? url.substring(1) : url, root };
-};
+}
 
 function selfBuilder(state) {
   state.self.$$state = () => state;
   return state.self;
 }
+
 function dataBuilder(state) {
   if (state.parent && state.parent.data) {
     state.data = state.self.data = inherit(state.parent.data, state.data);
   }
   return state.data;
 }
-const getUrlBuilder = ($urlService, root) =>
-  function urlBuilder(stateObject) {
+
+function getUrlBuilder($urlService, root) {
+  return function (stateObject) {
     let stateDec = stateObject.self;
     // For future states, i.e., states whose name ends with `.**`,
     // match anything that starts with the url prefix
@@ -56,31 +59,34 @@ const getUrlBuilder = ($urlService, root) =>
       ? url
       : ((parent && parent.navigable) || root()).url.append(url);
   };
-const getNavigableBuilder = (isRoot) =>
-  function navigableBuilder(state) {
+}
+
+function getNavigableBuilder(isRoot) {
+  return function (state) {
     return !isRoot(state) && state.url
       ? state
       : state.parent
         ? state.parent.navigable
         : null;
   };
-const getParamsBuilder = (paramFactory) =>
-  function paramsBuilder(state) {
+}
+
+function getParamsBuilder(paramFactory) {
+  return function (state) {
     const makeConfigParam = (config, id) =>
       paramFactory.fromConfig(id, null, state.self);
     const urlParams =
       (state.url && state.url.parameters({ inherit: false })) || [];
     const nonUrlParams = Object.values(
-      mapObj(
-        omit(state.params || {}, urlParams.map(prop("id"))),
-        makeConfigParam,
-      ),
+      map(omit(state.params || {}, urlParams.map(prop("id"))), makeConfigParam),
     );
     return urlParams
       .concat(nonUrlParams)
       .map((p) => [p.id, p])
       .reduce(applyPairs, {});
   };
+}
+
 function pathBuilder(state) {
   if (state.parent && !state.abstract) {
     return state.parent.path.concat(state);
@@ -88,11 +94,13 @@ function pathBuilder(state) {
     return [state];
   }
 }
+
 function includesBuilder(state) {
   const includes = state.parent ? Object.assign({}, state.parent.includes) : {};
   includes[state.name] = true;
   return includes;
 }
+
 /**
  * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].
  *
@@ -157,12 +165,6 @@ export function resolvablesBuilder(state) {
   };
   /** true if the object has both `token` and `resolveFn`, and is probably a [[ResolveLiteral]] */
   const isResolveLiteral = (obj) => !!(obj.token && obj.resolveFn);
-  /** true if the object looks like a provide literal, or a ng2 Provider */
-  const isLikeNg2Provider = (obj) =>
-    !!(
-      (obj.provide || obj.token) &&
-      (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass)
-    );
   /** true if the object looks like a tuple from obj2Tuples */
   const isTupleFromObj = (obj) =>
     !!(
@@ -170,8 +172,7 @@ export function resolvablesBuilder(state) {
       obj.val &&
       (isString(obj.val) || Array.isArray(obj.val) || isFunction(obj.val))
     );
-  /** extracts the token from a Provider or provide literal */
-  const getToken = (p) => p.provide || p.token;
+
   // Given a literal resolve or provider object, returns a Resolvable
   const literal2Resolvable = pattern([
     [
@@ -232,7 +233,6 @@ export function resolvablesBuilder(state) {
   const item2Resolvable = pattern([
     [is(Resolvable), (r) => r],
     [isResolveLiteral, literal2Resolvable],
-    [isLikeNg2Provider, literal2Resolvable],
     [isTupleFromObj, tuple2Resolvable],
     [
       val(true),
@@ -267,7 +267,6 @@ export class StateBuilder {
     this.$injector = undefined;
     const self = this;
     const root = () => matcher.find("");
-    const isRoot = (state) => state.name === "";
     function parentBuilder(state) {
       if (isRoot(state)) return null;
       return matcher.find(self.parentName(state)) || root();
@@ -358,3 +357,12 @@ export class StateBuilder {
     return parentName ? parentName + "." + name : name;
   }
 }
+
+function isRoot(state) {
+  return state.name === "";
+}
+
+/** extracts the token from a Provider or provide literal */
+function getToken(p) {
+  return p.provide || p.token;
+}

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

@@ -1,4 +1,4 @@
-import { removeFrom, tail, mapObj } from "../../shared/common";
+import { removeFrom, tail, map } from "../../shared/common";
 import { isString, isFunction } from "../../shared/utils";
 import { Glob } from "../common/glob";
 import { TransitionHookScope } from "./interface";
@@ -93,7 +93,7 @@ export class RegisteredHook {
    * }
    */
   _getDefaultMatchCriteria() {
-    return mapObj(this.tranSvc._pluginapi._getPathTypes(), () => true);
+    return map(this.tranSvc._pluginapi._getPathTypes(), () => true);
   }
   /**
    * Gets matching nodes as [[IMatchingNodes]]

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

@@ -2,7 +2,7 @@ import { TransitionHookPhase } from "./interface";
 import { defaults, silentRejection } from "../../shared/common";
 import { fnToString, maxLength } from "../../shared/strings";
 import { isPromise } from "../../shared/predicates";
-import { is, parse } from "../../shared/hof";
+import { parse } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Rejection } from "./reject-factory";
@@ -134,9 +134,9 @@ export class TransitionHook {
       // Abort this Transition
       return Rejection.aborted("Hook aborted transition").toPromise();
     }
-    const isTargetState = is(TargetState);
+
     // hook returned a TargetState
-    if (isTargetState(result)) {
+    if (result instanceof TargetState) {
       // Halt the current Transition and redirect (a new Transition) to the TargetState.
       return Rejection.redirected(result).toPromise();
     }

package/src/services/cookie-reader.js

@@ -12,7 +12,7 @@ export function getCookies() {
   let i;
   let index;
   let name;
-  const currentCookieString = window.document.cookie;
+  const currentCookieString = document.cookie;
 
   if (currentCookieString !== lastCookieString) {
     lastCookieString = currentCookieString;

package/src/services/http/http.js

@@ -5,7 +5,6 @@ import {
   isObject,
   isDate,
   toJson,
-  forEachSorted,
   isUndefined,
   isFunction,
   forEach,
@@ -60,20 +59,23 @@ export function $HttpParamSerializerProvider() {
     return function ngParamSerializer(params) {
       if (!params) return "";
       const parts = [];
-      forEachSorted(params, (value, key) => {
-        if (value === null || isUndefined(value) || isFunction(value)) return;
-        if (Array.isArray(value)) {
-          value.forEach((v) => {
+      Object.keys(params)
+        .sort()
+        .forEach((key) => {
+          const value = params[key];
+          if (value === null || isUndefined(value) || isFunction(value)) return;
+          if (Array.isArray(value)) {
+            value.forEach((v) => {
+              parts.push(
+                `${encodeUriQuery(key)}=${encodeUriQuery(serializeValue(v))}`,
+              );
+            });
+          } else {
             parts.push(
-              `${encodeUriQuery(key)}=${encodeUriQuery(serializeValue(v))}`,
+              `${encodeUriQuery(key)}=${encodeUriQuery(serializeValue(value))}`,
             );
-          });
-        } else {
-          parts.push(
-            `${encodeUriQuery(key)}=${encodeUriQuery(serializeValue(value))}`,
-          );
-        }
-      });
+          }
+        });
 
       return parts.join("&");
     };
@@ -134,12 +136,15 @@ export function $HttpParamSerializerJQLikeProvider() {
             serialize(value, `${prefix}[${isObject(value) ? index : ""}]`);
           });
         } else if (isObject(toSerialize) && !isDate(toSerialize)) {
-          forEachSorted(toSerialize, (value, key) => {
-            serialize(
-              value,
-              prefix + (topLevel ? "" : "[") + key + (topLevel ? "" : "]"),
-            );
-          });
+          Object.keys(toSerialize)
+            .sort()
+            .forEach((key) => {
+              const value = toSerialize[key];
+              serialize(
+                value,
+                prefix + (topLevel ? "" : "[") + key + (topLevel ? "" : "]"),
+              );
+            });
         } else {
           if (isFunction(toSerialize)) {
             toSerialize = toSerialize();

package/src/shared/common.js

@@ -230,6 +230,7 @@ export function filter(collection, callback) {
   });
   return result;
 }
+
 /** Finds an object from an array, or a property of an object, that matches a predicate */
 export function find(collection, callback) {
   let result;
@@ -239,8 +240,7 @@ export function find(collection, callback) {
   });
   return result;
 }
-/** Given an object, returns a new object, where each property is transformed by the callback function */
-export let mapObj = map;
+
 /** Maps an array or object properties using a callback function */
 export function map(collection, callback, target) {
   target = target || (Array.isArray(collection) ? [] : {});

package/src/shared/common.spec.js

@@ -1,5 +1,5 @@
-import { defaults, filter, map, mapObj, pick } from "./common";
-import { is, eq, pattern, val } from "./hof";
+import { defaults, filter, map, pick } from "./common";
+import { is, pattern, val } from "./hof";
 import { isInjectable } from "./predicates";
 import { Queue } from "../router/common/queue";
 
@@ -76,14 +76,12 @@ describe("common", function () {
         [is(Number), val("number!")],
         [is(String), val("string!")],
         [is(Boolean), val("boolean!")],
-        [eq(null), val("null!")],
       ]);
 
       expect(typeChecker(1)).toBe("number!");
       expect(typeChecker("foo!")).toBe("string!");
       expect(typeChecker(true)).toBe("boolean!");
       expect(typeChecker(false)).toBe("boolean!");
-      expect(typeChecker(null)).toBe("null!");
       expect(typeChecker(undefined)).toBe(undefined);
     });
   });
@@ -142,10 +140,10 @@ describe("common", function () {
     });
   });
 
-  describe("mapObj", () => {
+  describe("map", () => {
     it("should map objects", () => {
       const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = mapObj(src, (x) => x * 2);
+      const dest = map(src, (x) => x * 2);
 
       expect(src).toEqual({ foo: 1, bar: 2, baz: 3 });
       expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
@@ -153,7 +151,7 @@ describe("common", function () {
 
     it("should map objects in place when target === src", () => {
       const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = mapObj(src, (x) => x * 2, src);
+      const dest = map(src, (x) => x * 2, src);
 
       expect(src).toEqual({ foo: 2, bar: 4, baz: 6 });
       expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });

package/src/shared/hof.js

@@ -115,8 +115,7 @@ export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
 export const is = (ctor) => (obj) =>
   (obj != null && obj.constructor === ctor) || obj instanceof ctor;
-/** Given a value, returns a Predicate function that returns true if another value is === equal to the original value */
-export const eq = (value) => (other) => value === other;
+
 /** Given a value, returns a function which returns the value */
 export const val = (v) => () => v;
 /**

package/src/shared/jqlite/jqlite.js

@@ -59,8 +59,8 @@ const BOOLEAN_ELEMENTS = {};
   });
 
 /**
- * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
- * and execution of chain functions.
+ * JQLite is both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+ * and execution of chains of functions.
  *
  * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
  * @returns {JQLite}
@@ -841,7 +841,7 @@ export function buildFragment(html) {
     // Create wrappers & descend into them
     i = wrap.length;
     while (--i > -1) {
-      tmp.appendChild(window.document.createElement(wrap[i]));
+      tmp.appendChild(document.createElement(wrap[i]));
       tmp = /** @type {HTMLDivElement} */ (tmp.firstChild);
     }
     tmp.innerHTML = html;
@@ -953,29 +953,28 @@ export function getOrSetCacheData(element, key, value) {
  * @param {(Node|Array|NodeList|Object)} elements - The elements to add to the root. This can be a single DOM node, an array-like object (such as an Array or NodeList), or any other object.
  */
 function addNodes(root, elements) {
-  // THIS CODE IS VERY HOT. Don't make changes without benchmarking.
-
-  if (elements) {
-    // if a Node (the most common case)
-    if (elements.nodeType) {
-      root[root.length++] = elements;
-    } else {
-      const { length } = elements;
-
-      // if an Array or NodeList and not a Window
-      if (typeof length === "number" && elements.window !== elements) {
-        if (length) {
-          for (let i = 0; i < length; i++) {
-            root[root.length++] = elements[i];
-          }
-        }
-      } else {
-        root[root.length++] = elements;
-      }
+  if (!elements) return;
+  // If a Node (the most common case)
+  if (elements.nodeType) {
+    root[root.length++] = elements;
+    return;
+  }
+  const length = elements.length;
+  // If elements is an Array or NodeList, but not a Window object
+  if (typeof length === "number" && elements.window !== elements) {
+    for (let i = 0; i < length; i++) {
+      root[root.length++] = elements[i];
     }
+  } else {
+    root[root.length++] = elements;
   }
 }
 
+/**
+ * @param {Node} element
+ * @param {string} name
+ * @returns
+ */
 function getController(element, name) {
   return getInheritedData(element, `$${name || "ngController"}Controller`);
 }
@@ -991,7 +990,6 @@ function getInheritedData(element, name, value) {
   // if element is the document object work with the html element instead
   // this makes $(document).scope() possible
   if (element.nodeType === Node.DOCUMENT_NODE) {
-    // TODO Fix types
     element = /** @type {Document} */ (element).documentElement;
   }
   const names = Array.isArray(name) ? name : [name];
@@ -1031,20 +1029,20 @@ export function removeElement(element, keepData = false) {
 }
 
 /**
- * Executea a function on `DOMContentLoaded`
+ * Execute a function on `DOMContentLoaded`
  * @param {Function} fn
  */
 function onReady(fn) {
   function trigger() {
-    window.document.removeEventListener("DOMContentLoaded", trigger);
+    document.removeEventListener("DOMContentLoaded", trigger);
     fn();
   }
   // check if document is already loaded
-  if (window.document.readyState === "complete") {
-    window.setTimeout(fn);
+  if (document.readyState === "complete") {
+    setTimeout(fn);
   } else {
     // We can not use JQLite since we are not done loading.
-    window.document.addEventListener("DOMContentLoaded", trigger);
+    document.addEventListener("DOMContentLoaded", trigger);
   }
 }
 

package/src/shared/jqlite/jqlite.spec.js

@@ -122,7 +122,7 @@ describe("jqLite", () => {
     });
 
     it("should wrap document fragment", () => {
-      const fragment = JQLite(window.document.createDocumentFragment());
+      const fragment = JQLite(document.createDocumentFragment());
       expect(fragment.length).toBe(1);
       expect(fragment[0].nodeType).toBe(11);
     });
@@ -194,7 +194,7 @@ describe("jqLite", () => {
             done();
           }
         }
-        JQLite(window.document.body).append(container);
+        JQLite(document.body).append(container);
         window.xss = jasmine.createSpy("xss");
 
         // Thanks to Masato Kinugawa from Cure53 for providing the following test cases.
@@ -280,7 +280,7 @@ describe("jqLite", () => {
 
     it("should pass through DocumentFragment boundaries via host", () => {
       const host = JQLite("<div></div>");
-      const frag = window.document.createDocumentFragment();
+      const frag = document.createDocumentFragment();
       const $frag = JQLite(frag);
       frag.host = host[0];
       host.data("foo", 123);
@@ -848,7 +848,7 @@ describe("jqLite", () => {
     });
 
     it("should do nothing when setting or getting on attribute nodes", () => {
-      const attrNode = JQLite(window.document.createAttribute("myattr"));
+      const attrNode = JQLite(document.createAttribute("myattr"));
       expect(attrNode).toBeDefined();
       expect(attrNode[0].nodeType).toEqual(2);
       expect(attrNode.attr("some-attribute", "somevalue")).toEqual(attrNode);
@@ -856,7 +856,7 @@ describe("jqLite", () => {
     });
 
     it("should do nothing when setting or getting on text nodes", () => {
-      const textNode = JQLite(window.document.createTextNode("some text"));
+      const textNode = JQLite(document.createTextNode("some text"));
       expect(textNode).toBeDefined();
       expect(textNode[0].nodeType).toEqual(3);
       expect(textNode.attr("some-attribute", "somevalue")).toEqual(textNode);
@@ -864,7 +864,7 @@ describe("jqLite", () => {
     });
 
     it("should do nothing when setting or getting on comment nodes", () => {
-      const comment = JQLite(window.document.createComment("some comment"));
+      const comment = JQLite(document.createComment("some comment"));
       expect(comment).toBeDefined();
       expect(comment[0].nodeType).toEqual(8);
       expect(comment.attr("some-attribute", "somevalue")).toEqual(comment);
@@ -931,7 +931,7 @@ describe("jqLite", () => {
 
     it("should return text only for element or text nodes", () => {
       expect(JQLite("<div>foo</div>").text()).toBe("foo");
-      expect(JQLite(window.document.createComment("foo")).text()).toBe("");
+      expect(JQLite(document.createComment("foo")).text()).toBe("");
     });
   });
 
@@ -1202,7 +1202,7 @@ describe("jqLite", () => {
       function browserMoveTrigger(from, to) {
         const fireEvent = function (type, element, relatedTarget) {
           let evnt;
-          evnt = window.document.createEvent("MouseEvents");
+          evnt = document.createEvent("MouseEvents");
 
           const originalPreventDefault = evnt.preventDefault;
 
@@ -1700,7 +1700,7 @@ describe("jqLite", () => {
       expect(root.html()).toEqual("text");
     });
     it("should append to document fragment", () => {
-      const root = JQLite(window.document.createDocumentFragment());
+      const root = JQLite(document.createDocumentFragment());
       expect(root.append("<p>foo</p>")).toBe(root);
       expect(root.children().length).toBe(1);
     });
@@ -1802,7 +1802,7 @@ describe("jqLite", () => {
 
     it("should return empty JQLite object when parent is a document fragment", () => {
       // this is quite unfortunate but jQuery 1.5.1 behaves this way
-      const fragment = window.document.createDocumentFragment();
+      const fragment = document.createDocumentFragment();
       const child = JQLite("<p>foo</p>");
 
       fragment.appendChild(child[0]);

package/src/shared/utils.js

@@ -357,12 +357,6 @@ export function forEach(obj, iterator, context) {
   return obj;
 }
 
-export function forEachSorted(obj, iterator, context) {
-  const keys = Object.keys(obj).sort();
-  keys.forEach((el) => iterator.call(context, obj[el], el));
-  return keys;
-}
-
 /**
  * when using forEach the params are value, key, but it is often useful to have key, value.
  * @param {function(string, *):any} iteratorFn
@@ -686,8 +680,8 @@ const cspCache = {};
 export function csp() {
   if (!isDefined(cspCache.rules)) {
     const ngCspElement =
-      window.document.querySelector("[ng-csp]") ||
-      window.document.querySelector("[data-ng-csp]");
+      document.querySelector("[ng-csp]") ||
+      document.querySelector("[data-ng-csp]");
 
     if (ngCspElement) {
       const ngCspAttribute =
@@ -721,8 +715,8 @@ export function csp() {
 
 /**
  * throw error if the name given is hasOwnProperty
- * @param  {String} name    the name to test
- * @param  {String} context the context in which the name is used, such as module or directive
+ * @param  {string} name    the name to test
+ * @param  {string} context the context in which the name is used, such as module or directive
  */
 export function assertNotHasOwnProperty(name, context) {
   if (name === "hasOwnProperty") {
@@ -734,33 +728,6 @@ export function assertNotHasOwnProperty(name, context) {
   }
 }
 
-/**
- * Return the value accessible from the object by path. Any undefined traversals are ignored
- * @param {Object} obj starting object
- * @param {String} path path to traverse
- * @param {boolean} [bindFnToScope=true]
- * @returns {Object} value as accessible by path
- */
-// TODO(misko): this function needs to be removed
-export function getter(obj, path, bindFnToScope) {
-  if (!path) return obj;
-  const keys = path.split(".");
-  let key;
-  let lastInstance = obj;
-  const len = keys.length;
-
-  for (let i = 0; i < len; i++) {
-    key = keys[i];
-    if (obj) {
-      obj = (lastInstance = obj)[key];
-    }
-  }
-  if (!bindFnToScope && isFunction(obj)) {
-    return bind(lastInstance, obj);
-  }
-  return obj;
-}
-
 export function stringify(value) {
   if (value == null) {
     // null || undefined
@@ -1277,7 +1244,8 @@ export function mergeClasses(a, b) {
 
 /**
  * Converts all accepted directives format into proper directive name.
- * @param name Name to normalize
+ * @param {string} name Name to normalize
+ * @returns {string}
  */
 
 export function directiveNormalize(name) {