		@@ -6,80 +6,46 @@ "use strict";
		});
		exports.default = void 0;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _classnames = _interopRequireDefault(require("./classnames"));

		var _react = require("react");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _react2 = _interopRequireDefault(_react);

		var _classnames = require("./classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		class Annotation extends _react.default.Component {
		render() {
		const {
		x,
		y,
		nx,
		ny,
		events
		} = this.props;
		const cleanedProps = Object.assign({}, this.props);
		delete cleanedProps.children;
		const cleanedWithoutEvents = Object.assign({}, cleanedProps);
		delete cleanedWithoutEvents.events;
		if (nx !== undefined) cleanedProps.dx = nx - x;
		if (ny !== undefined) cleanedProps.dy = ny - y;

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
		const childrenWithProps = _react.default.Children.toArray(this.props.children).map(child => _react.default.cloneElement(child, { ...(typeof child.type === "string" ? cleanedWithoutEvents : cleanedProps),
		...child.props
		}));

		var Annotation = function (_React$Component) {
		_inherits(Annotation, _React$Component);

		function Annotation() {
		_classCallCheck(this, Annotation);

		return _possibleConstructorReturn(this, (Annotation.__proto__ \|\| Object.getPrototypeOf(Annotation)).apply(this, arguments));
		Object.keys(events).forEach(k => {
		events[k] = events[k].bind(this, this.props, this.state);
		});
		return _react.default.createElement("g", _extends({
		className: (0, _classnames.default)("annotation", this.props.className),
		transform: `translate(${x}, ${y})`
		}, events), childrenWithProps);
		}

		_createClass(Annotation, [{
		key: "render",
		value: function render() {
		var _this2 = this;
		}

		var _props = this.props,
		x = _props.x,
		y = _props.y,
		nx = _props.nx,
		ny = _props.ny,
		events = _props.events;


		var cleanedProps = Object.assign({}, this.props);
		delete cleanedProps.children;

		if (nx !== undefined) cleanedProps.dx = nx - x;
		if (ny !== undefined) cleanedProps.dy = ny - y;

		var childrenWithProps = _react2.default.Children.toArray(this.props.children).map(function (child) {
		return _react2.default.cloneElement(child, _extends({}, cleanedProps, child.props));
		});

		Object.keys(events).forEach(function (k) {
		events[k] = events[k].bind(_this2, _this2.props, _this2.state);
		});

		return _react2.default.createElement(
		"g",
		_extends({
		className: (0, _classnames2.default)("annotation", this.props.className),
		transform: "translate(" + x + ", " + y + ")"
		}, events),
		childrenWithProps
		);
		}
		}]);

		return Annotation;
		}(_react2.default.Component);

		exports.default = Annotation;


		Annotation.defaultProps = {
		@@ -93,11 +59,10 @@ x: 0,
		};

		Annotation.propTypes = {
		x: _propTypes2.default.number,
		y: _propTypes2.default.number,
		dx: _propTypes2.default.number,
		dy: _propTypes2.default.number,
		color: _propTypes2.default.string,
		editMode: _propTypes2.default.bool,
		events: _propTypes2.default.object
		x: _propTypes.default.number,
		y: _propTypes.default.number,
		dx: _propTypes.default.number,
		dy: _propTypes.default.number,
		color: _propTypes.default.string,
		editMode: _propTypes.default.bool,
		events: _propTypes.default.object
		};

lib/classnames.js

		@@ -6,11 +6,6 @@ "use strict";
		});
		exports.default = void 0;

		exports.default = function () {
		for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {
		params[_key] = arguments[_key];
		}
		var _default = (...params) => params.filter(d => d).join(" ").trim();

		return params.filter(function (d) {
		return d;
		}).join(" ").trim();
		};
		exports.default = _default;

118

lib/Connector/Connector.js

		@@ -6,89 +6,59 @@ "use strict";
		});
		exports.default = void 0;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		var _react = require("react");

		var _react2 = _interopRequireDefault(_react);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		class Connector extends _react.default.Component {
		getComponents() {}

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
		render() {
		const {
		color,
		dx,
		dy,
		customID
		} = this.props;

		var Connector = function (_React$Component) {
		_inherits(Connector, _React$Component);
		if (dx === 0 && dy === 0) {
		return _react.default.createElement("g", {
		className: "annotation-connector"
		});
		}

		function Connector() {
		_classCallCheck(this, Connector);
		const d = this.getComponents(this.props) \|\| [];
		const cleanedProps = Object.assign({}, this.props);
		delete cleanedProps.children;

		return _possibleConstructorReturn(this, (Connector.__proto__ \|\| Object.getPrototypeOf(Connector)).apply(this, arguments));
		}
		const childrenWithProps = _react.default.Children.map(this.props.children, child => _react.default.cloneElement(child, { ...cleanedProps,
		...child.props,
		scale: cleanedProps.endScale \|\| child.props.endScale,
		lineData: d.components[0].data
		}));

		_createClass(Connector, [{
		key: "getComponents",
		value: function getComponents() {}
		}, {
		key: "render",
		value: function render() {
		var _props = this.props,
		color = _props.color,
		dx = _props.dx,
		dy = _props.dy,
		customID = _props.customID;


		if (dx === 0 && dy === 0) {
		return _react2.default.createElement("g", { className: "annotation-connector" });
		}

		var d = this.getComponents(this.props) \|\| [];
		var cleanedProps = Object.assign({}, this.props);
		delete cleanedProps.children;

		var childrenWithProps = _react2.default.Children.map(this.props.children, function (child) {
		return _react2.default.cloneElement(child, _extends({}, cleanedProps, child.props, {
		scale: cleanedProps.endScale \|\| child.props.endScale,
		lineData: d.components[0].data
		}));
		return _react.default.createElement("g", _extends({
		className: "annotation-connector"
		}, this.props.gAttrs), d.components && d.components.map((c, i) => {
		const attrs = {};
		if (!c) return null;
		Object.keys(c.attrs).forEach(k => {
		if (c.attrs[k] && k !== "text") {
		attrs[k.replace(/-([a-z])/g, g => g[1].toUpperCase())] = c.attrs[k];
		}
		});
		return _react.default.createElement(c.type, _extends({
		mask: customID ? `url(#${customID})` : undefined,
		key: i,
		className: c.className,
		fill: "none",
		stroke: color
		}, attrs), c.attrs.text);
		}), childrenWithProps);
		}

		return _react2.default.createElement(
		"g",
		_extends({ className: "annotation-connector" }, this.props.gAttrs),
		d.components && d.components.map(function (c, i) {
		var attrs = {};
		if (!c) return null;
		Object.keys(c.attrs).forEach(function (k) {
		if (c.attrs[k] && k !== "text") {
		attrs[k.replace(/-([a-z])/g, function (g) {
		return g[1].toUpperCase();
		})] = c.attrs[k];
		}
		});
		return _react2.default.createElement(
		c.type,
		_extends({
		mask: customID ? "url(#" + customID + ")" : undefined,
		key: i,
		className: c.className,
		fill: "none",
		stroke: color
		}, attrs),
		c.attrs.text
		);
		}),
		childrenWithProps
		);
		}
		}]);
		}

		return Connector;
		}(_react2.default.Component);

		exports.default = Connector;

lib/Connector/ConnectorCurve.js

		@@ -6,69 +6,39 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _typeCurve = _interopRequireDefault(require("viz-annotation/lib/Connector/type-curve"));

		var _react = require("react");
		var _Connector = _interopRequireDefault(require("./Connector"));

		var _react2 = _interopRequireDefault(_react);

		var _typeCurve = require("viz-annotation/lib/Connector/type-curve");

		var _typeCurve2 = _interopRequireDefault(_typeCurve);

		var _Connector2 = require("./Connector");

		var _Connector3 = _interopRequireDefault(_Connector2);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */


		var ConnectorCurve = function (_Connector) {
		_inherits(ConnectorCurve, _Connector);

		function ConnectorCurve() {
		_classCallCheck(this, ConnectorCurve);

		return _possibleConstructorReturn(this, (ConnectorCurve.__proto__ \|\| Object.getPrototypeOf(ConnectorCurve)).apply(this, arguments));
		class ConnectorCurve extends _Connector.default {
		getComponents({
		curve,
		points,
		x,
		y,
		dx,
		dy,
		radius,
		outerRadius,
		width,
		height
		}) {
		return (0, _typeCurve.default)({
		curve,
		points,
		x,
		y,
		dx,
		dy,
		radius,
		outerRadius,
		width,
		height
		});
		}

		_createClass(ConnectorCurve, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var curve = _ref.curve,
		points = _ref.points,
		x = _ref.x,
		y = _ref.y,
		dx = _ref.dx,
		dy = _ref.dy,
		radius = _ref.radius,
		outerRadius = _ref.outerRadius,
		width = _ref.width,
		height = _ref.height;
		}

		return (0, _typeCurve2.default)({
		curve: curve,
		points: points,
		x: x,
		y: y,
		dx: dx,
		dy: dy,
		radius: radius,
		outerRadius: outerRadius,
		width: width,
		height: height
		});
		}
		}]);

		return ConnectorCurve;
		}(_Connector3.default);

		exports.default = ConnectorCurve;

lib/Connector/ConnectorElbow.js

		@@ -6,67 +6,42 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _typeElbow = _interopRequireDefault(require("viz-annotation/lib/Connector/type-elbow"));

		var _react2 = _interopRequireDefault(_react);
		var _Connector = _interopRequireDefault(require("./Connector"));

		var _typeElbow = require("viz-annotation/lib/Connector/type-elbow");

		var _typeElbow2 = _interopRequireDefault(_typeElbow);

		var _Connector2 = require("./Connector");

		var _Connector3 = _interopRequireDefault(_Connector2);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */


		var ConnectorElbow = function (_Connector) {
		_inherits(ConnectorElbow, _Connector);

		function ConnectorElbow() {
		_classCallCheck(this, ConnectorElbow);

		return _possibleConstructorReturn(this, (ConnectorElbow.__proto__ \|\| Object.getPrototypeOf(ConnectorElbow)).apply(this, arguments));
		class ConnectorElbow extends _Connector.default {
		getComponents({
		x,
		y,
		dy,
		dx,
		radius,
		radiusPadding,
		outerRadius,
		width,
		height
		}) {
		return (0, _typeElbow.default)({
		x,
		y,
		dx,
		dy,
		radius,
		radiusPadding,
		outerRadius,
		width,
		height
		});
		}

		_createClass(ConnectorElbow, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var x = _ref.x,
		y = _ref.y,
		dy = _ref.dy,
		dx = _ref.dx,
		radius = _ref.radius,
		radiusPadding = _ref.radiusPadding,
		outerRadius = _ref.outerRadius,
		width = _ref.width,
		height = _ref.height;
		}

		return (0, _typeElbow2.default)({
		x: x,
		y: y,
		dx: dx,
		dy: dy,
		radius: radius,
		radiusPadding: radiusPadding,
		outerRadius: outerRadius,
		width: width,
		height: height
		});
		}
		}]);

		return ConnectorElbow;
		}(_Connector3.default);

		exports.default = ConnectorElbow;

