@jaredwray/fumanchu 1.0.0

package/lib/math.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var isNumber = require('is-number');
+var utils = require('./utils');
+var helpers = module.exports;
+
+/**
+ * Return the magnitude of `a`.
+ *
+ * @param {Number} `a`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.abs = function(num) {
+  if (!isNumber(num)) {
+    throw new TypeError('expected a number');
+  }
+  return Math.abs(num);
+};
+
+/**
+ * Return the sum of `a` plus `b`.
+ *
+ * @param {Number} `a`
+ * @param {Number} `b`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.add = function(a, b) {
+  if (isNumber(a) && isNumber(b)) {
+    return Number(a) + Number(b);
+  }
+  if (typeof a === 'string' && typeof b === 'string') {
+    return a + b;
+  }
+  return '';
+};
+
+/**
+ * Returns the average of all numbers in the given array.
+ *
+ * ```handlebars
+ * {{avg "[1, 2, 3, 4, 5]"}}
+ * <!-- results in: '3' -->
+ * ```
+ *
+ * @param {Array} `array` Array of numbers to add up.
+ * @return {Number}
+ * @api public
+ */
+
+helpers.avg = function() {
+  var args = [].concat.apply([], arguments);
+  // remove handlebars options object
+  args.pop();
+  return helpers.sum(args) / args.length;
+};
+
+/**
+ * Get the `Math.ceil()` of the given value.
+ *
+ * @param {Number} `value`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.ceil = function(num) {
+  if (!isNumber(num)) {
+    throw new TypeError('expected a number');
+  }
+  return Math.ceil(num);
+};
+
+/**
+ * Divide `a` by `b`
+ *
+ * @param {Number} `a` numerator
+ * @param {Number} `b` denominator
+ * @api public
+ */
+
+helpers.divide = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) / Number(b);
+};
+
+/**
+ * Get the `Math.floor()` of the given value.
+ *
+ * @param {Number} `value`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.floor = function(num) {
+  if (!isNumber(num)) {
+    throw new TypeError('expected a number');
+  }
+  return Math.floor(num);
+};
+
+/**
+ * Return the difference of `a` minus `b`.
+ *
+ * @param {Number} `a`
+ * @param {Number} `b`
+ * @alias subtract
+ * @api public
+ */
+
+helpers.minus = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) - Number(b);
+};
+
+/**
+ * Get the remainder of a division operation.
+ *
+ * @param {Number} `a`
+ * @param {Number} `b`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.modulo = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) % Number(b);
+};
+
+/**
+ * Return the product of `a` times `b`.
+ *
+ * @param {Number} `a` factor
+ * @param {Number} `b` multiplier
+ * @return {Number}
+ * @alias times
+ * @api public
+ */
+
+helpers.multiply = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) * Number(b);
+};
+
+/**
+ * Add `a` by `b`.
+ *
+ * @param {Number} `a` factor
+ * @param {Number} `b` multiplier
+ * @api public
+ */
+
+helpers.plus = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) + Number(b);
+};
+
+/**
+ * Generate a random number between two values
+ *
+ * @param {Number} `min`
+ * @param {Number} `max`
+ * @return {String}
+ * @api public
+ */
+
+helpers.random = function(min, max) {
+  if (!isNumber(min)) {
+    throw new TypeError('expected minimum to be a number');
+  }
+  if (!isNumber(max)) {
+    throw new TypeError('expected maximum to be a number');
+  }
+  return utils.random(min, max);
+};
+
+/**
+ * Get the remainder when `a` is divided by `b`.
+ *
+ * @param {Number} `a` a
+ * @param {Number} `b` b
+ * @api public
+ */
+
+helpers.remainder = function(a, b) {
+  return a % b;
+};
+
+/**
+ * Round the given number.
+ *
+ * @param {Number} `number`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.round = function(num) {
+  if (!isNumber(num)) {
+    throw new TypeError('expected a number');
+  }
+  return Math.round(num);
+};
+
+/**
+ * Return the product of `a` minus `b`.
+ *
+ * @param {Number} `a`
+ * @param {Number} `b`
+ * @return {Number}
+ * @alias minus
+ * @api public
+ */
+
+helpers.subtract = function(a, b) {
+  if (!isNumber(a)) {
+    throw new TypeError('expected the first argument to be a number');
+  }
+  if (!isNumber(b)) {
+    throw new TypeError('expected the second argument to be a number');
+  }
+  return Number(a) - Number(b);
+};
+
+/**
+ * Returns the sum of all numbers in the given array.
+ *
+ * ```handlebars
+ * {{sum "[1, 2, 3, 4, 5]"}}
+ * <!-- results in: '15' -->
+ * ```
+ * @param {Array} `array` Array of numbers to add up.
+ * @return {Number}
+ * @api public
+ */
+
+helpers.sum = function() {
+  var args = [].concat.apply([], arguments);
+  var len = args.length;
+  var sum = 0;
+
+  while (len--) {
+    if (utils.isNumber(args[len])) {
+      sum += Number(args[len]);
+    }
+  }
+  return sum;
+};
+
+/**
+ * Multiply number `a` by number `b`.
+ *
+ * @param {Number} `a` factor
+ * @param {Number} `b` multiplier
+ * @return {Number}
+ * @alias multiply
+ * @api public
+ */
+
+helpers.times = function() {
+  return helpers.multiply.apply(this, arguments);
+};

