@baravak/risloo-profile-cli 3.1.0

package/src/handlebars/helpers/ceil.js

@@ -0,0 +1,8 @@
+// ceil Helper
+// Get the `Math.ceil()` of the given value.
+
+function ceil(num) {
+  return Math.ceil(num);
+};
+
+module.exports = ceil;

package/src/handlebars/helpers/concat.js

@@ -0,0 +1,8 @@
+// concat Helper
+// Concatenate Two Strings
+
+function concat(str1, str2, options) {
+  return String(str1) + String(str2);
+}
+
+module.exports = concat;

package/src/handlebars/helpers/cos.js

@@ -0,0 +1,8 @@
+// cos Helper
+// Calculate Cosine of An Angle
+
+function cos(angle) {
+  return Math.cos(angle);
+}
+
+module.exports = cos;

package/src/handlebars/helpers/displacePoint.js

@@ -0,0 +1,11 @@
+// displacePoint Helper
+// This helper is used to displace given point by given vector and distance
+
+function displacePoint(pt, u, d) {
+  return {
+    x: pt.x + d * u.x,
+    y: pt.y + d * u.y,
+  };
+}
+
+module.exports = displacePoint;

package/src/handlebars/helpers/ellipsisChars.js

@@ -0,0 +1,10 @@
+// ellipsisChars Helper
+// Putting Ellipsis onto String if Exceeded Our Limit
+
+function ellipsisChars(string, maxChar, options) {
+  if (string.length <= maxChar) return string;
+  const output = string.slice(0, maxChar) + " ...";
+  return output;
+}
+
+module.exports = ellipsisChars;

package/src/handlebars/helpers/ellipsisLines.js

@@ -0,0 +1,11 @@
+// ellipsisLines Helper
+// Putting Ellipsis onto Lines if Exceeded Our Limit
+
+function ellipsisLines(lines, maxLines, options) {
+  if (lines.length <= maxLines) return lines;
+  const output = lines.slice(0, maxLines);
+  output[maxLines - 1] += " ...";
+  return output;
+}
+
+module.exports = ellipsisLines;

package/src/handlebars/helpers/first.js

@@ -0,0 +1,11 @@
+// first Helper
+// Returns the first item, or first `n` items of an array.
+
+function first(array, n) {
+  if (typeof n !== 'number') {
+    return array[0];
+  }
+  return array.slice(0, n);
+}
+
+module.exports = first;

package/src/handlebars/helpers/floor.js

@@ -0,0 +1,8 @@
+// ceil Helper
+// Get the `Math.floor()` of the given value.
+
+function floor(num) {
+  return Math.floor(num);
+};
+
+module.exports = floor;

package/src/handlebars/helpers/forLoop.js

@@ -0,0 +1,15 @@
+// forLoop Helper
+// Implement For Loop in Handlebars
+
+function forLoop(from, to, incr, block) {
+  let accum = "";
+  for (let i = from; i < to; i += incr) {
+    block.data.i = i;
+    block.data.first = i === 0;
+    block.data.last = i === to - 1;
+    accum += block.fn({i});
+  }
+  return accum;
+}
+
+module.exports = forLoop;

package/src/handlebars/helpers/getArrOfProp.js

@@ -0,0 +1,8 @@
+// getArrOfProp Helper
+// Used to get one specific property of object in an array (as an array itself)
+
+function getArrOfProp(arr, prop) {
+  return arr.map(elem => elem[prop])
+}
+
+module.exports = getArrOfProp;

package/src/handlebars/helpers/isArray.js

@@ -0,0 +1,8 @@
+// isArray Helper
+// Checks whether input is array or not
+
+function isArray(arr) {
+  return Array.isArray(arr);
+}
+
+module.exports = isArray;

package/src/handlebars/helpers/join.js

