@pie-lib/graphing 2.11.3-next.52 → 2.11.4

package/src/tools/sine/component.jsx

@@ -6,7 +6,7 @@ const log = debug('pie-lib:graphing:sine');
 
 log('sine...');
 
-const Sine = withRootEdge(props => {
+const Sine = withRootEdge((props) => {
   const { domain } = props.graphProps;
 
   const { root, edge } = props;
@@ -23,7 +23,7 @@ const Sine = withRootEdge(props => {
           root,
           edge,
           interval,
-          sinY(amplitude, freq, { phase: root.x, vertical: root.y })
+          sinY(amplitude, freq, { phase: root.x, vertical: root.y }),
         );
   return { root: props.root, edge: props.edge, dataPoints };
 });

package/src/tools/sine/index.js

@@ -22,12 +22,12 @@ export const tool = () => ({
         root: point,
         edge: undefined,
         closed: false,
-        building: true
+        building: true,
       };
     } else if (mark && !mark.root) {
       throw new Error('no root - should never happen');
     } else {
       return { ...mark, edge: point, closed: true, building: false };
     }
-  }
+  },
 });

package/src/tools/vector/component.jsx

@@ -7,14 +7,14 @@ import classNames from 'classnames';
 import { withStyles } from '@material-ui/core/styles';
 import { getDistanceBetweenTwoPoints } from '../../utils';
 
