@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/params/param.js

@@ -0,0 +1,232 @@
+import { extend, filter, map, allTrueR, find } from "../common/common";
+import { prop } from "../common/hof";
+import {
+  isInjectable,
+  isDefined,
+  isString,
+  isArray,
+  isUndefined,
+} from "../common/predicates";
+import { services } from "../common/coreservices";
+import { ParamType } from "./paramType";
+const hasOwn = Object.prototype.hasOwnProperty;
+const isShorthand = (cfg) =>
+  ["value", "type", "squash", "array", "dynamic"].filter(hasOwn.bind(cfg || {}))
+    .length === 0;
+var DefType;
+(function (DefType) {
+  DefType[(DefType["PATH"] = 0)] = "PATH";
+  DefType[(DefType["SEARCH"] = 1)] = "SEARCH";
+  DefType[(DefType["CONFIG"] = 2)] = "CONFIG";
+})(DefType || (DefType = {}));
+export { DefType };
+function getParamDeclaration(paramName, location, state) {
+  const noReloadOnSearch =
+    (state.reloadOnSearch === false && location === DefType.SEARCH) ||
+    undefined;
+  const dynamic = find([state.dynamic, noReloadOnSearch], isDefined);
+  const defaultConfig = isDefined(dynamic) ? { dynamic } : {};
+  const paramConfig = unwrapShorthand(
+    state && state.params && state.params[paramName],
+  );
+  return extend(defaultConfig, paramConfig);
+}
+function unwrapShorthand(cfg) {
+  cfg = isShorthand(cfg) ? { value: cfg } : cfg;
+  getStaticDefaultValue["__cacheable"] = true;
+  function getStaticDefaultValue() {
+    return cfg.value;
+  }
+  const $$fn = isInjectable(cfg.value) ? cfg.value : getStaticDefaultValue;
+  return extend(cfg, { $$fn });
+}
+function getType(cfg, urlType, location, id, paramTypes) {
+  if (cfg.type && urlType && urlType.name !== "string")
+    throw new Error(`Param '${id}' has two type configurations.`);
+  if (
+    cfg.type &&
+    urlType &&
+    urlType.name === "string" &&
+    paramTypes.type(cfg.type)
+  )
+    return paramTypes.type(cfg.type);
+  if (urlType) return urlType;
+  if (!cfg.type) {
+    const type =
+      location === DefType.CONFIG
+        ? "any"
+        : location === DefType.PATH
+          ? "path"
+          : location === DefType.SEARCH
+            ? "query"
+            : "string";
+    return paramTypes.type(type);
+  }
+  return cfg.type instanceof ParamType ? cfg.type : paramTypes.type(cfg.type);
+}
+/** returns false, true, or the squash value to indicate the "default parameter url squash policy". */
+function getSquashPolicy(config, isOptional, defaultPolicy) {
+  const squash = config.squash;
+  if (!isOptional || squash === false) return false;
+  if (!isDefined(squash) || squash == null) return defaultPolicy;
+  if (squash === true || isString(squash)) return squash;
+  throw new Error(
+    `Invalid squash policy: '${squash}'. Valid policies: false, true, or arbitrary string`,
+  );
+}
+function getReplace(config, arrayMode, isOptional, squash) {
+  const defaultPolicy = [
+    { from: "", to: isOptional || arrayMode ? undefined : "" },
+    { from: null, to: isOptional || arrayMode ? undefined : "" },
+  ];
+  const replace = isArray(config.replace) ? config.replace : [];
+  if (isString(squash)) replace.push({ from: squash, to: undefined });
+  const configuredKeys = map(replace, prop("from"));
+  return filter(
+    defaultPolicy,
+    (item) => configuredKeys.indexOf(item.from) === -1,
+  ).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);
+    const arrayMode = getArrayMode();
+    type = arrayMode
+      ? type.$asArray(arrayMode, location === DefType.SEARCH)
+      : type;
+    const isOptional =
+      config.value !== undefined || location === DefType.SEARCH;
+    const dynamic = isDefined(config.dynamic)
+      ? !!config.dynamic
+      : !!type.dynamic;
+    const raw = isDefined(config.raw) ? !!config.raw : !!type.raw;
+    const squash = getSquashPolicy(
+      config,
+      isOptional,
+      urlConfig.defaultSquashPolicy(),
+    );
+    const replace = getReplace(config, arrayMode, isOptional, squash);
+    const inherit = isDefined(config.inherit)
+      ? !!config.inherit
+      : !!type.inherit;
+    // array config: param name (param[]) overrides default settings.  explicit config overrides param name.
+    function getArrayMode() {
+      const arrayDefaults = {
+        array: location === DefType.SEARCH ? "auto" : false,
+      };
+      const arrayParamNomenclature = id.match(/\[\]$/) ? { array: true } : {};
+      return extend(arrayDefaults, arrayParamNomenclature, config).array;
+    }
+    extend(this, {
+      id,
+      type,
+      location,
+      isOptional,
+      dynamic,
+      raw,
+      squash,
+      replace,
+      inherit,
+      array: arrayMode,
+      config,
+    });
+  }
+  isDefaultValue(value) {
+    return this.isOptional && this.type.equals(this.value(), value);
+  }
+  /**
+   * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the
+   * default value, which may be the result of an injectable function.
+   */
+  value(value) {
+    /**
+     * [Internal] Get the default value of a parameter, which may be an injectable function.
+     */
+    const getDefaultValue = () => {
+      if (this._defaultValueCache) return this._defaultValueCache.defaultValue;
+      if (!services.$injector)
+        throw new Error(
+          "Injectable functions cannot be called at configuration time",
+        );
+      const defaultValue = services.$injector.invoke(this.config.$$fn);
+      if (
+        defaultValue !== null &&
+        defaultValue !== undefined &&
+        !this.type.is(defaultValue)
+      )
+        throw new Error(
+          `Default value (${defaultValue}) for parameter '${this.id}' is not an instance of ParamType (${this.type.name})`,
+        );
+      if (this.config.$$fn["__cacheable"]) {
+        this._defaultValueCache = { defaultValue };
+      }
+      return defaultValue;
+    };
+    const replaceSpecialValues = (val) => {
+      for (const tuple of this.replace) {
+        if (tuple.from === val) return tuple.to;
+      }
+      return val;
+    };
+    value = replaceSpecialValues(value);
+    return isUndefined(value) ? getDefaultValue() : this.type.$normalize(value);
+  }
+  isSearch() {
+    return this.location === DefType.SEARCH;
+  }
+  validates(value) {
+    // There was no parameter value, but the param is optional
+    if ((isUndefined(value) || value === null) && this.isOptional) return true;
+    // The value was not of the correct ParamType, and could not be decoded to the correct ParamType
+    const normalized = this.type.$normalize(value);
+    if (!this.type.is(normalized)) return false;
+    // The value was of the correct type, but when encoded, did not match the ParamType's regexp
+    const encoded = this.type.encode(normalized);
+    return !(isString(encoded) && !this.type.pattern.exec(encoded));
+  }
+  toString() {
+    return `{Param:${this.id} ${this.type} squash: '${this.squash}' optional: ${this.isOptional}}`;
+  }
+}