@@ -0,0 +1,10 @@
+// join Helper
+// Join all elements of array into a string, optionally using a given separator
+
+function join(array, separator) {
+  if (typeof array === 'string') return array;
+  if (!Array.isArray(array)) return '';
+  return array.join(separator);
+};
+
+module.exports = join;

package/src/handlebars/helpers/last.js

@@ -0,0 +1,11 @@
+// last Helper
+// Returns the last item, or last `n` items of an array or string.
+
+function last(value, n) {
+  if (typeof n !== 'number') {
+    return value[value.length - 1];
+  }
+  return value.slice(-Math.abs(n));
+};
+
+module.exports = last;

package/src/handlebars/helpers/lineWrap.js

@@ -0,0 +1,28 @@
+// lineWrap Helper
+// Wrapping Words into Lines
+
+function lineWrap(string, maxChar, options) {
+  let tokens = string.split(" "); 
+  let lines = []; 
+  let i = 0; 
+  let L = 0;
+  while(true) { 
+    let tokenLength = tokens[i].replace(/‌/g, '').length; 
+    L += tokenLength + 1; 
+    if (L - 1 > maxChar) {
+      lines.push(tokens.slice(0, i).join(" ").trim()); 
+      tokens = tokens.slice(i); 
+      i = 0; 
+      L = 0;
+      continue;
+    } else if (i >= tokens.length - 1) { 
+      lines.push(tokens.slice(0, i + 1).join(" ")); 
+      break; 
+    } 
+    i++; 
+  } 
+
+  return lines; 
+}
+
+module.exports = lineWrap;

package/src/handlebars/helpers/math.js

@@ -0,0 +1,24 @@
+// math Helper
+// Implements Arithmetic Operations in Handlebars
+
+function math(lvalue, operator, rvalue, options) {
+  if (arguments.length < 4) {
+    // Operator omitted, assuming "+"
+    options = rvalue;
+    rvalue = operator;
+    operator = "+";
+  }
+
+  lvalue = parseFloat(lvalue);
+  rvalue = parseFloat(rvalue);
+
+  return {
+    "+": lvalue + rvalue,
+    "-": lvalue - rvalue,
+    "*": lvalue * rvalue,
+    "/": lvalue / rvalue,
+    "%": lvalue % rvalue,
+  }[operator];
+}
+
+module.exports = math;

package/src/handlebars/helpers/modulo.js

@@ -0,0 +1,8 @@
+// modulo Helper
+// Calculates Remainder of Division
+
+function modulo(a, b) {
+  return Number(a) % Number(b);
+}
+
+module.exports = modulo;

package/src/handlebars/helpers/normalizeAngle.js

@@ -0,0 +1,7 @@
+// This function is for normalizing given angles in the range (-PI, PI]
+
+function normalizeAngle(angle) {
+  return Math.atan2(Math.sin(angle), Math.cos(angle));
+}
+
+module.exports = normalizeAngle;

package/src/handlebars/helpers/object.js

@@ -0,0 +1,8 @@
+// object Helper
+// This helper is used to defined object literals in handlebars
+
+function object({hash}) {
+  return hash;
+}
+
+module.exports = object;

package/src/handlebars/helpers/objectEntries.js

@@ -0,0 +1,8 @@
+// objectEntries Helper
+// This helper is used to get object entries
+
+function objectEntries(obj) {
+  return Object.entries(obj);
+}
+
+module.exports = objectEntries;

package/src/handlebars/helpers/polarToCartesian.js

@@ -0,0 +1,14 @@
+// polarToCartesian Helper
+// Convert Polar Coordinates to Cartesian
+
+function polarToCartesian(r, theta) {
+  return {
+    x: +(r * Math.cos(theta)).toFixed(2),
+    y: +(r * Math.sin(theta)).toFixed(2),
+    get toString() {
+      return `${this.x} ${this.y}`
+    }
+  }
+}
+
+module.exports = polarToCartesian;

package/src/handlebars/helpers/prepend.js