-const lineStyles = theme => ({
+const lineStyles = (theme) => ({
   line: styles.line(theme),
   disabled: styles.disabled(theme),
   correct: styles.correct(theme, 'stroke'),
-  incorrect: styles.incorrect(theme, 'stroke')
+  incorrect: styles.incorrect(theme, 'stroke'),
 });
 
-export const Line = props => {
+export const Line = (props) => {
   const {
     className,
     classes,
@@ -31,12 +31,7 @@ export const Line = props => {
 
   return (
     <line
-      className={classNames(
-        classes.line,
-        disabled && classes.disabled,
-        classes[correctness],
-        className
-      )}
+      className={classNames(classes.line, disabled && classes.disabled, classes[correctness], className)}
       x1={startPoint.x}
       y1={startPoint.y}
       x2={endPoint.x}
@@ -54,7 +49,7 @@ Line.propTypes = {
   correctness: PropTypes.string,
   graphProps: PropTypes.any,
   from: types.PointType,
-  to: types.PointType
+  to: types.PointType,
 };
 
 const StyledLine = withStyles(lineStyles)(Line);

package/src/undo-redo.jsx

@@ -11,7 +11,7 @@ export class UndoRedo extends React.Component {
     className: PropTypes.string,
     onUndo: PropTypes.func.isRequired,
     onRedo: PropTypes.func.isRequired,
-    onReset: PropTypes.func.isRequired
+    onReset: PropTypes.func.isRequired,
   };
   static defaultProps = {};
   render() {
@@ -32,18 +32,18 @@ export class UndoRedo extends React.Component {
   }
 }
 
-const styles = theme => ({
+const styles = (theme) => ({
   button: {
     color: color.text(),
     backgroundColor: color.background(),
     marginBottom: theme.spacing.unit / 2,
     '&:not(:last-of-type)': {
-      marginRight: theme.spacing.unit / 2
+      marginRight: theme.spacing.unit / 2,
     },
     '&:hover': {
-      backgroundColor: color.primary()
-    }
-  }
+      backgroundColor: color.primary(),
+    },
+  },
 });
 
 export default withStyles(styles)(UndoRedo);

package/src/utils.js

@@ -15,7 +15,7 @@ export const getAngleDeg = () => 0;
 //TODO: This can be removed?
 export const arrowDimensions = () => 0;
 
-export const getTickValues = prop => {
+export const getTickValues = (prop) => {
   const tickValues = [];
   let tickVal = 0;
 
@@ -33,13 +33,13 @@ export const getTickValues = prop => {
 
   // return only ticks that are inside the min-max interval
   if (tickValues) {
-    return tickValues.filter(tV => tV >= prop.min && tV <= prop.max);
+    return tickValues.filter((tV) => tV >= prop.min && tV <= prop.max);
   }
 
   return [];
 };
 
-export const countWords = label => {
+export const countWords = (label) => {
   if (label == null || isEmpty(label)) {
     return 1;
   }
@@ -49,7 +49,7 @@ export const countWords = label => {
 };
 
 // findLongestWord is also used in plot
-export const findLongestWord = label => {
+export const findLongestWord = (label) => {
   let longestWord = (label || '')
     .replace(/<[^>]+>/g, '')
     .split(' ')
@@ -59,7 +59,7 @@ export const findLongestWord = label => {
 };
 
 // amountToIncreaseWidth is also used in plot
-export const amountToIncreaseWidth = longestWord => {
+export const amountToIncreaseWidth = (longestWord) => {
   if (!longestWord) {
     return 0;
   }
@@ -67,13 +67,13 @@ export const amountToIncreaseWidth = longestWord => {
   return longestWord * 10;
 };
 
-export const polygonToArea = points => {
+export const polygonToArea = (points) => {
   const h = head(points);
   const area = {
     left: h.x,
     top: h.y,
     bottom: h.y,
-    right: h.x
+    right: h.x,
   };
   return tail(points).reduce((a, p) => {
     a.left = Math.min(a.left, p.x);
@@ -96,13 +96,10 @@ export const pointsToArea = (a, b) => {
 };
 
 export const isDomainRangeEqual = (graphProps, nextGraphProps) => {
-  return (
-    isEqual(graphProps.domain, nextGraphProps.domain) &&
-    isEqual(graphProps.range, nextGraphProps.range)
-  );
+  return isEqual(graphProps.domain, nextGraphProps.domain) && isEqual(graphProps.range, nextGraphProps.range);
 };
 
-export const getRightestPoints = points => {
+export const getRightestPoints = (points) => {
   const sortedPoints = cloneDeep(points);
   sortedPoints.sort((a, b) => b.x - a.x);
 
@@ -111,10 +108,10 @@ export const getRightestPoints = points => {
 
 export const getMiddleOfTwoPoints = (a, b) => ({
   x: (a.x + b.x) / 2,
-  y: (a.y + b.y) / 2
+  y: (a.y + b.y) / 2,
 });
 
-export const roundNumber = number => parseFloat(number.toFixed(4));
+export const roundNumber = (number) => parseFloat(number.toFixed(4));
 
 export const sameAxes = (p1, p2) =>
   p1 && p2 && (roundNumber(p1.x) === roundNumber(p2.x) || roundNumber(p1.y) === roundNumber(p2.y));
@@ -125,12 +122,12 @@ export const equalPoints = (p1, p2) =>
   isEqual(
     {
       x: roundNumber(p1.x),
-      y: roundNumber(p1.y)
+      y: roundNumber(p1.y),
     },
     {
       x: roundNumber(p2.x),
-      y: roundNumber(p2.y)
-    }
+      y: roundNumber(p2.y),
+    },
   );
 
 const getDistanceBetweenTicks = (axis, size) => {
@@ -140,22 +137,22 @@ const getDistanceBetweenTicks = (axis, size) => {
   return size / nbOfTicks;
 };
 
-export const thinnerShapesNeeded = graphProps => {
+export const thinnerShapesNeeded = (graphProps) => {
   const {
     domain,
     range,
-    size: { width, height }
+    size: { width, height },
   } = graphProps;
 
   // 14 is the default width of a point
   return getDistanceBetweenTicks(domain, width) < 14 || getDistanceBetweenTicks(range, height) < 14;
 };
 
-export const getAdjustedGraphLimits = graphProps => {
+export const getAdjustedGraphLimits = (graphProps) => {
   const {
     domain,
     range,
-    size: { width, height }
+    size: { width, height },
   } = graphProps;
   const domainTicksDistance = getDistanceBetweenTicks(domain, width);
   const rangeTicksDistance = getDistanceBetweenTicks(range, height);
@@ -167,32 +164,29 @@ export const getAdjustedGraphLimits = graphProps => {
   return {
     domain: {
       min: domain.min - domainPadding,
-      max: domain.max + domainPadding
+      max: domain.max + domainPadding,
     },
     range: {
       min: range.min - rangePadding,
-      max: range.max + rangePadding
-    }
+      max: range.max + rangePadding,
+    },
   };
 };
 
-export const getDistanceBetweenTwoPoints = (a, b) =>
-  Math.sqrt((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
+export const getDistanceBetweenTwoPoints = (a, b) => Math.sqrt((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
 
-const sortPoints = array => (array || []).sort((a, b) => a.x - b.x || a.y - b.y);
+const sortPoints = (array) => (array || []).sort((a, b) => a.x - b.x || a.y - b.y);
 
 // check colliniarity of 3 points (source: https://www.geeksforgeeks.org/program-check-three-points-collinear/)
 const checkCollinearity = (a, b, c) => (a.x - b.x) * (c.y - b.y) === (c.x - b.x) * (a.y - b.y);
 
 // 2 lines are overlapping if all 4 points are collinear
 const isSameLine = (markA, markB) =>
-  checkCollinearity(markA.from, markB.from, markB.to) &&
-  checkCollinearity(markA.to, markB.from, markB.to);
+  checkCollinearity(markA.from, markB.from, markB.to) && checkCollinearity(markA.to, markB.from, markB.to);
 
 const isSameCircle = (markA, markB) =>
   equalPoints(markA.root, markB.root) &&
-  getDistanceBetweenTwoPoints(markB.root, markB.edge) ===
-    getDistanceBetweenTwoPoints(markA.root, markA.edge);
+  getDistanceBetweenTwoPoints(markB.root, markB.edge) === getDistanceBetweenTwoPoints(markA.root, markA.edge);
 
 export const isDuplicatedMark = (mark, marks, oldMark) => {
   const { type, building } = mark;
@@ -201,21 +195,18 @@ export const isDuplicatedMark = (mark, marks, oldMark) => {
     return false;
   }
 
-  const filteredMarks = (marks || []).filter(m => m.type === type && !m.building);
-  const index = filteredMarks.findIndex(m => isEqual(m, oldMark));
+  const filteredMarks = (marks || []).filter((m) => m.type === type && !m.building);
+  const index = filteredMarks.findIndex((m) => isEqual(m, oldMark));
 
   if (index !== -1) {
     filteredMarks.splice(index, 1);
   }
 
-  const duplicated = filteredMarks.find(m => {
+  const duplicated = filteredMarks.find((m) => {
     if (type === 'circle' || type === 'parabola' || type === 'sine') {
       const { root, edge } = mark;
 
-      return (
-        (equalPoints(root, m.root) && equalPoints(edge, m.edge)) ||
-        (type === 'circle' && isSameCircle(m, mark))
-      );
+      return (equalPoints(root, m.root) && equalPoints(edge, m.edge)) || (type === 'circle' && isSameCircle(m, mark));
     } else if (type === 'line' || type === 'ray' || type === 'segment' || type === 'vector') {
       const { from, to } = mark;