package/lib/misc.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var util = require('handlebars-utils');
+var utils = require('./utils');
+var helpers = module.exports;
+
+/**
+ * Block helper for exposing private `@` variables on the context
+ */
+
+helpers.frame = require('handlebars-helper-create-frame');
+
+/**
+ * Return the given value of `prop` from `this.options`.
+ *
+ * ```handlebars
+ * <!-- context = {options: {a: {b: {c: 'ddd'}}}} -->
+ * {{option "a.b.c"}}
+ * <!-- results => `ddd` -->
+ * ```
+ * @param {String} `prop`
+ * @return {any}
+ * @api public
+ */
+
+helpers.option = function(prop, locals, options) {
+  return utils.get(util.options(this, locals, options), prop);
+};
+
+/**
+ * Block helper that renders the block without taking any arguments.
+ *
+ * @param {Object} `options`
+ * @return {String}
+ * @block
+ * @api public
+ */
+
+helpers.noop = function(options) {
+  return options.fn(this);
+};
+
+/**
+ * Get the native type of the given `value`
+ *
+ * ```handlebars
+ * {{typeOf 1}}
+ * //=> 'number'
+ * {{typeOf "1"}}
+ * //=> 'string'
+ * {{typeOf "foo"}}
+ * //=> 'string'
+ * ```
+ * @param {any} `value`
+ * @return {String} Returns the type of value.
+ * @api public
+ */
+
+helpers.typeOf = require('kind-of');
+
+/**
+ * Block helper that builds the context for the block
+ * from the options hash.
+ *
+ * @param {Object} `options` Handlebars provided options object.
+ * @contributor Vladimir Kuznetsov <https://github.com/mistakster>
+ * @block
+ * @api public
+ */
+
+helpers.withHash = function(options) {
+  if (options.hash && Object.keys(options.hash).length) {
+    return options.fn(options.hash);
+  } else {
+    return options.inverse(this);
+  }
+};

package/lib/number.js