@@ -0,0 +1,10 @@
+// prepend Helper
+// Prepends the Given String with the Specified Prefix
+
+function prepend(str, prefix) {
+  return typeof str === 'string' && typeof prefix === 'string'
+    ? (prefix + str)
+    : str;
+};
+
+module.exports = prepend;

package/src/handlebars/helpers/profiles/bar.js

@@ -0,0 +1,45 @@
+// bar Helper
+// This helper is used to provide the path tag for the bar chart
+
+const Handlebars = require("handlebars");
+const polarToCartesian = require("../polarToCartesian");
+
+const P2C = polarToCartesian;
+const PI = Math.PI;
+
+function bar(W, H, brs, angle, options) {
+  // W: width
+  // H: height
+  // brs: border radiuses : {tl: top-left, tr: top-right, bl: bottom-left, br: bottom-right}
+
+  const attributes = [];
+
+  Object.keys(options.hash).forEach((key) => {
+    const escapedKey = Handlebars.escapeExpression(key);
+    const escapedValue = Handlebars.escapeExpression(options.hash[key]);
+    attributes.push(escapedKey + '="' + escapedValue + '"');
+  });
+
+  // Calculate "d" Attribute of Path
+  let dAttr = `M ${P2C(W / 2, angle).toString}`;
+
+  dAttr += `L ${P2C(brs.tl, angle).toString}`;
+  dAttr += brs.tl ? `A ${brs.tl} ${brs.tl} 90 0 0 ${P2C(brs.tl, PI / 2 + angle).toString}` : "";
+
+  dAttr += `L ${P2C(H - brs.bl, PI / 2 + angle).toString}`;
+  dAttr += brs.bl ? `a ${brs.bl} ${brs.bl} 90 0 0 ${P2C(1.414 * brs.bl, PI / 4 + angle).toString}` : "";
+
+  dAttr += `l ${P2C(W - brs.bl - brs.br, angle).toString}`;
+  dAttr += brs.br ? `a ${brs.br} ${brs.br} 90 0 0 ${P2C(1.414 * brs.br, -PI / 4 + angle).toString}` : "";
+
+  dAttr += `l ${P2C(-(H - brs.br - brs.tr), PI / 2 + angle).toString}`;
+  dAttr += brs.tr ? `A ${brs.tr} ${brs.tr} 90 0 0 ${P2C(W - brs.tr, angle).toString}` : "";
+
+  dAttr += `L ${P2C(W / 2, angle).toString}`;
+
+  let result = `<path d="${dAttr}" ${attributes.join(" ")}/>`;
+
+  return new Handlebars.SafeString(result);
+}
+
+module.exports = bar;

package/src/handlebars/helpers/profiles/calcGaugeSidePoints.js

@@ -0,0 +1,34 @@
+// This Function is Used in the Gauge Helper and It's not an Independant Helper Itself.
+
+const polarToCartesian = require("../polarToCartesian");
+const P2C = polarToCartesian;
+
+/**
+ * This function is used to calculate gauge element side points
+ * @param  {number} R - outer radius
+ * @param  {number} r - inner radius
+ * @param  {object} br - border radiuses: {top, bottom}
+ * @param  {number} angle - angle of the end in radians
+ * @param  {boolean} start - whether the corresponding side is start or end of the gauge element
+ * @param  {boolean} direction - direction of the gauge (false: clockwise, true: counterclockwise)
+ */
+function calcGaugeSidePoints(R, r, brs, angle, start, direction) {
+  const alpha = {},
+    theta = {};
+  for (let key in brs) {
+    alpha[key] = Math.asin(brs[key] / (R - brs[key]));
+    theta[key] = angle + (start ^ direction ? 1 : -1) * alpha[key];
+  }
+
+  let points = {
+    P1: P2C(R, theta.top),
+    P2: P2C(r, theta.bottom),
+  };
+
+  if (brs.top) points["P1_PRIME"] = P2C((R - brs.top) * Math.cos(alpha.top), angle);
+  if (brs.bottom) points["P2_PRIME"] = P2C((r + brs.bottom) * Math.cos(alpha.bottom), angle);
+
+  return points;
+}
+
+module.exports = calcGaugeSidePoints;

