@angular-wave/angular.ts 0.9.4 → 0.9.5

package/src/router/params/param-factory.js

@@ -1,23 +0,0 @@
-import { DefType, Param } from "./param.js";
-
-export class ParamFactory {
-  /**
-   * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
-   */
-  constructor(urlServiceConfig) {
-    /**
-     * @type {import("../url/url-config.js").UrlConfigProvider}
-     */
-    this.urlServiceConfig = urlServiceConfig;
-  }
-
-  fromConfig(id, type, state) {
-    return new Param(id, type, DefType.CONFIG, this.urlServiceConfig, state);
-  }
-  fromPath(id, type, state) {
-    return new Param(id, type, DefType.PATH, this.urlServiceConfig, state);
-  }
-  fromSearch(id, type, state) {
-    return new Param(id, type, DefType.SEARCH, this.urlServiceConfig, state);
-  }
-}

package/src/router/params/param-type.js

@@ -1,133 +0,0 @@
-import { filter, map } from "../../shared/common.js";
-import { isDefined } from "../../shared/utils.js";
-/**
- * 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.
-   */
-  constructor(def) {
-    this.pattern = /.*/;
-    this.inherit = true;
-    Object.assign(this, def);
-    this.name = undefined;
-  }
-  // consider these four methods to be "abstract methods" that should be overridden
-
-  is(val) {
-    return !!val;
-  }
-  encode(val) {
-    return val;
-  }
-  decode(val) {
-    return val;
-  }
-  equals(a, b) {
-    return a == b;
-  }
-  $subPattern() {
-    const sub = this.pattern.toString();
-    return sub.substring(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 Array.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 (Array.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);
-  });
-  Object.assign(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/params/param-types.js

@@ -1,153 +0,0 @@
-import { equals, inherit, map, pick } from "../../shared/common.js";
-import { hasOwn, isDefined, isNullOrUndefined } from "../../shared/utils.js";
-import { is } from "../../shared/hof.js";
-import { ParamType } from "./param-type.js";
-/**
- * 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(Object.assign({ name }, definition));
-    this.types = inherit(map(this.defaultTypes, makeType), {});
-  }
-  /**
-   * 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 (hasOwn(this.types, name))
-      throw new Error(`A type named '${name}' has already been defined.`);
-    this.types[name] = new ParamType(Object.assign({ 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.");
-      Object.assign(
-        this.types[type.name],
-        window["angular"].$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: /.*/,
-
-      equals: (a, b) => a == b, // allow coersion for null/undefined/""
-    };
-    return Object.assign({}, defaultTypeBase, def);
-  };
-  // Default Parameter Type Definitions
-  Object.assign(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: /[01]/,
-    }),
-    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: JSON.stringify,
-      decode: JSON.parse,
-      is: is(Object),
-      equals: equals,
-      pattern: /[^/]*/,
-    }),
-    // does not encode/decode
-    any: makeDefaultType({
-      encode: (x) => x,
-      decode: (x) => x,
-      is: () => true,
-      equals: equals,
-    }),
-  });
-}
-initDefaultTypes();

package/src/router/params/param.js

@@ -1,243 +0,0 @@
-import { filter, map, allTrueR, find } from "../../shared/common.js";
-import { isInjectable } from "../../shared/predicates.js";
-import { isDefined, isUndefined, isString } from "../../shared/utils.js";
-import { ParamType } from "./param-type.js";
-
-const isShorthand = (cfg) =>
-  ["value", "type", "squash", "array", "dynamic"].filter(
-    Object.prototype.hasOwnProperty.bind(cfg || {}),
-  ).length === 0;
-
-/**
- * @private
- * @enum {number}
- */
-export const DefType = {
-  PATH: 0,
-  SEARCH: 1,
-  CONFIG: 2,
-};
-
-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 Object.assign(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 Object.assign(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 = Array.isArray(config.replace) ? config.replace : [];
-  if (isString(squash)) replace.push({ from: squash, to: undefined });
-  const configuredKeys = map(replace, (x) => x.from);
-  return filter(
-    defaultPolicy,
-    (item) => configuredKeys.indexOf(item.from) === -1,
-  ).concat(replace);
-}
-
-export class Param {
-  /**
-   *
-   * @param {*} id
-   * @param {*} type
-   * @param {DefType} location
-   * @param {import("../url/url-config.js").UrlConfigProvider} urlConfig
-   * @param {*} state
-   */
-  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 Object.assign(arrayDefaults, arrayParamNomenclature, config).array;
-    }
-    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);
-  }
-  /**
-   * [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 (!window["angular"].$injector)
-        throw new Error(
-          "Injectable functions cannot be called at configuration time",
-        );
-      const defaultValue = window["angular"].$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 = normalized; // 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}}`;
-  }
-
-  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/params/state-params.js

@@ -1,36 +0,0 @@
-import { ancestors } from "../../shared/common.js";
-
-export class StateParams {
-  constructor(params = {}) {
-    Object.assign(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 Object.assign({}, inherited, newParams);
-  }
-}

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

@@ -1,78 +0,0 @@
-import { applyPairs, find } from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { Param } from "../params/param.js";
-
-/**
- * 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 = Object.assign({}, 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);
-  }
-}