@@ -0,0 +1,204 @@
+'use strict';
+
+var isNumber = require('is-number');
+var util = require('handlebars-utils');
+var utils = require('./utils');
+var helpers = module.exports;
+
+/**
+ * Format a number to it's equivalent in bytes. If a string is passed,
+ * it's length will be formatted and returned.
+ *
+ * **Examples:**
+ *
+ *   - `'foo' => 3 B`
+ *   - `13661855 => 13.66 MB`
+ *   - `825399 => 825.39 kB`
+ *   - `1396 => 1.4 kB`
+ *
+ * @param {Number|String} `number`
+ * @return {String}
+ * @api public
+ */
+
+helpers.bytes = function(number, precision, options) {
+  if (number == null) return '0 B';
+
+  if (!utils.isNumber(number)) {
+    number = number.length;
+    if (!number) return '0 B';
+  }
+
+  if (!utils.isNumber(precision)) {
+    precision = 2;
+  }
+
+  var abbr = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+  precision = Math.pow(10, precision);
+  number = Number(number);
+
+  var len = abbr.length - 1;
+  while (len-- >= 0) {
+    var size = Math.pow(10, len * 3);
+    if (size <= (number + 1)) {
+      number = Math.round(number * precision / size) / precision;
+      number += ' ' + abbr[len];
+      break;
+    }
+  }
+
+  return number;
+};
+
+/**
+ * Add commas to numbers
+ *
+ * @param {Number} `num`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.addCommas = function(num) {
+  return num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,');
+};
+
+/**
+ * Convert a string or number to a formatted phone number.
+ *
+ * @param {Number|String} `num` The phone number to format, e.g. `8005551212`
+ * @return {Number} Formatted phone number: `(800) 555-1212`
+ * @source http://bit.ly/QlPmPr
+ * @api public
+ */
+
+helpers.phoneNumber = function(num) {
+  num = num.toString();
+
+  return '(' + num.substr(0, 3) + ') '
+    + num.substr(3, 3) + '-'
+    + num.substr(6, 4);
+};
+
+/**
+ * Abbreviate numbers to the given number of `precision`. This is for
+ * general numbers, not size in bytes.
+ *
+ * @param {Number} `number`
+ * @param {Number} `precision`
+ * @return {String}
+ * @api public
+ */
+
+helpers.toAbbr = function(number, precision) {
+  if (!utils.isNumber(number)) {
+    number = 0;
+  }
+  if (util.isUndefined(precision)) {
+    precision = 2;
+  }
+
+  number = Number(number);
+  // 2 decimal places => 100, 3 => 1000, etc.
+  precision = Math.pow(10, precision);
+  var abbr = ['k', 'm', 'b', 't', 'q'];
+  var len = abbr.length - 1;
+
+  while (len >= 0) {
+    var size = Math.pow(10, (len + 1) * 3);
+    if (size <= (number + 1)) {
+      number = Math.round(number * precision / size) / precision;
+      number += abbr[len];
+      break;
+    }
+    len--;
+  }
+  return number;
+};
+
+/**
+ * Returns a string representing the given number in exponential notation.
+ *
+ * ```handlebars
+ * {{toExponential number digits}};
+ * ```
+ * @param {Number} `number`
+ * @param {Number} `fractionDigits` Optional. An integer specifying the number of digits to use after the decimal point. Defaults to as many digits as necessary to specify the number.
+ * @return {Number}
+ * @api public
+ */
+
+helpers.toExponential = function(number, digits) {
+  if (!utils.isNumber(number)) {
+    number = 0;
+  }
+  if (util.isUndefined(digits)) {
+    digits = 0;
+  }
+  return Number(number).toExponential(digits);
+};
+
+/**
+ * Formats the given number using fixed-point notation.
+ *
+ * ```handlebars
+ * {{toFixed "1.1234" 2}}
+ * //=> '1.12'
+ * ```
+ * @param {Number} `number`
+ * @param {Number} `digits` (Optional) The number of digits to appear after the decimal point; this may be a value between 0 and 20. If this argument is omitted, it is treated as 0.
+ * @return {String} A string representing the given number using fixed-point notation.
+ * @api public
+ */
+
+helpers.toFixed = function(number, digits) {
+  if (!utils.isNumber(number)) {
+    number = 0;
+  }
+  if (!isNumber(digits)) {
+    digits = 0;
+  }
+  return Number(number).toFixed(digits);
+};
+
+/**
+ * @param {Number} `number`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.toFloat = function(number) {
+  return parseFloat(number);
+};
+
+/**
+ * @param {Number} `number`
+ * @return {Number}
+ * @api public
+ */
+
+helpers.toInt = function(number) {
+  return parseInt(number, 10);
+};
+
+/**
+ * Returns a string representing the `Number` object to the specified precision.
+ *
+ * ```handlebars
+ * {{toPrecision "1.1234" 2}}
+ * //=> '1.1'
+ * ```
+ * @param {Number} `number`
+ * @param {Number} `precision` (Optional) An integer specifying the number of significant digits. If precison is not between 1 and 100 (inclusive), it will be coerced to `0`.
+ * @return {String} A string representing a Number object in fixed-point or exponential notation rounded to precision significant digits.
+ * @api public
+ */
+
+helpers.toPrecision = function(number, precision) {
+  if (!utils.isNumber(number)) {
+    number = 0;
+  }
+  if (!isNumber(precision)) {
+    precision = 1;
+  }
+  return Number(number).toPrecision(precision);
+};