package/src/router/core/params/paramType.js

@@ -0,0 +1,139 @@
+import { extend, filter, map } from "../common/common";
+import { isArray, isDefined } from "../common/predicates";
+/**
+ * An internal class which implements [[ParamTypeDefinition]].
+ *
+ * A [[ParamTypeDefinition]] is a plain javascript object used to register custom parameter types.
+ * When a param type definition is registered, an instance of this class is created internally.
+ *
+ * This class has naive implementations for all the [[ParamTypeDefinition]] methods.
+ *
+ * Used by [[UrlMatcher]] when matching or formatting URLs, or comparing and validating parameter values.
+ *
+ * #### Example:
+ * ```js
+ * var paramTypeDef = {
+ *   decode: function(val) { return parseInt(val, 10); },
+ *   encode: function(val) { return val && val.toString(); },
+ *   equals: function(a, b) { return this.is(a) && a === b; },
+ *   is: function(val) { return angular.isNumber(val) && isFinite(val) && val % 1 === 0; },
+ *   pattern: /\d+/
+ * }
+ *
+ * var paramType = new ParamType(paramTypeDef);
+ * ```
+ */
+export class ParamType {
+  /**
+   * @param def  A configuration object which contains the custom type definition.  The object's
+   *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
+   * @returns a new ParamType object
+   */
+  constructor(def) {
+    /** @inheritdoc */
+    this.pattern = /.*/;
+    /** @inheritdoc */
+    this.inherit = true;
+    extend(this, def);
+  }
+  // consider these four methods to be "abstract methods" that should be overridden
+  /** @inheritdoc */
+  is(val, key) {
+    return true;
+  }
+  /** @inheritdoc */
+  encode(val, key) {
+    return val;
+  }
+  /** @inheritdoc */
+  decode(val, key) {
+    return val;
+  }
+  /** @inheritdoc */
+  equals(a, b) {
+    // tslint:disable-next-line:triple-equals
+    return a == b;
+  }
+  $subPattern() {
+    const sub = this.pattern.toString();
+    return sub.substr(1, sub.length - 2);
+  }
+  toString() {
+    return `{ParamType:${this.name}}`;
+  }
+  /** Given an encoded string, or a decoded object, returns a decoded object */
+  $normalize(val) {
+    return this.is(val) ? val : this.decode(val);
+  }
+  /**
+   * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
+   * e.g.:
+   * - urlmatcher pattern "/path?{queryParam[]:int}"
+   * - url: "/path?queryParam=1&queryParam=2
+   * - $stateParams.queryParam will be [1, 2]
+   * if `mode` is "auto", then
+   * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
+   * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
+   */
+  $asArray(mode, isSearch) {
+    if (!mode) return this;
+    if (mode === "auto" && !isSearch)
+      throw new Error("'auto' array mode is for query parameters only");
+    return new ArrayType(this, mode);
+  }
+}
+/** Wraps up a `ParamType` object to handle array values. */
+function ArrayType(type, mode) {
+  // Wrap non-array value as array
+  function arrayWrap(val) {
+    return isArray(val) ? val : isDefined(val) ? [val] : [];
+  }
+  // Unwrap array value for "auto" mode. Return undefined for empty array.
+  function arrayUnwrap(val) {
+    switch (val.length) {
+      case 0:
+        return undefined;
+      case 1:
+        return mode === "auto" ? val[0] : val;
+      default:
+        return val;
+    }
+  }
+  // Wraps type (.is/.encode/.decode) functions to operate on each value of an array
+  function arrayHandler(callback, allTruthyMode) {
+    return function handleArray(val) {
+      if (isArray(val) && val.length === 0) return val;
+      const arr = arrayWrap(val);
+      const result = map(arr, callback);
+      return allTruthyMode === true
+        ? filter(result, (x) => !x).length === 0
+        : arrayUnwrap(result);
+    };
+  }
+  // Wraps type (.equals) functions to operate on each value of an array
+  function arrayEqualsHandler(callback) {
+    return function handleArray(val1, val2) {
+      const left = arrayWrap(val1),
+        right = arrayWrap(val2);
+      if (left.length !== right.length) return false;
+      for (let i = 0; i < left.length; i++) {
+        if (!callback(left[i], right[i])) return false;
+      }
+      return true;
+    };
+  }
+  ["encode", "decode", "equals", "$normalize"].forEach((name) => {
+    const paramTypeFn = type[name].bind(type);
+    const wrapperFn = name === "equals" ? arrayEqualsHandler : arrayHandler;
+    this[name] = wrapperFn(paramTypeFn);
+  });
+  extend(this, {
+    dynamic: type.dynamic,
+    name: type.name,
+    pattern: type.pattern,
+    inherit: type.inherit,
+    raw: type.raw,
+    is: arrayHandler(type.is.bind(type), true),
+    $arrayMode: mode,
+  });
+}

