@angular-wave/angular.ts 0.0.11 → 0.0.12

package/src/router/core/common/common.js

@@ -0,0 +1,506 @@
+/**
+ * Random utility functions used in the UI-Router code
+ *
+ * These functions are exported, but are subject to change without notice.
+ *
+ * @packageDocumentation
+ * @preferred
+ */
+import { isFunction, isString, isArray, isRegExp, isDate } from "./predicates";
+import { all, any, prop, curry, not } from "./hof";
+import { services } from "./coreservices";
+export const root =
+  (typeof self === "object" && self.self === self && self) ||
+  (typeof global === "object" && global.global === global && global) ||
+  this;
+const angular = root.angular || {};
+export const fromJson = angular.fromJson || JSON.parse.bind(JSON);
+export const toJson = angular.toJson || JSON.stringify.bind(JSON);
+export const forEach = angular.forEach || _forEach;
+export const extend = Object.assign || _extend;
+export const equals = angular.equals || _equals;
+export function identity(x) {
+  return x;
+}
+export function noop() {}
+/**
+ * Builds proxy functions on the `to` object which pass through to the `from` object.
+ *
+ * For each key in `fnNames`, creates a proxy function on the `to` object.
+ * The proxy function calls the real function on the `from` object.
+ *
+ *
+ * #### Example:
+ * This example creates an new class instance whose functions are prebound to the new'd object.
+ * ```js
+ * class Foo {
+ *   constructor(data) {
+ *     // Binds all functions from Foo.prototype to 'this',
+ *     // then copies them to 'this'
+ *     bindFunctions(Foo.prototype, this, this);
+ *     this.data = data;
+ *   }
+ *
+ *   log() {
+ *     console.log(this.data);
+ *   }
+ * }
+ *
+ * let myFoo = new Foo([1,2,3]);
+ * var logit = myFoo.log;
+ * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
+ * ```
+ *
+ * #### Example:
+ * This example creates a bound version of a service function, and copies it to another object
+ * ```
+ *
+ * var SomeService = {
+ *   this.data = [3, 4, 5];
+ *   this.log = function() {
+ *     console.log(this.data);
+ *   }
+ * }
+ *
+ * // Constructor fn
+ * function OtherThing() {
+ *   // Binds all functions from SomeService to SomeService,
+ *   // then copies them to 'this'
+ *   bindFunctions(SomeService, this, SomeService);
+ * }
+ *
+ * let myOtherThing = new OtherThing();
+ * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
+ * ```
+ *
+ * @param source A function that returns the source object which contains the original functions to be bound
+ * @param target A function that returns the target object which will receive the bound functions
+ * @param bind A function that returns the object which the functions will be bound to
+ * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
+ * @param latebind If true, the binding of the function is delayed until the first time it's invoked
+ */
+export function createProxyFunctions(
+  source,
+  target,
+  bind,
+  fnNames,
+  latebind = false,
+) {
+  const bindFunction = (fnName) => source()[fnName].bind(bind());
+  const makeLateRebindFn = (fnName) =>
+    function lateRebindFunction() {
+      target[fnName] = bindFunction(fnName);
+      return target[fnName].apply(null, arguments);
+    };
+  fnNames = fnNames || Object.keys(source());
+  return fnNames.reduce((acc, name) => {
+    acc[name] = latebind ? makeLateRebindFn(name) : bindFunction(name);
+    return acc;
+  }, target);
+}
+/**
+ * prototypal inheritance helper.
+ * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
+ */
+export const inherit = (parent, extra) => extend(Object.create(parent), extra);
+/** Given an array, returns true if the object is found in the array, (using indexOf) */
+export const inArray = curry(_inArray);
+export function _inArray(array, obj) {
+  return array.indexOf(obj) !== -1;
+}
+/**
+ * Given an array, and an item, if the item is found in the array, it removes it (in-place).
+ * The same array is returned
+ */
+export const removeFrom = curry(_removeFrom);
+export function _removeFrom(array, obj) {
+  const idx = array.indexOf(obj);
+  if (idx >= 0) array.splice(idx, 1);
+  return array;
+}
+/** pushes a values to an array and returns the value */
+export const pushTo = curry(_pushTo);
+export function _pushTo(arr, val) {
+  return arr.push(val), val;
+}
+/** Given an array of (deregistration) functions, calls all functions and removes each one from the source array */
+export const deregAll = (functions) =>
+  functions.slice().forEach((fn) => {
+    typeof fn === "function" && fn();
+    removeFrom(functions, fn);
+  });
+/**
+ * Applies a set of defaults to an options object.  The options object is filtered
+ * to only those properties of the objects in the defaultsList.
+ * Earlier objects in the defaultsList take precedence when applying defaults.
+ */
+export function defaults(opts, ...defaultsList) {
+  const defaultVals = extend({}, ...defaultsList.reverse());
+  return extend(defaultVals, pick(opts || {}, Object.keys(defaultVals)));
+}
+/** Reduce function that merges each element of the list into a single object, using extend */
+export const mergeR = (memo, item) => extend(memo, item);
+/**
+ * Finds the common ancestor path between two states.
+ *
+ * @param {Object} first The first state.
+ * @param {Object} second The second state.
+ * @return {Array} Returns an array of state names in descending order, not including the root.
+ */
+export function ancestors(first, second) {
+  const path = [];
+  // tslint:disable-next-line:forin
+  for (const n in first.path) {
+    if (first.path[n] !== second.path[n]) break;
+    path.push(first.path[n]);
+  }
+  return path;
+}
+/**
+ * Return a copy of the object only containing the whitelisted properties.
+ *
+ * #### Example:
+ * ```
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the whitelisted property names
+ */
+export function pick(obj, propNames) {
+  const objCopy = {};
+  for (const _prop in obj) {
+    if (propNames.indexOf(_prop) !== -1) {
+      objCopy[_prop] = obj[_prop];
+    }
+  }
+  return objCopy;
+}
+/**
+ * Return a copy of the object omitting the blacklisted properties.
+ *
+ * @example
+ * ```
+ *
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = omit(foo, ['a', 'b']); // { c: 3 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the blacklisted property names
+ */
+export function omit(obj, propNames) {
+  return Object.keys(obj)
+    .filter(not(inArray(propNames)))
+    .reduce((acc, key) => ((acc[key] = obj[key]), acc), {});
+}
+/**
+ * Maps an array, or object to a property (by name)
+ */
+export function pluck(collection, propName) {
+  return map(collection, prop(propName));
+}
+/** Filters an Array or an Object's properties based on a predicate */
+export function filter(collection, callback) {
+  const arr = isArray(collection),
+    result = arr ? [] : {};
+  const accept = arr ? (x) => result.push(x) : (x, key) => (result[key] = x);
+  forEach(collection, function (item, i) {
+    if (callback(item, i)) accept(item, i);
+  });
+  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;
+  forEach(collection, function (item, i) {
+    if (result) return;
+    if (callback(item, i)) result = item;
+  });
+  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 || (isArray(collection) ? [] : {});
+  forEach(collection, (item, i) => (target[i] = callback(item, i)));
+  return target;
+}
+/**
+ * Given an object, return its enumerable property values
+ *
+ * @example
+ * ```
+ *
+ * let foo = { a: 1, b: 2, c: 3 }
+ * let vals = values(foo); // [ 1, 2, 3 ]
+ * ```
+ */
+export const values = (obj) => Object.keys(obj).map((key) => obj[key]);
+/**
+ * Reduce function that returns true if all of the values are truthy.
+ *
+ * @example
+ * ```
+ *
+ * let vals = [ 1, true, {}, "hello world"];
+ * vals.reduce(allTrueR, true); // true
+ *
+ * vals.push(0);
+ * vals.reduce(allTrueR, true); // false
+ * ```
+ */
+export const allTrueR = (memo, elem) => memo && elem;
+/**
+ * Reduce function that returns true if any of the values are truthy.
+ *
+ *  * @example
+ * ```
+ *
+ * let vals = [ 0, null, undefined ];
+ * vals.reduce(anyTrueR, true); // false
+ *
+ * vals.push("hello world");
+ * vals.reduce(anyTrueR, true); // true
+ * ```
+ */
+export const anyTrueR = (memo, elem) => memo || elem;
+/**
+ * Reduce function which un-nests a single level of arrays
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+export const unnestR = (memo, elem) => memo.concat(elem);
+/**
+ * Reduce function which recursively un-nests all arrays
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * input.reduce(unnestR, []) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+export const flattenR = (memo, elem) =>
+  isArray(elem) ? memo.concat(elem.reduce(flattenR, [])) : pushR(memo, elem);
+/**
+ * Reduce function that pushes an object to an array, then returns the array.
+ * Mostly just for [[flattenR]] and [[uniqR]]
+ */
+export function pushR(arr, obj) {
+  arr.push(obj);
+  return arr;
+}
+/** Reduce function that filters out duplicates */
+export const uniqR = (acc, token) =>
+  inArray(acc, token) ? acc : pushR(acc, token);
+/**
+ * Return a new array with a single level of arrays unnested.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * unnest(input) // [ "a", "b", "c", "d", [ "double, "nested" ] ]
+ * ```
+ */
+export const unnest = (arr) => arr.reduce(unnestR, []);
+/**
+ * Return a completely flattened version of an array.
+ *
+ * @example
+ * ```
+ *
+ * let input = [ [ "a", "b" ], [ "c", "d" ], [ [ "double", "nested" ] ] ];
+ * flatten(input) // [ "a", "b", "c", "d", "double, "nested" ]
+ * ```
+ */
+export const flatten = (arr) => arr.reduce(flattenR, []);
+/**
+ * Given a .filter Predicate, builds a .filter Predicate which throws an error if any elements do not pass.
+ * @example
+ * ```
+ *
+ * let isNumber = (obj) => typeof(obj) === 'number';
+ * let allNumbers = [ 1, 2, 3, 4, 5 ];
+ * allNumbers.filter(assertPredicate(isNumber)); //OK
+ *
+ * let oneString = [ 1, 2, 3, 4, "5" ];
+ * oneString.filter(assertPredicate(isNumber, "Not all numbers")); // throws Error(""Not all numbers"");
+ * ```
+ */
+export const assertPredicate = assertFn;
+/**
+ * Given a .map function, builds a .map function which throws an error if any mapped elements do not pass a truthyness test.
+ * @example
+ * ```
+ *
+ * var data = { foo: 1, bar: 2 };
+ *
+ * let keys = [ 'foo', 'bar' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // values is [1, 2]
+ *
+ * let keys = [ 'foo', 'bar', 'baz' ]
+ * let values = keys.map(assertMap(key => data[key], "Key not found"));
+ * // throws Error("Key not found")
+ * ```
+ */
+export const assertMap = assertFn;
+export function assertFn(predicateOrMap, errMsg = "assert failure") {
+  return (obj) => {
+    const result = predicateOrMap(obj);
+    if (!result) {
+      throw new Error(isFunction(errMsg) ? errMsg(obj) : errMsg);
+    }
+    return result;
+  };
+}
+/**
+ * Like _.pairs: Given an object, returns an array of key/value pairs
+ *
+ * @example
+ * ```
+ *
+ * pairs({ foo: "FOO", bar: "BAR }) // [ [ "foo", "FOO" ], [ "bar": "BAR" ] ]
+ * ```
+ */
+export const pairs = (obj) => Object.keys(obj).map((key) => [key, obj[key]]);
+/**
+ * Given two or more parallel arrays, returns an array of tuples where
+ * each tuple is composed of [ a[i], b[i], ... z[i] ]
+ *
+ * @example
+ * ```
+ *
+ * let foo = [ 0, 2, 4, 6 ];
+ * let bar = [ 1, 3, 5, 7 ];
+ * let baz = [ 10, 30, 50, 70 ];
+ * arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
+ * arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]
+ * ```
+ */
+export function arrayTuples(...args) {
+  if (args.length === 0) return [];
+  const maxArrayLen = args.reduce(
+    (min, arr) => Math.min(arr.length, min),
+    9007199254740991,
+  ); // aka 2^53 − 1 aka Number.MAX_SAFE_INTEGER
+  const result = [];
+  for (let i = 0; i < maxArrayLen; i++) {
+    // This is a hot function
+    // Unroll when there are 1-4 arguments
+    switch (args.length) {
+      case 1:
+        result.push([args[0][i]]);
+        break;
+      case 2:
+        result.push([args[0][i], args[1][i]]);
+        break;
+      case 3:
+        result.push([args[0][i], args[1][i], args[2][i]]);
+        break;
+      case 4:
+        result.push([args[0][i], args[1][i], args[2][i], args[3][i]]);
+        break;
+      default:
+        result.push(args.map((array) => array[i]));
+        break;
+    }
+  }
+  return result;
+}
+/**
+ * Reduce function which builds an object from an array of [key, value] pairs.
+ *
+ * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
+ *
+ * Each keyValueTuple should be an array with values [ key: string, value: any ]
+ *
+ * @example
+ * ```
+ *
+ * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
+ *
+ * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ *
+ * // Or, more simply:
+ * var pairsToObj = pairs.reduce(applyPairs, {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ * ```
+ */
+export function applyPairs(memo, keyValTuple) {
+  let key, value;
+  if (isArray(keyValTuple)) [key, value] = keyValTuple;
+  if (!isString(key)) throw new Error("invalid parameters to applyPairs");
+  memo[key] = value;
+  return memo;
+}
+/** Get the last element of an array */
+export function tail(arr) {
+  return (arr.length && arr[arr.length - 1]) || undefined;
+}
+/**
+ * shallow copy from src to dest
+ */
+export function copy(src, dest) {
+  if (dest) Object.keys(dest).forEach((key) => delete dest[key]);
+  if (!dest) dest = {};
+  return extend(dest, src);
+}
+/** Naive forEach implementation works with Objects or Arrays */
+function _forEach(obj, cb, _this) {
+  if (isArray(obj)) return obj.forEach(cb, _this);
+  Object.keys(obj).forEach((key) => cb(obj[key], key));
+}
+export function _extend(toObj) {
+  for (let i = 1; i < arguments.length; i++) {
+    const obj = arguments[i];
+    if (!obj) continue;
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; j++) {
+      toObj[keys[j]] = obj[keys[j]];
+    }
+  }
+  return toObj;
+}
+function _equals(o1, o2) {
+  if (o1 === o2) return true;
+  if (o1 === null || o2 === null) return false;
+  if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+  const t1 = typeof o1,
+    t2 = typeof o2;
+  if (t1 !== t2 || t1 !== "object") return false;
+  const tup = [o1, o2];
+  if (all(isArray)(tup)) return _arraysEq(o1, o2);
+  if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
+  if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
+  if (all(isFunction)(tup)) return true; // meh
+  const predicates = [isFunction, isArray, isDate, isRegExp];
+  if (predicates.map(any).reduce((b, fn) => b || !!fn(tup), false))
+    return false;
+  const keys = {};
+  // tslint:disable-next-line:forin
+  for (const key in o1) {
+    if (!_equals(o1[key], o2[key])) return false;
+    keys[key] = true;
+  }
+  for (const key in o2) {
+    if (!keys[key]) return false;
+  }
+  return true;
+}
+function _arraysEq(a1, a2) {
+  if (a1.length !== a2.length) return false;
+  return arrayTuples(a1, a2).reduce((b, t) => b && _equals(t[0], t[1]), true);
+}
+// issue #2676
+export const silenceUncaughtInPromise = (promise) =>
+  promise.catch((e) => 0) && promise;
+export const silentRejection = (error) =>
+  silenceUncaughtInPromise(services.$q.reject(error));

