@angular-wave/angular.ts 0.0.1

package/src/filters/filter.js

@@ -0,0 +1,207 @@
+import {
+  minErr,
+  isArrayLike,
+  isFunction,
+  isUndefined,
+  isObject,
+  lowercase,
+  isArray,
+  hasCustomToString,
+  equals,
+} from "../core/utils";
+
+/**
+ * @returns {angular.IFilterFilter}
+ */
+export function filterFilter() {
+  return function (array, expression, comparator, anyPropertyKey) {
+    if (!isArrayLike(array)) {
+      if (array == null) {
+        return array;
+      }
+      throw minErr("filter")(
+        "notarray",
+        "Expected array but received: {0}",
+        array,
+      );
+    }
+
+    anyPropertyKey = anyPropertyKey || "$";
+    let predicateFn;
+    let matchAgainstAnyProp;
+
+    switch (getTypeForFilter(expression)) {
+      case "function":
+        predicateFn = expression;
+        break;
+      case "boolean":
+      case "null":
+      case "number":
+      case "string":
+        matchAgainstAnyProp = true;
+      // falls through
+      case "object":
+        predicateFn = createPredicateFn(
+          expression,
+          comparator,
+          anyPropertyKey,
+          matchAgainstAnyProp,
+        );
+        break;
+      default:
+        return array;
+    }
+
+    return Array.prototype.filter.call(array, predicateFn);
+  };
+}
+
+// Helper functions for `filterFilter`
+function createPredicateFn(
+  expression,
+  comparator,
+  anyPropertyKey,
+  matchAgainstAnyProp,
+) {
+  const shouldMatchPrimitives =
+    isObject(expression) && anyPropertyKey in expression;
+  let predicateFn;
+
+  if (comparator === true) {
+    comparator = equals;
+  } else if (!isFunction(comparator)) {
+    comparator = function (actual, expected) {
+      if (isUndefined(actual)) {
+        // No substring matching against `undefined`
+        return false;
+      }
+      if (actual === null || expected === null) {
+        // No substring matching against `null`; only match against `null`
+        return actual === expected;
+      }
+      if (
+        isObject(expected) ||
+        (isObject(actual) && !hasCustomToString(actual))
+      ) {
+        // Should not compare primitives against objects, unless they have custom `toString` method
+        return false;
+      }
+
+      actual = lowercase(`${actual}`);
+      expected = lowercase(`${expected}`);
+      return actual.indexOf(expected) !== -1;
+    };
+  }
+
+  predicateFn = function (item) {
+    if (shouldMatchPrimitives && !isObject(item)) {
+      return deepCompare(
+        item,
+        expression[anyPropertyKey],
+        comparator,
+        anyPropertyKey,
+        false,
+      );
+    }
+    return deepCompare(
+      item,
+      expression,
+      comparator,
+      anyPropertyKey,
+      matchAgainstAnyProp,
+    );
+  };
+
+  return predicateFn;
+}
+
+function deepCompare(
+  actual,
+  expected,
+  comparator,
+  anyPropertyKey,
+  matchAgainstAnyProp,
+  dontMatchWholeObject,
+) {
+  const actualType = getTypeForFilter(actual);
+  const expectedType = getTypeForFilter(expected);
+
+  if (expectedType === "string" && expected.charAt(0) === "!") {
+    return !deepCompare(
+      actual,
+      expected.substring(1),
+      comparator,
+      anyPropertyKey,
+      matchAgainstAnyProp,
+    );
+  }
+  if (isArray(actual)) {
+    // In case `actual` is an array, consider it a match
+    // if ANY of it's items matches `expected`
+    return actual.some((item) =>
+      deepCompare(
+        item,
+        expected,
+        comparator,
+        anyPropertyKey,
+        matchAgainstAnyProp,
+      ),
+    );
+  }
+
+  switch (actualType) {
+    case "object":
+      var key;
+      if (matchAgainstAnyProp) {
+        for (key in actual) {
+          // Under certain, rare, circumstances, key may not be a string and `charAt` will be undefined
+          // See: https://github.com/angular/angular.js/issues/15644
+          if (
+            key.charAt &&
+            key.charAt(0) !== "$" &&
+            deepCompare(actual[key], expected, comparator, anyPropertyKey, true)
+          ) {
+            return true;
+          }
+        }
+        return dontMatchWholeObject
+          ? false
+          : deepCompare(actual, expected, comparator, anyPropertyKey, false);
+      }
+      if (expectedType === "object") {
+        for (key in expected) {
+          const expectedVal = expected[key];
+          if (isFunction(expectedVal) || isUndefined(expectedVal)) {
+            continue;
+          }
+
+          const matchAnyProperty = key === anyPropertyKey;
+          const actualVal = matchAnyProperty ? actual : actual[key];
+          if (
+            !deepCompare(
+              actualVal,
+              expectedVal,
+              comparator,
+              anyPropertyKey,
+              matchAnyProperty,
+              matchAnyProperty,
+            )
+          ) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return comparator(actual, expected);
+
+    case "function":
+      return false;
+    default:
+      return comparator(actual, expected);
+  }
+}
+
+// Used for easily differentiating between `null` and actual `object`
+function getTypeForFilter(val) {
+  return val === null ? "null" : typeof val;
+}

package/src/filters/filter.md

@@ -0,0 +1,69 @@
+/\*\*
+
+- @ngdoc filter
+- @name filter
+- @kind function
+-
+- @description
+- Selects a subset of items from `array` and returns it as a new array.
+-
+- @param {Array} array The source array.
+- <div class="alert alert-info">
+- **Note**: If the array contains objects that reference themselves, filtering is not possible.
+- </div>
+- @param {string|Object|function()} expression The predicate to be used for selecting items from
+- `array`.
+-
+- Can be one of:
+-
+- - `string`: The string is used for matching against the contents of the `array`. All strings or
+-     objects with string properties in `array` that match this string will be returned. This also
+-     applies to nested object properties.
+-     The predicate can be negated by prefixing the string with `!`.
+-
+- - `Object`: A pattern object can be used to filter specific properties on objects contained
+-     by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
+-     which have property `name` containing "M" and property `phone` containing "1". A special
+-     property name (`$` by default) can be used (e.g. as in `{$: "text"}`) to accept a match
+-     against any property of the object or its nested object properties. That's equivalent to the
+-     simple substring match with a `string` as described above. The special property name can be
+-     overwritten, using the `anyPropertyKey` parameter.
+-     The predicate can be negated by prefixing the string with `!`.
+-     For example `{name: "!M"}` predicate will return an array of items which have property `name`
+-     not containing "M".
+-
+-     Note that a named property will match properties on the same level only, while the special
+-     `$` property will match properties on the same level or deeper. E.g. an array item like
+-     `{name: {first: 'John', last: 'Doe'}}` will **not** be matched by `{name: 'John'}`, but
+-     **will** be matched by `{$: 'John'}`.
+-
+- - `function(value, index, array)`: A predicate function can be used to write arbitrary filters.
+-     The function is called for each element of the array, with the element, its index, and
+-     the entire array itself as arguments.
+-
+-     The final result is an array of those elements that the predicate returned true for.
+-
+- @param {function(actual, expected)|true|false} [comparator] Comparator which is used in
+-     determining if values retrieved using `expression` (when it is not a function) should be
+-     considered a match based on the expected value (from the filter expression) and actual
+-     value (from the object in the array).
+-
+- Can be one of:
+-
+- - `function(actual, expected)`:
+-     The function will be given the object value and the predicate value to compare and
+-     should return true if both values should be considered equal.
+-
+- - `true`: A shorthand for `function(actual, expected) { return angular.equals(actual, expected)}`.
+-     This is essentially strict comparison of expected and actual.
+-
+- - `false`: A short hand for a function which will look for a substring match in a case
+-     insensitive way. Primitive values are converted to strings. Objects are not compared against
+-     primitives, unless they have a custom `toString` method (e.g. `Date` objects).
+-
+-
+- Defaults to `false`.
+-
+- @param {string} [anyPropertyKey] The special property name that matches against any property.
+-     By default `$`.
+- \*/

package/src/filters/filters.js

@@ -0,0 +1,239 @@
+import { isNumber, isString, isUndefined, toJson } from "../core/utils";
+
+const MAX_DIGITS = 22;
+const DECIMAL_SEP = ".";
+const ZERO_CHAR = "0";
+
+/**
+ * Parse a number (as a string) into three components that can be used
+ * for formatting the number.
+ *
+ * (Significant bits of this parse algorithm came from https://github.com/MikeMcl/big.js/)
+ *
+ * @param  {string} numStr The number to parse
+ * @return {object} An object describing this number, containing the following keys:
+ *  - d : an array of digits containing leading zeros as necessary
+ *  - i : the number of the digits in `d` that are to the left of the decimal point
+ *  - e : the exponent for numbers that would need more than `MAX_DIGITS` digits in `d`
+ *
+ */
+function parse(numStr) {
+  let exponent = 0;
+  let digits;
+  let numberOfIntegerDigits;
+  let i;
+  let j;
+  let zeros;
+
+  // Decimal point?
+  if ((numberOfIntegerDigits = numStr.indexOf(DECIMAL_SEP)) > -1) {
+    numStr = numStr.replace(DECIMAL_SEP, "");
+  }
+
+  // Exponential form?
+  if ((i = numStr.search(/e/i)) > 0) {
+    // Work out the exponent.
+    if (numberOfIntegerDigits < 0) numberOfIntegerDigits = i;
+    numberOfIntegerDigits += +numStr.slice(i + 1);
+    numStr = numStr.substring(0, i);
+  } else if (numberOfIntegerDigits < 0) {
+    // There was no decimal point or exponent so it is an integer.
+    numberOfIntegerDigits = numStr.length;
+  }
+
+  // Count the number of leading zeros.
+  for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) {
+    /* empty */
+  }
+
+  if (i === (zeros = numStr.length)) {
+    // The digits are all zero.
+    digits = [0];
+    numberOfIntegerDigits = 1;
+  } else {
+    // Count the number of trailing zeros
+    zeros--;
+    while (numStr.charAt(zeros) === ZERO_CHAR) zeros--;
+
+    // Trailing zeros are insignificant so ignore them
+    numberOfIntegerDigits -= i;
+    digits = [];
+    // Convert string to array of digits without leading/trailing zeros.
+    for (j = 0; i <= zeros; i++, j++) {
+      digits[j] = +numStr.charAt(i);
+    }
+  }
+
+  // If the number overflows the maximum allowed digits then use an exponent.
+  if (numberOfIntegerDigits > MAX_DIGITS) {
+    digits = digits.splice(0, MAX_DIGITS - 1);
+    exponent = numberOfIntegerDigits - 1;
+    numberOfIntegerDigits = 1;
+  }
+
+  return { d: digits, e: exponent, i: numberOfIntegerDigits };
+}
+
+/**
+ * Round the parsed number to the specified number of decimal places
+ * This function changed the parsedNumber in-place
+ */
+function roundNumber(parsedNumber, fractionSize, minFrac, maxFrac) {
+  const digits = parsedNumber.d;
+  let fractionLen = digits.length - parsedNumber.i;
+
+  // determine fractionSize if it is not specified; `+fractionSize` converts it to a number
+  fractionSize = isUndefined(fractionSize)
+    ? Math.min(Math.max(minFrac, fractionLen), maxFrac)
+    : +fractionSize;
+
+  // The index of the digit to where rounding is to occur
+  let roundAt = fractionSize + parsedNumber.i;
+  const digit = digits[roundAt];
+
+  if (roundAt > 0) {
+    // Drop fractional digits beyond `roundAt`
+    digits.splice(Math.max(parsedNumber.i, roundAt));
+
+    // Set non-fractional digits beyond `roundAt` to 0
+    for (let j = roundAt; j < digits.length; j++) {
+      digits[j] = 0;
+    }
+  } else {
+    // We rounded to zero so reset the parsedNumber
+    fractionLen = Math.max(0, fractionLen);
+    parsedNumber.i = 1;
+    digits.length = Math.max(1, (roundAt = fractionSize + 1));
+    digits[0] = 0;
+    for (let i = 1; i < roundAt; i++) digits[i] = 0;
+  }
+
+  if (digit >= 5) {
+    if (roundAt - 1 < 0) {
+      for (let k = 0; k > roundAt; k--) {
+        digits.unshift(0);
+        parsedNumber.i++;
+      }
+      digits.unshift(1);
+      parsedNumber.i++;
+    } else {
+      digits[roundAt - 1]++;
+    }
+  }
+
+  // Pad out with zeros to get the required fraction length
+  for (; fractionLen < Math.max(0, fractionSize); fractionLen++) digits.push(0);
+
+  // Do any carrying, e.g. a digit was rounded up to 10
+  const carry = digits.reduceRight((carry, d, i, digits) => {
+    d += carry;
+    digits[i] = d % 10;
+    return Math.floor(d / 10);
+  }, 0);
+  if (carry) {
+    digits.unshift(carry);
+    parsedNumber.i++;
+  }
+}
+
+/**
+ * Format a number into a string
+ * @param  {number} number       The number to format
+ * @param  {{
+ *           minFrac, // the minimum number of digits required in the fraction part of the number
+ *           maxFrac, // the maximum number of digits required in the fraction part of the number
+ *           gSize,   // number of digits in each group of separated digits
+ *           lgSize,  // number of digits in the last group of digits before the decimal separator
+ *           negPre,  // the string to go in front of a negative number (e.g. `-` or `(`))
+ *           posPre,  // the string to go in front of a positive number
+ *           negSuf,  // the string to go after a negative number (e.g. `)`)
+ *           posSuf   // the string to go after a positive number
+ *         }} pattern
+ * @param  {string} groupSep     The string to separate groups of number (e.g. `,`)
+ * @param  {string} decimalSep   The string to act as the decimal separator (e.g. `.`)
+ * @param  {[type]} fractionSize The size of the fractional part of the number
+ * @return {string}              The number formatted as a string
+ */
+
+export function formatNumber(
+  number,
+  pattern,
+  groupSep,
+  decimalSep,
+  fractionSize,
+) {
+  if (!(isString(number) || isNumber(number)) || Number.isNaN(number))
+    return "";
+
+  const isInfinity = !Number.isFinite(number);
+  let isZero = false;
+  const numStr = `${Math.abs(number)}`;
+  let formattedText = "";
+  let parsedNumber;
+
+  if (isInfinity) {
+    formattedText = "\u221e";
+  } else {
+    parsedNumber = parse(numStr);
+
+    roundNumber(parsedNumber, fractionSize, pattern.minFrac, pattern.maxFrac);
+
+    let digits = parsedNumber.d;
+    let integerLen = parsedNumber.i;
+    const exponent = parsedNumber.e;
+    let decimals = [];
+    isZero = digits.reduce((isZero, d) => isZero && !d, true);
+
+    // pad zeros for small numbers
+    while (integerLen < 0) {
+      digits.unshift(0);
+      integerLen++;
+    }
+
+    // extract decimals digits
+    if (integerLen > 0) {
+      decimals = digits.splice(integerLen, digits.length);
+    } else {
+      decimals = digits;
+      digits = [0];
+    }
+
+    // format the integer digits with grouping separators
+    const groups = [];
+    if (digits.length >= pattern.lgSize) {
+      groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(""));
+    }
+    while (digits.length > pattern.gSize) {
+      groups.unshift(digits.splice(-pattern.gSize, digits.length).join(""));
+    }
+    if (digits.length) {
+      groups.unshift(digits.join(""));
+    }
+    formattedText = groups.join(groupSep);
+
+    // append the decimal digits
+    if (decimals.length) {
+      formattedText += decimalSep + decimals.join("");
+    }
+
+    if (exponent) {
+      formattedText += `e+${exponent}`;
+    }
+  }
+  if (number < 0 && !isZero) {
+    return pattern.negPre + formattedText + pattern.negSuf;
+  }
+  return pattern.posPre + formattedText + pattern.posSuf;
+}
+
+/**
+ * @returns {angular.IFilterJson}
+ */
+export function jsonFilter() {
+  return function (object, spacing) {
+    if (isUndefined(spacing)) {
+      spacing = 2;
+    }
+    return toJson(object, spacing);
+  };
+}

