@pie-lib/graphing 2.15.0-beta.3 → 2.15.0-beta.5

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.15.0-beta.5](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.5) (2025-07-25)
+
+**Note:** Version bump only for package @pie-lib/graphing
+
+
+
+
+
+# [2.15.0-beta.4](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.4) (2025-07-25)
+
+**Note:** Version bump only for package @pie-lib/graphing
+
+
+
+
+
+# [2.15.0-beta.3](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.3) (2025-07-25)
+
+**Note:** Version bump only for package @pie-lib/graphing
+
+
+
+
+
+# [2.15.0-beta.4](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.4) (2025-07-23)
+
+**Note:** Version bump only for package @pie-lib/graphing
+
+
+
+
+
+# [2.15.0-beta.3](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.3) (2025-07-23)
+
+**Note:** Version bump only for package @pie-lib/graphing
+
+
+
+
+
 # [2.15.0-beta.3](https://github.com/pie-framework/pie-lib/compare/@pie-lib/graphing@2.14.21...@pie-lib/graphing@2.15.0-beta.3) (2025-07-20)
 
 **Note:** Version bump only for package @pie-lib/graphing

package/lib/__tests__/graph-with-controls.test.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _utils = require("./utils");
+
+var _graphWithControls = require("../graph-with-controls");
+
+var _tools = require("@pie-lib/tools");
+
+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; }
+
+var point = {
+  type: 'point',
+  x: 2,
+  y: 2,
+  label: 'Point',
+  showLabel: true
+};
+var line = {
+  type: 'line',
+  from: {
+    x: 0,
+    y: 0
+  },
+  to: {
+    x: 1,
+    y: 1
+  },
+  label: 'Line',
+  building: true
+};
+var circle = {
+  type: 'line',
+  edge: {
+    x: 0,
+    y: 0
+  },
+  root: {
+    x: 2,
+    y: 2
+  }
+};
+var marks = [point, line, circle];
+describe('setToolbarAvailability', function () {
+  it('sets `toolbar: true` if tool should be displayed in toolbar - all tools', function () {
+    var result = (0, _graphWithControls.setToolbarAvailability)(_tools.allTools);
+    var allTrue = new Array(_tools.toolsArr.length).fill(true);
+    expect(result.map(function (r) {
+      return r.toolbar;
+    })).toEqual(allTrue);
+  });
+  it('sets `toolbar: true` if tool should be displayed in toolbar - few tools', function () {
+    var result = (0, _graphWithControls.setToolbarAvailability)(['line', 'circle']);
+    var allOthersFalse = new Array(_tools.toolsArr.length - 2).fill(false);
+    expect(result.filter(function (r) {
+      return r.type === 'line' || r.type === 'circle';
+    }).map(function (r) {
+      return r.toolbar;
+    })).toEqual([true, true]);
+    expect(result.filter(function (r) {
+      return r.type !== 'line' && r.type !== 'circle';
+    }).map(function (r) {
+      return r.toolbar;
+    })).toEqual(allOthersFalse);
+  });
+});
+describe('toolIsAvailable', function () {
+  var tools = (0, _graphWithControls.setToolbarAvailability)(['line', 'circle']);
+  it('returns true if tool is available', function () {
+    expect((0, _graphWithControls.toolIsAvailable)(tools, (0, _tools.line)())).toEqual(true);
+  });
+  it('returns false if tool is not available', function () {
+    expect((0, _graphWithControls.toolIsAvailable)(tools, (0, _tools.point)())).toEqual(false);
+  });
+});
+describe('getAvailableTool', function () {
+  it('returns the first available tool in list if there is any', function () {
+    var tools = (0, _graphWithControls.setToolbarAvailability)(['line', 'circle']);
+    expect((0, _graphWithControls.getAvailableTool)(tools).toolbar).toEqual(true);
+  });
+  it('returns undefined list if there is no available tool', function () {
+    var tools = (0, _graphWithControls.setToolbarAvailability)([]);
+    expect((0, _graphWithControls.getAvailableTool)(tools)).toEqual(undefined);
+  });
+});
+describe('filterByValidToolTypes', function () {
+  it('filters marks by valid types', function () {
+    var marks = [{
+      type: 'point'
+    }, {
+      type: 'a'
+    }, {
+      type: 'b'
+    }, {
+      type: 'line'
+    }, {
+      type: 'c'
+    }];
+    expect((0, _graphWithControls.filterByValidToolTypes)(marks)).toEqual([{
+      type: 'point'
+    }, {
+      type: 'line'
+    }]);
+  });
+});
+describe('filterByVisibleToolTypes', function () {
+  it('filters marks by the types that should be visible', function () {
+    expect((0, _graphWithControls.filterByVisibleToolTypes)(['line', 'circle'], [{
+      type: 'point'
+    }, {
+      type: 'line'
+    }, {
+      type: 'circle'
+    }])).toEqual([{
+      type: 'line'
+    }, {
+      type: 'circle'
+    }]);
+    expect((0, _graphWithControls.filterByVisibleToolTypes)(['line', 'circle', 'point'], [{
+      type: 'point'
+    }, {
+      type: 'line'
+    }, {
+      type: 'circle'
+    }])).toEqual([{
+      type: 'point'
+    }, {
+      type: 'line'
+    }, {
+      type: 'circle'
+    }]);
+    expect((0, _graphWithControls.filterByVisibleToolTypes)(['line'], [{
+      type: 'point'
+    }, {
+      type: 'line'
+    }, {
+      type: 'circle'
+    }])).toEqual([{
+      type: 'line'
+    }]);
+    expect((0, _graphWithControls.filterByVisibleToolTypes)(['segment'], [{
+      type: 'point'
+    }, {
+      type: 'line'
+    }, {
+      type: 'circle'
+    }])).toEqual([]);
+  });
+});
+describe('GraphWithControls', function () {
+  var w;
+  var onChangeMarks = jest.fn();
+
+  var defaultProps = function defaultProps() {
+    return {
+      axesSettings: {
+        includeArrows: true
+      },
+      backgroundMarks: [point, line, circle],
+      classes: {},
+      className: '',
+      coordinatesOnHover: false,
+      domain: {
+        min: 0,
+        max: 10,
+        step: 1
+      },
+      labels: {
+        top: 'a',
+        left: 'b',
+        right: 'c',
+        bottom: 'd'
+      },
+      labelModeEnabled: true,
+      marks: marks,
+      onChangeMarks: onChangeMarks,
+      range: {
+        min: 0,
+        max: 10,
+        step: 1
+      },
+      size: {
+        width: 500,
+        height: 500
+      },
+      title: 'Title',
+      toolbarTools: _tools.allTools
+    };
+  };
+
+  var initialProps = defaultProps();
+
+  var wrapper = function wrapper(extras, opts) {
+    var props = _objectSpread(_objectSpread({}, initialProps), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_graphWithControls.GraphWithControls, props), opts);
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/graph-with-controls.test.jsx"],"names":["point","type","x","y","label","showLabel","line","from","to","building","circle","edge","root","marks","describe","it","result","allTools","allTrue","Array","toolsArr","length","fill","expect","map","r","toolbar","toEqual","allOthersFalse","filter","tools","undefined","w","onChangeMarks","jest","fn","defaultProps","axesSettings","includeArrows","backgroundMarks","classes","className","coordinatesOnHover","domain","min","max","step","labels","top","left","right","bottom","labelModeEnabled","range","size","width","height","title","toolbarTools","initialProps","wrapper","extras","opts","props","toMatchSnapshot"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\n\nimport { xy } from './utils';\n\nimport {\n  GraphWithControls,\n  setToolbarAvailability,\n  toolIsAvailable,\n  getAvailableTool,\n  filterByValidToolTypes,\n  filterByVisibleToolTypes,\n} from '../graph-with-controls';\nimport { toolsArr, allTools, line as lineTool, point as pointTool } from '@pie-lib/tools';\n\nconst point = {\n  type: 'point',\n  x: 2,\n  y: 2,\n  label: 'Point',\n  showLabel: true,\n};\n\nconst line = {\n  type: 'line',\n  from: { x: 0, y: 0 },\n  to: { x: 1, y: 1 },\n  label: 'Line',\n  building: true,\n};\n\nconst circle = {\n  type: 'line',\n  edge: { x: 0, y: 0 },\n  root: { x: 2, y: 2 },\n};\n\nconst marks = [point, line, circle];\n\ndescribe('setToolbarAvailability', () => {\n  it('sets `toolbar: true` if tool should be displayed in toolbar - all tools', () => {\n    const result = setToolbarAvailability(allTools);\n    const allTrue = new Array(toolsArr.length).fill(true);\n\n    expect(result.map((r) => r.toolbar)).toEqual(allTrue);\n  });\n\n  it('sets `toolbar: true` if tool should be displayed in toolbar - few tools', () => {\n    const result = setToolbarAvailability(['line', 'circle']);\n    const allOthersFalse = new Array(toolsArr.length - 2).fill(false);\n\n    expect(result.filter((r) => r.type === 'line' || r.type === 'circle').map((r) => r.toolbar)).toEqual([true, true]);\n    expect(result.filter((r) => r.type !== 'line' && r.type !== 'circle').map((r) => r.toolbar)).toEqual(\n      allOthersFalse,\n    );\n  });\n});\n\ndescribe('toolIsAvailable', () => {\n  const tools = setToolbarAvailability(['line', 'circle']);\n\n  it('returns true if tool is available', () => {\n    expect(toolIsAvailable(tools, lineTool())).toEqual(true);\n  });\n\n  it('returns false if tool is not available', () => {\n    expect(toolIsAvailable(tools, pointTool())).toEqual(false);\n  });\n});\n\ndescribe('getAvailableTool', () => {\n  it('returns the first available tool in list if there is any', () => {\n    const tools = setToolbarAvailability(['line', 'circle']);\n\n    expect(getAvailableTool(tools).toolbar).toEqual(true);\n  });\n\n  it('returns undefined list if there is no available tool', () => {\n    const tools = setToolbarAvailability([]);\n\n    expect(getAvailableTool(tools)).toEqual(undefined);\n  });\n});\n\ndescribe('filterByValidToolTypes', () => {\n  it('filters marks by valid types', () => {\n    const marks = [{ type: 'point' }, { type: 'a' }, { type: 'b' }, { type: 'line' }, { type: 'c' }];\n\n    expect(filterByValidToolTypes(marks)).toEqual([{ type: 'point' }, { type: 'line' }]);\n  });\n});\n\ndescribe('filterByVisibleToolTypes', () => {\n  it('filters marks by the types that should be visible', () => {\n    expect(\n      filterByVisibleToolTypes(['line', 'circle'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }]),\n    ).toEqual([{ type: 'line' }, { type: 'circle' }]);\n\n    expect(\n      filterByVisibleToolTypes(['line', 'circle', 'point'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }]),\n    ).toEqual([{ type: 'point' }, { type: 'line' }, { type: 'circle' }]);\n\n    expect(filterByVisibleToolTypes(['line'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }])).toEqual([\n      { type: 'line' },\n    ]);\n\n    expect(filterByVisibleToolTypes(['segment'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }])).toEqual(\n      [],\n    );\n  });\n});\n\ndescribe('GraphWithControls', () => {\n  let w;\n  let onChangeMarks = jest.fn();\n\n  const defaultProps = () => ({\n    axesSettings: { includeArrows: true },\n    backgroundMarks: [point, line, circle],\n    classes: {},\n    className: '',\n    coordinatesOnHover: false,\n    domain: { min: 0, max: 10, step: 1 },\n    labels: { top: 'a', left: 'b', right: 'c', bottom: 'd' },\n    labelModeEnabled: true,\n    marks,\n    onChangeMarks,\n    range: { min: 0, max: 10, step: 1 },\n    size: { width: 500, height: 500 },\n    title: 'Title',\n    toolbarTools: allTools,\n  });\n  const initialProps = defaultProps();\n\n  const wrapper = (extras, opts) => {\n    const props = { ...initialProps, ...extras };\n\n    return shallow(<GraphWithControls {...props} />, opts);\n  };\n\n  describe('snapshot', () => {\n    it('renders', () => {\n      w = wrapper();\n      expect(w).toMatchSnapshot();\n    });\n  });\n});\n"]}