package/src/router/core/common/coreservices.js

@@ -0,0 +1,15 @@
+const noImpl = (fnname) => () => {
+  throw new Error(
+    `No implementation for ${fnname}. The framework specific code did not implement this method.`,
+  );
+};
+export const makeStub = (service, methods) =>
+  methods.reduce(
+    (acc, key) => ((acc[key] = noImpl(`${service}.${key}()`)), acc),
+    {},
+  );
+const services = {
+  $q: undefined,
+  $injector: undefined,
+};
+export { services };

package/src/router/core/common/glob.js

@@ -0,0 +1,75 @@
+/**
+ * Matches state names using glob-like pattern strings.
+ *
+ * Globs can be used in specific APIs including:
+ *
+ * - [[StateService.is]]
+ * - [[StateService.includes]]
+ * - The first argument to Hook Registration functions like [[TransitionService.onStart]]
+ *    - [[HookMatchCriteria]] and [[HookMatchCriterion]]
+ *
+ * A `Glob` string is a pattern which matches state names.
+ * Nested state names are split into segments (separated by a dot) when processing.
+ * The state named `foo.bar.baz` is split into three segments ['foo', 'bar', 'baz']
+ *
+ * Globs work according to the following rules:
+ *
+ * ### Exact match:
+ *
+ * The glob `'A.B'` matches the state named exactly `'A.B'`.
+ *
+ * | Glob        |Matches states named|Does not match state named|
+ * |:------------|:--------------------|:---------------------|
+ * | `'A'`       | `'A'`               | `'B'` , `'A.C'`      |
+ * | `'A.B'`     | `'A.B'`             | `'A'` , `'A.B.C'`    |
+ * | `'foo'`     | `'foo'`             | `'FOO'` , `'foo.bar'`|
+ *
+ * ### Single star (`*`)
+ *
+ * A single star (`*`) is a wildcard that matches exactly one segment.
+ *
+ * | Glob        |Matches states named  |Does not match state named |
+ * |:------------|:---------------------|:--------------------------|
+ * | `'*'`       | `'A'` , `'Z'`        | `'A.B'` , `'Z.Y.X'`       |
+ * | `'A.*'`     | `'A.B'` , `'A.C'`    | `'A'` , `'A.B.C'`         |
+ * | `'A.*.*'`   | `'A.B.C'` , `'A.X.Y'`| `'A'`, `'A.B'` , `'Z.Y.X'`|
+ *
+ * ### Double star (`**`)
+ *
+ * A double star (`'**'`) is a wildcard that matches *zero or more segments*
+ *
+ * | Glob        |Matches states named                           |Does not match state named         |
+ * |:------------|:----------------------------------------------|:----------------------------------|
+ * | `'**'`      | `'A'` , `'A.B'`, `'Z.Y.X'`                    | (matches all states)              |
+ * | `'A.**'`    | `'A'` , `'A.B'` , `'A.C.X'`                   | `'Z.Y.X'`                         |
+ * | `'**.X'`    | `'X'` , `'A.X'` , `'Z.Y.X'`                   | `'A'` , `'A.login.Z'`             |
+ * | `'A.**.X'`  | `'A.X'` , `'A.B.X'` , `'A.B.C.X'`             | `'A'` , `'A.B.C'`                 |
+ *
+ * @packageDocumentation
+ */
+export class Glob {
+  /** Returns true if the string has glob-like characters in it */
+  static is(text) {
+    return !!/[!,*]+/.exec(text);
+  }
+  /** Returns a glob from the string, or null if the string isn't Glob-like */
+  static fromString(text) {
+    return Glob.is(text) ? new Glob(text) : null;
+  }
+  constructor(text) {
+    this.text = text;
+    this.glob = text.split(".");
+    const regexpString = this.text
+      .split(".")
+      .map((seg) => {
+        if (seg === "**") return "(?:|(?:\\.[^.]*)*)";
+        if (seg === "*") return "\\.[^.]*";
+        return "\\." + seg;
+      })
+      .join("");
+    this.regexp = new RegExp("^" + regexpString + "$");
+  }
+  matches(name) {
+    return this.regexp.test("." + name);
+  }
+}