package/src/router/core/params/paramTypes.js

@@ -0,0 +1,163 @@
+import {
+  fromJson,
+  toJson,
+  identity,
+  equals,
+  inherit,
+  map,
+  extend,
+  pick,
+} from "../common/common";
+import { isDefined, isNullOrUndefined } from "../common/predicates";
+import { is } from "../common/hof";
+import { services } from "../common/coreservices";
+import { ParamType } from "./paramType";
+/**
+ * A registry for parameter types.
+ *
+ * This registry manages the built-in (and custom) parameter types.
+ *
+ * The built-in parameter types are:
+ *
+ * - [[string]]
+ * - [[path]]
+ * - [[query]]
+ * - [[hash]]
+ * - [[int]]
+ * - [[bool]]
+ * - [[date]]
+ * - [[json]]
+ * - [[any]]
+ *
+ * To register custom parameter types, use [[UrlConfig.type]], i.e.,
+ *
+ * ```js
+ * router.urlService.config.type(customType)
+ * ```
+ */
+export class ParamTypes {
+  constructor() {
+    this.enqueue = true;
+    this.typeQueue = [];
+    this.defaultTypes = pick(ParamTypes.prototype, [
+      "hash",
+      "string",
+      "query",
+      "path",
+      "int",
+      "bool",
+      "date",
+      "json",
+      "any",
+    ]);
+    // Register default types. Store them in the prototype of this.types.
+    const makeType = (definition, name) =>
+      new ParamType(extend({ name }, definition));
+    this.types = inherit(map(this.defaultTypes, makeType), {});
+  }
+  dispose() {
+    this.types = {};
+  }
+  /**
+   * Registers a parameter type
+   *
+   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
+   */
+  type(name, definition, definitionFn) {
+    if (!isDefined(definition)) return this.types[name];
+    if (this.types.hasOwnProperty(name))
+      throw new Error(`A type named '${name}' has already been defined.`);
+    this.types[name] = new ParamType(extend({ name }, definition));
+    if (definitionFn) {
+      this.typeQueue.push({ name, def: definitionFn });
+      if (!this.enqueue) this._flushTypeQueue();
+    }
+    return this;
+  }
+  _flushTypeQueue() {
+    while (this.typeQueue.length) {
+      const type = this.typeQueue.shift();
+      if (type.pattern)
+        throw new Error("You cannot override a type's .pattern at runtime.");
+      extend(this.types[type.name], services.$injector.invoke(type.def));
+    }
+  }
+}
+function initDefaultTypes() {
+  const makeDefaultType = (def) => {
+    const valToString = (val) => (val != null ? val.toString() : val);
+    const defaultTypeBase = {
+      encode: valToString,
+      decode: valToString,
+      is: is(String),
+      pattern: /.*/,
+      // tslint:disable-next-line:triple-equals
+      equals: (a, b) => a == b, // allow coersion for null/undefined/""
+    };
+    return extend({}, defaultTypeBase, def);
+  };
+  // Default Parameter Type Definitions
+  extend(ParamTypes.prototype, {
+    string: makeDefaultType({}),
+    path: makeDefaultType({
+      pattern: /[^/]*/,
+    }),
+    query: makeDefaultType({}),
+    hash: makeDefaultType({
+      inherit: false,
+    }),
+    int: makeDefaultType({
+      decode: (val) => parseInt(val, 10),
+      is: function (val) {
+        return !isNullOrUndefined(val) && this.decode(val.toString()) === val;
+      },
+      pattern: /-?\d+/,
+    }),
+    bool: makeDefaultType({
+      encode: (val) => (val && 1) || 0,
+      decode: (val) => parseInt(val, 10) !== 0,
+      is: is(Boolean),
+      pattern: /0|1/,
+    }),
+    date: makeDefaultType({
+      encode: function (val) {
+        return !this.is(val)
+          ? undefined
+          : [
+              val.getFullYear(),
+              ("0" + (val.getMonth() + 1)).slice(-2),
+              ("0" + val.getDate()).slice(-2),
+            ].join("-");
+      },
+      decode: function (val) {
+        if (this.is(val)) return val;
+        const match = this.capture.exec(val);
+        return match ? new Date(match[1], match[2] - 1, match[3]) : undefined;
+      },
+      is: (val) => val instanceof Date && !isNaN(val.valueOf()),
+      equals(l, r) {
+        return ["getFullYear", "getMonth", "getDate"].reduce(
+          (acc, fn) => acc && l[fn]() === r[fn](),
+          true,
+        );
+      },
+      pattern: /[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,
+      capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/,
+    }),
+    json: makeDefaultType({
+      encode: toJson,
+      decode: fromJson,
+      is: is(Object),
+      equals: equals,
+      pattern: /[^/]*/,
+    }),
+    // does not encode/decode
+    any: makeDefaultType({
+      encode: identity,
+      decode: identity,
+      is: () => true,
+      equals: equals,
+    }),
+  });
+}
+initDefaultTypes();

package/src/router/core/params/stateParams.js

@@ -0,0 +1,35 @@
+import { extend, ancestors } from "../common/common";
+export class StateParams {
+  constructor(params = {}) {
+    extend(this, params);
+  }
+  /**
+   * Merges a set of parameters with all parameters inherited between the common parents of the
+   * current state and a given destination state.
+   *
+   * @param {Object} newParams The set of parameters which will be composited with inherited params.
+   * @param {Object} $current Internal definition of object representing the current state.
+   * @param {Object} $to Internal definition of object representing state to transition to.
+   */
+  $inherit(newParams, $current, $to) {
+    const parents = ancestors($current, $to),
+      inherited = {},
+      inheritList = [];
+    for (const i in parents) {
+      if (!parents[i] || !parents[i].params) continue;
+      const parentParams = parents[i].params;
+      const parentParamsKeys = Object.keys(parentParams);
+      if (!parentParamsKeys.length) continue;
+      for (const j in parentParamsKeys) {
+        if (
+          parentParams[parentParamsKeys[j]].inherit == false ||
+          inheritList.indexOf(parentParamsKeys[j]) >= 0
+        )
+          continue;
+        inheritList.push(parentParamsKeys[j]);
+        inherited[parentParamsKeys[j]] = this[parentParamsKeys[j]];
+      }
+    }
+    return extend({}, inherited, newParams);
+  }
+}

package/src/router/core/path/pathNode.js

@@ -0,0 +1,77 @@
+import { extend, applyPairs, find } from "../common/common";
+import { propEq } from "../common/hof";
+import { Param } from "../params/param";
+/**
+ * A node in a [[TreeChanges]] path
+ *
+ * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.
+ * Each PathNode corresponds to a state being entered, exited, or retained.
+ * The stateful information includes parameter values and resolve data.
+ */
+export class PathNode {
+  constructor(stateOrNode) {
+    if (stateOrNode instanceof PathNode) {
+      const node = stateOrNode;
+      this.state = node.state;
+      this.paramSchema = node.paramSchema.slice();
+      this.paramValues = extend({}, node.paramValues);
+      this.resolvables = node.resolvables.slice();
+      this.views = node.views && node.views.slice();
+    } else {
+      const state = stateOrNode;
+      this.state = state;
+      this.paramSchema = state.parameters({ inherit: false });
+      this.paramValues = {};
+      this.resolvables = state.resolvables.map((res) => res.clone());
+    }
+  }
+  clone() {
+    return new PathNode(this);
+  }
+  /** Sets [[paramValues]] for the node, from the values of an object hash */
+  applyRawParams(params) {
+    const getParamVal = (paramDef) => [
+      paramDef.id,
+      paramDef.value(params[paramDef.id]),
+    ];
+    this.paramValues = this.paramSchema.reduce(
+      (memo, pDef) => applyPairs(memo, getParamVal(pDef)),
+      {},
+    );
+    return this;
+  }
+  /** Gets a specific [[Param]] metadata that belongs to the node */
+  parameter(name) {
+    return find(this.paramSchema, propEq("id", name));
+  }
+  /**
+   * @returns true if the state and parameter values for another PathNode are
+   * equal to the state and param values for this PathNode
+   */
+  equals(node, paramsFn) {
+    const diff = this.diff(node, paramsFn);
+    return diff && diff.length === 0;
+  }
+  /**
+   * Finds Params with different parameter values on another PathNode.
+   *
+   * Given another node (of the same state), finds the parameter values which differ.
+   * Returns the [[Param]] (schema objects) whose parameter values differ.
+   *
+   * Given another node for a different state, returns `false`
+   *
+   * @param node The node to compare to
+   * @param paramsFn A function that returns which parameters should be compared.
+   * @returns The [[Param]]s which differ, or null if the two nodes are for different states
+   */
+  diff(node, paramsFn) {
+    if (this.state !== node.state) return false;
+    const params = paramsFn ? paramsFn(this) : this.paramSchema;
+    return Param.changed(params, this.paramValues, node.paramValues);
+  }
+}
+/**
+ * Returns a clone of the PathNode
+ * @deprecated use instance method `node.clone()`
+ */
+PathNode.clone = (node) => node.clone();