lib/Connector/ConnectorEnd.js

		@@ -6,46 +6,28 @@ "use strict";
		});
		exports.default = void 0;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

		var _react = require("react");

		var _react2 = _interopRequireDefault(_react);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		class ConnectorEnd extends _react.default.Component {
		getComponents() {}

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

		var ConnectorEnd = function (_React$Component) {
		_inherits(ConnectorEnd, _React$Component);

		function ConnectorEnd() {
		_classCallCheck(this, ConnectorEnd);

		return _possibleConstructorReturn(this, (ConnectorEnd.__proto__ \|\| Object.getPrototypeOf(ConnectorEnd)).apply(this, arguments));
		render() {
		const {
		color
		} = this.props;
		const d = this.getComponents(this.props) \|\| [];
		const c = d.components[0];
		return _react.default.createElement(c.type, _extends({
		className: c.className
		}, c.attrs, {
		fill: color
		}));
		}

		_createClass(ConnectorEnd, [{
		key: "getComponents",
		value: function getComponents() {}
		}, {
		key: "render",
		value: function render() {
		var color = this.props.color;
		}

		var d = this.getComponents(this.props) \|\| [];
		var c = d.components[0];

		return _react2.default.createElement(c.type, _extends({ className: c.className }, c.attrs, { fill: color }));
		}
		}]);

		return ConnectorEnd;
		}(_react2.default.Component);

		exports.default = ConnectorEnd;

lib/Connector/ConnectorEndArrow.js

		@@ -6,75 +6,55 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _endArrow = _interopRequireDefault(require("viz-annotation/lib/Connector/end-arrow"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorEnd = _interopRequireDefault(require("./ConnectorEnd"));

		var _endArrow = require("viz-annotation/lib/Connector/end-arrow");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _endArrow2 = _interopRequireDefault(_endArrow);

		var _ConnectorEnd2 = require("./ConnectorEnd");

		var _ConnectorEnd3 = _interopRequireDefault(_ConnectorEnd2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		class ConnectorEndArrow extends _ConnectorEnd.default {
		getComponents({
		x,
		y,
		dy,
		dx,
		lineData,
		scale
		}) {
		let start = lineData[1];
		const end = lineData[0];
		const distance = Math.sqrt(Math.pow(start[0] - end[0], 2) + Math.pow(start[1] - end[1], 2));

		if (distance < 5 && lineData[2]) {
		start = lineData[2];
		}

		var ConnectorEndArrow = function (_ConnectorEnd) {
		_inherits(ConnectorEndArrow, _ConnectorEnd);

		function ConnectorEndArrow() {
		_classCallCheck(this, ConnectorEndArrow);

		return _possibleConstructorReturn(this, (ConnectorEndArrow.__proto__ \|\| Object.getPrototypeOf(ConnectorEndArrow)).apply(this, arguments));
		return (0, _endArrow.default)({
		x,
		y,
		dx,
		dy,
		start,
		end,
		scale
		});
		}

		_createClass(ConnectorEndArrow, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var x = _ref.x,
		y = _ref.y,
		dy = _ref.dy,
		dx = _ref.dx,
		lineData = _ref.lineData,
		scale = _ref.scale;
		}

		var start = lineData[1];
		var end = lineData[0];
		var distance = Math.sqrt(Math.pow(start[0] - end[0], 2) + Math.pow(start[1] - end[1], 2));
		if (distance < 5 && lineData[2]) {
		start = lineData[2];
		}

		return (0, _endArrow2.default)({ x: x, y: y, dx: dx, dy: dy, start: start, end: end, scale: scale });
		}
		}]);

		return ConnectorEndArrow;
		}(_ConnectorEnd3.default);

		exports.default = ConnectorEndArrow;


		ConnectorEndArrow.propTypes = {
		x: _propTypes2.default.number,
		y: _propTypes2.default.number,
		dx: _propTypes2.default.number,
		dy: _propTypes2.default.number,
		scale: _propTypes2.default.number,
		lineData: _propTypes2.default.array
		x: _propTypes.default.number,
		y: _propTypes.default.number,
		dx: _propTypes.default.number,
		dy: _propTypes.default.number,
		scale: _propTypes.default.number,
		lineData: _propTypes.default.array
		};

lib/Connector/ConnectorEndDot.js

		@@ -6,69 +6,47 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _endDot = _interopRequireDefault(require("viz-annotation/lib/Connector/end-dot"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorEnd = _interopRequireDefault(require("./ConnectorEnd"));

		var _endDot = require("viz-annotation/lib/Connector/end-dot");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _endDot2 = _interopRequireDefault(_endDot);

		var _ConnectorEnd2 = require("./ConnectorEnd");

		var _ConnectorEnd3 = _interopRequireDefault(_ConnectorEnd2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */


		var ConnectorEndDot = function (_ConnectorEnd) {
		_inherits(ConnectorEndDot, _ConnectorEnd);

		function ConnectorEndDot() {
		_classCallCheck(this, ConnectorEndDot);

		return _possibleConstructorReturn(this, (ConnectorEndDot.__proto__ \|\| Object.getPrototypeOf(ConnectorEndDot)).apply(this, arguments));
		class ConnectorEndDot extends _ConnectorEnd.default {
		getComponents({
		x,
		y,
		dy,
		dx,
		lineData,
		scale
		}) {
		return (0, _endDot.default)({
		x,
		y,
		dx,
		dy,
		lineData,
		scale
		});
		}

		_createClass(ConnectorEndDot, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var x = _ref.x,
		y = _ref.y,
		dy = _ref.dy,
		dx = _ref.dx,
		lineData = _ref.lineData,
		scale = _ref.scale;
		}

		return (0, _endDot2.default)({ x: x, y: y, dx: dx, dy: dy, lineData: lineData, scale: scale });
		}
		}]);

		return ConnectorEndDot;
		}(_ConnectorEnd3.default);

		exports.default = ConnectorEndDot;
		ConnectorEndDot.propTypes = {
		x: _propTypes.default.number,
		y: _propTypes.default.number,
		dx: _propTypes.default.number,
		dy: _propTypes.default.number,
		scale: _propTypes.default.number,
		lineData: _propTypes.default.array //array of arrays of x,y coordinates for the connector line


		ConnectorEndDot.propTypes = {
		x: _propTypes2.default.number,
		y: _propTypes2.default.number,
		dx: _propTypes2.default.number,
		dy: _propTypes2.default.number,
		scale: _propTypes2.default.number,
		lineData: _propTypes2.default.array
		//array of arrays of x,y coordinates for the connector line
		};

lib/Connector/ConnectorLine.js

		@@ -6,56 +6,40 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _typeLine = _interopRequireDefault(require("viz-annotation/lib/Connector/type-line"));

		var _react2 = _interopRequireDefault(_react);
		var _Connector = _interopRequireDefault(require("./Connector"));

		var _typeLine = require("viz-annotation/lib/Connector/type-line");

		var _typeLine2 = _interopRequireDefault(_typeLine);

		var _Connector2 = require("./Connector");

		var _Connector3 = _interopRequireDefault(_Connector2);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */


		var ConnectorLine = function (_Connector) {
		_inherits(ConnectorLine, _Connector);

		function ConnectorLine() {
		_classCallCheck(this, ConnectorLine);

		return _possibleConstructorReturn(this, (ConnectorLine.__proto__ \|\| Object.getPrototypeOf(ConnectorLine)).apply(this, arguments));
		class ConnectorLine extends _Connector.default {
		getComponents({
		x,
		y,
		dy,
		dx,
		radius,
		outerRadius,
		width,
		height
		}) {
		return (0, _typeLine.default)({
		x,
		y,
		dx,
		dy,
		radius,
		outerRadius,
		width,
		height
		});
		}

		_createClass(ConnectorLine, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var x = _ref.x,
		y = _ref.y,
		dy = _ref.dy,
		dx = _ref.dx,
		radius = _ref.radius,
		outerRadius = _ref.outerRadius,
		width = _ref.width,
		height = _ref.height;
		}

		return (0, _typeLine2.default)({ x: x, y: y, dx: dx, dy: dy, radius: radius, outerRadius: outerRadius, width: width, height: height });
		}
		}]);

		return ConnectorLine;
		}(_Connector3.default);

		exports.default = ConnectorLine;

192

lib/EditableAnnotation.js

		@@ -6,42 +6,19 @@ "use strict";
		});
		exports.default = void 0;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _Annotation = _interopRequireDefault(require("./Annotation"));

		var _react = require("react");
		var _classnames = _interopRequireDefault(require("./classnames"));

		var _react2 = _interopRequireDefault(_react);

		var _Annotation = require("./Annotation");

		var _Annotation2 = _interopRequireDefault(_Annotation);

		var _classnames = require("./classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		class EditableAnnotation extends _react.default.Component {
		constructor(...args) {
		super(...args);

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

		var EditableAnnotation = function (_React$Component) {
		_inherits(EditableAnnotation, _React$Component);

		function EditableAnnotation() {
		var _ref;

		var _temp, _this, _ret;

		_classCallCheck(this, EditableAnnotation);

		for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = EditableAnnotation.__proto__ \|\| Object.getPrototypeOf(EditableAnnotation)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
		_defineProperty(this, "state", {
		x: 0,
		@@ -51,97 +28,78 @@ y: 0,
		dy: 0
		}, _temp), _possibleConstructorReturn(_this, _ret);
		});
		}

		_createClass(EditableAnnotation, [{
		key: "componentWillMount",
		value: function componentWillMount() {
		this.setState({
		x: this.props.x,
		y: this.props.y,
		dx: this.props.dx,
		dy: this.props.dy
		});
		}
		}, {
		key: "componentWillReceiveProps",
		value: function componentWillReceiveProps(nextProps) {
		this.setState({
		x: nextProps.x,
		y: nextProps.y,
		dx: nextProps.dx,
		dy: nextProps.dy
		});
		}
		}, {
		key: "getData",
		value: function getData() {
		return Object.assign({}, this.props, this.state);
		}
		}, {
		key: "dragEnd",
		value: function dragEnd() {
		if (this.props.onDragEnd) {
		this.props.onDragEnd(this.getData());
		}
		}
		}, {
		key: "dragStart",
		value: function dragStart() {
		if (this.props.onDragStart) {
		this.props.onDragStart(this.getData());
		}
		}
		}, {
		key: "dragSubject",
		value: function dragSubject(event, data) {
		var _this2 = this;
		componentWillMount() {
		this.setState({
		x: this.props.x,
		y: this.props.y,
		dx: this.props.dx,
		dy: this.props.dy
		});
		}

		this.setState({
		x: this.state.x + data.deltaX,
		y: this.state.y + data.deltaY
		}, function () {
		if (_this2.props.onDrag) _this2.props.onDrag(_this2.getData());
		});
		}
		}, {
		key: "dragSubjectSettings",
		value: function dragSubjectSettings(event, data) {
		var _this3 = this;
		componentWillReceiveProps(nextProps) {
		this.setState({
		x: nextProps.x,
		y: nextProps.y,
		dx: nextProps.dx,
		dy: nextProps.dy
		});
		}

		this.setState(data, function () {
		if (_this3.props.onDrag) _this3.props.onDrag(_this3.getData());
		});
		}
		}, {
		key: "dragNote",
		value: function dragNote(event, data) {
		var _this4 = this;
		getData() {
		return Object.assign({}, this.props, this.state);
		}

		this.setState({
		dx: this.state.dx + data.deltaX,
		dy: this.state.dy + data.deltaY
		}, function () {
		if (_this4.props.onDrag) _this4.props.onDrag(_this4.getData());
		});
		dragEnd() {
		if (this.props.onDragEnd) {
		this.props.onDragEnd(this.getData());
		}
		}, {
		key: "render",
		value: function render() {
		var cleanedProps = Object.assign({}, this.props, _extends({}, this.state, {
		dragSubject: this.dragSubject.bind(this),
		dragNote: this.dragNote.bind(this),
		dragSubjectSettings: this.dragSubjectSettings.bind(this),
		dragEnd: this.dragEnd.bind(this),
		dragStart: this.dragStart.bind(this),
		editMode: true,
		className: (0, _classnames2.default)(this.props.className, "editable")
		}));
		}

		return _react2.default.createElement(_Annotation2.default, cleanedProps);
		dragStart() {
		if (this.props.onDragStart) {
		this.props.onDragStart(this.getData());
		}
		}]);
		}

		return EditableAnnotation;
		}(_react2.default.Component);
		dragSubject(event, data) {
		this.setState({
		x: this.state.x + data.deltaX,
		y: this.state.y + data.deltaY
		}, () => {
		if (this.props.onDrag) this.props.onDrag(this.getData());
		});
		}

		dragSubjectSettings(event, data) {
		this.setState(data, () => {
		if (this.props.onDrag) this.props.onDrag(this.getData());
		});
		}

		dragNote(event, data) {
		this.setState({
		dx: this.state.dx + data.deltaX,
		dy: this.state.dy + data.deltaY
		}, () => {
		if (this.props.onDrag) this.props.onDrag(this.getData());
		});
		}

		render() {
		const cleanedProps = Object.assign({}, this.props, { ...this.state,
		dragSubject: this.dragSubject.bind(this),
		dragNote: this.dragNote.bind(this),
		dragSubjectSettings: this.dragSubjectSettings.bind(this),
		dragEnd: this.dragEnd.bind(this),
		dragStart: this.dragStart.bind(this),
		editMode: true,
		className: (0, _classnames.default)(this.props.className, "editable")
		});
		return _react.default.createElement(_Annotation.default, cleanedProps);
		}

		}

		exports.default = EditableAnnotation;

161

lib/Handle.js

		@@ -6,22 +6,11 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _react2 = _interopRequireDefault(_react);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

		var events = {
		const events = {
		mouse: {
		@@ -39,94 +28,72 @@ start: "mousedown",

		var Handle = function (_React$Component) {
		_inherits(Handle, _React$Component);
		class Handle extends _react.default.Component {
		render() {
		const {
		x = 0,
		y = 0,
		r = 10,
		handleStart,
		handleDrag,
		handleStop
		} = this.props;

		function Handle() {
		_classCallCheck(this, Handle);
		const makeHandler = type => {
		return e => {
		e.preventDefault();
		const xDim = "clientX";
		const yDim = "clientY";
		const oX = e.nativeEvent[xDim];
		const oY = e.nativeEvent[yDim];
		let x = oX;
		let y = oY;
		handleStart();

		return _possibleConstructorReturn(this, (Handle.__proto__ \|\| Object.getPrototypeOf(Handle)).apply(this, arguments));
		}
		const move = d => {
		d.preventDefault();
		handleDrag(d, {
		deltaX: d[xDim] - x,
		deltaY: d[yDim] - y,
		oDeltaX: d[xDim] - oX,
		oDeltaY: d[yDim] - oY
		});
		x = d[xDim];
		y = d[yDim];
		};

		_createClass(Handle, [{
		key: "render",
		value: function render() {
		var _this2 = this;

		var _props = this.props,
		_props$x = _props.x,
		x = _props$x === undefined ? 0 : _props$x,
		_props$y = _props.y,
		y = _props$y === undefined ? 0 : _props$y,
		_props$r = _props.r,
		r = _props$r === undefined ? 10 : _props$r,
		handleStart = _props.handleStart,
		handleDrag = _props.handleDrag,
		handleStop = _props.handleStop;


		var makeHandler = function makeHandler(type) {
		return function (e) {
		document.addEventListener(events[type].move, move);
		document.addEventListener(events[type].stop, e => {
		e.preventDefault();

		var xDim = "clientX";
		var yDim = "clientY";
		var oX = e.nativeEvent[xDim];
		var oY = e.nativeEvent[yDim];
		var x = oX;
		var y = oY;

		handleStart();

		var move = function move(d) {
		d.preventDefault();
		handleDrag(d, {
		deltaX: d[xDim] - x,
		deltaY: d[yDim] - y,
		oDeltaX: d[xDim] - oX,
		oDeltaY: d[yDim] - oY
		});

		x = d[xDim];
		y = d[yDim];
		};

		document.addEventListener(events[type].move, move);
		document.addEventListener(events[type].stop, function (e) {
		e.preventDefault();
		document.removeEventListener(events[type].move, move);
		document.removeEventListener(events[type].stop, move);
		handleStop();
		});
		};
		document.removeEventListener(events[type].move, move);
		document.removeEventListener(events[type].stop, move);
		handleStop();
		});
		};
		};

		return _react2.default.createElement("circle", {
		className: "handle",
		cx: x,
		cy: y,
		r: r,
		onMouseDown: makeHandler("mouse"),
		strokeDasharray: "5",
		stroke: "grey",
		fill: "white",
		ref: function ref(handle) {
		_this2.handle = handle;
		},
		fillOpacity: 0
		});
		}
		}]);
		return _react.default.createElement("circle", {
		className: "handle",
		cx: x,
		cy: y,
		r: r,
		onMouseDown: makeHandler("mouse"),
		strokeDasharray: "5",
		stroke: "grey",
		fill: "white",
		ref: handle => {
		this.handle = handle;
		},
		fillOpacity: 0
		});
		}

		return Handle;
		}(_react2.default.Component);
		}

		exports.default = Handle;


		Handle.propTypes = {
		x: _propTypes2.default.number,
		y: _propTypes2.default.number,
		r: _propTypes2.default.number,
		handleStart: _propTypes2.default.func,
		handleStop: _propTypes2.default.func,
		handleDrag: _propTypes2.default.func
		x: _propTypes.default.number,
		y: _propTypes.default.number,
		r: _propTypes.default.number,
		handleStart: _propTypes.default.func,
		handleStop: _propTypes.default.func,
		handleDrag: _propTypes.default.func
		};

360

lib/index.js

		@@ -6,170 +6,252 @@ "use strict";
		});
		exports.AnnotationCalloutCustom = exports.AnnotationBracket = exports.AnnotationBadge = exports.AnnotationXYThreshold = exports.AnnotationCalloutRect = exports.AnnotationCalloutElbow = exports.AnnotationCalloutCurve = exports.AnnotationCalloutCircle = exports.AnnotationCallout = exports.AnnotationLabel = exports.EditableAnnotation = exports.Annotation = exports.BracketNote = exports.Note = exports.SubjectCustom = exports.SubjectBracket = exports.SubjectThreshold = exports.SubjectRect = exports.SubjectCircle = exports.SubjectBadge = exports.Subject = exports.ConnectorEndArrow = exports.ConnectorEndDot = exports.ConnectorLine = exports.ConnectorElbow = exports.ConnectorCurve = exports.Connector = undefined;
		Object.defineProperty(exports, "Connector", {
		enumerable: true,
		get: function () {
		return _Connector.default;
		}
		});
		Object.defineProperty(exports, "ConnectorCurve", {
		enumerable: true,
		get: function () {
		return _ConnectorCurve.default;
		}
		});
		Object.defineProperty(exports, "ConnectorElbow", {
		enumerable: true,
		get: function () {
		return _ConnectorElbow.default;
		}
		});
		Object.defineProperty(exports, "ConnectorLine", {
		enumerable: true,
		get: function () {
		return _ConnectorLine.default;
		}
		});
		Object.defineProperty(exports, "ConnectorEndDot", {
		enumerable: true,
		get: function () {
		return _ConnectorEndDot.default;
		}
		});
		Object.defineProperty(exports, "ConnectorEndArrow", {
		enumerable: true,
		get: function () {
		return _ConnectorEndArrow.default;
		}
		});
		Object.defineProperty(exports, "Subject", {
		enumerable: true,
		get: function () {
		return _Subject.default;
		}
		});
		Object.defineProperty(exports, "SubjectBadge", {
		enumerable: true,
		get: function () {
		return _SubjectBadge.default;
		}
		});
		Object.defineProperty(exports, "SubjectCircle", {
		enumerable: true,
		get: function () {
		return _SubjectCircle.default;
		}
		});
		Object.defineProperty(exports, "SubjectRect", {
		enumerable: true,
		get: function () {
		return _SubjectRect.default;
		}
		});
		Object.defineProperty(exports, "SubjectThreshold", {
		enumerable: true,
		get: function () {
		return _SubjectThreshold.default;
		}
		});
		Object.defineProperty(exports, "SubjectBracket", {
		enumerable: true,
		get: function () {
		return _SubjectBracket.default;
		}
		});
		Object.defineProperty(exports, "SubjectCustom", {
		enumerable: true,
		get: function () {
		return _SubjectCustom.default;
		}
		});
		Object.defineProperty(exports, "Note", {
		enumerable: true,
		get: function () {
		return _Note.default;
		}
		});
		Object.defineProperty(exports, "BracketNote", {
		enumerable: true,
		get: function () {
		return _BracketNote.default;
		}
		});
		Object.defineProperty(exports, "Annotation", {
		enumerable: true,
		get: function () {
		return _Annotation.default;
		}
		});
		Object.defineProperty(exports, "EditableAnnotation", {
		enumerable: true,
		get: function () {
		return _EditableAnnotation.default;
		}
		});
		Object.defineProperty(exports, "AnnotationLabel", {
		enumerable: true,
		get: function () {
		return _AnnotationLabel.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCallout", {
		enumerable: true,
		get: function () {
		return _AnnotationCallout.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCalloutElbow", {
		enumerable: true,
		get: function () {
		return _AnnotationCalloutElbow.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCalloutCurve", {
		enumerable: true,
		get: function () {
		return _AnnotationCalloutCurve.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCalloutCircle", {
		enumerable: true,
		get: function () {
		return _AnnotationCalloutCircle.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCalloutRect", {
		enumerable: true,
		get: function () {
		return _AnnotationCalloutRect.default;
		}
		});
		Object.defineProperty(exports, "AnnotationXYThreshold", {
		enumerable: true,
		get: function () {
		return _AnnotationXYThreshold.default;
		}
		});
		Object.defineProperty(exports, "AnnotationBadge", {
		enumerable: true,
		get: function () {
		return _AnnotationBadge.default;
		}
		});
		Object.defineProperty(exports, "AnnotationBracket", {
		enumerable: true,
		get: function () {
		return _AnnotationBracket.default;
		}
		});
		Object.defineProperty(exports, "AnnotationCalloutCustom", {
		enumerable: true,
		get: function () {
		return _AnnotationCalloutCustom.default;
		}
		});
		exports.default = void 0;

		var _Connector = require("./Connector/Connector");
		var _Connector = _interopRequireDefault(require("./Connector/Connector"));

		var _Connector2 = _interopRequireDefault(_Connector);
		var _ConnectorCurve = _interopRequireDefault(require("./Connector/ConnectorCurve"));

		var _ConnectorCurve = require("./Connector/ConnectorCurve");
		var _ConnectorElbow = _interopRequireDefault(require("./Connector/ConnectorElbow"));

		var _ConnectorCurve2 = _interopRequireDefault(_ConnectorCurve);
		var _ConnectorLine = _interopRequireDefault(require("./Connector/ConnectorLine"));

		var _ConnectorElbow = require("./Connector/ConnectorElbow");
		var _ConnectorEndDot = _interopRequireDefault(require("./Connector/ConnectorEndDot"));

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);
		var _ConnectorEndArrow = _interopRequireDefault(require("./Connector/ConnectorEndArrow"));

		var _ConnectorLine = require("./Connector/ConnectorLine");
		var _Subject = _interopRequireDefault(require("./Subject/Subject"));

		var _ConnectorLine2 = _interopRequireDefault(_ConnectorLine);
		var _SubjectBadge = _interopRequireDefault(require("./Subject/SubjectBadge"));

		var _ConnectorEndDot = require("./Connector/ConnectorEndDot");
		var _SubjectCircle = _interopRequireDefault(require("./Subject/SubjectCircle"));

		var _ConnectorEndDot2 = _interopRequireDefault(_ConnectorEndDot);
		var _SubjectRect = _interopRequireDefault(require("./Subject/SubjectRect"));

		var _ConnectorEndArrow = require("./Connector/ConnectorEndArrow");
		var _SubjectThreshold = _interopRequireDefault(require("./Subject/SubjectThreshold"));

		var _ConnectorEndArrow2 = _interopRequireDefault(_ConnectorEndArrow);
		var _SubjectBracket = _interopRequireDefault(require("./Subject/SubjectBracket"));

		var _Subject = require("./Subject/Subject");
		var _SubjectCustom = _interopRequireDefault(require("./Subject/SubjectCustom"));

		var _Subject2 = _interopRequireDefault(_Subject);
		var _Note = _interopRequireDefault(require("./Note/Note"));

		var _SubjectBadge = require("./Subject/SubjectBadge");
		var _BracketNote = _interopRequireDefault(require("./Note/BracketNote"));

		var _SubjectBadge2 = _interopRequireDefault(_SubjectBadge);
		var _Annotation = _interopRequireDefault(require("./Annotation"));

		var _SubjectCircle = require("./Subject/SubjectCircle");
		var _EditableAnnotation = _interopRequireDefault(require("./EditableAnnotation"));

		var _SubjectCircle2 = _interopRequireDefault(_SubjectCircle);
		var _AnnotationLabel = _interopRequireDefault(require("./Types/AnnotationLabel"));

		var _SubjectRect = require("./Subject/SubjectRect");
		var _AnnotationCallout = _interopRequireDefault(require("./Types/AnnotationCallout"));

		var _SubjectRect2 = _interopRequireDefault(_SubjectRect);
		var _AnnotationCalloutElbow = _interopRequireDefault(require("./Types/AnnotationCalloutElbow"));

		var _SubjectThreshold = require("./Subject/SubjectThreshold");
		var _AnnotationCalloutCurve = _interopRequireDefault(require("./Types/AnnotationCalloutCurve"));

		var _SubjectThreshold2 = _interopRequireDefault(_SubjectThreshold);
		var _AnnotationCalloutCircle = _interopRequireDefault(require("./Types/AnnotationCalloutCircle"));

		var _SubjectBracket = require("./Subject/SubjectBracket");
		var _AnnotationCalloutRect = _interopRequireDefault(require("./Types/AnnotationCalloutRect"));

		var _SubjectBracket2 = _interopRequireDefault(_SubjectBracket);
		var _AnnotationXYThreshold = _interopRequireDefault(require("./Types/AnnotationXYThreshold"));

		var _SubjectCustom = require("./Subject/SubjectCustom");
		var _AnnotationBadge = _interopRequireDefault(require("./Types/AnnotationBadge"));

		var _SubjectCustom2 = _interopRequireDefault(_SubjectCustom);
		var _AnnotationBracket = _interopRequireDefault(require("./Types/AnnotationBracket"));

		var _Note = require("./Note/Note");
		var _AnnotationCalloutCustom = _interopRequireDefault(require("./Types/AnnotationCalloutCustom"));

		var _Note2 = _interopRequireDefault(_Note);

		var _BracketNote = require("./Note/BracketNote");

		var _BracketNote2 = _interopRequireDefault(_BracketNote);

		var _Annotation = require("./Annotation");

		var _Annotation2 = _interopRequireDefault(_Annotation);

		var _EditableAnnotation = require("./EditableAnnotation");

		var _EditableAnnotation2 = _interopRequireDefault(_EditableAnnotation);

		var _AnnotationLabel = require("./Types/AnnotationLabel");

		var _AnnotationLabel2 = _interopRequireDefault(_AnnotationLabel);

		var _AnnotationCallout = require("./Types/AnnotationCallout");

		var _AnnotationCallout2 = _interopRequireDefault(_AnnotationCallout);

		var _AnnotationCalloutElbow = require("./Types/AnnotationCalloutElbow");

		var _AnnotationCalloutElbow2 = _interopRequireDefault(_AnnotationCalloutElbow);

		var _AnnotationCalloutCurve = require("./Types/AnnotationCalloutCurve");

		var _AnnotationCalloutCurve2 = _interopRequireDefault(_AnnotationCalloutCurve);

		var _AnnotationCalloutCircle = require("./Types/AnnotationCalloutCircle");

		var _AnnotationCalloutCircle2 = _interopRequireDefault(_AnnotationCalloutCircle);

		var _AnnotationCalloutRect = require("./Types/AnnotationCalloutRect");

		var _AnnotationCalloutRect2 = _interopRequireDefault(_AnnotationCalloutRect);

		var _AnnotationXYThreshold = require("./Types/AnnotationXYThreshold");

		var _AnnotationXYThreshold2 = _interopRequireDefault(_AnnotationXYThreshold);

		var _AnnotationBadge = require("./Types/AnnotationBadge");

		var _AnnotationBadge2 = _interopRequireDefault(_AnnotationBadge);

		var _AnnotationBracket = require("./Types/AnnotationBracket");

		var _AnnotationBracket2 = _interopRequireDefault(_AnnotationBracket);

		var _AnnotationCalloutCustom = require("./Types/AnnotationCalloutCustom");

		var _AnnotationCalloutCustom2 = _interopRequireDefault(_AnnotationCalloutCustom);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		exports.Connector = _Connector2.default;
		exports.ConnectorCurve = _ConnectorCurve2.default;
		exports.ConnectorElbow = _ConnectorElbow2.default;
		exports.ConnectorLine = _ConnectorLine2.default;
		exports.ConnectorEndDot = _ConnectorEndDot2.default;
		exports.ConnectorEndArrow = _ConnectorEndArrow2.default;
		exports.Subject = _Subject2.default;
		exports.SubjectBadge = _SubjectBadge2.default;
		exports.SubjectCircle = _SubjectCircle2.default;
		exports.SubjectRect = _SubjectRect2.default;
		exports.SubjectThreshold = _SubjectThreshold2.default;
		exports.SubjectBracket = _SubjectBracket2.default;
		exports.SubjectCustom = _SubjectCustom2.default;
		exports.Note = _Note2.default;
		exports.BracketNote = _BracketNote2.default;
		exports.Annotation = _Annotation2.default;
		exports.EditableAnnotation = _EditableAnnotation2.default;
		exports.AnnotationLabel = _AnnotationLabel2.default;
		exports.AnnotationCallout = _AnnotationCallout2.default;
		exports.AnnotationCalloutCircle = _AnnotationCalloutCircle2.default;
		exports.AnnotationCalloutCurve = _AnnotationCalloutCurve2.default;
		exports.AnnotationCalloutElbow = _AnnotationCalloutElbow2.default;
		exports.AnnotationCalloutRect = _AnnotationCalloutRect2.default;
		exports.AnnotationXYThreshold = _AnnotationXYThreshold2.default;
		exports.AnnotationBadge = _AnnotationBadge2.default;
		exports.AnnotationBracket = _AnnotationBracket2.default;
		exports.AnnotationCalloutCustom = _AnnotationCalloutCustom2.default; // export individual components

		exports.default = {
		Connector: _Connector2.default,
		ConnectorCurve: _ConnectorCurve2.default,
		ConnectorElbow: _ConnectorElbow2.default,
		ConnectorLine: _ConnectorLine2.default,
		ConnectorEndDot: _ConnectorEndDot2.default,
		ConnectorEndArrow: _ConnectorEndArrow2.default,
		Subject: _Subject2.default,
		SubjectBadge: _SubjectBadge2.default,
		SubjectCircle: _SubjectCircle2.default,
		SubjectRect: _SubjectRect2.default,
		SubjectThreshold: _SubjectThreshold2.default,
		SubjectBracket: _SubjectBracket2.default,
		SubjectCustom: _SubjectCustom2.default,
		Note: _Note2.default,
		BracketNote: _BracketNote2.default,
		Annotation: _Annotation2.default,
		EditableAnnotation: _EditableAnnotation2.default,
		AnnotationLabel: _AnnotationLabel2.default,
		AnnotationCallout: _AnnotationCallout2.default,
		AnnotationCalloutCircle: _AnnotationCalloutCircle2.default,
		AnnotationCalloutCurve: _AnnotationCalloutCurve2.default,
		AnnotationCalloutElbow: _AnnotationCalloutElbow2.default,
		AnnotationCalloutRect: _AnnotationCalloutRect2.default,
		AnnotationXYThreshold: _AnnotationXYThreshold2.default,
		AnnotationBadge: _AnnotationBadge2.default,
		AnnotationBracket: _AnnotationBracket2.default,
		AnnotationCalloutCustom: _AnnotationCalloutCustom2.default
		};
		// export individual components
		var _default = {
		Connector: _Connector.default,
		ConnectorCurve: _ConnectorCurve.default,
		ConnectorElbow: _ConnectorElbow.default,
		ConnectorLine: _ConnectorLine.default,
		ConnectorEndDot: _ConnectorEndDot.default,
		ConnectorEndArrow: _ConnectorEndArrow.default,
		Subject: _Subject.default,
		SubjectBadge: _SubjectBadge.default,
		SubjectCircle: _SubjectCircle.default,
		SubjectRect: _SubjectRect.default,
		SubjectThreshold: _SubjectThreshold.default,
		SubjectBracket: _SubjectBracket.default,
		SubjectCustom: _SubjectCustom.default,
		Note: _Note.default,
		BracketNote: _BracketNote.default,
		Annotation: _Annotation.default,
		EditableAnnotation: _EditableAnnotation.default,
		AnnotationLabel: _AnnotationLabel.default,
		AnnotationCallout: _AnnotationCallout.default,
		AnnotationCalloutCircle: _AnnotationCalloutCircle.default,
		AnnotationCalloutCurve: _AnnotationCalloutCurve.default,
		AnnotationCalloutElbow: _AnnotationCalloutElbow.default,
		AnnotationCalloutRect: _AnnotationCalloutRect.default,
		AnnotationXYThreshold: _AnnotationXYThreshold.default,
		AnnotationBadge: _AnnotationBadge.default,
		AnnotationBracket: _AnnotationBracket.default,
		AnnotationCalloutCustom: _AnnotationCalloutCustom.default
		};
		exports.default = _default;

lib/Note/BracketNote.js

		@@ -6,29 +6,20 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = BracketNote;

		var _react = require("react");
		var _react = _interopRequireDefault(require("react"));

		var _react2 = _interopRequireDefault(_react);
		var _Note = _interopRequireDefault(require("./Note"));

		var _Note = require("./Note");

		var _Note2 = _interopRequireDefault(_Note);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } /* eslint-disable no-unused-vars */
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		/* eslint-enable no-unused-vars */

		function BracketNote(_ref) {
		var width = _ref.width,
		height = _ref.height,
		depth = _ref.depth,
		rest = _objectWithoutProperties(_ref, ["width", "height", "depth"]);

		var dx = rest.dx,
		orientation = void 0,
		function BracketNote({
		width,
		height,
		depth,
		...rest
		}) {
		let dx = rest.dx,
		orientation,
		align = "middle",
		@@ -47,3 +38,3 @@ dy = rest.dy;

		return _react2.default.createElement(_Note2.default, _extends({
		return _react.default.createElement(_Note.default, _extends({
		align: align,
		@@ -50,0 +41,0 @@ orientation: orientation,

638

lib/Note/Note.js

		@@ -6,69 +6,47 @@ "use strict";
		});
		exports.default = void 0;

		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
		var _react = _interopRequireDefault(require("react"));

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _alignment = _interopRequireDefault(require("viz-annotation/lib/Note/alignment"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _Handle = _interopRequireDefault(require("../Handle"));

		var _react = require("react");
		var _lineTypeVertical = _interopRequireDefault(require("viz-annotation/lib/Note/lineType-vertical"));

		var _react2 = _interopRequireDefault(_react);
		var _lineTypeHorizontal = _interopRequireDefault(require("viz-annotation/lib/Note/lineType-horizontal"));

		var _alignment4 = require("viz-annotation/lib/Note/alignment");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _alignment5 = _interopRequireDefault(_alignment4);

		var _Handle = require("../Handle");

		var _Handle2 = _interopRequireDefault(_Handle);

		var _lineTypeVertical = require("viz-annotation/lib/Note/lineType-vertical");

		var _lineTypeVertical2 = _interopRequireDefault(_lineTypeVertical);

		var _lineTypeHorizontal = require("viz-annotation/lib/Note/lineType-horizontal");

		var _lineTypeHorizontal2 = _interopRequireDefault(_lineTypeHorizontal);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

		var getOuterBBox = function getOuterBBox() {
		for (var _len = arguments.length, domNodes = Array(_len), _key = 0; _key < _len; _key++) {
		domNodes[_key] = arguments[_key];
		}

		return [].concat(domNodes).reduce(function (p, c) {
		const getOuterBBox = (...domNodes) => {
		return [...domNodes].reduce((p, c) => {
		if (c) {
		var bbox = c.getBBox();
		const bbox = c.getBBox();
		p.x = Math.min(p.x, bbox.x);
		p.y = Math.min(p.y, bbox.y);
		p.width = Math.max(p.width, bbox.width);

		var yOffset = c && c.attributes && c.attributes.y;
		const yOffset = c && c.attributes && c.attributes.y;
		p.height = Math.max(p.height, (yOffset && parseFloat(yOffset.value) \|\| 0) + bbox.height);
		}

		return p;
		}, { x: 0, y: 0, width: 0, height: 0 });
		}, {
		x: 0,
		y: 0,
		width: 0,
		height: 0
		});
		};

		var Note = function (_React$Component) {
		_inherits(Note, _React$Component);
		class Note extends _react.default.Component {
		constructor(props) {
		super(props);

		function Note(props) {
		_classCallCheck(this, Note);

		var _this = _possibleConstructorReturn(this, (Note.__proto__ \|\| Object.getPrototypeOf(Note)).call(this, props));

		_this.state = {
		_defineProperty(this, "state", {
		translateX: 0,
		@@ -78,332 +56,291 @@ translateY: 0,
		changed: 0,
		bbox: { width: 0, height: 0, x: 0, y: 0 }
		};
		bbox: {
		width: 0,
		height: 0,
		x: 0,
		y: 0
		}
		});


		_this.updateText = _this.updateText.bind(_this);

		// this.note = React.createRef()
		this.updateText = this.updateText.bind(this); // this.note = React.createRef()
		// this.title = React.createRef()
		// this.label = React.createRef()
		return _this;
		}

		_createClass(Note, [{
		key: "componentDidMount",
		value: function componentDidMount() {
		this.updateText(this.props);
		componentDidMount() {
		this.updateText(this.props);
		}

		componentWillReceiveProps(nextProps) {
		if (nextProps.title !== this.props.title \|\| nextProps.label !== this.props.label \|\| nextProps.wrap !== this.props.wrap) {
		this.updateText(nextProps);
		}
		}, {
		key: "componentWillReceiveProps",
		value: function componentWillReceiveProps(nextProps) {
		if (nextProps.title !== this.props.title \|\| nextProps.label !== this.props.label \|\| nextProps.wrap !== this.props.wrap) {
		this.updateText(nextProps);
		}
		if (nextProps.editMode && (nextProps.align === "dynamic" \|\| !nextProps.align)) {
		this.updateText(nextProps);
		}
		}
		}, {
		key: "updateText",
		value: function updateText(_ref) {
		var _this2 = this;

		var orientation = _ref.orientation,
		padding = _ref.padding,
		align = _ref.align,
		lineType = _ref.lineType,
		label = _ref.label,
		title = _ref.title,
		wrap = _ref.wrap,
		wrapSplitter = _ref.wrapSplitter,
		dx = _ref.dx,
		dy = _ref.dy;

		var newState = {
		titleWrapped: null,
		labelWrapped: null
		};
		newState.changed = this.state.changed + 1;

		if (title) {
		newState.titleWrapped = this.title && this.wrapText(this.title, newState.changed, title, wrap, wrapSplitter);
		}
		if (label) newState.labelWrapped = this.label && this.wrapText(this.label, newState.changed, label, wrap, wrapSplitter);

		this.setState(newState, function () {
		var setLabel = function setLabel() {
		var bbox = getOuterBBox(_this2.title, _this2.label);
		var noteParams = {
		padding: padding,
		bbox: bbox,
		offset: { x: dx, y: dy },
		orientation: orientation,
		align: align
		};
		if (lineType === "vertical") noteParams.orientation = "leftRight";else if (lineType === "horizontal") noteParams.orientation = "topBottom";

		var _alignment = (0, _alignment5.default)(noteParams),
		x = _alignment.x,
		y = _alignment.y;

		_this2.setState({
		translateX: x,
		translateY: y,
		bbox: bbox
		});
		};

		_this2.setState({
		labelOffset: title && _this2.title.getBBox().height \|\| 0
		}, setLabel);
		});
		if (nextProps.editMode && (nextProps.align === "dynamic" \|\| !nextProps.align)) {
		this.updateText(nextProps);
		}
		}, {
		key: "wrapText",
		value: function wrapText(textRef, key, text, width, wrapSplitter) {
		var initialAttrs = {
		x: 0,
		dy: "1.2em"
		};
		}

		var words = text.split(wrapSplitter \|\| /[ \t\r\n]+/).reverse().filter(function (w) {
		return w !== "";
		});
		updateText({
		orientation,
		padding,
		align,
		lineType,
		label,
		title,
		wrap,
		wrapSplitter,
		dx,
		dy
		}) {
		const newState = {
		titleWrapped: null,
		labelWrapped: null
		};
		newState.changed = this.state.changed + 1;

		var word = void 0,
		line = [];

		var tspans = [];

		while (word = words.pop()) {
		line.push(word);
		textRef.lastChild.textContent = line.join(" ");

		var length = textRef.lastChild.getComputedTextLength();

		textRef.lastChild.textContent = "";

		if (length > width && line.length > 1) {
		line.pop();
		tspans.push(_react2.default.createElement(
		"tspan",
		_extends({ key: tspans.length + text }, initialAttrs),
		line.join(" ")
		));
		line = [word];
		}
		}

		if (line.length !== 0) {
		tspans.push(_react2.default.createElement(
		"tspan",
		_extends({ key: tspans.length + text }, initialAttrs),
		line.join(" ")
		));
		}

		return _react2.default.createElement(
		"tspan",
		_extends({}, initialAttrs, { key: key + text }),
		tspans
		);
		if (title) {
		newState.titleWrapped = this.title && this.wrapText(this.title, newState.changed, title, wrap, wrapSplitter);
		}
		}, {
		key: "componentDidUpdate",
		value: function componentDidUpdate(prevProps) {
		var _props = this.props,
		orientation = _props.orientation,
		padding = _props.padding,
		align = _props.align,
		dx = _props.dx,
		dy = _props.dy,
		lineType = _props.lineType;


		if (this.state.bbox.width && (prevProps.dx !== this.props.dx \|\| prevProps.dy !== this.props.dy) && (this.title \|\| this.label)) {
		var bbox = getOuterBBox(this.title, this.label);
		var noteParams = {
		padding: padding,
		bbox: bbox,
		offset: { x: dx, y: dy },
		orientation: orientation,
		align: align
		if (label) newState.labelWrapped = this.label && this.wrapText(this.label, newState.changed, label, wrap, wrapSplitter);
		this.setState(newState, () => {
		const setLabel = () => {
		const bbox = getOuterBBox(this.title, this.label);
		const noteParams = {
		padding,
		bbox,
		offset: {
		x: dx,
		y: dy
		},
		orientation,
		align
		};

		if (lineType === "vertical") noteParams.orientation = "leftRight";else if (lineType === "horizontal") noteParams.orientation = "topBottom";
		const {
		x,
		y
		} = (0, _alignment.default)(noteParams);
		this.setState({
		translateX: x,
		translateY: y,
		bbox
		});
		};

		var _alignment2 = (0, _alignment5.default)(noteParams),
		x = _alignment2.x,
		y = _alignment2.y;
		this.setState({
		labelOffset: title && this.title.getBBox().height \|\| 0
		}, setLabel);
		});
		}

		var updates = { bbox: bbox };
		if (this.state.translateX !== x) updates.translateX = x;
		if (this.state.translateY !== y) updates.translateY = y;
		if (updates.translateX !== undefined \|\| updates.translateY !== undefined) {
		this.setState(updates);
		}
		} else if (this.state.align !== prevProps.align \|\| this.props.orientation !== prevProps.orientation \|\| this.props.padding !== prevProps.padding) {
		var _noteParams = {
		padding: padding,
		bbox: this.state.bbox,
		offset: { x: dx, y: dy },
		orientation: orientation,
		align: align
		};
		wrapText(textRef, key, text, width, wrapSplitter) {
		const initialAttrs = {
		x: 0,
		dy: "1.2em"
		};
		const words = text.split(wrapSplitter \|\| /[ \t\r\n]+/).reverse().filter(w => w !== "");
		let word,
		line = [];
		const tspans = [];

		if (lineType === "vertical") _noteParams.orientation = "leftRight";else if (lineType === "horizontal") _noteParams.orientation = "topBottom";
		while (word = words.pop()) {
		line.push(word);
		textRef.lastChild.textContent = line.join(" ");
		const length = textRef.lastChild.getComputedTextLength();
		textRef.lastChild.textContent = "";

		var _alignment3 = (0, _alignment5.default)(_noteParams),
		_x = _alignment3.x,
		_y = _alignment3.y;

		var _updates = {};
		if (this.state.translateX !== _x) _updates.translateX = _x;
		if (this.state.translateY !== _y) _updates.translateY = _y;
		if (_updates.translateX !== undefined \|\| _updates.translateY !== undefined) {
		this.setState(_updates);
		}
		if (length > width && line.length > 1) {
		line.pop();
		tspans.push(_react.default.createElement("tspan", _extends({
		key: tspans.length + text
		}, initialAttrs), line.join(" ")));
		line = [word];
		}
		}
		}, {
		key: "render",
		value: function render() {
		var _this3 = this;

		var _props2 = this.props,
		dx = _props2.dx,
		dy = _props2.dy,
		title = _props2.title,
		label = _props2.label,
		align = _props2.align,
		editMode = _props2.editMode,
		lineType = _props2.lineType,
		color = _props2.color,
		titleColor = _props2.titleColor,
		labelColor = _props2.labelColor,
		bgPadding = _props2.bgPadding;
		if (line.length !== 0) {
		tspans.push(_react.default.createElement("tspan", _extends({
		key: tspans.length + text
		}, initialAttrs), line.join(" ")));
		}

		return _react.default.createElement("tspan", _extends({}, initialAttrs, {
		key: key + text
		}), tspans);
		}

		var bgPaddingFinal = { top: 0, bottom: 0, left: 0, right: 0 };
		componentDidUpdate(prevProps) {
		const {
		orientation,
		padding,
		align,
		dx,
		dy,
		lineType
		} = this.props;

		if (typeof bgPadding === "number") {
		bgPaddingFinal = {
		top: bgPadding,
		bottom: bgPadding,
		left: bgPadding,
		right: bgPadding
		};
		} else if (bgPadding && (typeof bgPadding === "undefined" ? "undefined" : _typeof(bgPadding)) === "object") {
		bgPaddingFinal = Object.assign(bgPaddingFinal, bgPadding);
		}
		if (this.state.bbox.width && (prevProps.dx !== this.props.dx \|\| prevProps.dy !== this.props.dy) && (this.title \|\| this.label)) {
		const bbox = getOuterBBox(this.title, this.label);
		const noteParams = {
		padding,
		bbox,
		offset: {
		x: dx,
		y: dy
		},
		orientation,
		align
		};
		if (lineType === "vertical") noteParams.orientation = "leftRight";else if (lineType === "horizontal") noteParams.orientation = "topBottom";
		const {
		x,
		y
		} = (0, _alignment.default)(noteParams);
		const updates = {
		bbox
		};
		if (this.state.translateX !== x) updates.translateX = x;
		if (this.state.translateY !== y) updates.translateY = y;

		var noteTitle = void 0,
		noteText = void 0,
		noteLineType = void 0;
		if (title) {
		noteTitle = _react2.default.createElement(
		"text",
		{
		ref: function ref(el) {
		return _this3.title = el;
		},
		className: "annotation-note-title",
		fontWeight: "bold",
		key: "title",
		fill: titleColor \|\| color
		},
		this.state.titleWrapped \|\| _react2.default.createElement(
		"tspan",
		{ x: 0, dy: ".8em" },
		title
		)
		);
		if (updates.translateX !== undefined \|\| updates.translateY !== undefined) {
		this.setState(updates);
		}
		} else if (this.state.align !== prevProps.align \|\| this.props.orientation !== prevProps.orientation \|\| this.props.padding !== prevProps.padding) {
		const noteParams = {
		padding,
		bbox: this.state.bbox,
		offset: {
		x: dx,
		y: dy
		},
		orientation,
		align
		};
		if (lineType === "vertical") noteParams.orientation = "leftRight";else if (lineType === "horizontal") noteParams.orientation = "topBottom";
		const {
		x,
		y
		} = (0, _alignment.default)(noteParams);
		const updates = {};
		if (this.state.translateX !== x) updates.translateX = x;
		if (this.state.translateY !== y) updates.translateY = y;

		if (label) {
		noteText = _react2.default.createElement(
		"text",
		{
		ref: function ref(el) {
		return _this3.label = el;
		},
		className: "annotation-note-label",
		y: this.state.labelOffset * 1.1,
		key: "label",
		fill: labelColor \|\| color
		},
		this.state.labelWrapped \|\| _react2.default.createElement(
		"tspan",
		{ x: 0, dy: ".8em" },
		label
		)
		);
		if (updates.translateX !== undefined \|\| updates.translateY !== undefined) {
		this.setState(updates);
		}
		}
		}

		if (lineType && this.state.bbox.width) {
		var noteParams = {
		bbox: this.state.bbox,
		align: align,
		offset: { x: dx, y: dy }
		};
		render() {
		const {
		dx,
		dy,
		title,
		label,
		align,
		editMode,
		lineType,
		color,
		titleColor,
		labelColor,
		bgPadding
		} = this.props;
		let bgPaddingFinal = {
		top: 0,
		bottom: 0,
		left: 0,
		right: 0
		};

		var noteComponent = (lineType === "vertical" && (0, _lineTypeVertical2.default)(noteParams) \|\| lineType === "horizontal" && (0, _lineTypeHorizontal2.default)(noteParams)).components[0];
		if (typeof bgPadding === "number") {
		bgPaddingFinal = {
		top: bgPadding,
		bottom: bgPadding,
		left: bgPadding,
		right: bgPadding
		};
		} else if (bgPadding && typeof bgPadding === "object") {
		bgPaddingFinal = Object.assign(bgPaddingFinal, bgPadding);
		}

		noteLineType = _react2.default.createElement(noteComponent.type, _extends({
		className: noteComponent.className
		}, noteComponent.attrs, {
		stroke: color
		}));
		}
		let noteTitle, noteText, noteLineType;

		var handle = void 0;
		if (title) {
		noteTitle = _react.default.createElement("text", {
		ref: el => this.title = el,
		className: "annotation-note-title",
		fontWeight: "bold",
		key: "title",
		fill: titleColor \|\| color
		}, this.state.titleWrapped \|\| _react.default.createElement("tspan", {
		x: 0,
		dy: ".8em"
		}, title));
		}

		if (editMode) {
		handle = _react2.default.createElement(_Handle2.default, {
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragNote
		});
		}
		if (label) {
		noteText = _react.default.createElement("text", {
		ref: el => this.label = el,
		className: "annotation-note-label",
		y: this.state.labelOffset * 1.1,
		key: "label",
		fill: labelColor \|\| color
		}, this.state.labelWrapped \|\| _react.default.createElement("tspan", {
		x: 0,
		dy: ".8em"
		}, label));
		}

		return _react2.default.createElement(
		"g",
		_extends({
		transform: "translate(" + dx + ", " + dy + ")",
		className: "annotation-note"
		}, this.props.gProps),
		_react2.default.createElement(
		"g",
		{
		className: "annotation-note-content",
		transform: "translate(" + this.state.translateX + ",\n " + this.state.translateY + ")",
		ref: function ref(el) {
		return _this3.note = el;
		}
		},
		_react2.default.createElement("rect", {
		className: "annotation-note-bg",
		width: this.state.bbox.width + bgPaddingFinal.left + bgPaddingFinal.right,
		x: -bgPaddingFinal.left,
		y: -bgPaddingFinal.top,
		height: this.state.bbox.height + bgPaddingFinal.top + bgPaddingFinal.bottom,
		stroke: "none",
		fill: "white",
		fillOpacity: "0"
		}),
		noteTitle,
		noteText
		),
		noteLineType,
		handle
		);
		if (lineType && this.state.bbox.width) {
		const noteParams = {
		bbox: this.state.bbox,
		align,
		offset: {
		x: dx,
		y: dy
		}
		};
		const noteComponent = (lineType === "vertical" && (0, _lineTypeVertical.default)(noteParams) \|\| lineType === "horizontal" && (0, _lineTypeHorizontal.default)(noteParams)).components[0];
		noteLineType = _react.default.createElement(noteComponent.type, _extends({
		className: noteComponent.className
		}, noteComponent.attrs, {
		stroke: color
		}));
		}
		}]);

		return Note;
		}(_react2.default.Component);
		let handle;

		exports.default = Note;
		if (editMode) {
		handle = _react.default.createElement(_Handle.default, {
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragNote
		});
		}

		return _react.default.createElement("g", _extends({
		transform: `translate(${dx}, ${dy})`,
		className: "annotation-note"
		}, this.props.gProps), _react.default.createElement("g", {
		className: "annotation-note-content",
		transform: `translate(${this.state.translateX},
		${this.state.translateY})`,
		ref: el => this.note = el
		}, _react.default.createElement("rect", {
		className: "annotation-note-bg",
		width: this.state.bbox.width + bgPaddingFinal.left + bgPaddingFinal.right,
		x: -bgPaddingFinal.left,
		y: -bgPaddingFinal.top,
		height: this.state.bbox.height + bgPaddingFinal.top + bgPaddingFinal.bottom,
		stroke: "none",
		fill: "white",
		fillOpacity: "0"
		}), noteTitle, noteText), noteLineType, handle);
		}

		}

		exports.default = Note;
		Note.defaultProps = {
		@@ -415,17 +352,16 @@ wrap: 120,
		};

		Note.propTypes = {
		dx: _propTypes2.default.number,
		dy: _propTypes2.default.number,
		title: _propTypes2.default.string,
		label: _propTypes2.default.string,
		orientation: _propTypes2.default.oneOf(["leftRight", "topBottom"]),
		padding: _propTypes2.default.number,
		bgPadding: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.object]),
		align: _propTypes2.default.oneOf(["left", "right", "middle", "top", "bottom", "dynamic"]),
		editMode: _propTypes2.default.bool,
		lineType: _propTypes2.default.oneOf(["vertical", "horizontal"]),
		color: _propTypes2.default.string,
		titleColor: _propTypes2.default.string,
		labelColor: _propTypes2.default.string
		dx: _propTypes.default.number,
		dy: _propTypes.default.number,
		title: _propTypes.default.string,
		label: _propTypes.default.string,
		orientation: _propTypes.default.oneOf(["leftRight", "topBottom"]),
		padding: _propTypes.default.number,
		bgPadding: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.object]),
		align: _propTypes.default.oneOf(["left", "right", "middle", "top", "bottom", "dynamic"]),
		editMode: _propTypes.default.bool,
		lineType: _propTypes.default.oneOf(["vertical", "horizontal"]),
		color: _propTypes.default.string,
		titleColor: _propTypes.default.string,
		labelColor: _propTypes.default.string
		};

148

lib/Subject/Subject.js

		@@ -6,111 +6,71 @@ "use strict";
		});
		exports.default = void 0;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _Handle = _interopRequireDefault(require("../Handle"));

		var _react = require("react");

		var _react2 = _interopRequireDefault(_react);

		var _Handle = require("../Handle");

		var _Handle2 = _interopRequireDefault(_Handle);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }
		class Subject extends _react.default.Component {
		getComponents() {}

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
		render() {
		const {
		editMode,
		color
		} = this.props;
		const d = this.getComponents(this.props) \|\| {};
		let handles;

		var Subject = function (_React$Component) {
		_inherits(Subject, _React$Component);
		if (editMode) {
		handles = [_react.default.createElement(_Handle.default, {
		key: "subject-handle",
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragSubject
		})];

		function Subject() {
		_classCallCheck(this, Subject);

		return _possibleConstructorReturn(this, (Subject.__proto__ \|\| Object.getPrototypeOf(Subject)).apply(this, arguments));
		}

		_createClass(Subject, [{
		key: "getComponents",
		value: function getComponents() {}
		}, {
		key: "render",
		value: function render() {
		var _this2 = this;

		var _props = this.props,
		editMode = _props.editMode,
		color = _props.color;


		var d = this.getComponents(this.props) \|\| {};

		var handles = void 0;
		if (editMode) {
		handles = [_react2.default.createElement(_Handle2.default, {
		key: "subject-handle",
		if (d.handles) {
		handles = handles.concat(d.handles.map((h, i) => _react.default.createElement(_Handle.default, {
		key: `subjecthandle-${i}`,
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragSubject
		})];
		x: h.x,
		y: h.y,
		offsetParent: h.offsetParent && this.subject,
		handleDrag: (e, data) => {
		this.props.dragSubjectSettings(e, d.handleFunction(h, data));
		}
		})));
		}
		}

		if (d.handles) {
		handles = handles.concat(d.handles.map(function (h, i) {
		return _react2.default.createElement(_Handle2.default, {
		key: "subjecthandle-" + i,
		handleStart: _this2.props.dragStart,
		handleStop: _this2.props.dragEnd,
		x: h.x,
		y: h.y,
		offsetParent: h.offsetParent && _this2.subject,
		handleDrag: function handleDrag(e, data) {
		_this2.props.dragSubjectSettings(e, d.handleFunction(h, data));
		}
		});
		}));
		return _react.default.createElement("g", _extends({
		className: "annotation-subject"
		}, this.props.gAttrs, {
		ref: subject => {
		this.subject = subject;
		}
		}), d.components && d.components.map((c, i) => {
		const attrs = {};
		if (!c) return null;
		Object.keys(c.attrs).forEach(k => {
		if (c.attrs[k] && k !== "text") {
		attrs[k.replace(/-([a-z])/g, g => g[1].toUpperCase())] = c.attrs[k];
		}
		}
		});
		return _react.default.createElement(c.type, _extends({
		key: i,
		className: c.className,
		fill: "none",
		stroke: color
		}, attrs), c.attrs.text);
		}), handles);
		}

		return _react2.default.createElement(
		"g",
		_extends({
		className: "annotation-subject"
		}, this.props.gAttrs, {
		ref: function ref(subject) {
		_this2.subject = subject;
		}
		}),
		d.components && d.components.map(function (c, i) {
		var attrs = {};
		if (!c) return null;
		Object.keys(c.attrs).forEach(function (k) {
		if (c.attrs[k] && k !== "text") {
		attrs[k.replace(/-([a-z])/g, function (g) {
		return g[1].toUpperCase();
		})] = c.attrs[k];
		}
		});
		return _react2.default.createElement(
		c.type,
		_extends({
		key: i,
		className: c.className,
		fill: "none",
		stroke: color
		}, attrs),
		c.attrs.text
		);
		}),
		handles
		);
		}
		}]);
		}

		return Subject;
		}(_react2.default.Component);

		exports.default = Subject;

111

lib/Subject/SubjectBadge.js

		@@ -6,87 +6,60 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _badge = _interopRequireDefault(require("viz-annotation/lib/Subject/badge"));

		var _react2 = _interopRequireDefault(_react);
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _badge = require("viz-annotation/lib/Subject/badge");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _badge2 = _interopRequireDefault(_badge);

		var _Subject2 = require("./Subject");

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		class SubjectBadge extends _Subject.default {
		getComponents({
		leftRight,
		topBottom,
		text,
		editMode,
		color,
		radius
		}) {
		const components = (0, _badge.default)({
		leftRight,
		topBottom,
		text,
		editMode,
		color,
		radius
		});
		components.handleKeys = {
		leftRight,
		topBottom
		};

		components.handleFunction = (h, data) => {
		const lr = data.oDeltaX < -radius * 2 ? "left" : data.oDeltaX > radius * 2 ? "right" : undefined;
		const tb = data.oDeltaY < -radius * 2 ? "top" : data.oDeltaY > radius * 2 ? "bottom" : undefined;
		return {
		leftRight: lr,
		topBottom: tb
		};
		};

		var SubjectBadge = function (_Subject) {
		_inherits(SubjectBadge, _Subject);

		function SubjectBadge() {
		_classCallCheck(this, SubjectBadge);

		return _possibleConstructorReturn(this, (SubjectBadge.__proto__ \|\| Object.getPrototypeOf(SubjectBadge)).apply(this, arguments));
		return components;
		}

		_createClass(SubjectBadge, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var leftRight = _ref.leftRight,
		topBottom = _ref.topBottom,
		text = _ref.text,
		editMode = _ref.editMode,
		color = _ref.color,
		radius = _ref.radius;
		}

		var components = (0, _badge2.default)({
		leftRight: leftRight,
		topBottom: topBottom,
		text: text,
		editMode: editMode,
		color: color,
		radius: radius
		});

		components.handleKeys = { leftRight: leftRight, topBottom: topBottom };
		components.handleFunction = function (h, data) {
		var lr = data.oDeltaX < -radius * 2 ? "left" : data.oDeltaX > radius * 2 ? "right" : undefined;
		var tb = data.oDeltaY < -radius * 2 ? "top" : data.oDeltaY > radius * 2 ? "bottom" : undefined;

		return {
		leftRight: lr,
		topBottom: tb
		};
		};

		return components;
		}
		}]);

		return SubjectBadge;
		}(_Subject3.default);

		exports.default = SubjectBadge;


		SubjectBadge.propTypes = {
		leftRight: _propTypes2.default.oneOf(["left", "right"]),
		topBottom: _propTypes2.default.oneOf(["top", "bottom"]),
		text: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
		color: _propTypes2.default.string,
		editMode: _propTypes2.default.bool
		leftRight: _propTypes.default.oneOf(["left", "right"]),
		topBottom: _propTypes.default.oneOf(["top", "bottom"]),
		text: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
		color: _propTypes.default.string,
		editMode: _propTypes.default.bool
		};

107

lib/Subject/SubjectBracket.js

		@@ -6,82 +6,61 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _bracket = _interopRequireDefault(require("viz-annotation/lib/Subject/bracket"));

		var _react2 = _interopRequireDefault(_react);
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _bracket = require("viz-annotation/lib/Subject/bracket");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _bracket2 = _interopRequireDefault(_bracket);

		var _Subject2 = require("./Subject");

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		/* eslint-disable no-unused-vars */

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		class SubjectBracket extends _Subject.default {
		getComponents({
		height,
		width,
		depth = 20,
		type = "square",
		editMode
		}) {
		const components = (0, _bracket.default)({
		height,
		width,
		depth,
		type,
		editMode
		});
		const handleKeys = {
		height,
		width,
		depth
		};

		components.handleFunction = (h, data) => {
		if (h.key === "depth") {
		return {
		depth: depth + data[`oDelta${h.type}`]
		};
		} else {
		return {
		[h.key]: handleKeys[h.key] + data[h.key === "width" ? "oDeltaX" : "oDeltaY"]
		};
		}
		};

		var SubjectBracket = function (_Subject) {
		_inherits(SubjectBracket, _Subject);

		function SubjectBracket() {
		_classCallCheck(this, SubjectBracket);

		return _possibleConstructorReturn(this, (SubjectBracket.__proto__ \|\| Object.getPrototypeOf(SubjectBracket)).apply(this, arguments));
		return components;
		}

		_createClass(SubjectBracket, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var height = _ref.height,
		width = _ref.width,
		_ref$depth = _ref.depth,
		depth = _ref$depth === undefined ? 20 : _ref$depth,
		_ref$type = _ref.type,
		type = _ref$type === undefined ? "square" : _ref$type,
		editMode = _ref.editMode;
		}

		var components = (0, _bracket2.default)({ height: height, width: width, depth: depth, type: type, editMode: editMode });

		var handleKeys = { height: height, width: width, depth: depth };
		components.handleFunction = function (h, data) {
		if (h.key === "depth") {
		return {
		depth: depth + data["oDelta" + h.type]
		};
		} else {
		return _defineProperty({}, h.key, handleKeys[h.key] + data[h.key === "width" ? "oDeltaX" : "oDeltaY"]);
		}
		};

		return components;
		}
		}]);

		return SubjectBracket;
		}(_Subject3.default);

		exports.default = SubjectBracket;


		SubjectBracket.propTypes = {
		width: _propTypes2.default.number,
		height: _propTypes2.default.number,
		depth: _propTypes2.default.number,
		editMode: _propTypes2.default.bool
		width: _propTypes.default.number,
		height: _propTypes.default.number,
		depth: _propTypes.default.number,
		editMode: _propTypes.default.bool
		};

101

lib/Subject/SubjectCircle.js

		@@ -6,81 +6,56 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _circle = _interopRequireDefault(require("viz-annotation/lib/Subject/circle"));

		var _react2 = _interopRequireDefault(_react);
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _circle = require("viz-annotation/lib/Subject/circle");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _circle2 = _interopRequireDefault(_circle);

		var _Subject2 = require("./Subject");

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		/* eslint-disable no-unused-vars */

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		class SubjectCircle extends _Subject.default {
		getComponents({
		radius = 20,
		innerRadius,
		outerRadius,
		radiusPadding,
		editMode
		}) {
		const components = (0, _circle.default)({
		radius,
		radiusPadding,
		innerRadius,
		outerRadius,
		editMode
		});
		components.handleKeys = {
		radius,
		innerRadius,
		outerRadius
		};

		components.handleFunction = (h, data) => {
		return {
		[h.key]: components.handleKeys[h.key] + data.oDeltaX * Math.sqrt(2)
		};
		};

		var SubjectCircle = function (_Subject) {
		_inherits(SubjectCircle, _Subject);

		function SubjectCircle() {
		_classCallCheck(this, SubjectCircle);

		return _possibleConstructorReturn(this, (SubjectCircle.__proto__ \|\| Object.getPrototypeOf(SubjectCircle)).apply(this, arguments));
		return components;
		}

		_createClass(SubjectCircle, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var _ref$radius = _ref.radius,
		radius = _ref$radius === undefined ? 20 : _ref$radius,
		innerRadius = _ref.innerRadius,
		outerRadius = _ref.outerRadius,
		radiusPadding = _ref.radiusPadding,
		editMode = _ref.editMode;
		}

		var components = (0, _circle2.default)({
		radius: radius,
		radiusPadding: radiusPadding,
		innerRadius: innerRadius,
		outerRadius: outerRadius,
		editMode: editMode
		});

		components.handleKeys = { radius: radius, innerRadius: innerRadius, outerRadius: outerRadius };
		components.handleFunction = function (h, data) {
		return _defineProperty({}, h.key, components.handleKeys[h.key] + data.oDeltaX * Math.sqrt(2));
		};
		return components;
		}
		}]);

		return SubjectCircle;
		}(_Subject3.default);

		exports.default = SubjectCircle;


		SubjectCircle.propTypes = {
		radius: _propTypes2.default.number,
		innerRadius: _propTypes2.default.number,
		outerRadius: _propTypes2.default.number,
		radiusPadding: _propTypes2.default.number,
		editMode: _propTypes2.default.bool
		radius: _propTypes.default.number,
		innerRadius: _propTypes.default.number,
		outerRadius: _propTypes.default.number,
		radiusPadding: _propTypes.default.number,
		editMode: _propTypes.default.bool
		};

lib/Subject/SubjectCustom.js

		@@ -6,85 +6,52 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _react2 = _interopRequireDefault(_react);
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _Subject2 = require("./Subject");
		var _Handle = _interopRequireDefault(require("../Handle"));

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		var _Handle = require("../Handle");

		var _Handle2 = _interopRequireDefault(_Handle);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		// import Bracket from "./bracket"
		class SubjectCustom extends _Subject.default {
		render() {
		const {
		custom = "M0,0",
		editMode,
		transform
		} = this.props;
		let handles;

		if (editMode) {
		handles = _react.default.createElement(_Handle.default, {
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragSubject
		});
		}

		var SubjectCustom = function (_Subject) {
		_inherits(SubjectCustom, _Subject);

		function SubjectCustom() {
		_classCallCheck(this, SubjectCustom);

		return _possibleConstructorReturn(this, (SubjectCustom.__proto__ \|\| Object.getPrototypeOf(SubjectCustom)).apply(this, arguments));
		return _react.default.createElement("g", {
		className: "annotation-subject"
		}, _react.default.createElement("g", {
		transform: transform
		}, typeof custom === "string" ? _react.default.createElement("path", {
		d: custom,
		pointerEvents: "none"
		}) : _react.default.createElement("g", {
		pointerEvents: "none"
		}, custom)), handles);
		}

		_createClass(SubjectCustom, [{
		key: "render",
		value: function render() {
		var _props = this.props,
		_props$custom = _props.custom,
		custom = _props$custom === undefined ? "M0,0" : _props$custom,
		editMode = _props.editMode,
		transform = _props.transform;
		}


		var handles = void 0;
		if (editMode) {
		handles = _react2.default.createElement(_Handle2.default, {
		handleStart: this.props.dragStart,
		handleStop: this.props.dragEnd,
		handleDrag: this.props.dragSubject
		});
		}
		return _react2.default.createElement(
		"g",
		{ className: "annotation-subject" },
		_react2.default.createElement(
		"g",
		{ transform: transform },
		typeof custom === "string" ? _react2.default.createElement("path", { d: custom, pointerEvents: "none" }) : _react2.default.createElement(
		"g",
		{ pointerEvents: "none" },
		custom
		)
		),
		handles
		);
		}
		}]);

		return SubjectCustom;
		}(_Subject3.default);

		exports.default = SubjectCustom;


		SubjectCustom.propTypes = {
		editMode: _propTypes2.default.bool
		editMode: _propTypes.default.bool
		};

lib/Subject/SubjectRect.js

		@@ -6,73 +6,49 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _rect = _interopRequireDefault(require("viz-annotation/lib/Subject/rect"));

		var _react2 = _interopRequireDefault(_react);
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _rect = require("viz-annotation/lib/Subject/rect");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _rect2 = _interopRequireDefault(_rect);

		var _Subject2 = require("./Subject");

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
		/* eslint-disable no-unused-vars */

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */
		class SubjectRect extends _Subject.default {
		getComponents({
		width = 100,
		height = 100,
		editMode
		}) {
		const components = (0, _rect.default)({
		width,
		height,
		editMode
		});
		components.handleKeys = {
		width,
		height
		};

		components.handleFunction = (h, data) => {
		return {
		[h.key]: h.key === "width" ? width + data.oDeltaX : height + data.oDeltaY
		};
		};

		var SubjectRect = function (_Subject) {
		_inherits(SubjectRect, _Subject);

		function SubjectRect() {
		_classCallCheck(this, SubjectRect);

		return _possibleConstructorReturn(this, (SubjectRect.__proto__ \|\| Object.getPrototypeOf(SubjectRect)).apply(this, arguments));
		return components;
		}

		_createClass(SubjectRect, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var _ref$width = _ref.width,
		width = _ref$width === undefined ? 100 : _ref$width,
		_ref$height = _ref.height,
		height = _ref$height === undefined ? 100 : _ref$height,
		editMode = _ref.editMode;
		}

		var components = (0, _rect2.default)({ width: width, height: height, editMode: editMode });
		components.handleKeys = { width: width, height: height };

		components.handleFunction = function (h, data) {
		return _defineProperty({}, h.key, h.key === "width" ? width + data.oDeltaX : height + data.oDeltaY);
		};

		return components;
		}
		}]);

		return SubjectRect;
		}(_Subject3.default);

		exports.default = SubjectRect;


		SubjectRect.propTypes = {
		width: _propTypes2.default.number,
		height: _propTypes2.default.number,
		editMode: _propTypes2.default.bool
		width: _propTypes.default.number,
		height: _propTypes.default.number,
		editMode: _propTypes.default.bool
		};

lib/Subject/SubjectThreshold.js

		@@ -6,70 +6,49 @@ "use strict";
		});
		exports.default = void 0;

		var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
		var _react = _interopRequireDefault(require("react"));

		var _react = require("react");
		var _threshold = _interopRequireDefault(require("viz-annotation/lib/Subject/threshold"));

		var _react2 = _interopRequireDefault(_react);
		var _Subject = _interopRequireDefault(require("./Subject"));

		var _threshold = require("viz-annotation/lib/Subject/threshold");
		var _propTypes = _interopRequireDefault(require("prop-types"));

		var _threshold2 = _interopRequireDefault(_threshold);

		var _Subject2 = require("./Subject");

		var _Subject3 = _interopRequireDefault(_Subject2);

		var _propTypes = require("prop-types");

		var _propTypes2 = _interopRequireDefault(_propTypes);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
		/* eslint-disable no-unused-vars */

		function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" \|\| typeof call === "function") ? call : self; }

		function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint-disable no-unused-vars */

		/* eslint-enable no-unused-vars */


		var SubjectThreshold = function (_Subject) {
		_inherits(SubjectThreshold, _Subject);

		function SubjectThreshold() {
		_classCallCheck(this, SubjectThreshold);

		return _possibleConstructorReturn(this, (SubjectThreshold.__proto__ \|\| Object.getPrototypeOf(SubjectThreshold)).apply(this, arguments));
		class SubjectThreshold extends _Subject.default {
		getComponents({
		x1,
		x2,
		y1,
		y2,
		x,
		y,
		editMode
		}) {
		return (0, _threshold.default)({
		x1,
		x2,
		y1,
		y2,
		x,
		y,
		editMode
		});
		}

		_createClass(SubjectThreshold, [{
		key: "getComponents",
		value: function getComponents(_ref) {
		var x1 = _ref.x1,
		x2 = _ref.x2,
		y1 = _ref.y1,
		y2 = _ref.y2,
		x = _ref.x,
		y = _ref.y,
		editMode = _ref.editMode;
		}

		return (0, _threshold2.default)({ x1: x1, x2: x2, y1: y1, y2: y2, x: x, y: y, editMode: editMode });
		}
		}]);

		return SubjectThreshold;
		}(_Subject3.default);

		exports.default = SubjectThreshold;


		SubjectThreshold.propTypes = {
		x: _propTypes2.default.number,
		x1: _propTypes2.default.number,
		x2: _propTypes2.default.number,
		y: _propTypes2.default.number,
		y1: _propTypes2.default.number,
		y2: _propTypes2.default.number,
		editMode: _propTypes2.default.bool
		x: _propTypes.default.number,
		x1: _propTypes.default.number,
		x2: _propTypes.default.number,
		y: _propTypes.default.number,
		y1: _propTypes.default.number,
		y2: _propTypes.default.number,
		editMode: _propTypes.default.bool
		};

lib/Types/AnnotationBadge.js

		@@ -6,28 +6,19 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationBadge;

		var _react = require("react");
		var _SubjectBadge = _interopRequireDefault(require("../Subject/SubjectBadge"));

		var _react2 = _interopRequireDefault(_react);
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectBadge = require("../Subject/SubjectBadge");
		var _Type = _interopRequireDefault(require("./Type"));

		var _SubjectBadge2 = _interopRequireDefault(_SubjectBadge);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationBadge(props) {
		var className = (0, _classnames2.default)("badge", props.className);
		return (0, _Type2.default)(_extends({ disable: ["connector", "note"] }, props, { className: className }), null, null, _SubjectBadge2.default);
		const className = (0, _classnames.default)("badge", props.className);
		return (0, _Type.default)({
		disable: ["connector", "note"],
		...props,
		className
		}, null, null, _SubjectBadge.default);
		}

lib/Types/AnnotationBracket.js

		@@ -6,32 +6,23 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationBracket;

		var _react = require("react");
		var _SubjectBracket = _interopRequireDefault(require("../Subject/SubjectBracket"));

		var _react2 = _interopRequireDefault(_react);
		var _BracketNote = _interopRequireDefault(require("../Note/BracketNote"));

		var _SubjectBracket = require("../Subject/SubjectBracket");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectBracket2 = _interopRequireDefault(_SubjectBracket);
		var _Type = _interopRequireDefault(require("./Type"));

		var _BracketNote = require("../Note/BracketNote");

		var _BracketNote2 = _interopRequireDefault(_BracketNote);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationBracket(props) {
		var className = (0, _classnames2.default)("bracket", props.className);
		return (0, _Type2.default)(_extends({ disable: ["connector"] }, props, { className: className }), null, null, _SubjectBracket2.default, { depth: 20 }, _BracketNote2.default);
		const className = (0, _classnames.default)("bracket", props.className);
		return (0, _Type.default)({
		disable: ["connector"],
		...props,
		className
		}, null, null, _SubjectBracket.default, {
		depth: 20
		}, _BracketNote.default);
		}

lib/Types/AnnotationCallout.js

		@@ -6,30 +6,19 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCallout;

		var _react = require("react");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _react2 = _interopRequireDefault(_react);
		var _Type = _interopRequireDefault(require("./Type"));

		var _classnames = require("../classnames");
		var _ConnectorLine = _interopRequireDefault(require("../Connector/ConnectorLine"));

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		var _ConnectorLine = require("../Connector/ConnectorLine");

		var _ConnectorLine2 = _interopRequireDefault(_ConnectorLine);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCallout(props) {
		var className = (0, _classnames2.default)("callout", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorLine2.default, {
		const className = (0, _classnames.default)("callout", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorLine.default, {
		lineType: "horizontal"
		});
		}

lib/Types/AnnotationCalloutCircle.js

		@@ -6,32 +6,23 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCalloutCircle;

		var _react = require("react");
		var _SubjectCircle = _interopRequireDefault(require("../Subject/SubjectCircle"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _SubjectCircle = require("../Subject/SubjectCircle");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectCircle2 = _interopRequireDefault(_SubjectCircle);
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorElbow = require("../Connector/ConnectorElbow");

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCalloutCircle(props) {
		var className = (0, _classnames2.default)("callout circle", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorElbow2.default, { lineType: "horizontal" }, _SubjectCircle2.default, { radius: 20 });
		const className = (0, _classnames.default)("callout circle", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorElbow.default, {
		lineType: "horizontal"
		}, _SubjectCircle.default, {
		radius: 20
		});
		}

lib/Types/AnnotationCalloutCurve.js

		@@ -6,30 +6,19 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCalloutCurve;

		var _react = require("react");
		var _ConnectorCurve = _interopRequireDefault(require("../Connector/ConnectorCurve"));

		var _react2 = _interopRequireDefault(_react);
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _ConnectorCurve = require("../Connector/ConnectorCurve");
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorCurve2 = _interopRequireDefault(_ConnectorCurve);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCalloutCurve(props) {
		var className = (0, _classnames2.default)("callout curve", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorCurve2.default, {
		const className = (0, _classnames.default)("callout curve", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorCurve.default, {
		lineType: "horizontal"
		});
		}

lib/Types/AnnotationCalloutCustom.js

		@@ -6,32 +6,21 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCalloutCustom;

		var _react = require("react");
		var _SubjectCustom = _interopRequireDefault(require("../Subject/SubjectCustom"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _SubjectCustom = require("../Subject/SubjectCustom");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectCustom2 = _interopRequireDefault(_SubjectCustom);
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorElbow = require("../Connector/ConnectorElbow");

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCalloutCustom(props) {
		var className = (0, _classnames2.default)("callout custom", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorElbow2.default, { lineType: "horizontal" }, _SubjectCustom2.default);
		const className = (0, _classnames.default)("callout custom", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorElbow.default, {
		lineType: "horizontal"
		}, _SubjectCustom.default);
		}

lib/Types/AnnotationCalloutElbow.js

		@@ -6,30 +6,19 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCalloutElbow;

		var _react = require("react");
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _react2 = _interopRequireDefault(_react);
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _ConnectorElbow = require("../Connector/ConnectorElbow");
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCalloutElbow(props) {
		var className = (0, _classnames2.default)("callout elbow", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorElbow2.default, {
		const className = (0, _classnames.default)("callout elbow", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorElbow.default, {
		lineType: "horizontal"
		});
		}

lib/Types/AnnotationCalloutRect.js

		@@ -6,32 +6,24 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationCalloutRect;

		var _react = require("react");
		var _SubjectRect = _interopRequireDefault(require("../Subject/SubjectRect"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _SubjectRect = require("../Subject/SubjectRect");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectRect2 = _interopRequireDefault(_SubjectRect);
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorElbow = require("../Connector/ConnectorElbow");

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationCalloutRect(props) {
		var className = (0, _classnames2.default)("callout rect", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorElbow2.default, { lineType: "horizontal" }, _SubjectRect2.default, { width: 100, height: 100 });
		const className = (0, _classnames.default)("callout rect", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorElbow.default, {
		lineType: "horizontal"
		}, _SubjectRect.default, {
		width: 100,
		height: 100
		});
		}

lib/Types/AnnotationLabel.js

		@@ -6,30 +6,19 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationLabel;

		var _react = require("react");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _react2 = _interopRequireDefault(_react);
		var _Type = _interopRequireDefault(require("./Type"));

		var _classnames = require("../classnames");
		var _ConnectorLine = _interopRequireDefault(require("../Connector/ConnectorLine"));

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		var _ConnectorLine = require("../Connector/ConnectorLine");

		var _ConnectorLine2 = _interopRequireDefault(_ConnectorLine);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationLabel(props) {
		var className = (0, _classnames2.default)("label", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorLine2.default, {
		const className = (0, _classnames.default)("label", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorLine.default, {
		align: "middle"
		});
		}

lib/Types/AnnotationXYThreshold.js

		@@ -6,32 +6,21 @@ "use strict";
		});

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

		exports.default = AnnotationXYThreshold;

		var _react = require("react");
		var _SubjectThreshold = _interopRequireDefault(require("../Subject/SubjectThreshold"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _SubjectThreshold = require("../Subject/SubjectThreshold");
		var _classnames = _interopRequireDefault(require("../classnames"));

		var _SubjectThreshold2 = _interopRequireDefault(_SubjectThreshold);
		var _Type = _interopRequireDefault(require("./Type"));

		var _ConnectorElbow = require("../Connector/ConnectorElbow");

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);

		var _classnames = require("../classnames");

		var _classnames2 = _interopRequireDefault(_classnames);

		var _Type = require("./Type");

		var _Type2 = _interopRequireDefault(_Type);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function AnnotationXYThreshold(props) {
		var className = (0, _classnames2.default)("callout xythreshold", props.className);
		return (0, _Type2.default)(_extends({}, props, { className: className }), _ConnectorElbow2.default, { lineType: "horizontal" }, _SubjectThreshold2.default);
		const className = (0, _classnames.default)("callout xythreshold", props.className);
		return (0, _Type.default)({ ...props,
		className
		}, _ConnectorElbow.default, {
		lineType: "horizontal"
		}, _SubjectThreshold.default);
		}

175

lib/Types/Type.js

		@@ -6,121 +6,90 @@ "use strict";
		});
		exports.default = _default;

		var _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
		var _react = _interopRequireDefault(require("react"));

		exports.default = function (props, Connector) {
		var NoteDefaultProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
		var Subject = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _Subject2.default;
		var SubjectDefaultProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
		var NoteType = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : _Note2.default;
		var _props$disable = props.disable,
		disable = _props$disable === undefined ? [] : _props$disable,
		connector = props.connector,
		note = props.note,
		subject = props.subject,
		x = props.x,
		y = props.y,
		dx = props.dx,
		dy = props.dy,
		nx = props.nx,
		ny = props.ny,
		color = props.color,
		className = props.className,
		onDrag = props.onDrag,
		onDragStart = props.onDragStart,
		onDragEnd = props.onDragEnd,
		editMode = props.editMode,
		events = props.events;
		var _Annotation = _interopRequireDefault(require("../Annotation"));

		var CONNECTORS = {
		type: {
		curve: _ConnectorCurve2.default,
		line: _ConnectorLine2.default,
		elbow: _ConnectorElbow2.default
		},
		end: {
		dot: _ConnectorEndDot2.default,
		arrow: _ConnectorEndArrow2.default
		}
		};
		var _EditableAnnotation = _interopRequireDefault(require("../EditableAnnotation"));

		var ConnectorType = void 0,
		ConnectorEndType = void 0;
		if (disable.indexOf("connector") === -1) {
		ConnectorType = connector && CONNECTORS.type[connector.type] \|\| Connector;
		ConnectorEndType = connector && CONNECTORS.end[connector.end];
		}
		var _ConnectorLine = _interopRequireDefault(require("../Connector/ConnectorLine"));

		var AnnotationType = getAnnotationType(props.editMode);
		return _react2.default.createElement(
		AnnotationType,
		_extends({
		x: x,
		y: y,
		dx: dx,
		dy: dy,
		nx: nx,
		ny: ny,
		color: color,
		className: className,
		onDrag: onDrag,
		onDragStart: onDragStart,
		onDragEnd: onDragEnd,
		editMode: editMode
		}, SubjectDefaultProps, subject, {
		events: events
		}),
		ConnectorType && _react2.default.createElement(
		ConnectorType,
		connector,
		ConnectorEndType && _react2.default.createElement(ConnectorEndType, null)
		),
		Subject && disable.indexOf("subject") === -1 && _react2.default.createElement(Subject, null),
		note && disable.indexOf("note") === -1 && _react2.default.createElement(NoteType, _extends({}, NoteDefaultProps, note))
		);
		};
		var _ConnectorElbow = _interopRequireDefault(require("../Connector/ConnectorElbow"));

		var _react = require("react");
		var _ConnectorCurve = _interopRequireDefault(require("../Connector/ConnectorCurve"));

		var _react2 = _interopRequireDefault(_react);
		var _ConnectorEndDot = _interopRequireDefault(require("../Connector/ConnectorEndDot"));

		var _Annotation = require("../Annotation");
		var _ConnectorEndArrow = _interopRequireDefault(require("../Connector/ConnectorEndArrow"));

		var _Annotation2 = _interopRequireDefault(_Annotation);
		var _Subject = _interopRequireDefault(require("../Subject/Subject"));

		var _EditableAnnotation = require("../EditableAnnotation");
		var _Note = _interopRequireDefault(require("../Note/Note"));

		var _EditableAnnotation2 = _interopRequireDefault(_EditableAnnotation);
		var _JSXNote = _interopRequireDefault(require("../Note/JSXNote"));

		var _ConnectorLine = require("../Connector/ConnectorLine");
		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var _ConnectorLine2 = _interopRequireDefault(_ConnectorLine);
		function _extends() { _extends = Object.assign \|\| function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

		var _ConnectorElbow = require("../Connector/ConnectorElbow");
		const getAnnotationType = editMode => editMode ? _EditableAnnotation.default : _Annotation.default;

		var _ConnectorElbow2 = _interopRequireDefault(_ConnectorElbow);
		function _default(props, Connector, NoteDefaultProps = {}, Subject = _Subject.default, SubjectDefaultProps = {}, NoteType = _Note.default) {
		const {
		disable = [],
		connector,
		note,
		subject,
		x,
		y,
		dx,
		dy,
		nx,
		ny,
		color,
		className,
		onDrag,
		onDragStart,
		onDragEnd,
		editMode,
		events
		} = props;
		const CONNECTORS = {
		type: {
		curve: _ConnectorCurve.default,
		line: _ConnectorLine.default,
		elbow: _ConnectorElbow.default
		},
		end: {
		dot: _ConnectorEndDot.default,
		arrow: _ConnectorEndArrow.default
		}
		};
		let ConnectorType, ConnectorEndType;

		var _ConnectorCurve = require("../Connector/ConnectorCurve");
		if (disable.indexOf("connector") === -1) {
		ConnectorType = connector && CONNECTORS.type[connector.type] \|\| Connector;
		ConnectorEndType = connector && CONNECTORS.end[connector.end];
		}

		var _ConnectorCurve2 = _interopRequireDefault(_ConnectorCurve);

		var _ConnectorEndDot = require("../Connector/ConnectorEndDot");

		var _ConnectorEndDot2 = _interopRequireDefault(_ConnectorEndDot);

		var _ConnectorEndArrow = require("../Connector/ConnectorEndArrow");

		var _ConnectorEndArrow2 = _interopRequireDefault(_ConnectorEndArrow);

		var _Subject = require("../Subject/Subject");

		var _Subject2 = _interopRequireDefault(_Subject);

		var _Note = require("../Note/Note");

		var _Note2 = _interopRequireDefault(_Note);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var getAnnotationType = function getAnnotationType(editMode) {
		return editMode ? _EditableAnnotation2.default : _Annotation2.default;
		};
		const AnnotationType = getAnnotationType(props.editMode);
		return _react.default.createElement(AnnotationType, _extends({
		x: x,
		y: y,
		dx: dx,
		dy: dy,
		nx: nx,
		ny: ny,
		color: color,
		className: className,
		onDrag: onDrag,
		onDragStart: onDragStart,
		onDragEnd: onDragEnd,
		editMode: editMode
		}, SubjectDefaultProps, subject, {
		events: events
		}), ConnectorType && _react.default.createElement(ConnectorType, connector, ConnectorEndType && _react.default.createElement(ConnectorEndType, null)), Subject && disable.indexOf("subject") === -1 && _react.default.createElement(Subject, null), note && disable.indexOf("note") === -1 && (_react.default.isValidElement(note) \|\| typeof note === "function") ? _react.default.createElement(_JSXNote.default, {
		noteDefaultProps: NoteDefaultProps,
		note: note
		}) : _react.default.createElement(NoteType, _extends({}, NoteDefaultProps, note)));
		}

lib/web.js

		"use strict";

		var _index = require("./index");
		var _index = _interopRequireDefault(require("./index"));

		var _index2 = _interopRequireDefault(_index);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		window.Annotations = _index2.default;
		window.Annotations = _index.default;

package.json

		{
		"name": "react-annotation",
		"description": "React components for annotating SVG elements ",
		"version": "2.0.0",
		"version": "2.1.0",
		"homepage": ".",
		@@ -20,3 +20,2 @@ "repository": {
		"lint": "eslint src",
		"cypress": "cypress run",
		"webpack": "NODE_ENV=production webpack",
		@@ -26,10 +25,11 @@ "prebuild": "babel src/components --out-dir lib --ignore test.js"
		"devDependencies": {
		"babel-cli": "6.14.0",
		"babel-eslint": "8.0.1",
		"babel-preset-es2015": "6.14.0",
		"babel-preset-react": "6.11.1",
		"babel-preset-stage-0": "6.5.0",
		"@babel/cli": "^7.0.0-beta.56",
		"@babel/core": "^7.0.0-beta.56",
		"@babel/plugin-proposal-class-properties": "^7.0.0-beta.56",
		"@babel/preset-env": "^7.0.0-beta.56",
		"@babel/preset-flow": "^7.0.0-beta.56",
		"@babel/preset-react": "^7.0.0-beta.56",
		"babel-loader": "^8.0.0-beta",
		"conventional-changelog-cli": "1.1.1",
		"conventional-recommended-bump": "0.3.0",
		"cypress": "^3.1.0",
		"d3-array": "1.2.1",
		@@ -42,4 +42,4 @@ "d3-axis": "1.0.8",
		"enzyme": "2.9.1",
		"eslint": "3.8.1",
		"eslint-plugin-react": "7.4.0",
		"eslint": "5.3.0",
		"eslint-plugin-react": "^7.10.0",
		"history": "4.2.0",
		@@ -62,3 +62,4 @@ "material-ui": "^0.17.1",
		"uglifyify": "4.0.4",
		"webpack": "1.13.1"
		"webpack": "^4.16.4",
		"webpack-cli": "^3.1.0"
		},
		@@ -65,0 +66,0 @@ "peerDependencies": {

react-annotation - npm Package Compare versions

New alerts

Improved metrics

Worsened metrics