victory-cursor-container 36.9.2 → 37.0.0

package/lib/victory-cursor-container.js

@@ -5,234 +5,157 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VictoryCursorContainer = void 0;
 exports.cursorContainerMixin = cursorContainerMixin;
-
 var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
-
 var _defaults2 = _interopRequireDefault(require("lodash/defaults"));
-
 var _react = _interopRequireDefault(require("react"));
-
 var _victoryCore = require("victory-core");
-
 var _cursorHelpers = require("./cursor-helpers");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 function cursorContainerMixin(Base) {
-  var _class;
-
   // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
-  return _class = /*#__PURE__*/function (_Base) {
-    _inherits(VictoryCursorContainer, _Base);
-
-    var _super = _createSuper(VictoryCursorContainer);
-
-    function VictoryCursorContainer() {
-      _classCallCheck(this, VictoryCursorContainer);
-
-      return _super.apply(this, arguments);
-    }
-
-    _createClass(VictoryCursorContainer, [{
-      key: "getCursorPosition",
-      value: function getCursorPosition(props) {
-        var cursorValue = props.cursorValue,
-            defaultCursorValue = props.defaultCursorValue,
-            domain = props.domain,
-            cursorDimension = props.cursorDimension;
-
-        if (cursorValue) {
-          return cursorValue;
-        }
-
-        if (typeof defaultCursorValue === "number") {
-          return _defineProperty({
-            x: (domain.x[0] + domain.x[1]) / 2,
-            y: (domain.y[0] + domain.y[1]) / 2
-          }, cursorDimension, defaultCursorValue);
-        }
-
-        return defaultCursorValue;
-      }
-    }, {
-      key: "getCursorLabelOffset",
-      value: function getCursorLabelOffset(props) {
-        var cursorLabelOffset = props.cursorLabelOffset;
-
-        if (typeof cursorLabelOffset === "number") {
-          return {
-            x: cursorLabelOffset,
-            y: cursorLabelOffset
-          };
+  return class VictoryCursorContainer extends Base {
+    static displayName = "VictoryCursorContainer";
+    static defaultProps = {
+      ..._victoryCore.VictoryContainer.defaultProps,
+      cursorLabelComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryLabel, null),
+      cursorLabelOffset: {
+        x: 5,
+        y: -10
+      },
+      cursorComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.LineSegment, null)
+    };
+    static defaultEvents = props => {
+      return [{
+        target: "parent",
+        eventHandlers: {
+          onMouseLeave: (evt, targetProps) => {
+            return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseLeave(evt, targetProps);
+          },
+          onTouchCancel: () => {
+            return [];
+          },
+          onMouseMove: (evt, targetProps) => {
+            return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
+          },
+          onTouchMove: (evt, targetProps) => {
+            return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
+          }
         }
-
-        return cursorLabelOffset;
+      }];
+    };
+    getCursorPosition(props) {
+      const {
+        cursorValue,
+        defaultCursorValue,
+        domain,
+        cursorDimension
+      } = props;
+      if (cursorValue) {
+        return cursorValue;
       }
-    }, {
-      key: "getPadding",
-      value: function getPadding(props) {
-        if (props.padding === undefined) {
-          var child = props.children.find(function (c) {
-            return (0, _isObject2.default)(c.props) && c.props.padding !== undefined;
-          });
-          return _victoryCore.Helpers.getPadding(child.props);
-        }
-
-        return _victoryCore.Helpers.getPadding(props);
+      if (typeof defaultCursorValue === "number") {
+        return {
+          x: (domain.x[0] + domain.x[1]) / 2,
+          y: (domain.y[0] + domain.y[1]) / 2,
+          [cursorDimension]: defaultCursorValue
+        };
       }
-    }, {
-      key: "getCursorElements",
-      value: function getCursorElements(props) {
-        // eslint-disable-line max-statements
-        var scale = props.scale,
-            cursorLabelComponent = props.cursorLabelComponent,
-            cursorLabel = props.cursorLabel,
-            cursorComponent = props.cursorComponent,
-            width = props.width,
-            height = props.height,
-            name = props.name,
-            horizontal = props.horizontal,
-            theme = props.theme;
-
-        var cursorDimension = _cursorHelpers.CursorHelpers.getDimension(props);
-
-        var cursorValue = this.getCursorPosition(props);
-        var cursorLabelOffset = this.getCursorLabelOffset(props);
-
-        if (!cursorValue) {
-          return [];
-        }
-
-        var newElements = [];
-        var padding = this.getPadding(props);
-        var cursorCoordinates = {
-          x: horizontal ? scale.y(cursorValue.y) : scale.x(cursorValue.x),
-          y: horizontal ? scale.x(cursorValue.x) : scale.y(cursorValue.y)
+      return defaultCursorValue;
+    }
+    getCursorLabelOffset(props) {
+      const {
+        cursorLabelOffset
+      } = props;
+      if (typeof cursorLabelOffset === "number") {
+        return {
+          x: cursorLabelOffset,
+          y: cursorLabelOffset
         };
-
-        if (cursorLabel) {
-          var labelProps = (0, _defaults2.default)({
-            active: true
-          }, cursorLabelComponent.props, {
-            x: cursorCoordinates.x + cursorLabelOffset.x,
-            y: cursorCoordinates.y + cursorLabelOffset.y,
-            datum: cursorValue,
-            active: true,
-            key: "".concat(name, "-cursor-label")
-          });
-
-          if (_victoryCore.Helpers.isTooltip(cursorLabelComponent)) {
-            var tooltipTheme = theme && theme.tooltip || {};
-            labelProps = (0, _defaults2.default)({}, labelProps, tooltipTheme);
-          }
-
-          newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorLabelComponent, (0, _defaults2.default)({}, labelProps, {
-            text: _victoryCore.Helpers.evaluateProp(cursorLabel, labelProps)
-          })));
-        }
-
-        var cursorStyle = Object.assign({
-          stroke: "black"
-        }, cursorComponent.props.style);
-
-        if (cursorDimension === "x" || cursorDimension === undefined) {
-          newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
-            key: "".concat(name, "-x-cursor"),
-            x1: cursorCoordinates.x,
-            x2: cursorCoordinates.x,
-            y1: padding.top,
-            y2: height - padding.bottom,
-            style: cursorStyle
-          }));
-        }
-
-        if (cursorDimension === "y" || cursorDimension === undefined) {
-          newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
-            key: "".concat(name, "-y-cursor"),
-            x1: padding.left,
-            x2: width - padding.right,
-            y1: cursorCoordinates.y,
-            y2: cursorCoordinates.y,
-            style: cursorStyle
-          }));
-        }
-
-        return newElements;
-      } // Overrides method in VictoryContainer
-
-    }, {
-      key: "getChildren",
-      value: function getChildren(props) {
-        return [].concat(_toConsumableArray(_react.default.Children.toArray(props.children)), _toConsumableArray(this.getCursorElements(props)));
       }
-    }]);
-
-    return VictoryCursorContainer;
-  }(Base), _class.displayName = "VictoryCursorContainer", _class.defaultProps = _objectSpread(_objectSpread({}, _victoryCore.VictoryContainer.defaultProps), {}, {
-    cursorLabelComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryLabel, null),
-    cursorLabelOffset: {
-      x: 5,
-      y: -10
-    },
-    cursorComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.LineSegment, null)
-  }), _class.defaultEvents = function (props) {
-    return [{
-      target: "parent",
-      eventHandlers: {
-        onMouseLeave: function (evt, targetProps) {
-          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseLeave(evt, targetProps);
-        },
-        onTouchCancel: function () {
-          return [];
-        },
-        onMouseMove: function (evt, targetProps) {
-          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
-        },
-        onTouchMove: function (evt, targetProps) {
-          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
+      return cursorLabelOffset;
+    }
+    getPadding(props) {
+      if (props.padding === undefined) {
+        const child = props.children.find(c => {
+          return (0, _isObject2.default)(c.props) && c.props.padding !== undefined;
+        });
+        return _victoryCore.Helpers.getPadding(child.props);
+      }
+      return _victoryCore.Helpers.getPadding(props);
+    }
+    getCursorElements(props) {
+      // eslint-disable-line max-statements
+      const {
+        scale,
+        cursorLabelComponent,
+        cursorLabel,
+        cursorComponent,
+        width,
+        height,
+        name,
+        horizontal,
+        theme
+      } = props;
+      const cursorDimension = _cursorHelpers.CursorHelpers.getDimension(props);
+      const cursorValue = this.getCursorPosition(props);
+      const cursorLabelOffset = this.getCursorLabelOffset(props);
+      if (!cursorValue) {
+        return [];
+      }
+      const newElements = [];
+      const padding = this.getPadding(props);
+      const cursorCoordinates = {
+        x: horizontal ? scale.y(cursorValue.y) : scale.x(cursorValue.x),
+        y: horizontal ? scale.x(cursorValue.x) : scale.y(cursorValue.y)
+      };
+      if (cursorLabel) {
+        let labelProps = (0, _defaults2.default)({
+          active: true
+        }, cursorLabelComponent.props, {
+          x: cursorCoordinates.x + cursorLabelOffset.x,
+          y: cursorCoordinates.y + cursorLabelOffset.y,
+          datum: cursorValue,
+          active: true,
+          key: `${name}-cursor-label`
+        });
+        if (_victoryCore.Helpers.isTooltip(cursorLabelComponent)) {
+          const tooltipTheme = theme && theme.tooltip || {};
+          labelProps = (0, _defaults2.default)({}, labelProps, tooltipTheme);
         }
+        newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorLabelComponent, (0, _defaults2.default)({}, labelProps, {
+          text: _victoryCore.Helpers.evaluateProp(cursorLabel, labelProps)
+        })));
       }
-    }];
-  }, _class;
-}
+      const cursorStyle = Object.assign({
+        stroke: "black"
+      }, cursorComponent.props.style);
+      if (cursorDimension === "x" || cursorDimension === undefined) {
+        newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
+          key: `${name}-x-cursor`,
+          x1: cursorCoordinates.x,
+          x2: cursorCoordinates.x,
+          y1: padding.top,
+          y2: height - padding.bottom,
+          style: cursorStyle
+        }));
+      }
+      if (cursorDimension === "y" || cursorDimension === undefined) {
+        newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
+          key: `${name}-y-cursor`,
+          x1: padding.left,
+          x2: width - padding.right,
+          y1: cursorCoordinates.y,
+          y2: cursorCoordinates.y,
+          style: cursorStyle
+        }));
+      }
+      return newElements;
+    }
 
-var VictoryCursorContainer = cursorContainerMixin(_victoryCore.VictoryContainer);
-exports.VictoryCursorContainer = VictoryCursorContainer;
+    // Overrides method in VictoryContainer
+    getChildren(props) {
+      return [..._react.default.Children.toArray(props.children), ...this.getCursorElements(props)];
+    }
+  };
+}
+const VictoryCursorContainer = exports.VictoryCursorContainer = cursorContainerMixin(_victoryCore.VictoryContainer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-cursor-container",
-  "version": "36.9.2",
+  "version": "37.0.0",
   "description": "Interactive Cursor Component for Victory",
   "keywords": [
     "data visualization",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "lodash": "^4.17.19",
-    "victory-core": "^36.9.2"
+    "victory-core": "^37.0.0"
   },
   "peerDependencies": {
     "react": ">=16.6.0"