@pie-element/number-line 11.3.4-next.0 → 12.0.0-beta.0

package/lib/number-line/graph/tick-utils.js

@@ -1,45 +1,26 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.zeroBasedRange = exports.zbrErrorMessage = exports.snapTo = exports.snapElements = exports.simpleRange = exports.normalizeTicks = exports.labelMultiplier = exports.isMultiple = exports.getMinorLimits = exports.generateMinorValues = exports.generateMajorValuesForMinor = exports.fractionTickValues = exports.fractionSnapTo = exports.fractionRange = exports.fraction = exports.decimalTickValues = exports.closeTo = exports.buildTickDataAsFractions = exports.buildTickData = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var math = _interopRequireWildcard(require("mathjs"));
-
 var _uniqWith = _interopRequireDefault(require("lodash/uniqWith"));
-
 var _isObject = _interopRequireDefault(require("lodash/isObject"));
-
 var _isNumber = _interopRequireDefault(require("lodash/isNumber"));
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 // All these functions are duplicated in  controller/src/tickUtils
 
 /*This will store the possible decimal tick values*/
-var decimalTickValues = [0.001, 0.01, 0.02, 0.04, 0.05, 0.1, 0.125, 0.2, 0.25, 0.5];
+const decimalTickValues = exports.decimalTickValues = [0.001, 0.01, 0.02, 0.04, 0.05, 0.1, 0.125, 0.2, 0.25, 0.5];
+
 /*This will store the possible fraction tick values*/
+const fractionTickValues = exports.fractionTickValues = ['1/1000', '1/100', '1/64', '1/50', '1/32', '1/25', '1/20', '1/16', '1/15', '1/12', '1/10', '1/9', '1/8', '1/7', '1/6', '1/5', '1/4', '1/3', '1/2'];
 
-exports.decimalTickValues = decimalTickValues;
-var fractionTickValues = ['1/1000', '1/100', '1/64', '1/50', '1/32', '1/25', '1/20', '1/16', '1/15', '1/12', '1/10', '1/9', '1/8', '1/7', '1/6', '1/5', '1/4', '1/3', '1/2'];
 /*This const will store possible multiplier for label interval that needs to be multiplied
 with tick interval with denominator represented with object key.*/