package/src/handlebars/helpers/profiles/gauge.js

@@ -0,0 +1,61 @@
+// gauge Helper
+// This helper is used to provide the path tag for the gauge chart
+
+const Handlebars = require("handlebars");
+const calcGaugeSidePoints = require("./calcGaugeSidePoints");
+const normalizeAngle = require("../normalizeAngle");
+
+/**
+ * Create path tag for the gauge element used in the profiles
+ * @param  {number} R - outer radius
+ * @param  {number} r - inner radius
+ * @param  {object} brs - border radiuses: {tl: top-left, tr: top-right, bl: bottom-left, br: bottom-right}
+ * @param  {object} angles - angles of sides of the gauge: {start, end}
+ * @param  {boolean} direction - direction of the gauge (false: clockwise, true: counterclockwise)
+ * @param  {object} options
+ */
+function gauge(R, r, brs, angles, direction, options) {
+  // Extract attributes out of options
+  const attributes = [];
+
+  Object.keys(options.hash).forEach((key) => {
+    const escapedKey = Handlebars.escapeExpression(key);
+    const escapedValue = Handlebars.escapeExpression(options.hash[key]);
+    attributes.push(escapedKey + '="' + escapedValue + '"');
+  });
+
+  // Normalize the angles to be in the range (-PI, PI]
+  for (let key in angles) angles[key] = normalizeAngle(angles[key]);
+
+  let isGreater = true;
+  if (angles.end < angles.start) isGreater = false;
+
+  const totalAngle =
+    direction ^ isGreater ? Math.abs(angles.end - angles.start) : 2 * Math.PI - Math.abs(angles.end - angles.start);
+
+  const sidePoints = {
+    start: calcGaugeSidePoints(R, r, { top: brs.tl, bottom: brs.bl }, angles.start, true, direction),
+    end: calcGaugeSidePoints(R, r, { top: brs.tr, bottom: brs.br }, angles.end, false, direction),
+  };
+
+  // Calculate "d" Attribute of Path
+  let dAttr = `M ${sidePoints.start.P1.toString}`;
+
+  dAttr += `A ${R} ${R} 1 ${totalAngle > Math.PI ? 1 : 0} ${direction ? 0 : 1} ${sidePoints.end.P1.toString}`;
+
+  dAttr += brs.tr ? `A ${brs.tr} ${brs.tr} 1 0 ${direction ? 0 : 1} ${sidePoints.end.P1_PRIME.toString}` : "";
+  dAttr += `L ${sidePoints.end.P2_PRIME?.toString || sidePoints.end.P2.toString}`;
+  dAttr += brs.br ? `A ${brs.br} ${brs.br} 1 0 ${direction ? 0 : 1} ${sidePoints.end.P2.toString}` : "";
+
+  dAttr += `A ${r} ${r} 1 ${totalAngle > Math.PI ? 1 : 0} ${direction ? 1 : 0} ${sidePoints.start.P2.toString}`;
+
+  dAttr += brs.bl ? `A ${brs.bl} ${brs.bl} 1 0 ${direction ? 0 : 1} ${sidePoints.start.P2_PRIME.toString}` : "";
+  dAttr += `L ${sidePoints.start.P1_PRIME?.toString || sidePoints.start.P1.toString}`;
+  dAttr += brs.tl ? `A ${brs.tl} ${brs.tl} 1 0 ${direction ? 0 : 1} ${sidePoints.start.P1.toString}` : "";
+
+  let result = `<path d="${dAttr}" ${attributes.join(" ")}/>`;
+
+  return new Handlebars.SafeString(result);
+}
+
+module.exports = gauge;

package/src/handlebars/helpers/profiles/polygon.js

