@pie-element/graphing-solution-set 4.3.4-next.3 → 5.0.0-beta.0

package/configure/lib/utils.js

@@ -1,35 +1,19 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.pointInsidePolygon = exports.getLabelValues = exports.getGridValues = exports.findSectionsInSolutionSet = exports.filterPlotableMarks = exports.checkIfLinesAreAdded = exports.applyConstraints = exports.VALID_LABEL_VALUES = void 0;
-
-var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
-
-var _excluded = ["angle"];
-
-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; }
-
 /*Valid grid values*/
-var VALID_GRID_VALUES = [0.01, 0.02, 0.04, 0.05, 0.0625, 0.1, 0.125, 0.2, 0.25, 0.5, 1, 2, 3, 4, 5, 8, 10, 12, 15, 20, 40, 50, 64, 100, 500, 1000]; // same as VALID_GRID_VALUES but next values are excluded: 0.04, 0.0625, 0.125, 3, 4, 8, 12, 15, 40, 64
+const VALID_GRID_VALUES = [0.01, 0.02, 0.04, 0.05, 0.0625, 0.1, 0.125, 0.2, 0.25, 0.5, 1, 2, 3, 4, 5, 8, 10, 12, 15, 20, 40, 50, 64, 100, 500, 1000];
 
-var PREFERRED_VALID_GRID_VALUES = [0.01, 0.02, 0.05, 0.1, 0.2, 0.25, 0.5, 1, 2, 5, 10, 20, 50, 100, 500, 1000];
-/*Valid label values*/
+// same as VALID_GRID_VALUES but next values are excluded: 0.04, 0.0625, 0.125, 3, 4, 8, 12, 15, 40, 64
+const PREFERRED_VALID_GRID_VALUES = [0.01, 0.02, 0.05, 0.1, 0.2, 0.25, 0.5, 1, 2, 5, 10, 20, 50, 100, 500, 1000];
 
