@pie-lib/graphing 4.0.23 → 4.0.24-beta.10

package/lib/tools/polygon/__tests__/index.test.js

@@ -0,0 +1,303 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _index = require("../index");
+var _component = _interopRequireDefault(require("../component"));
+var xy = function xy(x, y) {
+  return {
+    x: x,
+    y: y
+  };
+};
+
+/**
+ * Test suite for polygon tool
+ *
+ * Note: equalPoints() uses roundNumber() which rounds to 4 decimal places.
+ * - Values like 1.0001 and 1.0002 are considered DIFFERENT (round to 1.0001 and 1.0002)
+ * - Values like 1.00001 and 1.00002 are considered EQUAL (both round to 1.0000)
+ */
+
+describe('polygon', function () {
+  describe('addPointToArray', function () {
+    var assertAddPoint = function assertAddPoint(point, arr, expected) {
+      it("returns expected result when adding point to array", function () {
+        var result = (0, _index.addPointToArray)(point, arr);
+        expect(result).toEqual(expected);
+      });
+    };
+    assertAddPoint(xy(0, 0), [], {
+      closed: false,
+      points: [xy(0, 0)]
+    });
+    assertAddPoint(xy(0, 0), [xy(0, 0)], {
+      closed: false,
+      points: [xy(0, 0)]
+    });
+    assertAddPoint(xy(1, 1), [xy(0, 0)], {
+      closed: false,
+      points: [xy(0, 0), xy(1, 1)]
+    });
+    it('handles undefined array', function () {
+      var result = (0, _index.addPointToArray)(xy(1, 2), undefined);
+      expect(result).toEqual({
+        points: [xy(1, 2)],
+        closed: false
+      });
+    });
+    it('handles null array', function () {
+      var result = (0, _index.addPointToArray)(xy(1, 2), null);
+      expect(result).toEqual({
+        points: [xy(1, 2)],
+        closed: false
+      });
+    });
+    it('closes polygon when clicking first point', function () {
+      var firstPoint = xy(1, 2);
+      var points = [firstPoint, xy(3, 4), xy(5, 6)];
+      var result = (0, _index.addPointToArray)(firstPoint, points);
+      expect(result).toEqual({
+        points: points,
+        closed: true
+      });
+    });
+    it('does not add duplicate point in middle', function () {
+      var points = [xy(1, 2), xy(3, 4), xy(5, 6)];
+      var result = (0, _index.addPointToArray)(points[1], points);
+      expect(result).toEqual({
+        points: points,
+        closed: false
+      });
+    });
+    it('adds new point to array with 2+ points', function () {
+      var points = [xy(0, 0), xy(1, 1)];
+      var newPoint = xy(2, 2);
+      var result = (0, _index.addPointToArray)(newPoint, points);
+      expect(result).toEqual({
+        points: [].concat(points, [newPoint]),
+        closed: false
+      });
+    });
+    it('handles points within rounding tolerance', function () {
+      // roundNumber rounds to 4 decimal places
+      // 1.0001 and 1.0002 round to different values after toFixed(4)
+      var firstPoint = xy(1.0001, 2.0001);
+      var closePoint = xy(1.0002, 2.0002);
+      var result = (0, _index.addPointToArray)(closePoint, [firstPoint]);
+
+      // Since they round to different values, both points are added
+      expect(result).toEqual({
+        points: [firstPoint, closePoint],
+        closed: false
+      });
+    });
+    it('handles points that round to exactly the same value', function () {
+      // Points that round to exactly the same value after toFixed(4)
+      var firstPoint = xy(1.0001, 2.0001);
+      var samePoint = xy(1.0001, 2.0001);
+      var result = (0, _index.addPointToArray)(samePoint, [firstPoint]);
+
+      // Since they round to the same value, point is not added
+      expect(result).toEqual({
+        points: [firstPoint],
+        closed: false
+      });
+    });
+  });
+});
+describe('tool', function () {
+  var t;
+  beforeEach(function () {
+    t = (0, _index.tool)();
+  });
+  describe('tool structure', function () {
+    it('creates polygon type', function () {
+      expect(t.type).toEqual('polygon');
+    });
+    it('has Component property', function () {
+      expect(t.Component).toBe(_component["default"]);
+    });
+    it('has complete method', function () {
+      expect((0, _typeof2["default"])(t.complete)).toBe('function');
+    });
+    it('has addPoint method', function () {
+      expect((0, _typeof2["default"])(t.addPoint)).toBe('function');
+    });
+  });
+  describe('complete', function () {
+    it('closes polygon', function () {
+      expect(t.complete()).toEqual({
+        building: false,
+        closed: true
+      });
+    });
+    it('marks polygon as not building', function () {
+      var mark = {
+        type: 'polygon',
+        points: [xy(1, 2), xy(3, 4)],
+        closed: false,
+        building: true
+      };
+      var result = t.complete(null, mark);
+      expect(result.building).toBe(false);
+    });
+    it('marks polygon as closed', function () {
+      var mark = {
+        type: 'polygon',
+        points: [xy(1, 2), xy(3, 4)],
+        closed: false,
+        building: true
+      };
+      var result = t.complete(null, mark);
+      expect(result.closed).toBe(true);
+    });
+    it('preserves other mark properties', function () {
+      var mark = {
+        type: 'polygon',
+        points: [xy(1, 2)],
+        closed: false,
+        building: true,
+        label: 'Test',
+        color: 'red'
+      };
+      var result = t.complete(null, mark);
+      expect(result.label).toBe('Test');
+      expect(result.color).toBe('red');
+    });
+  });
+  describe('addPoint', function () {
+    it('creates new polygon with first point', function () {
+      var mark = t.addPoint({
+        x: 0,
+        y: 0
+      });
+      expect(mark).toEqual({
+        type: 'polygon',
+        points: [{
+          x: 0,
+          y: 0
+        }],
+        closed: false,
+        building: true
+      });
+    });
+    it('adds second point to existing mark', function () {
+      var mark = t.addPoint({
+        x: 0,
+        y: 0
+      }, {
+        points: [{
+          x: 1,
+          y: 1
+        }]
+      });
+      expect(mark).toEqual({
+        building: true,
+        closed: false,
+        points: [{
+          x: 1,
+          y: 1
+        }, {
+          x: 0,
+          y: 0
+        }]
+      });
+    });
+    it('creates mark with building flag true', function () {
+      var mark = t.addPoint(xy(1, 2));
+      expect(mark.building).toBe(true);
+    });
+    it('creates mark with closed flag false', function () {
+      var mark = t.addPoint(xy(1, 2));
+      expect(mark.closed).toBe(false);
+    });
+    it('adds multiple points sequentially', function () {
+      var mark = t.addPoint(xy(0, 0));
+      mark = t.addPoint(xy(1, 1), mark);
+      mark = t.addPoint(xy(2, 2), mark);
+      expect(mark.points).toHaveLength(3);
+      expect(mark.points).toEqual([xy(0, 0), xy(1, 1), xy(2, 2)]);
+    });
+    it('closes polygon when clicking first point', function () {
+      var firstPoint = xy(1, 2);
+      var mark = t.addPoint(firstPoint);
+      mark = t.addPoint(xy(3, 4), mark);
+      mark = t.addPoint(xy(5, 6), mark);
+      mark = t.addPoint(firstPoint, mark);
+      expect(mark.closed).toBe(true);
+      expect(mark.building).toBe(false);
+    });
+    it('does not add duplicate points', function () {
+      var point = xy(1, 2);
+      var mark = t.addPoint(point);
+      mark = t.addPoint(xy(3, 4), mark);
+      // Adding the first point again would close it
+      // Let's add it one more time after closing to test duplicate handling
+      mark = t.addPoint(point, mark);
+
+      // When we add the first point to a polygon with 2+ points, it closes
+      expect(mark.points).toHaveLength(2);
+      expect(mark.closed).toBe(true);
+      expect(mark.building).toBe(false);
+    });
+    it('does not add duplicate non-first points', function () {
+      var firstPoint = xy(1, 2);
+      var secondPoint = xy(3, 4);
+      var mark = t.addPoint(firstPoint);
+      mark = t.addPoint(secondPoint, mark);
+      mark = t.addPoint(xy(5, 6), mark);
+      // Try to add the second point again (not the first point)
+      mark = t.addPoint(secondPoint, mark);
+
+      // Should not add the duplicate point
+      expect(mark.points).toHaveLength(3);
+      expect(mark.points).toEqual([firstPoint, secondPoint, xy(5, 6)]);
+      expect(mark.closed).toBe(false);
+    });
+    it('preserves mark properties when adding points', function () {
+      var mark = {
+        type: 'polygon',
+        points: [xy(1, 2)],
+        closed: false,
+        building: true,
+        label: 'My Shape'
+      };
+      var result = t.addPoint(xy(3, 4), mark);
+      expect(result.label).toBe('My Shape');
+    });
+  });
+  describe('integration scenarios', function () {
+    it('creates complete triangle', function () {
+      var p1 = xy(0, 0);
+      var p2 = xy(1, 0);
+      var p3 = xy(0.5, 1);
+      var mark = t.addPoint(p1);
+      mark = t.addPoint(p2, mark);
+      mark = t.addPoint(p3, mark);
+      mark = t.addPoint(p1, mark);
+      expect(mark.points).toEqual([p1, p2, p3]);
+      expect(mark.closed).toBe(true);
+      expect(mark.building).toBe(false);
+    });
+    it('creates complete square', function () {
+      var points = [xy(0, 0), xy(1, 0), xy(1, 1), xy(0, 1)];
+      var mark = t.addPoint(points[0]);
+      points.slice(1).forEach(function (p) {
+        mark = t.addPoint(p, mark);
+      });
+      mark = t.addPoint(points[0], mark);
+      expect(mark.points).toEqual(points);
+      expect(mark.closed).toBe(true);
+    });
+    it('can force complete without closing', function () {
+      var mark = t.addPoint(xy(0, 0));
+      mark = t.addPoint(xy(1, 1), mark);
+      mark = t.complete(null, mark);
+      expect(mark.closed).toBe(true);
+      expect(mark.building).toBe(false);
+      expect(mark.points).toHaveLength(2);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_index","require","_component","_interopRequireDefault","xy","x","y","describe","assertAddPoint","point","arr","expected","it","result","addPointToArray","expect","toEqual","closed","points","undefined","firstPoint","newPoint","concat","closePoint","samePoint","t","beforeEach","tool","type","Component","toBe","Polygon","_typeof2","complete","addPoint","building","mark","label","color","toHaveLength","secondPoint","p1","p2","p3","slice","forEach","p"],"sources":["../../../../src/tools/polygon/__tests__/index.test.js"],"sourcesContent":["import { addPointToArray, tool } from '../index';\nimport Polygon from '../component';\n\nconst xy = (x, y) => ({ x, y });\n\n/**\n * Test suite for polygon tool\n *\n * Note: equalPoints() uses roundNumber() which rounds to 4 decimal places.\n * - Values like 1.0001 and 1.0002 are considered DIFFERENT (round to 1.0001 and 1.0002)\n * - Values like 1.00001 and 1.00002 are considered EQUAL (both round to 1.0000)\n */\n\ndescribe('polygon', () => {\n  describe('addPointToArray', () => {\n    const assertAddPoint = (point, arr, expected) => {\n      it(`returns expected result when adding point to array`, () => {\n        const result = addPointToArray(point, arr);\n        expect(result).toEqual(expected);\n      });\n    };\n\n    assertAddPoint(xy(0, 0), [], { closed: false, points: [xy(0, 0)] });\n    assertAddPoint(xy(0, 0), [xy(0, 0)], { closed: false, points: [xy(0, 0)] });\n    assertAddPoint(xy(1, 1), [xy(0, 0)], {\n      closed: false,\n      points: [xy(0, 0), xy(1, 1)],\n    });\n\n    it('handles undefined array', () => {\n      const result = addPointToArray(xy(1, 2), undefined);\n      expect(result).toEqual({ points: [xy(1, 2)], closed: false });\n    });\n\n    it('handles null array', () => {\n      const result = addPointToArray(xy(1, 2), null);\n      expect(result).toEqual({ points: [xy(1, 2)], closed: false });\n    });\n\n    it('closes polygon when clicking first point', () => {\n      const firstPoint = xy(1, 2);\n      const points = [firstPoint, xy(3, 4), xy(5, 6)];\n      const result = addPointToArray(firstPoint, points);\n\n      expect(result).toEqual({ points, closed: true });\n    });\n\n    it('does not add duplicate point in middle', () => {\n      const points = [xy(1, 2), xy(3, 4), xy(5, 6)];\n      const result = addPointToArray(points[1], points);\n\n      expect(result).toEqual({ points, closed: false });\n    });\n\n    it('adds new point to array with 2+ points', () => {\n      const points = [xy(0, 0), xy(1, 1)];\n      const newPoint = xy(2, 2);\n      const result = addPointToArray(newPoint, points);\n\n      expect(result).toEqual({\n        points: [...points, newPoint],\n        closed: false,\n      });\n    });\n\n    it('handles points within rounding tolerance', () => {\n      // roundNumber rounds to 4 decimal places\n      // 1.0001 and 1.0002 round to different values after toFixed(4)\n      const firstPoint = xy(1.0001, 2.0001);\n      const closePoint = xy(1.0002, 2.0002);\n      const result = addPointToArray(closePoint, [firstPoint]);\n\n      // Since they round to different values, both points are added\n      expect(result).toEqual({ points: [firstPoint, closePoint], closed: false });\n    });\n\n    it('handles points that round to exactly the same value', () => {\n      // Points that round to exactly the same value after toFixed(4)\n      const firstPoint = xy(1.0001, 2.0001);\n      const samePoint = xy(1.0001, 2.0001);\n      const result = addPointToArray(samePoint, [firstPoint]);\n\n      // Since they round to the same value, point is not added\n      expect(result).toEqual({ points: [firstPoint], closed: false });\n    });\n  });\n});\n\ndescribe('tool', () => {\n  let t;\n\n  beforeEach(() => {\n    t = tool();\n  });\n\n  describe('tool structure', () => {\n    it('creates polygon type', () => {\n      expect(t.type).toEqual('polygon');\n    });\n\n    it('has Component property', () => {\n      expect(t.Component).toBe(Polygon);\n    });\n\n    it('has complete method', () => {\n      expect(typeof t.complete).toBe('function');\n    });\n\n    it('has addPoint method', () => {\n      expect(typeof t.addPoint).toBe('function');\n    });\n  });\n\n  describe('complete', () => {\n    it('closes polygon', () => {\n      expect(t.complete()).toEqual({ building: false, closed: true });\n    });\n\n    it('marks polygon as not building', () => {\n      const mark = {\n        type: 'polygon',\n        points: [xy(1, 2), xy(3, 4)],\n        closed: false,\n        building: true,\n      };\n      const result = t.complete(null, mark);\n\n      expect(result.building).toBe(false);\n    });\n\n    it('marks polygon as closed', () => {\n      const mark = {\n        type: 'polygon',\n        points: [xy(1, 2), xy(3, 4)],\n        closed: false,\n        building: true,\n      };\n      const result = t.complete(null, mark);\n\n      expect(result.closed).toBe(true);\n    });\n\n    it('preserves other mark properties', () => {\n      const mark = {\n        type: 'polygon',\n        points: [xy(1, 2)],\n        closed: false,\n        building: true,\n        label: 'Test',\n        color: 'red',\n      };\n      const result = t.complete(null, mark);\n\n      expect(result.label).toBe('Test');\n      expect(result.color).toBe('red');\n    });\n  });\n\n  describe('addPoint', () => {\n    it('creates new polygon with first point', () => {\n      const mark = t.addPoint({ x: 0, y: 0 });\n      expect(mark).toEqual({\n        type: 'polygon',\n        points: [{ x: 0, y: 0 }],\n        closed: false,\n        building: true,\n      });\n    });\n\n    it('adds second point to existing mark', () => {\n      const mark = t.addPoint({ x: 0, y: 0 }, { points: [{ x: 1, y: 1 }] });\n      expect(mark).toEqual({\n        building: true,\n        closed: false,\n        points: [\n          { x: 1, y: 1 },\n          { x: 0, y: 0 },\n        ],\n      });\n    });\n\n    it('creates mark with building flag true', () => {\n      const mark = t.addPoint(xy(1, 2));\n      expect(mark.building).toBe(true);\n    });\n\n    it('creates mark with closed flag false', () => {\n      const mark = t.addPoint(xy(1, 2));\n      expect(mark.closed).toBe(false);\n    });\n\n    it('adds multiple points sequentially', () => {\n      let mark = t.addPoint(xy(0, 0));\n      mark = t.addPoint(xy(1, 1), mark);\n      mark = t.addPoint(xy(2, 2), mark);\n\n      expect(mark.points).toHaveLength(3);\n      expect(mark.points).toEqual([xy(0, 0), xy(1, 1), xy(2, 2)]);\n    });\n\n    it('closes polygon when clicking first point', () => {\n      const firstPoint = xy(1, 2);\n      let mark = t.addPoint(firstPoint);\n      mark = t.addPoint(xy(3, 4), mark);\n      mark = t.addPoint(xy(5, 6), mark);\n      mark = t.addPoint(firstPoint, mark);\n\n      expect(mark.closed).toBe(true);\n      expect(mark.building).toBe(false);\n    });\n\n    it('does not add duplicate points', () => {\n      const point = xy(1, 2);\n      let mark = t.addPoint(point);\n      mark = t.addPoint(xy(3, 4), mark);\n      // Adding the first point again would close it\n      // Let's add it one more time after closing to test duplicate handling\n      mark = t.addPoint(point, mark);\n\n      // When we add the first point to a polygon with 2+ points, it closes\n      expect(mark.points).toHaveLength(2);\n      expect(mark.closed).toBe(true);\n      expect(mark.building).toBe(false);\n    });\n\n    it('does not add duplicate non-first points', () => {\n      const firstPoint = xy(1, 2);\n      const secondPoint = xy(3, 4);\n      let mark = t.addPoint(firstPoint);\n      mark = t.addPoint(secondPoint, mark);\n      mark = t.addPoint(xy(5, 6), mark);\n      // Try to add the second point again (not the first point)\n      mark = t.addPoint(secondPoint, mark);\n\n      // Should not add the duplicate point\n      expect(mark.points).toHaveLength(3);\n      expect(mark.points).toEqual([firstPoint, secondPoint, xy(5, 6)]);\n      expect(mark.closed).toBe(false);\n    });\n\n    it('preserves mark properties when adding points', () => {\n      const mark = {\n        type: 'polygon',\n        points: [xy(1, 2)],\n        closed: false,\n        building: true,\n        label: 'My Shape',\n      };\n\n      const result = t.addPoint(xy(3, 4), mark);\n      expect(result.label).toBe('My Shape');\n    });\n  });\n\n  describe('integration scenarios', () => {\n    it('creates complete triangle', () => {\n      const p1 = xy(0, 0);\n      const p2 = xy(1, 0);\n      const p3 = xy(0.5, 1);\n\n      let mark = t.addPoint(p1);\n      mark = t.addPoint(p2, mark);\n      mark = t.addPoint(p3, mark);\n      mark = t.addPoint(p1, mark);\n\n      expect(mark.points).toEqual([p1, p2, p3]);\n      expect(mark.closed).toBe(true);\n      expect(mark.building).toBe(false);\n    });\n\n    it('creates complete square', () => {\n      const points = [xy(0, 0), xy(1, 0), xy(1, 1), xy(0, 1)];\n\n      let mark = t.addPoint(points[0]);\n      points.slice(1).forEach((p) => {\n        mark = t.addPoint(p, mark);\n      });\n      mark = t.addPoint(points[0], mark);\n\n      expect(mark.points).toEqual(points);\n      expect(mark.closed).toBe(true);\n    });\n\n    it('can force complete without closing', () => {\n      let mark = t.addPoint(xy(0, 0));\n      mark = t.addPoint(xy(1, 1), mark);\n      mark = t.complete(null, mark);\n\n      expect(mark.closed).toBe(true);\n      expect(mark.building).toBe(false);\n      expect(mark.points).toHaveLength(2);\n    });\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAMG,EAAE,GAAG,SAALA,EAAEA,CAAIC,CAAC,EAAEC,CAAC;EAAA,OAAM;IAAED,CAAC,EAADA,CAAC;IAAEC,CAAC,EAADA;EAAE,CAAC;AAAA,CAAC;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEAC,QAAQ,CAAC,SAAS,EAAE,YAAM;EACxBA,QAAQ,CAAC,iBAAiB,EAAE,YAAM;IAChC,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CAAIC,KAAK,EAAEC,GAAG,EAAEC,QAAQ,EAAK;MAC/CC,EAAE,uDAAuD,YAAM;QAC7D,IAAMC,MAAM,GAAG,IAAAC,sBAAe,EAACL,KAAK,EAAEC,GAAG,CAAC;QAC1CK,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAACL,QAAQ,CAAC;MAClC,CAAC,CAAC;IACJ,CAAC;IAEDH,cAAc,CAACJ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE;MAAEa,MAAM,EAAE,KAAK;MAAEC,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAAE,CAAC,CAAC;IACnEI,cAAc,CAACJ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAACA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;MAAEa,MAAM,EAAE,KAAK;MAAEC,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAAE,CAAC,CAAC;IAC3EI,cAAc,CAACJ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAACA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;MACnCa,MAAM,EAAE,KAAK;MACbC,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC,CAAC;IAEFQ,EAAE,CAAC,yBAAyB,EAAE,YAAM;MAClC,IAAMC,MAAM,GAAG,IAAAC,sBAAe,EAACV,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEe,SAAS,CAAC;MACnDJ,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAAEa,MAAM,EAAE;MAAM,CAAC,CAAC;IAC/D,CAAC,CAAC;IAEFL,EAAE,CAAC,oBAAoB,EAAE,YAAM;MAC7B,IAAMC,MAAM,GAAG,IAAAC,sBAAe,EAACV,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC;MAC9CW,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAAEa,MAAM,EAAE;MAAM,CAAC,CAAC;IAC/D,CAAC,CAAC;IAEFL,EAAE,CAAC,0CAA0C,EAAE,YAAM;MACnD,IAAMQ,UAAU,GAAGhB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MAC3B,IAAMc,MAAM,GAAG,CAACE,UAAU,EAAEhB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC/C,IAAMS,MAAM,GAAG,IAAAC,sBAAe,EAACM,UAAU,EAAEF,MAAM,CAAC;MAElDH,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAANA,MAAM;QAAED,MAAM,EAAE;MAAK,CAAC,CAAC;IAClD,CAAC,CAAC;IAEFL,EAAE,CAAC,wCAAwC,EAAE,YAAM;MACjD,IAAMM,MAAM,GAAG,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC7C,IAAMS,MAAM,GAAG,IAAAC,sBAAe,EAACI,MAAM,CAAC,CAAC,CAAC,EAAEA,MAAM,CAAC;MAEjDH,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAANA,MAAM;QAAED,MAAM,EAAE;MAAM,CAAC,CAAC;IACnD,CAAC,CAAC;IAEFL,EAAE,CAAC,wCAAwC,EAAE,YAAM;MACjD,IAAMM,MAAM,GAAG,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MACnC,IAAMiB,QAAQ,GAAGjB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MACzB,IAAMS,MAAM,GAAG,IAAAC,sBAAe,EAACO,QAAQ,EAAEH,MAAM,CAAC;MAEhDH,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QACrBE,MAAM,KAAAI,MAAA,CAAMJ,MAAM,GAAEG,QAAQ,EAAC;QAC7BJ,MAAM,EAAE;MACV,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFL,EAAE,CAAC,0CAA0C,EAAE,YAAM;MACnD;MACA;MACA,IAAMQ,UAAU,GAAGhB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;MACrC,IAAMmB,UAAU,GAAGnB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;MACrC,IAAMS,MAAM,GAAG,IAAAC,sBAAe,EAACS,UAAU,EAAE,CAACH,UAAU,CAAC,CAAC;;MAExD;MACAL,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAAE,CAACE,UAAU,EAAEG,UAAU,CAAC;QAAEN,MAAM,EAAE;MAAM,CAAC,CAAC;IAC7E,CAAC,CAAC;IAEFL,EAAE,CAAC,qDAAqD,EAAE,YAAM;MAC9D;MACA,IAAMQ,UAAU,GAAGhB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;MACrC,IAAMoB,SAAS,GAAGpB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;MACpC,IAAMS,MAAM,GAAG,IAAAC,sBAAe,EAACU,SAAS,EAAE,CAACJ,UAAU,CAAC,CAAC;;MAEvD;MACAL,MAAM,CAACF,MAAM,CAAC,CAACG,OAAO,CAAC;QAAEE,MAAM,EAAE,CAACE,UAAU,CAAC;QAAEH,MAAM,EAAE;MAAM,CAAC,CAAC;IACjE,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC;AAEFV,QAAQ,CAAC,MAAM,EAAE,YAAM;EACrB,IAAIkB,CAAC;EAELC,UAAU,CAAC,YAAM;IACfD,CAAC,GAAG,IAAAE,WAAI,EAAC,CAAC;EACZ,CAAC,CAAC;EAEFpB,QAAQ,CAAC,gBAAgB,EAAE,YAAM;IAC/BK,EAAE,CAAC,sBAAsB,EAAE,YAAM;MAC/BG,MAAM,CAACU,CAAC,CAACG,IAAI,CAAC,CAACZ,OAAO,CAAC,SAAS,CAAC;IACnC,CAAC,CAAC;IAEFJ,EAAE,CAAC,wBAAwB,EAAE,YAAM;MACjCG,MAAM,CAACU,CAAC,CAACI,SAAS,CAAC,CAACC,IAAI,CAACC,qBAAO,CAAC;IACnC,CAAC,CAAC;IAEFnB,EAAE,CAAC,qBAAqB,EAAE,YAAM;MAC9BG,MAAM,KAAAiB,QAAA,aAAQP,CAAC,CAACQ,QAAQ,EAAC,CAACH,IAAI,CAAC,UAAU,CAAC;IAC5C,CAAC,CAAC;IAEFlB,EAAE,CAAC,qBAAqB,EAAE,YAAM;MAC9BG,MAAM,KAAAiB,QAAA,aAAQP,CAAC,CAACS,QAAQ,EAAC,CAACJ,IAAI,CAAC,UAAU,CAAC;IAC5C,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFvB,QAAQ,CAAC,UAAU,EAAE,YAAM;IACzBK,EAAE,CAAC,gBAAgB,EAAE,YAAM;MACzBG,MAAM,CAACU,CAAC,CAACQ,QAAQ,CAAC,CAAC,CAAC,CAACjB,OAAO,CAAC;QAAEmB,QAAQ,EAAE,KAAK;QAAElB,MAAM,EAAE;MAAK,CAAC,CAAC;IACjE,CAAC,CAAC;IAEFL,EAAE,CAAC,+BAA+B,EAAE,YAAM;MACxC,IAAMwB,IAAI,GAAG;QACXR,IAAI,EAAE,SAAS;QACfV,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5Ba,MAAM,EAAE,KAAK;QACbkB,QAAQ,EAAE;MACZ,CAAC;MACD,IAAMtB,MAAM,GAAGY,CAAC,CAACQ,QAAQ,CAAC,IAAI,EAAEG,IAAI,CAAC;MAErCrB,MAAM,CAACF,MAAM,CAACsB,QAAQ,CAAC,CAACL,IAAI,CAAC,KAAK,CAAC;IACrC,CAAC,CAAC;IAEFlB,EAAE,CAAC,yBAAyB,EAAE,YAAM;MAClC,IAAMwB,IAAI,GAAG;QACXR,IAAI,EAAE,SAAS;QACfV,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5Ba,MAAM,EAAE,KAAK;QACbkB,QAAQ,EAAE;MACZ,CAAC;MACD,IAAMtB,MAAM,GAAGY,CAAC,CAACQ,QAAQ,CAAC,IAAI,EAAEG,IAAI,CAAC;MAErCrB,MAAM,CAACF,MAAM,CAACI,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;IAClC,CAAC,CAAC;IAEFlB,EAAE,CAAC,iCAAiC,EAAE,YAAM;MAC1C,IAAMwB,IAAI,GAAG;QACXR,IAAI,EAAE,SAAS;QACfV,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClBa,MAAM,EAAE,KAAK;QACbkB,QAAQ,EAAE,IAAI;QACdE,KAAK,EAAE,MAAM;QACbC,KAAK,EAAE;MACT,CAAC;MACD,IAAMzB,MAAM,GAAGY,CAAC,CAACQ,QAAQ,CAAC,IAAI,EAAEG,IAAI,CAAC;MAErCrB,MAAM,CAACF,MAAM,CAACwB,KAAK,CAAC,CAACP,IAAI,CAAC,MAAM,CAAC;MACjCf,MAAM,CAACF,MAAM,CAACyB,KAAK,CAAC,CAACR,IAAI,CAAC,KAAK,CAAC;IAClC,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFvB,QAAQ,CAAC,UAAU,EAAE,YAAM;IACzBK,EAAE,CAAC,sCAAsC,EAAE,YAAM;MAC/C,IAAMwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC;QAAE7B,CAAC,EAAE,CAAC;QAAEC,CAAC,EAAE;MAAE,CAAC,CAAC;MACvCS,MAAM,CAACqB,IAAI,CAAC,CAACpB,OAAO,CAAC;QACnBY,IAAI,EAAE,SAAS;QACfV,MAAM,EAAE,CAAC;UAAEb,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC,CAAC;QACxBW,MAAM,EAAE,KAAK;QACbkB,QAAQ,EAAE;MACZ,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFvB,EAAE,CAAC,oCAAoC,EAAE,YAAM;MAC7C,IAAMwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC;QAAE7B,CAAC,EAAE,CAAC;QAAEC,CAAC,EAAE;MAAE,CAAC,EAAE;QAAEY,MAAM,EAAE,CAAC;UAAEb,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC;MAAE,CAAC,CAAC;MACrES,MAAM,CAACqB,IAAI,CAAC,CAACpB,OAAO,CAAC;QACnBmB,QAAQ,EAAE,IAAI;QACdlB,MAAM,EAAE,KAAK;QACbC,MAAM,EAAE,CACN;UAAEb,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC,EACd;UAAED,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC;MAElB,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFM,EAAE,CAAC,sCAAsC,EAAE,YAAM;MAC/C,IAAMwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MACjCW,MAAM,CAACqB,IAAI,CAACD,QAAQ,CAAC,CAACL,IAAI,CAAC,IAAI,CAAC;IAClC,CAAC,CAAC;IAEFlB,EAAE,CAAC,qCAAqC,EAAE,YAAM;MAC9C,IAAMwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MACjCW,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC,CAAC;IAEFlB,EAAE,CAAC,mCAAmC,EAAE,YAAM;MAC5C,IAAIwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC/BgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjCA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MAEjCrB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACqB,YAAY,CAAC,CAAC,CAAC;MACnCxB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACF,OAAO,CAAC,CAACZ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7D,CAAC,CAAC;IAEFQ,EAAE,CAAC,0CAA0C,EAAE,YAAM;MACnD,IAAMQ,UAAU,GAAGhB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MAC3B,IAAIgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACd,UAAU,CAAC;MACjCgB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjCA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjCA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACd,UAAU,EAAEgB,IAAI,CAAC;MAEnCrB,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;MAC9Bf,MAAM,CAACqB,IAAI,CAACD,QAAQ,CAAC,CAACL,IAAI,CAAC,KAAK,CAAC;IACnC,CAAC,CAAC;IAEFlB,EAAE,CAAC,+BAA+B,EAAE,YAAM;MACxC,IAAMH,KAAK,GAAGL,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MACtB,IAAIgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACzB,KAAK,CAAC;MAC5B2B,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjC;MACA;MACAA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACzB,KAAK,EAAE2B,IAAI,CAAC;;MAE9B;MACArB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACqB,YAAY,CAAC,CAAC,CAAC;MACnCxB,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;MAC9Bf,MAAM,CAACqB,IAAI,CAACD,QAAQ,CAAC,CAACL,IAAI,CAAC,KAAK,CAAC;IACnC,CAAC,CAAC;IAEFlB,EAAE,CAAC,yCAAyC,EAAE,YAAM;MAClD,IAAMQ,UAAU,GAAGhB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MAC3B,IAAMoC,WAAW,GAAGpC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MAC5B,IAAIgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACd,UAAU,CAAC;MACjCgB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACM,WAAW,EAAEJ,IAAI,CAAC;MACpCA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjC;MACAA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACM,WAAW,EAAEJ,IAAI,CAAC;;MAEpC;MACArB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACqB,YAAY,CAAC,CAAC,CAAC;MACnCxB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACF,OAAO,CAAC,CAACI,UAAU,EAAEoB,WAAW,EAAEpC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;MAChEW,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,KAAK,CAAC;IACjC,CAAC,CAAC;IAEFlB,EAAE,CAAC,8CAA8C,EAAE,YAAM;MACvD,IAAMwB,IAAI,GAAG;QACXR,IAAI,EAAE,SAAS;QACfV,MAAM,EAAE,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClBa,MAAM,EAAE,KAAK;QACbkB,QAAQ,EAAE,IAAI;QACdE,KAAK,EAAE;MACT,CAAC;MAED,IAAMxB,MAAM,GAAGY,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACzCrB,MAAM,CAACF,MAAM,CAACwB,KAAK,CAAC,CAACP,IAAI,CAAC,UAAU,CAAC;IACvC,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFvB,QAAQ,CAAC,uBAAuB,EAAE,YAAM;IACtCK,EAAE,CAAC,2BAA2B,EAAE,YAAM;MACpC,IAAM6B,EAAE,GAAGrC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MACnB,IAAMsC,EAAE,GAAGtC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;MACnB,IAAMuC,EAAE,GAAGvC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;MAErB,IAAIgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACO,EAAE,CAAC;MACzBL,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACQ,EAAE,EAAEN,IAAI,CAAC;MAC3BA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACS,EAAE,EAAEP,IAAI,CAAC;MAC3BA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACO,EAAE,EAAEL,IAAI,CAAC;MAE3BrB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACF,OAAO,CAAC,CAACyB,EAAE,EAAEC,EAAE,EAAEC,EAAE,CAAC,CAAC;MACzC5B,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;MAC9Bf,MAAM,CAACqB,IAAI,CAACD,QAAQ,CAAC,CAACL,IAAI,CAAC,KAAK,CAAC;IACnC,CAAC,CAAC;IAEFlB,EAAE,CAAC,yBAAyB,EAAE,YAAM;MAClC,IAAMM,MAAM,GAAG,CAACd,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAEvD,IAAIgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAChB,MAAM,CAAC,CAAC,CAAC,CAAC;MAChCA,MAAM,CAAC0B,KAAK,CAAC,CAAC,CAAC,CAACC,OAAO,CAAC,UAACC,CAAC,EAAK;QAC7BV,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAACY,CAAC,EAAEV,IAAI,CAAC;MAC5B,CAAC,CAAC;MACFA,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAChB,MAAM,CAAC,CAAC,CAAC,EAAEkB,IAAI,CAAC;MAElCrB,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACF,OAAO,CAACE,MAAM,CAAC;MACnCH,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;IAChC,CAAC,CAAC;IAEFlB,EAAE,CAAC,oCAAoC,EAAE,YAAM;MAC7C,IAAIwB,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC/BgC,IAAI,GAAGX,CAAC,CAACS,QAAQ,CAAC9B,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEgC,IAAI,CAAC;MACjCA,IAAI,GAAGX,CAAC,CAACQ,QAAQ,CAAC,IAAI,EAAEG,IAAI,CAAC;MAE7BrB,MAAM,CAACqB,IAAI,CAACnB,MAAM,CAAC,CAACa,IAAI,CAAC,IAAI,CAAC;MAC9Bf,MAAM,CAACqB,IAAI,CAACD,QAAQ,CAAC,CAACL,IAAI,CAAC,KAAK,CAAC;MACjCf,MAAM,CAACqB,IAAI,CAAClB,MAAM,CAAC,CAACqB,YAAY,CAAC,CAAC,CAAC;IACrC,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/tools/polygon/__tests__/line.test.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _testUtils = require("@pie-lib/test-utils");
+var _react = _interopRequireDefault(require("react"));
+var _line = require("../line");
+var _utils = require("../../../__tests__/utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+describe('Line', function () {
+  var renderComponent = function renderComponent(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      graphProps: (0, _utils.graphProps)()
+    };
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+    return (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_line.Line, props));
+  };
+  describe('rendering', function () {
+    it('renders without crashing', function () {
+      var _renderComponent = renderComponent(),
+        container = _renderComponent.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders with from and to points', function () {
+      var _renderComponent2 = renderComponent({
+          from: {
+            x: 0,
+            y: 0
+          },
+          to: {
+            x: 5,
+            y: 5
+          }
+        }),
+        container = _renderComponent2.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders with className', function () {
+      var _renderComponent3 = renderComponent({
+          className: 'custom-line'
+        }),
+        container = _renderComponent3.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfdGVzdFV0aWxzIiwicmVxdWlyZSIsIl9yZWFjdCIsIl9pbnRlcm9wUmVxdWlyZURlZmF1bHQiLCJfbGluZSIsIl91dGlscyIsIm93bktleXMiLCJlIiwiciIsInQiLCJPYmplY3QiLCJrZXlzIiwiZ2V0T3duUHJvcGVydHlTeW1ib2xzIiwibyIsImZpbHRlciIsImdldE93blByb3BlcnR5RGVzY3JpcHRvciIsImVudW1lcmFibGUiLCJwdXNoIiwiYXBwbHkiLCJfb2JqZWN0U3ByZWFkIiwiYXJndW1lbnRzIiwibGVuZ3RoIiwiZm9yRWFjaCIsIl9kZWZpbmVQcm9wZXJ0eTIiLCJnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3JzIiwiZGVmaW5lUHJvcGVydGllcyIsImRlZmluZVByb3BlcnR5IiwiZGVzY3JpYmUiLCJyZW5kZXJDb21wb25lbnQiLCJleHRyYXMiLCJkZWZhdWx0cyIsImNsYXNzZXMiLCJjbGFzc05hbWUiLCJncmFwaFByb3BzIiwicHJvcHMiLCJyZW5kZXIiLCJjcmVhdGVFbGVtZW50IiwiTGluZSIsIml0IiwiX3JlbmRlckNvbXBvbmVudCIsImNvbnRhaW5lciIsImV4cGVjdCIsImZpcnN0Q2hpbGQiLCJ0b0JlSW5UaGVEb2N1bWVudCIsIl9yZW5kZXJDb21wb25lbnQyIiwiZnJvbSIsIngiLCJ5IiwidG8iLCJfcmVuZGVyQ29tcG9uZW50MyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90b29scy9wb2x5Z29uL19fdGVzdHNfXy9saW5lLnRlc3QuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHJlbmRlciB9IGZyb20gJ0BwaWUtbGliL3Rlc3QtdXRpbHMnO1xuaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7IExpbmUgfSBmcm9tICcuLi9saW5lJztcbmltcG9ydCB7IGdyYXBoUHJvcHMgfSBmcm9tICcuLi8uLi8uLi9fX3Rlc3RzX18vdXRpbHMnO1xuXG5kZXNjcmliZSgnTGluZScsICgpID0+IHtcbiAgY29uc3QgcmVuZGVyQ29tcG9uZW50ID0gKGV4dHJhcykgPT4ge1xuICAgIGNvbnN0IGRlZmF1bHRzID0ge1xuICAgICAgY2xhc3Nlczoge30sXG4gICAgICBjbGFzc05hbWU6ICdjbGFzc05hbWUnLFxuICAgICAgZ3JhcGhQcm9wczogZ3JhcGhQcm9wcygpLFxuICAgIH07XG4gICAgY29uc3QgcHJvcHMgPSB7IC4uLmRlZmF1bHRzLCAuLi5leHRyYXMgfTtcbiAgICByZXR1cm4gcmVuZGVyKDxMaW5lIHsuLi5wcm9wc30gLz4pO1xuICB9O1xuICBkZXNjcmliZSgncmVuZGVyaW5nJywgKCkgPT4ge1xuICAgIGl0KCdyZW5kZXJzIHdpdGhvdXQgY3Jhc2hpbmcnLCAoKSA9PiB7XG4gICAgICBjb25zdCB7IGNvbnRhaW5lciB9ID0gcmVuZGVyQ29tcG9uZW50KCk7XG4gICAgICBleHBlY3QoY29udGFpbmVyLmZpcnN0Q2hpbGQpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gICAgfSk7XG5cbiAgICBpdCgncmVuZGVycyB3aXRoIGZyb20gYW5kIHRvIHBvaW50cycsICgpID0+IHtcbiAgICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXJDb21wb25lbnQoe1xuICAgICAgICBmcm9tOiB7IHg6IDAsIHk6IDAgfSxcbiAgICAgICAgdG86IHsgeDogNSwgeTogNSB9LFxuICAgICAgfSk7XG4gICAgICBleHBlY3QoY29udGFpbmVyLmZpcnN0Q2hpbGQpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gICAgfSk7XG5cbiAgICBpdCgncmVuZGVycyB3aXRoIGNsYXNzTmFtZScsICgpID0+IHtcbiAgICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXJDb21wb25lbnQoeyBjbGFzc05hbWU6ICdjdXN0b20tbGluZScgfSk7XG4gICAgICBleHBlY3QoY29udGFpbmVyLmZpcnN0Q2hpbGQpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gICAgfSk7XG4gIH0pO1xufSk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxJQUFBQSxVQUFBLEdBQUFDLE9BQUE7QUFDQSxJQUFBQyxNQUFBLEdBQUFDLHNCQUFBLENBQUFGLE9BQUE7QUFDQSxJQUFBRyxLQUFBLEdBQUFILE9BQUE7QUFDQSxJQUFBSSxNQUFBLEdBQUFKLE9BQUE7QUFBc0QsU0FBQUssUUFBQUMsQ0FBQSxFQUFBQyxDQUFBLFFBQUFDLENBQUEsR0FBQUMsTUFBQSxDQUFBQyxJQUFBLENBQUFKLENBQUEsT0FBQUcsTUFBQSxDQUFBRSxxQkFBQSxRQUFBQyxDQUFBLEdBQUFILE1BQUEsQ0FBQUUscUJBQUEsQ0FBQUwsQ0FBQSxHQUFBQyxDQUFBLEtBQUFLLENBQUEsR0FBQUEsQ0FBQSxDQUFBQyxNQUFBLFdBQUFOLENBQUEsV0FBQUUsTUFBQSxDQUFBSyx3QkFBQSxDQUFBUixDQUFBLEVBQUFDLENBQUEsRUFBQVEsVUFBQSxPQUFBUCxDQUFBLENBQUFRLElBQUEsQ0FBQUMsS0FBQSxDQUFBVCxDQUFBLEVBQUFJLENBQUEsWUFBQUosQ0FBQTtBQUFBLFNBQUFVLGNBQUFaLENBQUEsYUFBQUMsQ0FBQSxNQUFBQSxDQUFBLEdBQUFZLFNBQUEsQ0FBQUMsTUFBQSxFQUFBYixDQUFBLFVBQUFDLENBQUEsV0FBQVcsU0FBQSxDQUFBWixDQUFBLElBQUFZLFNBQUEsQ0FBQVosQ0FBQSxRQUFBQSxDQUFBLE9BQUFGLE9BQUEsQ0FBQUksTUFBQSxDQUFBRCxDQUFBLE9BQUFhLE9BQUEsV0FBQWQsQ0FBQSxRQUFBZSxnQkFBQSxhQUFBaEIsQ0FBQSxFQUFBQyxDQUFBLEVBQUFDLENBQUEsQ0FBQUQsQ0FBQSxTQUFBRSxNQUFBLENBQUFjLHlCQUFBLEdBQUFkLE1BQUEsQ0FBQWUsZ0JBQUEsQ0FBQWxCLENBQUEsRUFBQUcsTUFBQSxDQUFBYyx5QkFBQSxDQUFBZixDQUFBLEtBQUFILE9BQUEsQ0FBQUksTUFBQSxDQUFBRCxDQUFBLEdBQUFhLE9BQUEsV0FBQWQsQ0FBQSxJQUFBRSxNQUFBLENBQUFnQixjQUFBLENBQUFuQixDQUFBLEVBQUFDLENBQUEsRUFBQUUsTUFBQSxDQUFBSyx3QkFBQSxDQUFBTixDQUFBLEVBQUFELENBQUEsaUJBQUFELENBQUE7QUFFdERvQixRQUFRLENBQUMsTUFBTSxFQUFFLFlBQU07RUFDckIsSUFBTUMsZUFBZSxHQUFHLFNBQWxCQSxlQUFlQSxDQUFJQyxNQUFNLEVBQUs7SUFDbEMsSUFBTUMsUUFBUSxHQUFHO01BQ2ZDLE9BQU8sRUFBRSxDQUFDLENBQUM7TUFDWEMsU0FBUyxFQUFFLFdBQVc7TUFDdEJDLFVBQVUsRUFBRSxJQUFBQSxpQkFBVSxFQUFDO0lBQ3pCLENBQUM7SUFDRCxJQUFNQyxLQUFLLEdBQUFmLGFBQUEsQ0FBQUEsYUFBQSxLQUFRVyxRQUFRLEdBQUtELE1BQU0sQ0FBRTtJQUN4QyxPQUFPLElBQUFNLGlCQUFNLGVBQUNqQyxNQUFBLFlBQUFrQyxhQUFBLENBQUNoQyxLQUFBLENBQUFpQyxJQUFJLEVBQUtILEtBQVEsQ0FBQyxDQUFDO0VBQ3BDLENBQUM7RUFDRFAsUUFBUSxDQUFDLFdBQVcsRUFBRSxZQUFNO0lBQzFCVyxFQUFFLENBQUMsMEJBQTBCLEVBQUUsWUFBTTtNQUNuQyxJQUFBQyxnQkFBQSxHQUFzQlgsZUFBZSxDQUFDLENBQUM7UUFBL0JZLFNBQVMsR0FBQUQsZ0JBQUEsQ0FBVEMsU0FBUztNQUNqQkMsTUFBTSxDQUFDRCxTQUFTLENBQUNFLFVBQVUsQ0FBQyxDQUFDQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xELENBQUMsQ0FBQztJQUVGTCxFQUFFLENBQUMsaUNBQWlDLEVBQUUsWUFBTTtNQUMxQyxJQUFBTSxpQkFBQSxHQUFzQmhCLGVBQWUsQ0FBQztVQUNwQ2lCLElBQUksRUFBRTtZQUFFQyxDQUFDLEVBQUUsQ0FBQztZQUFFQyxDQUFDLEVBQUU7VUFBRSxDQUFDO1VBQ3BCQyxFQUFFLEVBQUU7WUFBRUYsQ0FBQyxFQUFFLENBQUM7WUFBRUMsQ0FBQyxFQUFFO1VBQUU7UUFDbkIsQ0FBQyxDQUFDO1FBSE1QLFNBQVMsR0FBQUksaUJBQUEsQ0FBVEosU0FBUztNQUlqQkMsTUFBTSxDQUFDRCxTQUFTLENBQUNFLFVBQVUsQ0FBQyxDQUFDQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xELENBQUMsQ0FBQztJQUVGTCxFQUFFLENBQUMsd0JBQXdCLEVBQUUsWUFBTTtNQUNqQyxJQUFBVyxpQkFBQSxHQUFzQnJCLGVBQWUsQ0FBQztVQUFFSSxTQUFTLEVBQUU7UUFBYyxDQUFDLENBQUM7UUFBM0RRLFNBQVMsR0FBQVMsaUJBQUEsQ0FBVFQsU0FBUztNQUNqQkMsTUFBTSxDQUFDRCxTQUFTLENBQUNFLFVBQVUsQ0FBQyxDQUFDQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xELENBQUMsQ0FBQztFQUNKLENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/tools/polygon/__tests__/polygon.test.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _testUtils = require("@pie-lib/test-utils");
+var _react = _interopRequireDefault(require("react"));
+var _polygon = require("../polygon");
+var _utils = require("../../../__tests__/utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var xy = function xy(x, y) {
+  return {
+    x: x,
+    y: y
+  };
+};
+describe('Polygon', function () {
+  var renderComponent = function renderComponent(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      graphProps: (0, _utils.graphProps)(),
+      closed: false
+    };
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+    return (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_polygon.Polygon, props));
+  };
+  describe('rendering', function () {
+    it('renders without crashing', function () {
+      var _renderComponent = renderComponent({
+          points: [{
+            x: 1,
+            y: 1
+          }]
+        }),
+        container = _renderComponent.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders multiple points', function () {
+      var points = [xy(0, 0), xy(1, 1), xy(2, 0)];
+      var _renderComponent2 = renderComponent({
+          points: points
+        }),
+        container = _renderComponent2.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders closed polygon', function () {
+      var points = [xy(0, 0), xy(1, 1), xy(2, 0)];
+      var _renderComponent3 = renderComponent({
+          points: points,
+          closed: true
+        }),
+        container = _renderComponent3.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders open polygon', function () {
+      var points = [xy(0, 0), xy(1, 1)];
+      var _renderComponent4 = renderComponent({
+          points: points,
+          closed: false
+        }),
+        container = _renderComponent4.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+  });
+});
+describe('getPointString', function () {
+  var assertString = function assertString(arr, expected) {
+    it('creates: ', function () {
+      var result = (0, _polygon.getPointString)(arr, {
+        x: jest.fn(function (n) {
+          return n;
+        }),
+        y: jest.fn(function (n) {
+          return n;
+        })
+      });
+      expect(result).toEqual(expected);
+    });
+  };
+  assertString([xy(1, 1)], '1,1');
+  assertString([xy(1, 1), xy(2, 1)], '1,1 2,1');
+  assertString([xy(1, 1), xy(2, 1), xy(4, 4)], '1,1 2,1 4,4');
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_testUtils","require","_react","_interopRequireDefault","_polygon","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","xy","x","y","describe","renderComponent","extras","defaults","classes","className","graphProps","closed","props","render","createElement","Polygon","it","_renderComponent","points","container","expect","firstChild","toBeInTheDocument","_renderComponent2","_renderComponent3","_renderComponent4","assertString","arr","expected","result","getPointString","jest","fn","n","toEqual"],"sources":["../../../../src/tools/polygon/__tests__/polygon.test.jsx"],"sourcesContent":["import { render } from '@pie-lib/test-utils';\nimport React from 'react';\nimport { getPointString, Polygon } from '../polygon';\nimport { graphProps } from '../../../__tests__/utils';\n\nconst xy = (x, y) => ({ x, y });\n\ndescribe('Polygon', () => {\n  const renderComponent = (extras) => {\n    const defaults = {\n      classes: {},\n      className: 'className',\n      graphProps: graphProps(),\n      closed: false,\n    };\n    const props = { ...defaults, ...extras };\n    return render(<Polygon {...props} />);\n  };\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderComponent({ points: [{ x: 1, y: 1 }] });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('renders multiple points', () => {\n      const points = [xy(0, 0), xy(1, 1), xy(2, 0)];\n      const { container } = renderComponent({ points });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('renders closed polygon', () => {\n      const points = [xy(0, 0), xy(1, 1), xy(2, 0)];\n      const { container } = renderComponent({ points, closed: true });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('renders open polygon', () => {\n      const points = [xy(0, 0), xy(1, 1)];\n      const { container } = renderComponent({ points, closed: false });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n  });\n});\n\ndescribe('getPointString', () => {\n  const assertString = (arr, expected) => {\n    it('creates: ', () => {\n      const result = getPointString(arr, {\n        x: jest.fn((n) => n),\n        y: jest.fn((n) => n),\n      });\n\n      expect(result).toEqual(expected);\n    });\n  };\n\n  assertString([xy(1, 1)], '1,1');\n  assertString([xy(1, 1), xy(2, 1)], '1,1 2,1');\n  assertString([xy(1, 1), xy(2, 1), xy(4, 4)], '1,1 2,1 4,4');\n});\n"],"mappings":";;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,MAAA,GAAAJ,OAAA;AAAsD,SAAAK,QAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAJ,CAAA,OAAAG,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAL,CAAA,GAAAC,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAR,CAAA,EAAAC,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAZ,CAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAF,OAAA,CAAAI,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,QAAAe,gBAAA,aAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAAlB,CAAA,EAAAG,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAH,OAAA,CAAAI,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAD,CAAA;AAEtD,IAAMoB,EAAE,GAAG,SAALA,EAAEA,CAAIC,CAAC,EAAEC,CAAC;EAAA,OAAM;IAAED,CAAC,EAADA,CAAC;IAAEC,CAAC,EAADA;EAAE,CAAC;AAAA,CAAC;AAE/BC,QAAQ,CAAC,SAAS,EAAE,YAAM;EACxB,IAAMC,eAAe,GAAG,SAAlBA,eAAeA,CAAIC,MAAM,EAAK;IAClC,IAAMC,QAAQ,GAAG;MACfC,OAAO,EAAE,CAAC,CAAC;MACXC,SAAS,EAAE,WAAW;MACtBC,UAAU,EAAE,IAAAA,iBAAU,EAAC,CAAC;MACxBC,MAAM,EAAE;IACV,CAAC;IACD,IAAMC,KAAK,GAAAnB,aAAA,CAAAA,aAAA,KAAQc,QAAQ,GAAKD,MAAM,CAAE;IACxC,OAAO,IAAAO,iBAAM,eAACrC,MAAA,YAAAsC,aAAA,CAACpC,QAAA,CAAAqC,OAAO,EAAKH,KAAQ,CAAC,CAAC;EACvC,CAAC;EAEDR,QAAQ,CAAC,WAAW,EAAE,YAAM;IAC1BY,EAAE,CAAC,0BAA0B,EAAE,YAAM;MACnC,IAAAC,gBAAA,GAAsBZ,eAAe,CAAC;UAAEa,MAAM,EAAE,CAAC;YAAEhB,CAAC,EAAE,CAAC;YAAEC,CAAC,EAAE;UAAE,CAAC;QAAE,CAAC,CAAC;QAA3DgB,SAAS,GAAAF,gBAAA,CAATE,SAAS;MACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAClD,CAAC,CAAC;IAEFN,EAAE,CAAC,yBAAyB,EAAE,YAAM;MAClC,IAAME,MAAM,GAAG,CAACjB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC7C,IAAAsB,iBAAA,GAAsBlB,eAAe,CAAC;UAAEa,MAAM,EAANA;QAAO,CAAC,CAAC;QAAzCC,SAAS,GAAAI,iBAAA,CAATJ,SAAS;MACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAClD,CAAC,CAAC;IAEFN,EAAE,CAAC,wBAAwB,EAAE,YAAM;MACjC,IAAME,MAAM,GAAG,CAACjB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MAC7C,IAAAuB,iBAAA,GAAsBnB,eAAe,CAAC;UAAEa,MAAM,EAANA,MAAM;UAAEP,MAAM,EAAE;QAAK,CAAC,CAAC;QAAvDQ,SAAS,GAAAK,iBAAA,CAATL,SAAS;MACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAClD,CAAC,CAAC;IAEFN,EAAE,CAAC,sBAAsB,EAAE,YAAM;MAC/B,IAAME,MAAM,GAAG,CAACjB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MACnC,IAAAwB,iBAAA,GAAsBpB,eAAe,CAAC;UAAEa,MAAM,EAANA,MAAM;UAAEP,MAAM,EAAE;QAAM,CAAC,CAAC;QAAxDQ,SAAS,GAAAM,iBAAA,CAATN,SAAS;MACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAClD,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC;AAEFlB,QAAQ,CAAC,gBAAgB,EAAE,YAAM;EAC/B,IAAMsB,YAAY,GAAG,SAAfA,YAAYA,CAAIC,GAAG,EAAEC,QAAQ,EAAK;IACtCZ,EAAE,CAAC,WAAW,EAAE,YAAM;MACpB,IAAMa,MAAM,GAAG,IAAAC,uBAAc,EAACH,GAAG,EAAE;QACjCzB,CAAC,EAAE6B,IAAI,CAACC,EAAE,CAAC,UAACC,CAAC;UAAA,OAAKA,CAAC;QAAA,EAAC;QACpB9B,CAAC,EAAE4B,IAAI,CAACC,EAAE,CAAC,UAACC,CAAC;UAAA,OAAKA,CAAC;QAAA;MACrB,CAAC,CAAC;MAEFb,MAAM,CAACS,MAAM,CAAC,CAACK,OAAO,CAACN,QAAQ,CAAC;IAClC,CAAC,CAAC;EACJ,CAAC;EAEDF,YAAY,CAAC,CAACzB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;EAC/ByB,YAAY,CAAC,CAACzB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;EAC7CyB,YAAY,CAAC,CAACzB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC;AAC7D,CAAC,CAAC","ignoreList":[]}

package/lib/tools/polygon/component.js

@@ -90,10 +90,6 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
       args[_key2] = arguments[_key2];
     }
     _this = _callSuper(this, RawBaseComponent, [].concat(args));
-    // index of the point whose label is edited (points.length for the polygon label), null if none
-    (0, _defineProperty2["default"])(_this, "state", {
-      editingLabel: null
-    });
     (0, _defineProperty2["default"])(_this, "dragPoint", function (index, from, to) {
       log('[dragPoint] from, to:', from, to);
       var _this$props = _this.props,
@@ -157,13 +153,6 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
       update.splice(index, 1, updatedPoint);
       onChangeProps(update);
     });
-    (0, _defineProperty2["default"])(_this, "stopEditingLabel", function () {
-      if (_this.state.editingLabel !== null) {
-        _this.setState({
-          editingLabel: null
-        });
-      }
-    });
     (0, _defineProperty2["default"])(_this, "clickPoint", function (point, index, data) {
       var _this$props4 = _this.props,
         closed = _this$props4.closed,
@@ -197,11 +186,12 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
           onSetMiddleLabel(strippedMiddle, strippedPoints);
         }
 
-        // MarkLabel focuses itself once it is rendered - it also holds on to the focus if the model
-        // that comes back from the host (api save) remounts the input.
-        _this.setState({
-          editingLabel: index
-        });
+        // defer the focus() call with setTimeout to allow the re-render to complete first.
+        setTimeout(function () {
+          if (_this.input[index]) {
+            _this.input[index].focus();
+          }
+        }, 0);
         return;
       }
       if (isToolActive && !closed && index === 0) {
@@ -216,16 +206,6 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
   }
   (0, _inherits2["default"])(RawBaseComponent, _React$Component);
   return (0, _createClass2["default"])(RawBaseComponent, [{
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      // leaving label mode closes any label that is still being edited
-      if (prevProps.labelModeEnabled && !this.props.labelModeEnabled && this.state.editingLabel !== null) {
-        this.setState({
-          editingLabel: null
-        });
-      }
-    }
-  }, {
     key: "render",
     value: function render() {
       var _this2 = this;
@@ -242,7 +222,6 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
         middle = _this$props5.middle,
         labelNode = _this$props5.labelNode,
         labelModeEnabled = _this$props5.labelModeEnabled;
-      var editingLabel = this.state.editingLabel;
       var lines = buildLines(points, closed);
       var common = {
         onDragStart: onDragStart,
@@ -258,11 +237,9 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
           inputRef: function inputRef(r) {
             return _this2.input[polygonLabelIndex] = r;
           },
-          autoFocus: editingLabel === polygonLabelIndex,
           disabled: disabled || !labelModeEnabled,
           mark: middle,
           graphProps: graphProps,
-          onBlur: this.stopEditingLabel,
           onChange: function onChange(label) {
             return onChangeLabelProps(_objectSpread(_objectSpread({}, middle), {}, {
               label: label
@@ -303,11 +280,9 @@ var RawBaseComponent = exports.RawBaseComponent = /*#__PURE__*/function (_React$
           inputRef: function inputRef(r) {
             return _this2.input[index] = r;
           },
-          autoFocus: editingLabel === index,
           disabled: disabled || !labelModeEnabled,
           mark: p,
           graphProps: graphProps,
-          onBlur: _this2.stopEditingLabel,
           onChange: function onChange(label) {
             return _this2.labelChange(_objectSpread(_objectSpread({}, p), {}, {
               label: label