@@ -0,0 +1,40 @@
+// bar Helper
+// This helper is used to provide the path tag for the radar chart
+
+const Handlebars = require("handlebars");
+const polarToCartesian = require("../polarToCartesian");
+
+const P2C = polarToCartesian;
+const PI = Math.PI;
+
+/**
+ * Create path tag for the polygon of the radar chart
+ * @param  {number} n - number of the vertices of the polygon
+ * @param  {array} radiuses - array of radius of the corresponding vertice of the polygon
+ * @param  {number} angle - angle of one vertice in radians
+ * @param  {object} options
+ */
+function polygon(n, radiuses, angle, options) {
+  if (!Array.isArray(radiuses)) radiuses = Array(n).fill(radiuses);
+
+  const attributes = [];
+
+  Object.keys(options.hash).forEach((key) => {
+    const escapedKey = Handlebars.escapeExpression(key);
+    const escapedValue = Handlebars.escapeExpression(options.hash[key]);
+    attributes.push(escapedKey + '="' + escapedValue + '"');
+  });
+
+  // theta is the angle of the polygon
+  const theta = (2 * PI) / n;
+
+  const points = radiuses.map((radius, index) => P2C(radius, angle - index * theta));
+
+  let pointsAttr = points.reduce((accm, point) => accm + `${point.x},${point.y} `, "");
+
+  let result = `<polygon points="${pointsAttr}" ${attributes.join(" ")}/>`;
+
+  return new Handlebars.SafeString(result);
+}
+
+module.exports = polygon;

package/src/handlebars/helpers/reverse.js

@@ -0,0 +1,9 @@
+// reverse Helper
+// This helper is used to reverse an array elements
+
+function reverse(arr) {
+  const newArr = arr.slice();
+  return newArr.reverse();
+}
+
+module.exports = reverse;

package/src/handlebars/helpers/roundToTwo.js

@@ -0,0 +1,8 @@
+// roundToTwo Helper
+// This helper rounds given number to two decimal places
+
+function roundToTwo(num) {
+  return +num.toFixed(2);
+}
+
+module.exports = roundToTwo;

package/src/handlebars/helpers/setVar.js

@@ -0,0 +1,8 @@
+// setVar Helper
+// Setting Variable inside Handlebars
+
+function setVar(varName, varValue, options) {
+  this[varName] = varValue
+}
+
+module.exports = setVar;

package/src/handlebars/helpers/sin.js

@@ -0,0 +1,8 @@
+// sin Helper
+// Calculate Sine of An Angle
+
+function sin(angle) {
+  return Math.sin(angle);
+}
+
+module.exports = sin;

package/src/handlebars/helpers/split.js

@@ -0,0 +1,8 @@
+// split Helper
+// Split string by the given character
+
+function split(str, ch) {
+  return str.split(ch);
+};
+
+module.exports = split;

package/src/handlebars/helpers/tan.js

@@ -0,0 +1,8 @@
+// tan Helper
+// Calculate Tangent of An Angle
+
+function tan(angle) {
+  return Math.tan(angle);
+}
+
+module.exports = tan;

package/src/handlebars/helpers/ternary.js

@@ -0,0 +1,9 @@
+// ternary Helper
+// Evaluates Ternary Conditional Operator
+
+function ternary(boolean, v1, v2, options) {
+  return boolean ? v1 : v2;
+}
+
+module.exports = ternary;
+

package/src/handlebars/helpers/toDeg.js

@@ -0,0 +1,8 @@
+// toDeg Helper
+// Convert an Angle to Degree
+
+function toDeg(angle) {
+  return angle * 180 / Math.PI;
+}
+
+module.exports = toDeg;

package/src/handlebars/helpers/toRad.js

@@ -0,0 +1,8 @@
+// toRad Helper
+// Convert an Angle to Radians
+
+function toRad(angle) {
+  return angle * Math.PI / 180;
+}
+
+module.exports = toRad;