-var VALID_LABEL_VALUES = {
+/*Valid label values*/
+const VALID_LABEL_VALUES = exports.VALID_LABEL_VALUES = {
   0.01: [0, 0.01, 0.02, 0.04, 0.05, 0.1],
   0.02: [0, 0.02, 0.04, 0.1],
   0.04: [0, 0.04, 0.08, 0.16, 0.2],
@@ -57,35 +41,27 @@ var VALID_LABEL_VALUES = {
   500: [0, 500, 1000, 2500],
   1000: [0, 1000, 2000, 4000, 5000]
 };
+
 /*
  * Function to get grid values
  * @param {Object} axis - axis object
  * @param {Number} size - size of the axis
  * @param {Boolean} prefferedValues - flag to get preffered values
  * */
-
-exports.VALID_LABEL_VALUES = VALID_LABEL_VALUES;
-
-var getGridValues = function getGridValues(axis, size) {
-  var prefferedValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var minValue = 10 * (axis.max - axis.min) / size;
-  var maxValue = minValue * 10;
-  var values = prefferedValues ? PREFERRED_VALID_GRID_VALUES : VALID_GRID_VALUES;
-  return values.filter(function (value) {
-    return value >= minValue && value <= maxValue;
-  });
+const getGridValues = (axis, size, prefferedValues = false) => {
+  const minValue = 10 * (axis.max - axis.min) / size;
+  const maxValue = minValue * 10;
+  const values = prefferedValues ? PREFERRED_VALID_GRID_VALUES : VALID_GRID_VALUES;
+  return values.filter(value => value >= minValue && value <= maxValue);
 };
+
 /*
  * Function to get label values
  * @param {Number} value - value of the axis step
  * */
-
-
 exports.getGridValues = getGridValues;
+const getLabelValues = value => VALID_LABEL_VALUES[value] || [];
 
-var getLabelValues = function getLabelValues(value) {
-  return VALID_LABEL_VALUES[value] || [];
-};
 /*
  * Function to apply constraints
  * @param {Object} axis - axis object
@@ -93,114 +69,87 @@ var getLabelValues = function getLabelValues(value) {
  * @param {Array} oldGridValues - old grid values
  * @param {Array} oldLabelValues - old label values
  * */
-
-
 exports.getLabelValues = getLabelValues;
-
-var applyConstraints = function applyConstraints(axis, size, oldGridValues, oldLabelValues) {
-  var gridValues = getGridValues(axis, size);
-  var labelValues = getLabelValues(axis.step);
-
-  if (!(0, _isEqual["default"])(oldGridValues, gridValues) && !gridValues.includes(axis.step)) {
-    var preferredValues = getGridValues(axis, size, true);
-    var lowestValue = preferredValues[0] || 1;
+const applyConstraints = (axis, size, oldGridValues, oldLabelValues) => {
+  const gridValues = getGridValues(axis, size);
+  let labelValues = getLabelValues(axis.step);
+  if (!(0, _isEqual.default)(oldGridValues, gridValues) && !gridValues.includes(axis.step)) {
+    const preferredValues = getGridValues(axis, size, true);
+    const lowestValue = preferredValues[0] || 1;
     axis.step = lowestValue;
     labelValues = getLabelValues(lowestValue);
-
     if (!labelValues.includes(axis.labelStep)) {
       axis.labelStep = lowestValue;
     }
-
     return {
-      gridValues: gridValues,
-      labelValues: labelValues
+      gridValues,
+      labelValues
     };
   }
-
-  if (!(0, _isEqual["default"])(oldLabelValues, labelValues) && !labelValues.includes(axis.labelStep)) {
+  if (!(0, _isEqual.default)(oldLabelValues, labelValues) && !labelValues.includes(axis.labelStep)) {
     axis.labelStep = axis.step;
   }
-
   return {
-    gridValues: gridValues,
-    labelValues: labelValues
+    gridValues,
+    labelValues
   };
-}; // also used in pie-lib/graphing/utils as 'getTickValues'
+};
 
+// also used in pie-lib/graphing/utils as 'getTickValues'
 /*
  * Function to get plotable points
  * @param {Object} prop - axis object
  * */
-
-
 exports.applyConstraints = applyConstraints;
-
-var getPlotablePoints = function getPlotablePoints(prop) {
-  var tickValues = [];
-  var tickVal = 0;
-
+const getPlotablePoints = prop => {
+  const tickValues = [];
+  let tickVal = 0;
   while (tickVal >= prop.min && tickValues.indexOf(tickVal) < 0) {
     tickValues.push(tickVal);
     tickVal = Math.round((tickVal - prop.step) * 10000) / 10000;
   }
-
   tickVal = Math.round(prop.step * 10000) / 10000;
-
   while (tickVal <= prop.max && tickValues.indexOf(tickVal) < 0) {
     tickValues.push(tickVal);
     tickVal = Math.round((tickVal + prop.step) * 10000) / 10000;
-  } // return only ticks that are inside the min-max interval
-
-
+  }
+  // return only ticks that are inside the min-max interval
   if (tickValues) {
-    return tickValues.filter(function (tV) {
-      return tV >= prop.min && tV <= prop.max;
-    });
+    return tickValues.filter(tV => tV >= prop.min && tV <= prop.max);
   }
-
   return [];
 };
+
 /*
  * Function to get plotable marks
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * @param {Object} answers - answers object
  * */
-
-
-var filterPlotableMarks = function filterPlotableMarks(domain, range, answers) {
-  var domainValues = getPlotablePoints(domain);
-  var rangeValues = getPlotablePoints(range);
-
-  var isPointPlotable = function isPointPlotable(x, y) {
-    return domainValues.includes(x) && rangeValues.includes(y);
-  };
-
-  return Object.entries(answers || {}).reduce(function (newAnswers, _ref) {
-    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
-        key = _ref2[0],
-        answer = _ref2[1];
-
-    newAnswers[key] = _objectSpread(_objectSpread({}, answer), {}, {
-      marks: (answer.marks || []).filter(function (mark) {
+const filterPlotableMarks = (domain, range, answers) => {
+  const domainValues = getPlotablePoints(domain);
+  const rangeValues = getPlotablePoints(range);
+  const isPointPlotable = (x, y) => domainValues.includes(x) && rangeValues.includes(y);
+  return Object.entries(answers || {}).reduce((newAnswers, [key, answer]) => {
+    newAnswers[key] = {
+      ...answer,
+      marks: (answer.marks || []).filter(mark => {
         if (mark.type === 'point') {
           return isPointPlotable(mark.x, mark.y);
         }
-
         if (mark.type === 'polygon') {
-          return !mark.points.find(function (point) {
-            return !isPointPlotable(point.x, point.y);
-          });
+          return !mark.points.find(point => !isPointPlotable(point.x, point.y));
         }
-
-        var from = mark.from || mark.root;
-        var to = mark.to || mark.edge;
+        const from = mark.from || mark.root;
+        const to = mark.to || mark.edge;
         return mark.building ? isPointPlotable(from.x, from.y) : isPointPlotable(from.x, from.y) && isPointPlotable(to.x, to.y);
       })
-    });
+    };
     return newAnswers;
   }, {});
-}; //////////////////////////////////////////////////////////////////////////////////
+};
+
+//////////////////////////////////////////////////////////////////////////////////
 // BELOW FUNCTIONS ARE USED IN src/utils as well
 //////////////////////////////////////////////////////////////////////////////////
 
@@ -209,38 +158,33 @@ var filterPlotableMarks = function filterPlotableMarks(domain, range, answers) {
  * @param {Object} a - point a
  * @param {Object} b - point b
  * */
-
-
 exports.filterPlotableMarks = filterPlotableMarks;
-
-var distance = function distance(a, b) {
-  return Number(Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2)).toFixed(3));
+const distance = (a, b) => {
+  return Number(Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2).toFixed(3));
 };
+
 /*
  * Function to check if a point lies on edges of a polygon
  * @param {Object} point - point object
  * @param {Array} polygon - polygon points array
  * */
-
-
-var pointInPolygon = function pointInPolygon(point, polygon) {
-  var c = point;
-  var inside = false;
-  var clonePolygon = (0, _toConsumableArray2["default"])(polygon);
+const pointInPolygon = (point, polygon) => {
+  let c = point;
+  let inside = false;
+  let clonePolygon = [...polygon];
   clonePolygon.push(polygon[0]);
-
-  for (var i = 0; i < clonePolygon.length - 1; i++) {
-    var a = clonePolygon[i];
-    var b = clonePolygon[i + 1]; // check if point is on the edge
-
+  for (let i = 0; i < clonePolygon.length - 1; i++) {
+    let a = clonePolygon[i];
+    let b = clonePolygon[i + 1];
+    // check if point is on the edge
     if (distance(a, c) + distance(c, b) === distance(a, b)) {
       inside = true;
       break;
     }
   }
-
   return inside;
 };
+
 /*
  * Function to get the intersection point of two lines
  * @param {Number} x1 - x coordinate of point 1 of line 1
@@ -252,95 +196,79 @@ var pointInPolygon = function pointInPolygon(point, polygon) {
  * @param {Number} x4 - x coordinate of point 2 of line 2
  * @param {Number} y4 - y coordinate of point 2 of line 2
  * */
-
-
-var lineIntersect = function lineIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {
-  var ua,
-      denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
-
+const lineIntersect = (x1, y1, x2, y2, x3, y3, x4, y4) => {
+  let ua,
+    denominator = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
   if (denominator === 0) {
     return null;
   }
-
   ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator;
   return {
     x: Number((x1 + ua * (x2 - x1)).toFixed(3)),
     y: Number((y1 + ua * (y2 - y1)).toFixed(3))
   };
 };
+
 /*
  * Check if a point is inside the graph
  * @param {Object} point - point object
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var isPointInsideGraph = function isPointInsideGraph(point, domain, range) {
+const isPointInsideGraph = (point, domain, range) => {
   return point.x > domain.min && point.x < domain.max && point.y > range.min && point.y < range.max;
 };
+
 /*
  * Check if a point is on or inside the graph
  * @param {Object} point - point object
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var isPointOnOrInsideGraph = function isPointOnOrInsideGraph(point, domain, range) {
+const isPointOnOrInsideGraph = (point, domain, range) => {
   return point.x >= domain.min && point.x <= domain.max && point.y >= range.min && point.y <= range.max;
 };
+
 /*
  * Find the intersection point of a mark with the graph
  * @param {Object} mark - mark object
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var findIntersectionPointForMark = function findIntersectionPointForMark(mark, domain, range) {
-  var intersectionPoint = [];
-  var tempData = [[domain.max, range.max, domain.max, range.min], [domain.min, range.max, domain.min, range.min], [domain.min, range.max, domain.max, range.max], [domain.min, range.min, domain.max, range.min]];
-
-  for (var i = 0; i < tempData.length; i++) {
-    var intersection = lineIntersect(mark.from.x, mark.from.y, mark.to.x, mark.to.y, tempData[i][0], tempData[i][1], tempData[i][2], tempData[i][3]);
-
+const findIntersectionPointForMark = (mark, domain, range) => {
+  let intersectionPoint = [];
+  let tempData = [[domain.max, range.max, domain.max, range.min], [domain.min, range.max, domain.min, range.min], [domain.min, range.max, domain.max, range.max], [domain.min, range.min, domain.max, range.min]];
+  for (let i = 0; i < tempData.length; i++) {
+    let intersection = lineIntersect(mark.from.x, mark.from.y, mark.to.x, mark.to.y, tempData[i][0], tempData[i][1], tempData[i][2], tempData[i][3]);
     if (intersection && isPointOnOrInsideGraph(intersection, domain, range)) {
       intersectionPoint.push(intersection);
     }
   }
-
   return intersectionPoint;
 };
+
 /*
  * Sort points in clockwise direction for a polygon
  * @param {Array} points - points array
  * */
-
-
-var sortPointsClockWise = function sortPointsClockWise(points) {
+const sortPointsClockWise = points => {
   // Find min max to get center and Sort from top to bottom
-  points.sort(function (a, b) {
-    return a.y - b.y;
-  }); // Get center y
-
-  var cy = (points[0].y + points[points.length - 1].y) / 2; // Sort from right to left
-
-  points.sort(function (a, b) {
-    return b.x - a.x;
-  }); // Get center x
-
-  var cx = (points[0].x + points[points.length - 1].x) / 2; // Center point
-
-  var center = {
+  points.sort((a, b) => a.y - b.y);
+  // Get center y
+  const cy = (points[0].y + points[points.length - 1].y) / 2;
+  // Sort from right to left
+  points.sort((a, b) => b.x - a.x);
+  // Get center x
+  const cx = (points[0].x + points[points.length - 1].x) / 2;
+  // Center point
+  const center = {
     x: cx,
     y: cy
-  }; // As the points are sorted from right to left the first point is the rightmost Starting angle used to reference other angles
-
-  var startAng;
-  points.forEach(function (point) {
-    var ang = Math.atan2(point.y - center.y, point.x - center.x);
-
+  };
+  // As the points are sorted from right to left the first point is the rightmost Starting angle used to reference other angles
+  let startAng;
+  points.forEach(point => {
+    let ang = Math.atan2(point.y - center.y, point.x - center.x);
     if (!startAng) {
       startAng = ang;
     } else {
@@ -349,56 +277,50 @@ var sortPointsClockWise = function sortPointsClockWise(points) {
         ang += Math.PI * 2;
       }
     }
-
     point.angle = ang; // add the angle to the point
-  }); // first sort clockwise
-
-  points.sort(function (a, b) {
-    return a.angle - b.angle;
-  }); // then reverse the order
-
-  var ccwPoints = points.reverse(); // move the last point back to the start
-
-  ccwPoints.unshift(ccwPoints.pop());
-  return ccwPoints.map(function (_ref3) {
-    var angle = _ref3.angle,
-        attr = (0, _objectWithoutProperties2["default"])(_ref3, _excluded);
-    return attr;
   });
+  // first sort clockwise
+  points.sort((a, b) => a.angle - b.angle);
+  // then reverse the order
+  const ccwPoints = points.reverse();
+  // move the last point back to the start
+  ccwPoints.unshift(ccwPoints.pop());
+  return ccwPoints.map(({
+    angle,
+    ...attr
+  }) => attr);
 };
+
 /*
  * Function to calculate the dot product of two vectors
  * @param {Object} v1 - point 1
  * @param {Object} v2 - point 2
  * */
-
-
-var dotProduct = function dotProduct(v1, v2) {
+const dotProduct = (v1, v2) => {
   return v1.x * v2.x + v1.y * v2.y;
 };
+
 /*
  * Function to calculate the magnitude of a vector
  * @param {Object} v - point object
  * */
-
-
-var magnitude = function magnitude(v) {
+const magnitude = v => {
   return Math.sqrt(v.x * v.x + v.y * v.y);
 };
+
 /*
  * Function to calculate the angle between two vectors in radians
  * @param {Object} v1 - point 1
  * @param {Object} v2 - point 2
  * */
-
-
-var angleBetweenVectors = function angleBetweenVectors(v1, v2) {
-  var dot = dotProduct(v1, v2);
-  var magV1 = magnitude(v1);
-  var magV2 = magnitude(v2); // Ensure the dot product is within the domain of the acos function
-
+const angleBetweenVectors = (v1, v2) => {
+  const dot = dotProduct(v1, v2);
+  const magV1 = magnitude(v1);
+  const magV2 = magnitude(v2);
+  // Ensure the dot product is within the domain of the acos function
   return Math.acos(dot / (magV1 * magV2));
 };
+
 /*
  * Function to check if a point lies between the angle formed by two lines
  * @param {Object} commonPoint - common point of the two lines
@@ -406,86 +328,68 @@ var angleBetweenVectors = function angleBetweenVectors(v1, v2) {
  * @param {Object} point2 - point 2 of cone
  * @param {Object} testPoint - point to be tested
  * */
-
-
-var pointInAngle = function pointInAngle(commonPoint, point1, point2, testPoint) {
-  var vector1 = {
+const pointInAngle = (commonPoint, point1, point2, testPoint) => {
+  const vector1 = {
     x: point1.x - commonPoint.x,
     y: point1.y - commonPoint.y
   };
-  var vector2 = {
+  const vector2 = {
     x: point2.x - commonPoint.x,
     y: point2.y - commonPoint.y
   };
-  var testVector = {
+  const testVector = {
     x: testPoint.x - commonPoint.x,
     y: testPoint.y - commonPoint.y
   };
-  var angle1 = angleBetweenVectors(vector1, testVector);
-  var angle2 = angleBetweenVectors(vector2, testVector);
-  var angleSum = angle1 + angle2; // Check if the sum of angles is approximately equal to the angle between the two lines
+  const angle1 = angleBetweenVectors(vector1, testVector);
+  const angle2 = angleBetweenVectors(vector2, testVector);
+  const angleSum = angle1 + angle2;
+  // Check if the sum of angles is approximately equal to the angle between the two lines
   // You may need to adjust the tolerance (e.g., 0.0001) based on your specific requirements
-
-  var tolerance = 0.0001;
+  const tolerance = 0.0001;
   return Math.abs(angleSum - angleBetweenVectors(vector1, vector2)) < tolerance;
 };
+
 /*
  * Function to remove duplicate points from an array
  * @param {Array} array - array of points
  * */
-
-
-var removeDuplicatesFromArray = function removeDuplicatesFromArray(array) {
-  return array.filter(function (obj, index) {
-    return index === array.findIndex(function (o) {
-      return obj.x === o.x && obj.y === o.y;
-    });
+const removeDuplicatesFromArray = array => {
+  return array.filter((obj, index) => {
+    return index === array.findIndex(o => obj.x === o.x && obj.y === o.y);
   });
 };
+
 /*
  * Function to remove duplicate points and filter sections
  * @param {Array} sections - array of sections
  * */
-
-
-var removeDuplicateAndFilterSections = function removeDuplicateAndFilterSections(sections) {
-  var _loop = function _loop(i) {
-    sections[i] = sections[i].filter(function (obj, index) {
-      return index === sections[i].findIndex(function (o) {
-        return obj.x === o.x && obj.y === o.y;
-      });
-    });
-  };
-
+const removeDuplicateAndFilterSections = sections => {
   //removing duplicate points.
-  for (var i = 0; i < sections.length; i++) {
-    _loop(i);
-  } //removing arrays with two points
-
-
-  sections = sections.filter(function (section) {
-    return section.length > 2;
-  }); //sorting the points in clockwise direction
-
-  for (var _i = 0; _i < sections.length; _i++) {
-    sections[_i] = sortPointsClockWise(sections[_i]);
+  for (let i = 0; i < sections.length; i++) {
+    sections[i] = sections[i].filter((obj, index) => {
+      return index === sections[i].findIndex(o => obj.x === o.x && obj.y === o.y);
+    });
+  }
+  //removing arrays with two points
+  sections = sections.filter(section => section.length > 2);
+  //sorting the points in clockwise direction
+  for (let i = 0; i < sections.length; i++) {
+    sections[i] = sortPointsClockWise(sections[i]);
   }
-
   return sections;
 };
+
 /*
  * Function to find sections in solution set for one line
  * @param {Array} intersectionPoint - intersection point
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var findSectionsInSolutionSetForOneLine = function findSectionsInSolutionSetForOneLine(intersectionPoint, domain, range) {
-  var sections = [];
+const findSectionsInSolutionSetForOneLine = (intersectionPoint, domain, range) => {
+  let sections = [];
   sections.push([].concat(intersectionPoint));
   sections.push([].concat(intersectionPoint));
-
   if (intersectionPoint[0].x === domain.max && intersectionPoint[1].y === range.max || intersectionPoint[1].x === domain.max && intersectionPoint[0].y === range.max) {
     sections[0].push({
       x: domain.max,
@@ -577,9 +481,9 @@ var findSectionsInSolutionSetForOneLine = function findSectionsInSolutionSetForO
       y: range.max
     });
   }
-
   return removeDuplicateAndFilterSections(sections);
 };
+
 /*
  * Function to find sections in solution set for two lines
  * @param {Object} gssLineData - graphing solution set line data
@@ -587,12 +491,10 @@ var findSectionsInSolutionSetForOneLine = function findSectionsInSolutionSetForO
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var findSectionsInSolutionSetForTwoLines = function findSectionsInSolutionSetForTwoLines(gssLineData, answers, domain, range) {
-  var mark1 = answers[0];
-  var mark2 = answers[1];
-  var cornerPoints = [{
+const findSectionsInSolutionSetForTwoLines = (gssLineData, answers, domain, range) => {
+  let mark1 = answers[0];
+  let mark2 = answers[1];
+  let cornerPoints = [{
     x: domain.min,
     y: range.min
   }, {
@@ -605,68 +507,57 @@ var findSectionsInSolutionSetForTwoLines = function findSectionsInSolutionSetFor
     x: domain.max,
     y: range.max
   }];
-  var intersectPoint = lineIntersect(mark1.from.x, mark1.from.y, mark1.to.x, mark1.to.y, mark2.from.x, mark2.from.y, mark2.to.x, mark2.to.y);
-  var sections = [];
-  var intersectionPoint1 = findIntersectionPointForMark(mark1, domain, range);
+  let intersectPoint = lineIntersect(mark1.from.x, mark1.from.y, mark1.to.x, mark1.to.y, mark2.from.x, mark2.from.y, mark2.to.x, mark2.to.y);
+  let sections = [];
+  let intersectionPoint1 = findIntersectionPointForMark(mark1, domain, range);
   intersectionPoint1 = removeDuplicatesFromArray(intersectionPoint1);
-  var intersectionPoint2 = findIntersectionPointForMark(mark2, domain, range);
+  let intersectionPoint2 = findIntersectionPointForMark(mark2, domain, range);
   intersectionPoint2 = removeDuplicatesFromArray(intersectionPoint2);
-
   if (intersectPoint && isPointInsideGraph(intersectPoint, domain, range)) {
-    for (var i = 0; i < intersectionPoint1.length; i++) {
-      for (var j = 0; j < intersectionPoint2.length; j++) {
-        var bucket = [];
-        var newCornerPoints = [];
+    for (let i = 0; i < intersectionPoint1.length; i++) {
+      for (let j = 0; j < intersectionPoint2.length; j++) {
+        let bucket = [];
+        let newCornerPoints = [];
         bucket.push(intersectPoint);
         bucket.push(intersectionPoint1[i]);
         bucket.push(intersectionPoint2[j]);
-
-        for (var k = 0; k < cornerPoints.length; k++) {
+        for (let k = 0; k < cornerPoints.length; k++) {
           if (pointInAngle(intersectPoint, intersectionPoint1[i], intersectionPoint2[j], cornerPoints[k])) {
             bucket.push(cornerPoints[k]);
           } else {
             newCornerPoints.push(cornerPoints[k]);
           }
         }
-
         cornerPoints = newCornerPoints;
         sections.push(bucket);
       }
     }
   } else {
-    var sections1 = findSectionsInSolutionSetForOneLine(intersectionPoint1, domain, range);
-    var sections2 = findSectionsInSolutionSetForOneLine(intersectionPoint2, domain, range);
-
-    for (var _i2 = 0; _i2 < sections1.length; _i2++) {
-      if (!(pointInPolygon(intersectionPoint2[0], sections1[_i2]) && pointInPolygon(intersectionPoint2[1], sections1[_i2]))) {
-        sections.push(sections1[_i2]);
+    let sections1 = findSectionsInSolutionSetForOneLine(intersectionPoint1, domain, range);
+    let sections2 = findSectionsInSolutionSetForOneLine(intersectionPoint2, domain, range);
+    for (let i = 0; i < sections1.length; i++) {
+      if (!(pointInPolygon(intersectionPoint2[0], sections1[i]) && pointInPolygon(intersectionPoint2[1], sections1[i]))) {
+        sections.push(sections1[i]);
       }
     }
-
-    for (var _i3 = 0; _i3 < sections2.length; _i3++) {
-      if (!(pointInPolygon(intersectionPoint1[0], sections2[_i3]) && pointInPolygon(intersectionPoint1[1], sections2[_i3]))) {
-        sections.push(sections2[_i3]);
+    for (let i = 0; i < sections2.length; i++) {
+      if (!(pointInPolygon(intersectionPoint1[0], sections2[i]) && pointInPolygon(intersectionPoint1[1], sections2[i]))) {
+        sections.push(sections2[i]);
       }
     }
-
-    var _loop2 = function _loop2(_i4) {
+    for (let i = 0; i < sections.length; i++) {
       cornerPoints = cornerPoints.filter(function (o1) {
-        return !sections[_i4].some(function (o2) {
+        return !sections[i].some(function (o2) {
           return o1.x === o2.x && o1.y === o2.y;
         });
       });
-    };
-
-    for (var _i4 = 0; _i4 < sections.length; _i4++) {
-      _loop2(_i4);
     }
-
-    var sections3 = cornerPoints.concat(intersectionPoint1, intersectionPoint2);
+    let sections3 = cornerPoints.concat(intersectionPoint1, intersectionPoint2);
     sections.push(sections3);
   }
-
   return removeDuplicateAndFilterSections(sections);
 };
+
 /*
  * Function to find sections in solution set
  * @param {Object} gssLineData - graphing solution set line data
@@ -674,69 +565,56 @@ var findSectionsInSolutionSetForTwoLines = function findSectionsInSolutionSetFor
  * @param {Object} domain - domain object
  * @param {Object} range - range object
  * */
-
-
-var findSectionsInSolutionSet = function findSectionsInSolutionSet(gssLineData, answers, domain, range) {
+const findSectionsInSolutionSet = (gssLineData, answers, domain, range) => {
   if (gssLineData.numberOfLines === 1) {
-    var intersectionPoint = findIntersectionPointForMark(answers[0], domain, range);
+    const intersectionPoint = findIntersectionPointForMark(answers[0], domain, range);
     gssLineData.sections = findSectionsInSolutionSetForOneLine(intersectionPoint, domain, range);
   } else {
     gssLineData.sections = findSectionsInSolutionSetForTwoLines(gssLineData, answers, domain, range);
   }
-
   return gssLineData;
 };
+
 /*
  * Function to check if a point is inside a polygon
  * @param {Object} point - point to be checked
  * @param {Array} polygon - polygon points array
  * */
-
-
 exports.findSectionsInSolutionSet = findSectionsInSolutionSet;
-
-var pointInsidePolygon = function pointInsidePolygon(point, polygon) {
-  var num_vertices = polygon.length;
-  var x = point.x;
-  var y = point.y;
-  var inside = false;
-  var p1 = polygon[0];
-  var p2;
-
-  for (var i = 1; i <= num_vertices; i++) {
+const pointInsidePolygon = (point, polygon) => {
+  const num_vertices = polygon.length;
+  const x = point.x;
+  const y = point.y;
+  let inside = false;
+  let p1 = polygon[0];
+  let p2;
+  for (let i = 1; i <= num_vertices; i++) {
     p2 = polygon[i % num_vertices];
-
     if (y > Math.min(p1.y, p2.y)) {
       if (y <= Math.max(p1.y, p2.y)) {
         if (x <= Math.max(p1.x, p2.x)) {
-          var x_intersection = (y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y) + p1.x;
-
+          const x_intersection = (y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y) + p1.x;
           if (p1.x === p2.x || x <= x_intersection) {
             inside = !inside;
           }
         }
       }
     }
-
     p1 = p2;
   }
-
   return inside;
 };
+
 /*
  * Function to check if lines are added in the graph
  * @param {Object} gssLineData - graphing solution set line data
  * @param {Array} answer - answer array
  * */
-
-
 exports.pointInsidePolygon = pointInsidePolygon;
-
-var checkIfLinesAreAdded = function checkIfLinesAreAdded(gssLineData, answer) {
+const checkIfLinesAreAdded = (gssLineData, answer) => {
   if (answer.length === 0) {
     return false;
   }
-
   if (gssLineData.numberOfLines === 1) {
     if (answer.length === 1) {
       return !answer[0].building;
@@ -749,6 +627,5 @@ var checkIfLinesAreAdded = function checkIfLinesAreAdded(gssLineData, answer) {
     }
   }
 };
-
 exports.checkIfLinesAreAdded = checkIfLinesAreAdded;
 //# sourceMappingURL=utils.js.map