@pie-lib/graphing-solution-set 2.16.0-beta.0

package/lib/undo-redo.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.UndoRedo = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _Button = _interopRequireDefault(require("@material-ui/core/Button"));
+
+var _core = require("@material-ui/core");
+
+var _renderUi = require("@pie-lib/render-ui");
+
+var _translator = _interopRequireDefault(require("@pie-lib/translator"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var translator = _translator["default"].translator;
+
+var UndoRedo = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(UndoRedo, _React$Component);
+
+  var _super = _createSuper(UndoRedo);
+
+  function UndoRedo() {
+    (0, _classCallCheck2["default"])(this, UndoRedo);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(UndoRedo, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          classes = _this$props.classes,
+          className = _this$props.className,
+          _this$props$onReset = _this$props.onReset,
+          onReset = _this$props$onReset === void 0 ? false : _this$props$onReset,
+          language = _this$props.language;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: (0, _classnames["default"])(className)
+      }, /*#__PURE__*/_react["default"].createElement(_Button["default"], {
+        classes: {
+          root: classes.button
+        },
+        onClick: function onClick() {
+          return onReset();
+        }
+      }, translator.t('graphing.reset', {
+        lng: language
+      })));
+    }
+  }]);
+  return UndoRedo;
+}(_react["default"].Component);
+
+exports.UndoRedo = UndoRedo;
+(0, _defineProperty2["default"])(UndoRedo, "propTypes", {
+  classes: _propTypes["default"].object,
+  className: _propTypes["default"].string,
+  onReset: _propTypes["default"].func.isRequired,
+  language: _propTypes["default"].string
+});
+(0, _defineProperty2["default"])(UndoRedo, "defaultProps", {});
+
+var styles = function styles(theme) {
+  return {
+    button: {
+      color: _renderUi.color.text(),
+      fontWeight: 'bold',
+      marginBottom: theme.spacing.unit / 2,
+      '&:not(:last-of-type)': {
+        marginRight: theme.spacing.unit / 2
+      }
+    },
+    undoRedoDiv: {
+      display: 'flex',
+      flexDirection: 'row'
+    }
+  };
+};
+
+var _default = (0, _core.withStyles)(styles)(UndoRedo);
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/use-debounce.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDebounce = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = require("react");
+
+var useDebounce = function useDebounce(value, delay) {
+  var _useState = (0, _react.useState)(value),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      debouncedValue = _useState2[0],
+      setDebouncedValue = _useState2[1];
+
+  (0, _react.useEffect)(function () {
+    var handler = setTimeout(function () {
+      setDebouncedValue(value);
+    }, delay);
+    return function () {
+      return clearTimeout(handler);
+    };
+  }, [value]);
+  return debouncedValue;
+};
+
+exports.useDebounce = useDebounce;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy91c2UtZGVib3VuY2UuanMiXSwibmFtZXMiOlsidXNlRGVib3VuY2UiLCJ2YWx1ZSIsImRlbGF5IiwiZGVib3VuY2VkVmFsdWUiLCJzZXREZWJvdW5jZWRWYWx1ZSIsImhhbmRsZXIiLCJzZXRUaW1lb3V0IiwiY2xlYXJUaW1lb3V0Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUFBOztBQUVPLElBQU1BLFdBQVcsR0FBRyxTQUFkQSxXQUFjLENBQUNDLEtBQUQsRUFBUUMsS0FBUixFQUFrQjtBQUMzQyxrQkFBNEMscUJBQVNELEtBQVQsQ0FBNUM7QUFBQTtBQUFBLE1BQU9FLGNBQVA7QUFBQSxNQUF1QkMsaUJBQXZCOztBQUVBLHdCQUFVLFlBQU07QUFDZCxRQUFNQyxPQUFPLEdBQUdDLFVBQVUsQ0FBQyxZQUFNO0FBQy9CRixNQUFBQSxpQkFBaUIsQ0FBQ0gsS0FBRCxDQUFqQjtBQUNELEtBRnlCLEVBRXZCQyxLQUZ1QixDQUExQjtBQUdBLFdBQU87QUFBQSxhQUFNSyxZQUFZLENBQUNGLE9BQUQsQ0FBbEI7QUFBQSxLQUFQO0FBQ0QsR0FMRCxFQUtHLENBQUNKLEtBQUQsQ0FMSDtBQU1BLFNBQU9FLGNBQVA7QUFDRCxDQVZNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdXNlU3RhdGUsIHVzZUVmZmVjdCB9IGZyb20gJ3JlYWN0JztcblxuZXhwb3J0IGNvbnN0IHVzZURlYm91bmNlID0gKHZhbHVlLCBkZWxheSkgPT4ge1xuICBjb25zdCBbZGVib3VuY2VkVmFsdWUsIHNldERlYm91bmNlZFZhbHVlXSA9IHVzZVN0YXRlKHZhbHVlKTtcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGNvbnN0IGhhbmRsZXIgPSBzZXRUaW1lb3V0KCgpID0+IHtcbiAgICAgIHNldERlYm91bmNlZFZhbHVlKHZhbHVlKTtcbiAgICB9LCBkZWxheSk7XG4gICAgcmV0dXJuICgpID0+IGNsZWFyVGltZW91dChoYW5kbGVyKTtcbiAgfSwgW3ZhbHVlXSk7XG4gIHJldHVybiBkZWJvdW5jZWRWYWx1ZTtcbn07XG4iXX0=