package/src/handlebars/helpers/withGroup.js

@@ -0,0 +1,20 @@
+// withGroup Helper
+// Block Helper that Groups Array Elements by Given Group Size
+
+function withGroup(array, size, options) {
+  var result = '';
+  if (Array.isArray(array) && array.length > 0) {
+    var subcontext = [];
+    for (var i = 0; i < array.length; i++) {
+      if (i > 0 && (i % size) === 0) {
+        result += options.fn(subcontext);
+        subcontext = [];
+      }
+      subcontext.push(array[i]);
+    }
+    result += options.fn(subcontext);
+  }
+  return result;
+};
+
+module.exports = withGroup;

package/src/handlebars/helpers/wrapOnNewline.js

@@ -0,0 +1,11 @@
+// wrapOnNewline Helper
+// Used to split a string by \n to create lines
+
+const Handlebars = require("handlebars");
+
+function wrapOnNewline(string) {
+  string = string.replace(/\\n/gm, '\n');
+  return string.split(/\n/gm);
+}
+
+module.exports = wrapOnNewline;

package/src/handlebars/helpers.js

@@ -0,0 +1,86 @@
+const isArray = require("./helpers/isArray");
+const addCommas = require("./helpers/addCommas");
+const boolean = require("./helpers/boolean");
+const math = require("./helpers/math");
+const modulo = require("./helpers/modulo");
+const ternary = require("./helpers/ternary");
+const lineWrap = require("./helpers/lineWrap");
+const wrapOnNewline = require("./helpers/wrapOnNewline");
+const ellipsisLines = require("./helpers/ellipsisLines");
+const ellipsisChars = require("./helpers/ellipsisChars");
+const setVar = require("./helpers/setVar");
+const assignGlobal = require("./helpers/assignGlobal");
+const forLoop = require("./helpers/forLoop");
+const concat = require("./helpers/concat");
+const sin = require("./helpers/sin");
+const cos = require("./helpers/cos");
+const tan = require("./helpers/tan");
+const toDeg = require("./helpers/toDeg");
+const toRad = require("./helpers/toRad");
+const roundToTwo = require("./helpers/roundToTwo");
+const objectEntries = require("./helpers/objectEntries");
+const object = require("./helpers/object");
+const array = require("./helpers/array");
+const reverse = require("./helpers/reverse");
+const prepend = require("./helpers/prepend");
+const polarToCartesian = require("./helpers/polarToCartesian");
+const abs = require("./helpers/abs");
+const getArrOfProp = require("./helpers/getArrOfProp");
+const displacePoint = require("./helpers/displacePoint");
+const normalizeAngle = require("./helpers/normalizeAngle");
+const withGroup = require("./helpers/withGroup");
+const join = require("./helpers/join");
+const split = require("./helpers/split");
+const first = require("./helpers/first");
+const last = require("./helpers/last");
+const ceil = require("./helpers/ceil");
+const floor = require("./helpers/floor");
+
+const polygon = require("./helpers/profiles/polygon");
+const gauge = require("./helpers/profiles/gauge");
+const bar = require("./helpers/profiles/bar");
+
+const helpers = {
+  isArray,
+  addCommas,
+  boolean,
+  math,
+  modulo,
+  ternary,
+  lineWrap,
+  wrapOnNewline,
+  ellipsisLines,
+  ellipsisChars,
+  setVar,
+  assignGlobal,
+  forLoop,
+  concat,
+  sin,
+  cos,
+  tan,
+  toDeg,
+  toRad,
+  roundToTwo,
+  objectEntries,
+  object,
+  array,
+  reverse,
+  prepend,
+  polarToCartesian,
+  abs,
+  getArrOfProp,
+  displacePoint,
+  normalizeAngle,
+  withGroup,
+  join,
+  split,
+  first,
+  last,
+  ceil,
+  floor,
+  polygon,
+  gauge,
+  bar,
+};
+
+module.exports = helpers;