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

package/lib/utils.js

@@ -1,44 +1,30 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.removeInvalidAnswers = exports.pointInsidePolygon = exports.findSectionsInSolutionSet = exports.checkIfLinesAreAdded = void 0;
-
-var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _excluded = ["angle"],
-    _excluded2 = ["type"];
-
 /*
  * Check if a line is complete
  * @param {Object} item - mark object
  * */
-var completeFromTo = function completeFromTo(item) {
-  return item && completeMark.point(item.from) && completeMark.point(item.to);
-};
+const completeFromTo = item => item && completeMark.point(item.from) && completeMark.point(item.to);
+
 /*
  * Check if a point is correct and complete
  * @param {Object} point - point object
  * */
+const completePoint = point => point && Number.isFinite(point.x) && Number.isFinite(point.y);
 
-
-var completePoint = function completePoint(point) {
-  return point && Number.isFinite(point.x) && Number.isFinite(point.y);
-};
 /*
  * Complete mark object for line and point
  * */
-
-
-var completeMark = {
+const completeMark = {
   line: completeFromTo,
   point: completePoint
-}; //////////////////////////////////////////////////////////////////////////////////
+};
+
+//////////////////////////////////////////////////////////////////////////////////
 // BELOW FUNCTIONS ARE USED IN configure/src/utils as well
 //////////////////////////////////////////////////////////////////////////////////
 
@@ -47,35 +33,32 @@ var completeMark = {
  * @param {Object} a - point a
  * @param {Object} b - point b
  * */
-
-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
@@ -87,95 +70,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 {
@@ -184,56 +151,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 (_ref) {
-    var angle = _ref.angle,
-        attr = (0, _objectWithoutProperties2["default"])(_ref, _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
@@ -241,86 +202,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,
@@ -412,9 +355,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
@@ -422,12 +365,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
   }, {
@@ -440,68 +381,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
@@ -509,69 +439,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;
@@ -584,21 +501,15 @@ var checkIfLinesAreAdded = function checkIfLinesAreAdded(gssLineData, answer) {
     }
   }
 };
+
 /*
  * Function to remove invalid answers
  * @param {Array} answers - answers array
  * */
-
-
 exports.checkIfLinesAreAdded = checkIfLinesAreAdded;
-
-var removeInvalidAnswers = function removeInvalidAnswers(answers) {
-  return answers ? (answers || []).filter(function (_ref2) {
-    var type = _ref2.type,
-        answer = (0, _objectWithoutProperties2["default"])(_ref2, _excluded2);
-    return completeMark[type] ? completeMark[type](answer) : false;
-  }) : [];
-};
-
+const removeInvalidAnswers = answers => answers ? (answers || []).filter(({
+  type,
+  ...answer
+}) => completeMark[type] ? completeMark[type](answer) : false) : [];
 exports.removeInvalidAnswers = removeInvalidAnswers;
 //# sourceMappingURL=utils.js.map