-
-exports.fractionTickValues = fractionTickValues;
-var labelMultiplier = {
+const labelMultiplier = exports.labelMultiplier = {
   1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
   2: [1, 2, 4, 6, 8, 10],
   3: [1, 3, 6, 9],
@@ -61,89 +42,71 @@ var labelMultiplier = {
   100: [1, 2, 4, 5, 10],
   1000: [1, 2, 4, 5, 8, 10]
 };
-exports.labelMultiplier = labelMultiplier;
-
-var fractionRange = function fractionRange(start, end, interval) {
-  var m = math.mod(math.abs(start), math.abs(interval));
-
+const fractionRange = (start, end, interval) => {
+  const m = math.mod(math.abs(start), math.abs(interval));
   if (!math.equal(m, 0)) {
     throw new Error('start point must be divisible by interval');
   }
-
   if (math.equal(start, end)) {
     return [];
   }
-
-  var e = math.subtract(end, math.mod(end, math.abs(interval)));
-  var direction = math.larger(interval, 0) ? 'positive' : 'negative';
-
+  const e = math.subtract(end, math.mod(end, math.abs(interval)));
+  const direction = math.larger(interval, 0) ? 'positive' : 'negative';
   if (direction === 'negative' && math.largerEq(end, start)) {
     throw new Error('start must be > than end when doing a negative decrement');
   }
-
   if (direction === 'positive' && math.smallerEq(end, start)) {
     throw new Error('start must be < end when doing increments');
   }
-
-  var compareFn = direction === 'positive' ? math.smallerEq : math.equal(e, end) ? math.largerEq : math.larger;
-  var out = [];
-  var next = start;
-
+  let compareFn;
+  if (direction === 'positive') {
+    compareFn = math.smallerEq;
+  } else if (math.equal(e, end)) {
+    compareFn = math.largerEq;
+  } else {
+    compareFn = math.larger;
+  }
+  const out = [];
+  let next = start;
   while (compareFn(next, e)) {
     out.push(next);
     next = math.add(next, interval);
   }
-
   return out;
 };
-
 exports.fractionRange = fractionRange;
-
-var zbrErrorMessage = function zbrErrorMessage(start, end) {
-  return "Can only do a positive or negative range, but got: start: ".concat(start, " and end:").concat(end);
-};
-
+const zbrErrorMessage = (start, end) => `Can only do a positive or negative range, but got: start: ${start} and end:${end}`;
 exports.zbrErrorMessage = zbrErrorMessage;
-
-var zeroBasedRange = function zeroBasedRange(start, end, interval) {
+const zeroBasedRange = (start, end, interval) => {
   start = math.fraction(start);
   end = math.fraction(end);
   interval = math.fraction(interval);
-  var length = math.abs(math.subtract(end, start));
-
+  const length = math.abs(math.subtract(end, start));
   if (math.larger(length, math.abs(end))) {
     throw new Error(zbrErrorMessage(start, end));
   }
-
-  var a = {
+  const a = {
     start: math.abs(start),
     end: math.abs(end),
     interval: math.abs(interval),
     multiplier: math.smaller(interval, 0) ? -1 : 1
   };
-  var m = math.mod(a.start, a.interval);
-  var s = math.larger(m, 0) ? math.add(math.subtract(a.start, m), a.interval) : a.start;
-  var r = fractionRange(s, a.end, a.interval);
-  var out = a.multiplier === -1 ? r.map(function (v) {
-    return math.multiply(v, -1);
-  }) : r;
-
+  const m = math.mod(a.start, a.interval);
+  const s = math.larger(m, 0) ? math.add(math.subtract(a.start, m), a.interval) : a.start;
+  const r = fractionRange(s, a.end, a.interval);
+  const out = a.multiplier === -1 ? r.map(v => math.multiply(v, -1)) : r;
   if (math.smaller(interval, 0)) {
     out.reverse();
   }
-
   return out;
 };
-
 exports.zeroBasedRange = zeroBasedRange;
-
-var fmin = function fmin(a, b) {
+const fmin = (a, b) => {
   a = math.fraction(a);
   b = math.fraction(b);
   return math.smaller(a, b) ? a : b;
 };
-
-var fmax = function fmax(a, b) {
+const fmax = (a, b) => {
   a = math.fraction(a);
   b = math.fraction(b);
   return math.larger(a, b) ? a : b;
@@ -153,160 +116,136 @@ var fmax = function fmax(a, b) {
  * such that it was hard to round the numbers.
  * This is a more simplistic version but makes rounding work.
  */
-
-
-var simpleRange = function simpleRange(start, end, interval) {
+const simpleRange = (start, end, interval) => {
   start = math.fraction(start);
   end = math.fraction(end);
   interval = math.fraction(interval);
-  var positiveRange = math.larger(end, 0) ? zeroBasedRange(fmax(0, start), end, interval) : [];
-  var negativeRange = math.smaller(start, 0) ? zeroBasedRange(fmin(0, end), start, math.multiply(interval, -1)) : [];
-  var together = negativeRange.concat(positiveRange);
-  var out = (0, _uniqWith["default"])(together, math.equal);
+  const positiveRange = math.larger(end, 0) ? zeroBasedRange(fmax(0, start), end, interval) : [];
+  const negativeRange = math.smaller(start, 0) ? zeroBasedRange(fmin(0, end), start, math.multiply(interval, -1)) : [];
+  let together = negativeRange.concat(positiveRange);
+  const out = (0, _uniqWith.default)(together, math.equal);
   return out;
 };
-
 exports.simpleRange = simpleRange;
-
-var closeTo = function closeTo(a, b, precision) {
+const closeTo = (a, b, precision) => {
   precision = precision || 2;
-  var expectedDiff = Math.pow(10, -precision) / 2;
-  var receivedDiff = Math.abs(a - b);
+  const expectedDiff = Math.pow(10, -precision) / 2;
+  const receivedDiff = Math.abs(a - b);
   return receivedDiff < expectedDiff;
 };
-
 exports.closeTo = closeTo;
-
-var limit = function limit(v, min, max) {
+const limit = (v, min, max) => {
   if (math.smaller(fraction(v), fraction(min))) {
     return min;
   }
-
   if (math.larger(fraction(v), fraction(max))) {
     return max;
   }
-
   return v;
 };
+
 /*
  * Function to get tick interval limits based on min, max and width entered by the user.
  * @param domain object containing max and min value.
  * @param width number represents width of number line.
  * */
-
-
-var getMinorLimits = function getMinorLimits(domain, width) {
-  var end = domain.max - domain.min;
-  var min = math.number(math.multiply(10, math.divide(math.fraction(end), width)));
-  var max = math.number(math.multiply(20, min));
+const getMinorLimits = (domain, width) => {
+  const end = domain.max - domain.min;
+  const min = math.number(math.multiply(10, math.divide(math.fraction(end), width)));
+  const max = math.number(math.multiply(20, min));
   return {
     min: min,
     max: max
   };
 };
-
 exports.getMinorLimits = getMinorLimits;
-
-var isMultiple = function isMultiple(multiple, src) {
-  var mod = math.mod(multiple, src);
+const isMultiple = (multiple, src) => {
+  const mod = math.mod(multiple, src);
   return math.equal(mod, 0);
 };
+
 /**
  * Accepts a fraction object {n,d,s} or number.
  * @param {*} v
  * @return mathjs.fraction
  */
-
-
 exports.isMultiple = isMultiple;
-
-var fraction = function fraction(v) {
-  if ((0, _isObject["default"])(v)) {
+const fraction = v => {
+  if ((0, _isObject.default)(v)) {
     return math.fraction(v.n * v.s, v.d);
-  } else if ((0, _isNumber["default"])(v)) {
+  } else if ((0, _isNumber.default)(v)) {
     return math.fraction(v);
   }
 };
-
 exports.fraction = fraction;
-
-var normalizeTicks = function normalizeTicks(domain, width, ticks, opts) {
-  var useLimit = opts ? opts.limit !== false : true;
-  var minorLimits = getMinorLimits(domain, width);
-  var minor = useLimit ? limit(fraction(ticks.minor), minorLimits.min, minorLimits.max) : fraction(ticks.minor);
-  var major = useLimit ? limit(fraction(ticks.major), minor, math.multiply(minor, 20)) : fraction(ticks.major);
-  var isMajorMultiple = isMultiple(major, minor);
-
+const normalizeTicks = (domain, width, ticks, opts) => {
+  const useLimit = opts ? opts.limit !== false : true;
+  const minorLimits = getMinorLimits(domain, width);
+  const minor = useLimit ? limit(fraction(ticks.minor), minorLimits.min, minorLimits.max) : fraction(ticks.minor);
+  const major = useLimit ? limit(fraction(ticks.major), minor, math.multiply(minor, 20)) : fraction(ticks.major);
+  const isMajorMultiple = isMultiple(major, minor);
   if (!isMajorMultiple) {
-    var multiplier = math.divide(major, minor);
-    var multiplyBy = multiplier <= 2 ? 2 : Math.round(multiplier); // major must be a multiple of minor
+    const multiplier = math.divide(major, minor);
+    const multiplyBy = multiplier <= 2 ? 2 : Math.round(multiplier);
 
+    // major must be a multiple of minor
     return {
-      minor: minor,
+      minor,
       major: math.multiply(minor, multiplyBy)
     };
   }
-
   return {
-    major: major,
-    minor: minor
+    major,
+    minor
   };
 };
+
 /**
  * Build ticks as an array of mathjs Fractions
  */
-
-
 exports.normalizeTicks = normalizeTicks;
-
-var buildTickDataAsFractions = function buildTickDataAsFractions(domain, width, ticks, opts) {
+const buildTickDataAsFractions = (domain, width, ticks, opts) => {
   ticks = normalizeTicks(domain, width, ticks, opts);
-  var rng = simpleRange(domain.min, domain.max, ticks.minor);
-  var o = rng.filter(function (x) {
-    return math.smallerEq(x, math.fraction(domain.max));
-  }).map(function (x) {
-    var type = 'minor';
-    var modulo = math.mod(x, ticks.major);
-
+  const rng = simpleRange(domain.min, domain.max, ticks.minor);
+  const o = rng.filter(x => math.smallerEq(x, math.fraction(domain.max))).map(x => {
+    let type = 'minor';
+    const modulo = math.mod(x, ticks.major);
     if (closeTo(math.number(modulo), 0)) {
       type = 'major';
     }
-
     return {
-      x: x,
-      type: type
+      x,
+      type
     };
   });
   return o;
 };
+
 /*
  * This function will generate tick interval values based on min and max limits of ticks.
  * @param minorLimits object containing min and max values
  * @return out object containing three arrays 1. fraction values, 2. decimal values,
  * */
-
-
 exports.buildTickDataAsFractions = buildTickDataAsFractions;
-
-var generateMinorValues = function generateMinorValues(minorLimits) {
-  var out = {
+const generateMinorValues = minorLimits => {
+  let out = {
     fraction: [],
     decimal: []
   };
-  decimalTickValues.forEach(function (value) {
+  decimalTickValues.forEach(value => {
     if (value >= minorLimits.min && value <= minorLimits.max) {
       out.decimal.push(value);
     }
   });
-  fractionTickValues.forEach(function (value) {
-    var decimalValue = math.number(math.fraction(value));
-
+  fractionTickValues.forEach(value => {
+    let decimalValue = math.number(math.fraction(value));
     if (decimalValue >= minorLimits.min && decimalValue <= minorLimits.max) {
       out.fraction.push(value);
     }
   });
   return out;
 };
+
 /*
  * This function will generate label interval values for provided tick interval value.
  * @param minor number representing tick interval value.
@@ -314,126 +253,98 @@ var generateMinorValues = function generateMinorValues(minorLimits) {
  * @param width number representing width of number line.
  * @return out object containing three arrays 1. fraction values, 2. decimal values,
  * */
-
-
 exports.generateMinorValues = generateMinorValues;
-
-var generateMajorValuesForMinor = function generateMajorValuesForMinor(minor, domain, width) {
-  var out = {
+const generateMajorValuesForMinor = (minor, domain, width) => {
+  let out = {
     decimal: [],
     fraction: []
   };
-  var fraction = math.fraction(math.number(math.number(minor)));
-  var n = fraction.n;
-  var d = fraction.d;
-
+  let fraction = math.fraction(math.number(math.number(minor)));
+  let n = fraction.n;
+  let d = fraction.d;
   if (n >= 1 && d === 1) {
-    for (var i = 1; i <= 10; i++) {
-      var num = math.number(math.multiply(n, i)); //Here we check if this major value can plot at least 2 points on number line.
-
-      var ticksData = {
+    for (let i = 1; i <= 10; i++) {
+      let num = math.number(math.multiply(n, i));
+      //Here we check if this major value can plot at least 2 points on number line.
+      let ticksData = {
         minor: minor,
         major: num
       };
-      var output = buildTickData(domain, width, ticksData, {
+      let output = buildTickData(domain, width, ticksData, {
         fraction: undefined
       });
-
-      if (output.filter(function (x) {
-        return x.type === 'major';
-      }).length > 1) {
+      if (output.filter(x => x.type === 'major').length > 1) {
         out.fraction.push(num.toString());
         out.decimal.push(num);
       }
     }
   } else {
-    for (var multiplierKey in labelMultiplier[d]) {
-      var _num = math.multiply(math.fraction(n, d), labelMultiplier[d][multiplierKey]); //Here we check if this major value can plot at least 2 points on number line.
-
-
-      var _ticksData = {
+    for (const multiplierKey in labelMultiplier[d]) {
+      let num = math.multiply(math.fraction(n, d), labelMultiplier[d][multiplierKey]);
+      //Here we check if this major value can plot at least 2 points on number line.
+      let ticksData = {
         minor: minor,
-        major: math.number(_num)
+        major: math.number(num)
       };
-
-      var _output = buildTickData(domain, width, _ticksData, {
+      let output = buildTickData(domain, width, ticksData, {
         fraction: undefined
       });
-
-      if (_output.filter(function (x) {
-        return x.type === 'major';
-      }).length > 1) {
-        if (_num.d !== 1) {
-          out.fraction.push(_num.n + '/' + _num.d);
+      if (output.filter(x => x.type === 'major').length > 1) {
+        if (num.d !== 1) {
+          out.fraction.push(num.n + '/' + num.d);
         } else {
-          out.fraction.push(_num.n.toString());
+          out.fraction.push(num.n.toString());
         }
-
-        out.decimal.push(math.number(_num));
+        out.decimal.push(math.number(num));
       }
     }
   }
-
   return out;
 };
-
 exports.generateMajorValuesForMinor = generateMajorValuesForMinor;
-
-var buildTickData = function buildTickData(domain, width, ticks, opts) {
-  var result = buildTickDataAsFractions(domain, width, ticks, opts);
-  var out = result.map(function (o) {
-    return opts.fraction ? o : _objectSpread(_objectSpread({}, o), {}, {
-      x: math.number(o.x) || 0
-    });
+const buildTickData = (domain, width, ticks, opts) => {
+  const result = buildTickDataAsFractions(domain, width, ticks, opts);
+  const out = result.map(o => opts.fraction ? o : {
+    ...o,
+    x: math.number(o.x) || 0
   });
   return out;
 };
-
 exports.buildTickData = buildTickData;
-
-var fractionSnapTo = function fractionSnapTo(min, max, interval, value) {
+const fractionSnapTo = (min, max, interval, value) => {
   value = fmax(fmin(value, max), min);
-  var mod = value.mod(interval);
-  var v;
-  var half = interval.div(2);
-
+  const mod = value.mod(interval);
+  let v;
+  const half = interval.div(2);
   if (math.largerEq(math.abs(mod), half)) {
-    var d = interval.sub(math.abs(mod));
-    var fn = math.largerEq(value, 0) ? 'add' : 'sub';
+    const d = interval.sub(math.abs(mod));
+    const fn = math.largerEq(value, 0) ? 'add' : 'sub';
     v = value[fn](d);
   } else {
-    var fn2 = math.largerEq(value, 0) ? 'sub' : 'add';
+    const fn2 = math.largerEq(value, 0) ? 'sub' : 'add';
     v = value[fn2](math.abs(mod));
   }
-
   return v;
 };
-
 exports.fractionSnapTo = fractionSnapTo;
-
-var snapTo = function snapTo(min, max, interval, value) {
-  var out = fractionSnapTo(math.fraction(min), math.fraction(max), math.fraction(interval), math.fraction(value));
+const snapTo = (min, max, interval, value) => {
+  const out = fractionSnapTo(math.fraction(min), math.fraction(max), math.fraction(interval), math.fraction(value));
   return math.number(out);
 };
-
 exports.snapTo = snapTo;
-
-var snapElements = function snapElements(domain, ticks, elements) {
-  return elements.map(function (e) {
-    var size = Number.isFinite(e.size) ? snapTo(0, e.size, ticks.minor, e.size) : undefined;
-    var domainPosition = snapTo(domain.min, domain.max, ticks.minor, e.domainPosition);
-
-    var out = _objectSpread(_objectSpread({}, e), {}, {
-      domainPosition: domainPosition
-    });
-
+const snapElements = (domain, ticks, elements) => {
+  return elements.map(e => {
+    const size = Number.isFinite(e.size) ? snapTo(0, e.size, ticks.minor, e.size) : undefined;
+    const domainPosition = snapTo(domain.min, domain.max, ticks.minor, e.domainPosition);
+    const out = {
+      ...e,
+      domainPosition
+    };
     if (Number.isFinite(size)) {
       out.size = size;
     }
-
     return out;
   });
 };
-
 exports.snapElements = snapElements;
 //# sourceMappingURL=tick-utils.js.map