package/lib/__tests__/graph.test.js

@@ -0,0 +1,290 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _utils = require("./utils");
+
+var _graph = _interopRequireWildcard(require("../graph"));
+
+var _tools = require("@pie-lib/tools");
+
+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; }
+
+describe('removeBuildingToolIfCurrentToolDiffers', function () {
+  var marks = [{
+    type: 'point',
+    x: 2,
+    y: 2,
+    label: 'Point',
+    showLabel: true
+  }, {
+    type: 'line',
+    from: {
+      x: 0,
+      y: 0
+    },
+    label: 'Line',
+    building: true
+  }];
+  it('keeps all marks if currentTool is the same', function () {
+    expect((0, _graph.removeBuildingToolIfCurrentToolDiffers)({
+      marks: marks,
+      currentTool: {
+        type: 'line'
+      }
+    })).toEqual(marks);
+  });
+  it('removes building marks if currentTool is different', function () {
+    expect((0, _graph.removeBuildingToolIfCurrentToolDiffers)({
+      marks: marks,
+      currentTool: {
+        type: 'different'
+      }
+    })).toEqual([marks[0]]);
+  });
+});
+describe('Graph', function () {
+  var onChangeMarks = jest.fn();
+  var wrapper;
+  var complete = jest.fn();
+  var addPoint = jest.fn();
+  var currentTool = _tools.toolsArr[0];
+  currentTool.complete = complete;
+  currentTool.addPoint = addPoint;
+  var props = {
+    classes: {},
+    className: 'className',
+    onChangeMarks: onChangeMarks,
+    tools: _tools.toolsArr,
+    domain: {
+      min: 0,
+      max: 1,
+      step: 1
+    },
+    range: {
+      min: 0,
+      max: 1,
+      step: 1
+    },
+    size: {
+      width: 400,
+      height: 400
+    },
+    currentTool: currentTool
+  };
+  beforeEach(function () {
+    wrapper = function wrapper(extras, opts) {
+      var properties = _objectSpread(_objectSpread({}, props), {}, {
+        marks: [{
+          type: 'point',
+          x: 2,
+          y: 2,
+          label: 'Point',
+          showLabel: true
+        }, {
+          type: 'line',
+          from: {
+            x: 0,
+            y: 0
+          },
+          label: 'Line',
+          building: true
+        }]
+      }, extras);
+
+      console.log('props', props.marks);
+      return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_graph["default"], properties), opts);
+    };
+  });
+  describe('snapshot', function () {
+    it('renders', function () {
+      jest.spyOn(_graph["default"].prototype, 'generateMaskId').mockReturnValue('graph-1618');
+      var w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    describe('componentDidMount', function () {
+      it('sets the labelNode to state', function () {
+        var w = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_graph["default"], props), {
+          disableLifecycleMethods: true
+        });
+        w.instance().labelNode = {};
+        w.instance().componentDidMount();
+        expect(w.state('labelNode')).toEqual(w.instance().labelNode);
+      });
+    });
+    describe('changeMark', function () {
+      it('does not call onChangeMarks', function () {
+        var newMark = {
+          type: 'mark',
+          x: 2,
+          y: 2
+        };
+        var w = wrapper();
+        w.instance().changeMark(newMark, newMark);
+        expect(onChangeMarks).not.toBeCalled();
+      });
+      it('calls onChangeMarks', function () {
+        var newMark = {
+          type: 'mark',
+          x: 2,
+          y: 2
+        };
+        var w = wrapper();
+        var marks = w.instance().props.marks;
+        console.log('w model', w.instance().props.marks);
+        w.instance().changeMark(marks[0], newMark);
+        expect(onChangeMarks).toHaveBeenCalledWith([newMark, marks[1]]);
+      });
+    });
+    describe('completeMark', function () {
+      it('does not call updateMarks if no building mark', function () {
+        var updateMarks = jest.fn();
+        var w = wrapper({
+          marks: [{
+            type: 'point',
+            x: 1,
+            y: 1
+          }]
+        });
+        w.instance().updateMarks = updateMarks;
+        w.instance().completeMark({
+          x: 3,
+          y: 3
+        });
+        expect(complete).not.toBeCalled();
+        expect(updateMarks).not.toBeCalled();
+      });
+      it('does not call updateMarks if no current tool', function () {
+        var updateMarks = jest.fn();
+        var w = wrapper({
+          currentTool: null
+        });
+        w.instance().updateMarks = updateMarks;
+        w.instance().completeMark({
+          x: 3,
+          y: 3
+        });
+        expect(complete).not.toBeCalled();
+        expect(updateMarks).not.toBeCalled();
+      });
+      it('calls updateMarks', function () {
+        var updateMarks = jest.fn();
+        var w = wrapper();
+        w.instance().updateMarks = updateMarks;
+        w.instance().completeMark({
+          x: 3,
+          y: 3
+        });
+        expect(complete).toHaveBeenCalled();
+        expect(updateMarks).toHaveBeenCalled();
+      });
+    });
+    describe('updateMarks', function () {
+      it('calls onChangeMarks', function () {
+        var marks = [_objectSpread({
+          type: 'mark'
+        }, (0, _utils.xy)(2, 2))];
+
+        var update = _objectSpread({
+          type: 'mark'
+        }, (0, _utils.xy)(4, 4));
+
+        wrapper({
+          marks: marks
+        }).instance().updateMarks(marks[0], update, false);
+      });
+      it('calls onChangeMarks with added mark', function () {
+        var marks = [];
+
+        var update = _objectSpread({
+          type: 'mark'
+        }, (0, _utils.xy)(4, 4));
+
+        wrapper({
+          marks: marks
+        }).instance().updateMarks(marks[0], [update], true);
+      });
+    });
+    describe('getComponent', function () {
+      var compMock = jest.fn();
+      it('returns null if no mark', function () {
+        var w = wrapper();
+        expect(w.instance().getComponent()).toEqual(null);
+        expect(w.instance().getComponent(undefined)).toEqual(null);
+        expect(w.instance().getComponent(null)).toEqual(null);
+      });
+      it('returns the component', function () {
+        var w = wrapper();
+        w.instance().props.tools[0].Component = compMock;
+        var Comp = w.instance().getComponent({
+          type: _tools.toolsArr[0].type
+        });
+        expect(Comp).toEqual(compMock);
+      });
+      it('returns null if there is no tool', function () {
+        var w = wrapper();
+        expect(w.instance().getComponent({
+          type: 'mark'
+        })).toEqual(null);
+      });
+      it('returns null if there is no tool.Component', function () {
+        var w = wrapper();
+        w.instance().props.tools[0].Component = undefined;
+        expect(w.instance().getComponent({
+          type: _tools.toolsArr[0].type
+        })).toEqual(null);
+      });
+    });
+    describe('onBgClick', function () {
+      it('calls updateMarks', function () {
+        var buildingMark = {
+          type: 'mark',
+          building: true,
+          x: 1,
+          y: 1
+        };
+        var marks = [{
+          type: 'mark'
+        }, buildingMark];
+        var updateMarks = jest.fn();
+        var w = wrapper({
+          marks: marks
+        });
+        w.instance().updateMarks = updateMarks;
+        w.instance().onBgClick({
+          x: 3,
+          y: 3
+        });
+        expect(w.instance().updateMarks).toHaveBeenCalled();
+      });
+      it('returns early of labelModeEnabled', function () {
+        var w = wrapper({
+          labelModeEnabled: true
+        });
+        w.instance().updateMarks = jest.fn();
+        w.instance().onBgClick({
+          x: 3,
+          y: 3
+        });
+        expect(w.instance().updateMarks).not.toHaveBeenCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/graph.test.jsx"],"names":["describe","marks","type","x","y","label","showLabel","from","building","it","expect","currentTool","toEqual","onChangeMarks","jest","fn","wrapper","complete","addPoint","toolsArr","props","classes","className","tools","domain","min","max","step","range","size","width","height","beforeEach","extras","opts","properties","console","log","spyOn","Graph","prototype","mockReturnValue","w","toMatchSnapshot","disableLifecycleMethods","instance","labelNode","componentDidMount","state","newMark","changeMark","not","toBeCalled","toHaveBeenCalledWith","updateMarks","completeMark","toHaveBeenCalled","update","compMock","getComponent","undefined","Component","Comp","buildingMark","onBgClick","labelModeEnabled"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\n\nimport { xy } from './utils';\n\nimport Graph, { removeBuildingToolIfCurrentToolDiffers } from '../graph';\nimport { toolsArr } from '@pie-lib/tools';\n\ndescribe('removeBuildingToolIfCurrentToolDiffers', () => {\n  let marks = [\n    {\n      type: 'point',\n      x: 2,\n      y: 2,\n      label: 'Point',\n      showLabel: true,\n    },\n    {\n      type: 'line',\n      from: { x: 0, y: 0 },\n      label: 'Line',\n      building: true,\n    },\n  ];\n\n  it('keeps all marks if currentTool is the same', () => {\n    expect(removeBuildingToolIfCurrentToolDiffers({ marks, currentTool: { type: 'line' } })).toEqual(marks);\n  });\n\n  it('removes building marks if currentTool is different', () => {\n    expect(removeBuildingToolIfCurrentToolDiffers({ marks, currentTool: { type: 'different' } })).toEqual([marks[0]]);\n  });\n});\n\ndescribe('Graph', () => {\n  let onChangeMarks = jest.fn();\n  let wrapper;\n\n  const complete = jest.fn();\n  const addPoint = jest.fn();\n  const currentTool = toolsArr[0];\n  currentTool.complete = complete;\n  currentTool.addPoint = addPoint;\n\n  const props = {\n    classes: {},\n    className: 'className',\n    onChangeMarks,\n    tools: toolsArr,\n    domain: { min: 0, max: 1, step: 1 },\n    range: { min: 0, max: 1, step: 1 },\n    size: { width: 400, height: 400 },\n    currentTool,\n  };\n\n  beforeEach(() => {\n    wrapper = (extras, opts) => {\n      const properties = {\n        ...props,\n        marks: [\n          {\n            type: 'point',\n            x: 2,\n            y: 2,\n            label: 'Point',\n            showLabel: true,\n          },\n          {\n            type: 'line',\n            from: { x: 0, y: 0 },\n            label: 'Line',\n            building: true,\n          },\n        ],\n        ...extras,\n      };\n      console.log('props', props.marks);\n      return shallow(<Graph {...properties} />, opts);\n    };\n  });\n\n  describe('snapshot', () => {\n    it('renders', () => {\n      jest.spyOn(Graph.prototype, 'generateMaskId').mockReturnValue('graph-1618');\n      let w = wrapper();\n      expect(w).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    describe('componentDidMount', () => {\n      it('sets the labelNode to state', () => {\n        let w = shallow(<Graph {...props} />, { disableLifecycleMethods: true });\n\n        w.instance().labelNode = {};\n        w.instance().componentDidMount();\n        expect(w.state('labelNode')).toEqual(w.instance().labelNode);\n      });\n    });\n\n    describe('changeMark', () => {\n      it('does not call onChangeMarks', () => {\n        const newMark = { type: 'mark', x: 2, y: 2 };\n\n        let w = wrapper();\n        w.instance().changeMark(newMark, newMark);\n        expect(onChangeMarks).not.toBeCalled();\n      });\n\n      it('calls onChangeMarks', () => {\n        const newMark = { type: 'mark', x: 2, y: 2 };\n\n        let w = wrapper();\n        let marks = w.instance().props.marks;\n\n        console.log('w model', w.instance().props.marks);\n        w.instance().changeMark(marks[0], newMark);\n        expect(onChangeMarks).toHaveBeenCalledWith([newMark, marks[1]]);\n      });\n    });\n\n    describe('completeMark', () => {\n      it('does not call updateMarks if no building mark', () => {\n        const updateMarks = jest.fn();\n        let w = wrapper({ marks: [{ type: 'point', x: 1, y: 1 }] });\n\n        w.instance().updateMarks = updateMarks;\n        w.instance().completeMark({ x: 3, y: 3 });\n\n        expect(complete).not.toBeCalled();\n        expect(updateMarks).not.toBeCalled();\n      });\n\n      it('does not call updateMarks if no current tool', () => {\n        const updateMarks = jest.fn();\n        let w = wrapper({ currentTool: null });\n\n        w.instance().updateMarks = updateMarks;\n        w.instance().completeMark({ x: 3, y: 3 });\n\n        expect(complete).not.toBeCalled();\n        expect(updateMarks).not.toBeCalled();\n      });\n\n      it('calls updateMarks', () => {\n        const updateMarks = jest.fn();\n        let w = wrapper();\n\n        w.instance().updateMarks = updateMarks;\n        w.instance().completeMark({ x: 3, y: 3 });\n\n        expect(complete).toHaveBeenCalled();\n        expect(updateMarks).toHaveBeenCalled();\n      });\n    });\n\n    describe('updateMarks', () => {\n      it('calls onChangeMarks', () => {\n        const marks = [{ type: 'mark', ...xy(2, 2) }];\n        const update = { type: 'mark', ...xy(4, 4) };\n\n        wrapper({ marks })\n          .instance()\n          .updateMarks(marks[0], update, false);\n      });\n\n      it('calls onChangeMarks with added mark', () => {\n        const marks = [];\n        const update = { type: 'mark', ...xy(4, 4) };\n\n        wrapper({ marks })\n          .instance()\n          .updateMarks(marks[0], [update], true);\n      });\n    });\n\n    describe('getComponent', () => {\n      let compMock = jest.fn();\n\n      it('returns null if no mark', () => {\n        let w = wrapper();\n\n        expect(w.instance().getComponent()).toEqual(null);\n        expect(w.instance().getComponent(undefined)).toEqual(null);\n        expect(w.instance().getComponent(null)).toEqual(null);\n      });\n\n      it('returns the component', () => {\n        let w = wrapper();\n        w.instance().props.tools[0].Component = compMock;\n\n        const Comp = w.instance().getComponent({ type: toolsArr[0].type });\n        expect(Comp).toEqual(compMock);\n      });\n\n      it('returns null if there is no tool', () => {\n        let w = wrapper();\n        expect(w.instance().getComponent({ type: 'mark' })).toEqual(null);\n      });\n\n      it('returns null if there is no tool.Component', () => {\n        let w = wrapper();\n        w.instance().props.tools[0].Component = undefined;\n\n        expect(w.instance().getComponent({ type: toolsArr[0].type })).toEqual(null);\n      });\n    });\n\n    describe('onBgClick', () => {\n      it('calls updateMarks', () => {\n        const buildingMark = { type: 'mark', building: true, x: 1, y: 1 };\n        const marks = [{ type: 'mark' }, buildingMark];\n\n        const updateMarks = jest.fn();\n\n        let w = wrapper({ marks });\n        w.instance().updateMarks = updateMarks;\n        w.instance().onBgClick({ x: 3, y: 3 });\n        expect(w.instance().updateMarks).toHaveBeenCalled();\n      });\n\n      it('returns early of labelModeEnabled', () => {\n        let w = wrapper({ labelModeEnabled: true });\n        w.instance().updateMarks = jest.fn();\n        w.instance().onBgClick({ x: 3, y: 3 });\n        expect(w.instance().updateMarks).not.toHaveBeenCalled();\n      });\n    });\n  });\n});\n"]}

package/lib/__tests__/grid.test.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _grid = require("../grid");
+
+var _utils = require("./utils");
+
+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; }
+
+describe('Grid', function () {
+  var w;
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      graphProps: (0, _utils.graphProps)()
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_grid.Grid, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      return expect(wrapper()).toMatchSnapshot();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9fX3Rlc3RzX18vZ3JpZC50ZXN0LmpzeCJdLCJuYW1lcyI6WyJkZXNjcmliZSIsInciLCJ3cmFwcGVyIiwiZXh0cmFzIiwiZGVmYXVsdHMiLCJjbGFzc2VzIiwiY2xhc3NOYW1lIiwiZ3JhcGhQcm9wcyIsInByb3BzIiwiaXQiLCJleHBlY3QiLCJ0b01hdGNoU25hcHNob3QiXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBOztBQUNBOztBQUNBOztBQUNBOzs7Ozs7QUFFQUEsUUFBUSxDQUFDLE1BQUQsRUFBUyxZQUFNO0FBQ3JCLE1BQUlDLENBQUo7O0FBQ0EsTUFBTUMsT0FBTyxHQUFHLFNBQVZBLE9BQVUsQ0FBQ0MsTUFBRCxFQUFZO0FBQzFCLFFBQU1DLFFBQVEsR0FBRztBQUNmQyxNQUFBQSxPQUFPLEVBQUUsRUFETTtBQUVmQyxNQUFBQSxTQUFTLEVBQUUsV0FGSTtBQUdmQyxNQUFBQSxVQUFVLEVBQUU7QUFIRyxLQUFqQjs7QUFLQSxRQUFNQyxLQUFLLG1DQUFRSixRQUFSLEdBQXFCRCxNQUFyQixDQUFYOztBQUNBLFdBQU8sbUNBQVEsZ0NBQUMsVUFBRCxFQUFVSyxLQUFWLENBQVIsQ0FBUDtBQUNELEdBUkQ7O0FBU0FSLEVBQUFBLFFBQVEsQ0FBQyxVQUFELEVBQWEsWUFBTTtBQUN6QlMsSUFBQUEsRUFBRSxDQUFDLFNBQUQsRUFBWTtBQUFBLGFBQU1DLE1BQU0sQ0FBQ1IsT0FBTyxFQUFSLENBQU4sQ0FBa0JTLGVBQWxCLEVBQU47QUFBQSxLQUFaLENBQUY7QUFDRCxHQUZPLENBQVI7QUFHRCxDQWRPLENBQVIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaGFsbG93IH0gZnJvbSAnZW56eW1lJztcbmltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQgeyBHcmlkIH0gZnJvbSAnLi4vZ3JpZCc7XG5pbXBvcnQgeyBncmFwaFByb3BzIH0gZnJvbSAnLi91dGlscyc7XG5cbmRlc2NyaWJlKCdHcmlkJywgKCkgPT4ge1xuICBsZXQgdztcbiAgY29uc3Qgd3JhcHBlciA9IChleHRyYXMpID0+IHtcbiAgICBjb25zdCBkZWZhdWx0cyA9IHtcbiAgICAgIGNsYXNzZXM6IHt9LFxuICAgICAgY2xhc3NOYW1lOiAnY2xhc3NOYW1lJyxcbiAgICAgIGdyYXBoUHJvcHM6IGdyYXBoUHJvcHMoKSxcbiAgICB9O1xuICAgIGNvbnN0IHByb3BzID0geyAuLi5kZWZhdWx0cywgLi4uZXh0cmFzIH07XG4gICAgcmV0dXJuIHNoYWxsb3coPEdyaWQgey4uLnByb3BzfSAvPik7XG4gIH07XG4gIGRlc2NyaWJlKCdzbmFwc2hvdCcsICgpID0+IHtcbiAgICBpdCgncmVuZGVycycsICgpID0+IGV4cGVjdCh3cmFwcGVyKCkpLnRvTWF0Y2hTbmFwc2hvdCgpKTtcbiAgfSk7XG59KTtcbiJdfQ==