package/lib/utils.js

@@ -0,0 +1,314 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.thinnerShapesNeeded = exports.sameAxes = exports.roundNumber = exports.polygonToArea = exports.pointsToArea = exports.point = exports.lineToArea = exports.isDuplicatedMark = exports.getTickValues = exports.getRightestPoints = exports.getMiddleOfTwoPoints = exports.getAngleDeg = exports.getAdjustedGraphLimits = exports.findLongestWord = exports.equalPoints = exports.countWords = exports.bounds = exports.arrowDimensions = exports.areArraysOfObjectsEqual = exports.amountToIncreaseWidth = void 0;
+
+var _head = _interopRequireDefault(require("lodash/head"));
+
+var _tail = _interopRequireDefault(require("lodash/tail"));
+
+var _plot = require("@pie-lib/plot");
+
+var _invariant = _interopRequireDefault(require("invariant"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var bounds = _plot.utils.bounds;
+exports.bounds = bounds;
+var point = _plot.utils.point; //TODO: This can be removed?
+
+exports.point = point;
+
+var getAngleDeg = function getAngleDeg() {
+  return 0;
+}; //TODO: This can be removed?
+
+
+exports.getAngleDeg = getAngleDeg;
+
+var arrowDimensions = function arrowDimensions() {
+  return 0;
+};
+
+exports.arrowDimensions = arrowDimensions;
+
+var getTickValues = function getTickValues(prop) {
+  var tickValues = [];
+  var 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
+
+
+  if (tickValues) {
+    return tickValues.filter(function (tV) {
+      return tV >= prop.min && tV <= prop.max;
+    });
+  }
+
+  return [];
+};
+
+exports.getTickValues = getTickValues;
+
+var countWords = function countWords(label) {
+  if (label == null || (0, _isEmpty["default"])(label)) {
+    return 1;
+  }
+
+  var words = label.split(' ');
+  return words.length;
+}; // findLongestWord is also used in plot
+
+
+exports.countWords = countWords;
+
+var findLongestWord = function findLongestWord(label) {
+  var longestWord = (label || '').replace(/<[^>]+>/g, '').split(' ').sort(function (a, b) {
+    return b.length - a.length;
+  });
+  return longestWord[0].length;
+}; // amountToIncreaseWidth is also used in plot
+
+
+exports.findLongestWord = findLongestWord;
+
+var amountToIncreaseWidth = function amountToIncreaseWidth(longestWord) {
+  if (!longestWord) {
+    return 0;
+  }
+
+  return longestWord * 10;
+};
+
+exports.amountToIncreaseWidth = amountToIncreaseWidth;
+
+var polygonToArea = function polygonToArea(points) {
+  var h = (0, _head["default"])(points);
+  var area = {
+    left: h.x,
+    top: h.y,
+    bottom: h.y,
+    right: h.x
+  };
+  return (0, _tail["default"])(points).reduce(function (a, p) {
+    a.left = Math.min(a.left, p.x);
+    a.top = Math.max(a.top, p.y);
+    a.bottom = Math.min(a.bottom, p.y);
+    a.right = Math.max(a.right, p.x);
+    return a;
+  }, area);
+};
+
+exports.polygonToArea = polygonToArea;
+
+var lineToArea = function lineToArea(from, to) {
+  return pointsToArea(from, to);
+};
+
+exports.lineToArea = lineToArea;
+
+var pointsToArea = function pointsToArea(a, b) {
+  (0, _invariant["default"])(!!a && !!b, 'a or b is undefined');
+  var left = Math.min(a.x, b.x);
+  var top = Math.max(a.y, b.y);
+  var bottom = Math.min(a.y, b.y);
+  var right = Math.max(a.x, b.x);
+  return {
+    left: left,
+    top: top,
+    bottom: bottom,
+    right: right
+  };
+};
+
+exports.pointsToArea = pointsToArea;
+
+var getRightestPoints = function getRightestPoints(points) {
+  var sortedPoints = (0, _cloneDeep["default"])(points);
+  sortedPoints.sort(function (a, b) {
+    return b.x - a.x;
+  });
+  return {
+    a: sortedPoints[0],
+    b: sortedPoints[1]
+  };
+};
+
+exports.getRightestPoints = getRightestPoints;
+
+var getMiddleOfTwoPoints = function getMiddleOfTwoPoints(a, b) {
+  return {
+    x: (a.x + b.x) / 2,
+    y: (a.y + b.y) / 2
+  };
+};
+
+exports.getMiddleOfTwoPoints = getMiddleOfTwoPoints;
+
+var roundNumber = function roundNumber(number) {
+  return parseFloat(number.toFixed(4));
+};
+
+exports.roundNumber = roundNumber;
+
+var sameAxes = function sameAxes(p1, p2) {
+  return p1 && p2 && (roundNumber(p1.x) === roundNumber(p2.x) || roundNumber(p1.y) === roundNumber(p2.y));
+};
+
+exports.sameAxes = sameAxes;
+
+var equalPoints = function equalPoints(p1, p2) {
+  return p1 && p2 && (0, _isEqual["default"])({
+    x: roundNumber(p1.x),
+    y: roundNumber(p1.y)
+  }, {
+    x: roundNumber(p2.x),
+    y: roundNumber(p2.y)
+  });
+};
+
+exports.equalPoints = equalPoints;
+
+var getDistanceBetweenTicks = function getDistanceBetweenTicks(axis, size) {
+  var min = axis.min,
+      max = axis.max,
+      step = axis.step;
+  var nbOfTicks = (max - min) / step;
+  return size / nbOfTicks;
+};
+
+var thinnerShapesNeeded = function thinnerShapesNeeded(graphProps) {
+  var domain = graphProps.domain,
+      range = graphProps.range,
+      _graphProps$size = graphProps.size,
+      width = _graphProps$size.width,
+      height = _graphProps$size.height; // 14 is the default width of a point
+
+  return getDistanceBetweenTicks(domain, width) < 14 || getDistanceBetweenTicks(range, height) < 14;
+};
+
+exports.thinnerShapesNeeded = thinnerShapesNeeded;
+
+var getAdjustedGraphLimits = function getAdjustedGraphLimits(graphProps) {
+  var domain = graphProps.domain,
+      range = graphProps.range,
+      _graphProps$size2 = graphProps.size,
+      width = _graphProps$size2.width,
+      height = _graphProps$size2.height;
+  var domainTicksDistance = getDistanceBetweenTicks(domain, width);
+  var rangeTicksDistance = getDistanceBetweenTicks(range, height); // 15 is the distance required for the arrow to extend the graph
+
+  var domainPadding = domain.step / (domainTicksDistance / 15);
+  var rangePadding = range.step / (rangeTicksDistance / 15);
+  return {
+    domain: {
+      min: domain.min - domainPadding,
+      max: domain.max + domainPadding
+    },
+    range: {
+      min: range.min - rangePadding,
+      max: range.max + rangePadding
+    }
+  };
+};
+
+exports.getAdjustedGraphLimits = getAdjustedGraphLimits;
+
+var sortPoints = function sortPoints(array) {
+  return (array || []).sort(function (a, b) {
+    return a.x - b.x || a.y - b.y;
+  });
+}; // check colliniarity of 3 points (source: https://www.geeksforgeeks.org/program-check-three-points-collinear/)
+
+
+var checkCollinearity = function checkCollinearity(a, b, c) {
+  return (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
+
+
+var isSameLine = function isSameLine(markA, markB) {
+  return checkCollinearity(markA.from, markB.from, markB.to) && checkCollinearity(markA.to, markB.from, markB.to);
+};
+
+var isDuplicatedMark = function isDuplicatedMark(mark, marks, oldMark) {
+  var type = mark.type,
+      building = mark.building;
+
+  if (building) {
+    return false;
+  }
+
+  var filteredMarks = (marks || []).filter(function (m) {
+    return m.type === type && !m.building;
+  });
+  var index = filteredMarks.findIndex(function (m) {
+    return (0, _isEqual["default"])(m, oldMark);
+  });
+
+  if (index !== -1) {
+    filteredMarks.splice(index, 1);
+  }
+
+  var duplicated = filteredMarks.find(function (m) {
+    if (type === 'line') {
+      var from = mark.from,
+          to = mark.to;
+      return equalPoints(from, m.from) && equalPoints(to, m.to) || equalPoints(from, m.to) && equalPoints(to, m.from) || type === 'line' && isSameLine(m, mark);
+    } else if (type === 'polygon') {
+      return (0, _isEqual["default"])(sortPoints((0, _cloneDeep["default"])(mark.points)), sortPoints((0, _cloneDeep["default"])(m.points)));
+    }
+  });
+  return !!duplicated;
+};
+
+exports.isDuplicatedMark = isDuplicatedMark;
+
+var areArraysOfObjectsEqual = function areArraysOfObjectsEqual(array1, array2) {
+  // Check if both arrays have the same length
+  if (array1.length !== array2.length) {
+    return false;
+  } // Iterate through each object in the arrays
+
+
+  for (var i = 0; i < array1.length; i++) {
+    // Get the current objects in both arrays
+    var obj1 = array1[i];
+    var obj2 = array2[i]; // Check if the objects have the same number of properties
+
+    if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+      return false;
+    } // Iterate through each property in the objects
+
+
+    for (var key in obj1) {
+      // Check if the properties and their values are equal
+      if (obj1[key] !== obj2[key]) {
+        return false;
+      }
+    }
+  } // If all objects are equal, the arrays are the same
+
+
+  return true;
+};
+
+exports.areArraysOfObjectsEqual = areArraysOfObjectsEqual;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/utils.js"],"names":["bounds","utils","point","getAngleDeg","arrowDimensions","getTickValues","prop","tickValues","tickVal","min","indexOf","push","Math","round","step","max","filter","tV","countWords","label","words","split","length","findLongestWord","longestWord","replace","sort","a","b","amountToIncreaseWidth","polygonToArea","points","h","area","left","x","top","y","bottom","right","reduce","p","lineToArea","from","to","pointsToArea","getRightestPoints","sortedPoints","getMiddleOfTwoPoints","roundNumber","number","parseFloat","toFixed","sameAxes","p1","p2","equalPoints","getDistanceBetweenTicks","axis","size","nbOfTicks","thinnerShapesNeeded","graphProps","domain","range","width","height","getAdjustedGraphLimits","domainTicksDistance","rangeTicksDistance","domainPadding","rangePadding","sortPoints","array","checkCollinearity","c","isSameLine","markA","markB","isDuplicatedMark","mark","marks","oldMark","type","building","filteredMarks","m","index","findIndex","splice","duplicated","find","areArraysOfObjectsEqual","array1","array2","i","obj1","obj2","Object","keys","key"],"mappings":"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","sourcesContent":["import head from 'lodash/head';\nimport tail from 'lodash/tail';\nimport { utils } from '@pie-lib/plot';\nimport invariant from 'invariant';\nimport isEqual from 'lodash/isEqual';\nimport isEmpty from 'lodash/isEmpty';\nimport cloneDeep from 'lodash/cloneDeep';\n\nexport const bounds = utils.bounds;\nexport const point = utils.point;\n\n//TODO: This can be removed?\nexport const getAngleDeg = () => 0;\n//TODO: This can be removed?\nexport const arrowDimensions = () => 0;\n\nexport const getTickValues = (prop) => {\n  const tickValues = [];\n  let tickVal = 0;\n\n  while (tickVal >= prop.min && tickValues.indexOf(tickVal) < 0) {\n    tickValues.push(tickVal);\n    tickVal = Math.round((tickVal - prop.step) * 10000) / 10000;\n  }\n\n  tickVal = Math.round(prop.step * 10000) / 10000;\n\n  while (tickVal <= prop.max && tickValues.indexOf(tickVal) < 0) {\n    tickValues.push(tickVal);\n    tickVal = Math.round((tickVal + prop.step) * 10000) / 10000;\n  }\n\n  // return only ticks that are inside the min-max interval\n  if (tickValues) {\n    return tickValues.filter((tV) => tV >= prop.min && tV <= prop.max);\n  }\n\n  return [];\n};\n\nexport const countWords = (label) => {\n  if (label == null || isEmpty(label)) {\n    return 1;\n  }\n\n  const words = label.split(' ');\n  return words.length;\n};\n\n// findLongestWord is also used in plot\nexport const findLongestWord = (label) => {\n  let longestWord = (label || '')\n    .replace(/<[^>]+>/g, '')\n    .split(' ')\n    .sort((a, b) => b.length - a.length);\n\n  return longestWord[0].length;\n};\n\n// amountToIncreaseWidth is also used in plot\nexport const amountToIncreaseWidth = (longestWord) => {\n  if (!longestWord) {\n    return 0;\n  }\n\n  return longestWord * 10;\n};\n\nexport const polygonToArea = (points) => {\n  const h = head(points);\n  const area = {\n    left: h.x,\n    top: h.y,\n    bottom: h.y,\n    right: h.x,\n  };\n  return tail(points).reduce((a, p) => {\n    a.left = Math.min(a.left, p.x);\n    a.top = Math.max(a.top, p.y);\n    a.bottom = Math.min(a.bottom, p.y);\n    a.right = Math.max(a.right, p.x);\n    return a;\n  }, area);\n};\n\nexport const lineToArea = (from, to) => pointsToArea(from, to);\n\nexport const pointsToArea = (a, b) => {\n  invariant(!!a && !!b, 'a or b is undefined');\n  const left = Math.min(a.x, b.x);\n  const top = Math.max(a.y, b.y);\n  const bottom = Math.min(a.y, b.y);\n  const right = Math.max(a.x, b.x);\n  return { left, top, bottom, right };\n};\n\nexport const getRightestPoints = (points) => {\n  const sortedPoints = cloneDeep(points);\n  sortedPoints.sort((a, b) => b.x - a.x);\n\n  return { a: sortedPoints[0], b: sortedPoints[1] };\n};\n\nexport const getMiddleOfTwoPoints = (a, b) => ({\n  x: (a.x + b.x) / 2,\n  y: (a.y + b.y) / 2,\n});\n\nexport const roundNumber = (number) => parseFloat(number.toFixed(4));\n\nexport const sameAxes = (p1, p2) =>\n  p1 && p2 && (roundNumber(p1.x) === roundNumber(p2.x) || roundNumber(p1.y) === roundNumber(p2.y));\n\nexport const equalPoints = (p1, p2) =>\n  p1 &&\n  p2 &&\n  isEqual(\n    {\n      x: roundNumber(p1.x),\n      y: roundNumber(p1.y),\n    },\n    {\n      x: roundNumber(p2.x),\n      y: roundNumber(p2.y),\n    },\n  );\n\nconst getDistanceBetweenTicks = (axis, size) => {\n  const { min, max, step } = axis;\n  const nbOfTicks = (max - min) / step;\n\n  return size / nbOfTicks;\n};\n\nexport const thinnerShapesNeeded = (graphProps) => {\n  const {\n    domain,\n    range,\n    size: { width, height },\n  } = graphProps;\n\n  // 14 is the default width of a point\n  return getDistanceBetweenTicks(domain, width) < 14 || getDistanceBetweenTicks(range, height) < 14;\n};\n\nexport const getAdjustedGraphLimits = (graphProps) => {\n  const {\n    domain,\n    range,\n    size: { width, height },\n  } = graphProps;\n  const domainTicksDistance = getDistanceBetweenTicks(domain, width);\n  const rangeTicksDistance = getDistanceBetweenTicks(range, height);\n\n  // 15 is the distance required for the arrow to extend the graph\n  const domainPadding = domain.step / (domainTicksDistance / 15);\n  const rangePadding = range.step / (rangeTicksDistance / 15);\n\n  return {\n    domain: {\n      min: domain.min - domainPadding,\n      max: domain.max + domainPadding,\n    },\n    range: {\n      min: range.min - rangePadding,\n      max: range.max + rangePadding,\n    },\n  };\n};\n\nconst sortPoints = (array) => (array || []).sort((a, b) => a.x - b.x || a.y - b.y);\n\n// check colliniarity of 3 points (source: https://www.geeksforgeeks.org/program-check-three-points-collinear/)\nconst checkCollinearity = (a, b, c) => (a.x - b.x) * (c.y - b.y) === (c.x - b.x) * (a.y - b.y);\n\n// 2 lines are overlapping if all 4 points are collinear\nconst isSameLine = (markA, markB) =>\n  checkCollinearity(markA.from, markB.from, markB.to) && checkCollinearity(markA.to, markB.from, markB.to);\n\nexport const isDuplicatedMark = (mark, marks, oldMark) => {\n  const { type, building } = mark;\n\n  if (building) {\n    return false;\n  }\n\n  const filteredMarks = (marks || []).filter((m) => m.type === type && !m.building);\n  const index = filteredMarks.findIndex((m) => isEqual(m, oldMark));\n\n  if (index !== -1) {\n    filteredMarks.splice(index, 1);\n  }\n\n  const duplicated = filteredMarks.find((m) => {\n    if (type === 'line') {\n      const { from, to } = mark;\n      return (\n        (equalPoints(from, m.from) && equalPoints(to, m.to)) ||\n        (equalPoints(from, m.to) && equalPoints(to, m.from)) ||\n        (type === 'line' && isSameLine(m, mark))\n      );\n    } else if (type === 'polygon') {\n      return isEqual(sortPoints(cloneDeep(mark.points)), sortPoints(cloneDeep(m.points)));\n    }\n  });\n\n  return !!duplicated;\n};\n\nexport const areArraysOfObjectsEqual = (array1, array2) => {\n  // Check if both arrays have the same length\n  if (array1.length !== array2.length) {\n    return false;\n  }\n  // Iterate through each object in the arrays\n  for (let i = 0; i < array1.length; i++) {\n    // Get the current objects in both arrays\n    const obj1 = array1[i];\n    const obj2 = array2[i];\n    // Check if the objects have the same number of properties\n    if (Object.keys(obj1).length !== Object.keys(obj2).length) {\n      return false;\n    }\n    // Iterate through each property in the objects\n    for (const key in obj1) {\n      // Check if the properties and their values are equal\n      if (obj1[key] !== obj2[key]) {\n        return false;\n      }\n    }\n  }\n  // If all objects are equal, the arrays are the same\n  return true;\n};\n"]}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@pie-lib/graphing-solution-set",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "2.16.0-beta.0",
+  "description": "Graphing components",
+  "keywords": [
+    "react",
+    "pie",
+    "graphing"
+  ],
+  "repository": "pie-framework/pie-lib",
+  "main": "lib/index.js",
+  "module": "src/index.js",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@mapbox/point-geometry": "^0.1.0",
+    "@material-ui/core": "^3.8.3",
+    "@pie-lib/drag": "^2.4.0-beta.0",
+    "@pie-lib/graphing-utils": "^1.3.0-beta.0",
+    "@pie-lib/plot": "^2.9.0-beta.0",
+    "@pie-lib/render-ui": "^4.17.0-beta.0",
+    "@pie-lib/translator": "^2.5.0-beta.0",
+    "@vx/axis": "^0.0.189",
+    "@vx/clip-path": "^0.0.189",
+    "@vx/event": "^0.0.189",
+    "@vx/grid": "^0.0.189",
+    "@vx/point": "^0.0.189",
+    "@vx/shape": "^0.0.189",
+    "classnames": "^2.2.6",
+    "d3-scale": "^2.1.2",
+    "d3-selection": "^1.3.2",
+    "debug": "^4.1.1",
+    "invariant": "^2.2.4",
+    "lodash": "^4.17.11",
+    "react": "^16.8.1",
+    "react-draggable": "^3.3.0",
+    "react-input-autosize": "^2.2.1",
+    "react-redux": "^6.0.0",
+    "redux": "^4.0.1",
+    "redux-undo": "beta"
+  },
+  "peerDependencies": {
+    "react": "^16.8.1"
+  },
+  "gitHead": "3818c24530f62b5bb9be7a2c6aa5428f13a17e0a",
+  "scripts": {}
+}

package/src/__tests__/__snapshots__/graph-with-controls.test.jsx.snap

@@ -0,0 +1,114 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`GraphWithControls snapshot renders 1`] = `
+<div
+  className=""
+>
+  <div />
+  <div />
+  <Graph
+    axesSettings={
+      Object {
+        "includeArrows": true,
+      }
+    }
+    backgroundMarks={Array []}
+    coordinatesOnHover={false}
+    currentTool={
+      Object {
+        "Component": [Function],
+        "addPoint": [Function],
+        "toolbar": true,
+        "type": "line",
+      }
+    }
+    disabled={false}
+    disabledLabels={false}
+    disabledTitle={false}
+    domain={
+      Object {
+        "max": 10,
+        "min": 0,
+        "step": 1,
+      }
+    }
+    labelModeEnabled={false}
+    labels={
+      Object {
+        "bottom": "d",
+        "left": "b",
+        "right": "c",
+        "top": "a",
+      }
+    }
+    marks={
+      Array [
+        Object {
+          "building": true,
+          "from": Object {
+            "x": 0,
+            "y": 0,
+          },
+          "label": "Line",
+          "to": Object {
+            "x": 1,
+            "y": 1,
+          },
+          "type": "line",
+        },
+        Object {
+          "points": Array [
+            Object {
+              "x": 0,
+              "y": 0,
+            },
+            Object {
+              "x": 1,
+              "y": 1,
+            },
+            Object {
+              "x": 2,
+              "y": 2,
+            },
+          ],
+          "type": "polygon",
+        },
+      ]
+    }
+    onChangeMarks={[MockFunction]}
+    range={
+      Object {
+        "max": 10,
+        "min": 0,
+        "step": 1,
+      }
+    }
+    showLabels={true}
+    showTitle={true}
+    size={
+      Object {
+        "height": 500,
+        "width": 500,
+      }
+    }
+    title="Title"
+    tools={
+      Array [
+        Object {
+          "Component": [Function],
+          "addPoint": [Function],
+          "toolbar": true,
+          "type": "line",
+        },
+        Object {
+          "Component": [Function],
+          "addPoint": [Function],
+          "complete": [Function],
+          "toolbar": true,
+          "type": "polygon",
+        },
+      ]
+    }
+  />
+</div>
+`;