package/src/filters/json.md

@@ -0,0 +1,16 @@
+# JSON Filter
+
+## Description
+
+Allows you to convert a JavaScript object into a JSON string.
+
+This filter is mostly useful for debugging. When using the double curly `{{value}}` notation, the binding is automatically converted to JSON.
+
+## Parameters
+
+- **object** `{*}`: Any JavaScript object (including arrays and primitive types) to filter.
+- **spacing** `{number=}`: The number of spaces to use per indentation, defaults to 2.
+
+## Returns
+
+- `{string}`: JSON string.

package/src/filters/limit-to.js

@@ -0,0 +1,43 @@
+import {
+  isArrayLike,
+  isNumber,
+  isNumberNaN,
+  isString,
+  toInt,
+} from "../core/utils";
+
+/**
+ * @returns {angular.IFilterLimitTo}
+ */
+export function limitToFilter() {
+  return function (input, limit, begin) {
+    if (Math.abs(Number(limit)) === Infinity) {
+      limit = Number(limit);
+    } else {
+      limit = toInt(limit);
+    }
+    if (isNumberNaN(limit)) return input;
+
+    if (isNumber(input)) input = input.toString();
+    if (!isArrayLike(input)) return input;
+
+    begin = !begin || isNaN(begin) ? 0 : toInt(begin);
+    begin = begin < 0 ? Math.max(0, input.length + begin) : begin;
+
+    if (limit >= 0) {
+      return sliceFn(input, begin, begin + limit);
+    } else {
+      if (begin === 0) {
+        return sliceFn(input, limit, input.length);
+      } else {
+        return sliceFn(input, Math.max(0, begin + limit), begin);
+      }
+    }
+  };
+}
+
+function sliceFn(input, begin, end) {
+  if (isString(input)) return input.slice(begin, end);
+
+  return [].slice.call(input, begin, end);
+}

package/src/filters/limit-to.md

@@ -0,0 +1,19 @@
+# limitTo Filter
+
+## Description
+
+Creates a new array or string containing only a specified number of elements. The elements are taken from either the beginning or the end of the source array, string, or number, as specified by the value and sign (positive or negative) of `limit`. Other array-like objects are also supported (e.g., array subclasses, NodeLists, jqLite/jQuery collections, etc.). If a number is used as input, it is converted to a string.
+
+## Parameters
+
+- **input** `{Array|ArrayLike|string|number}`: Array/array-like, string, or number to be limited.
+- **limit** `{string|number}`: The length of the returned array or string.
+  - If the `limit` number is positive, `limit` number of items from the beginning of the source array/string are copied.
+  - If the number is negative, `limit` number of items from the end of the source array/string are copied.
+  - The `limit` will be trimmed if it exceeds `array.length`.
+  - If `limit` is undefined, the input will be returned unchanged.
+- **begin** `{(string|number)=}`: Index at which to begin limitation. As a negative index, `begin` indicates an offset from the end of `input`. Defaults to `0`.
+
+## Returns
+
+- `{Array|string}`: A new sub-array or substring of length `limit` or less if the input had less than `limit` elements.