victory-cursor-container 36.9.2-next.1 → 36.9.2

package/es/victory-cursor-container.js

@@ -1,6 +1,10 @@
 import _isObject from "lodash/isObject";
 import _defaults from "lodash/defaults";
 
+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."); }
@@ -13,181 +17,204 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 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 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 _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 _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 _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 _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); } }
 
-import React from "react";
-import { Helpers, VictoryLabel, LineSegment, VictoryContainer } from "victory-core";
-import { CursorHelpers } from "./cursor-helpers";
-export var VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS = {
-  cursorLabelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
-  cursorLabelOffset: {
-    x: 5,
-    y: -10
-  },
-  cursorComponent: /*#__PURE__*/React.createElement(LineSegment, null)
-};
-export var useVictoryCursorContainer = function (initialProps) {
-  var props = _objectSpread(_objectSpread({}, VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS), initialProps);
-
-  var children = props.children;
-
-  var getCursorPosition = function () {
-    var cursorValue = props.cursorValue,
-        defaultCursorValue = props.defaultCursorValue,
-        domain = props.domain,
-        cursorDimension = props.cursorDimension;
-
-    if (cursorValue) {
-      return cursorValue;
-    }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-    if (typeof defaultCursorValue === "number") {
-      return _objectSpread({
-        x: (domain.x[0] + domain.x[1]) / 2,
-        y: (domain.y[0] + domain.y[1]) / 2
-      }, cursorDimension ? _defineProperty({}, cursorDimension, defaultCursorValue) : {});
-    }
+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); }
 
-    return defaultCursorValue;
-  };
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-  var getCursorLabelOffset = function () {
-    var cursorLabelOffset = props.cursorLabelOffset;
+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); }; }
 
-    if (typeof cursorLabelOffset === "number") {
-      return {
-        x: cursorLabelOffset,
-        y: cursorLabelOffset
-      };
-    }
+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); }
 
-    return cursorLabelOffset;
-  };
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-  var getPadding = function () {
-    if (props.padding === undefined) {
-      var child = Array.isArray(props.children) ? props.children.find(function (c) {
-        return _isObject(c.props) && c.props.padding !== undefined;
-      }) : props.children;
-      return Helpers.getPadding(child === null || child === void 0 ? void 0 : child.props);
-    }
+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; } }
 
-    return Helpers.getPadding(props);
-  };
-
-  var getCursorElements = function () {
-    var _scale$y, _scale$x, _scale$x2, _scale$y2;
-
-    // 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.getDimension(props);
-    var cursorValue = getCursorPosition();
-    var cursorLabelOffset = getCursorLabelOffset();
-
-    if (!cursorValue) {
-      return [];
-    }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-    var newElements = [];
-    var padding = getPadding();
-    var cursorCoordinates = {
-      x: horizontal ? scale === null || scale === void 0 ? void 0 : (_scale$y = scale.y) === null || _scale$y === void 0 ? void 0 : _scale$y.call(scale, cursorValue.y) : scale === null || scale === void 0 ? void 0 : (_scale$x = scale.x) === null || _scale$x === void 0 ? void 0 : _scale$x.call(scale, cursorValue.x),
-      y: horizontal ? scale === null || scale === void 0 ? void 0 : (_scale$x2 = scale.x) === null || _scale$x2 === void 0 ? void 0 : _scale$x2.call(scale, cursorValue.x) : scale === null || scale === void 0 ? void 0 : (_scale$y2 = scale.y) === null || _scale$y2 === void 0 ? void 0 : _scale$y2.call(scale, cursorValue.y)
-    };
-
-    if (cursorLabel) {
-      var labelProps = _defaults({
-        active: true
-      }, cursorLabelComponent.props, {
-        x: cursorCoordinates.x || 0 + cursorLabelOffset.x,
-        y: cursorCoordinates.y || 0 + cursorLabelOffset.y,
-        datum: cursorValue,
-        active: true,
-        key: "".concat(name, "-cursor-label")
-      });
-
-      if (Helpers.isTooltip(cursorLabelComponent)) {
-        var tooltipTheme = theme && theme.tooltip || {};
-        labelProps = _defaults({}, labelProps, tooltipTheme);
-      }
+import React from "react";
+import { VictoryContainer, Helpers, VictoryLabel, LineSegment } from "victory-core";
+import { CursorHelpers } from "./cursor-helpers";
+export function cursorContainerMixin(Base) {
+  var _class;
 
-      newElements.push( /*#__PURE__*/React.cloneElement(cursorLabelComponent, _defaults({}, labelProps, {
-        text: Helpers.evaluateProp(cursorLabel, labelProps)
-      })));
-    }
+  // @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 cursorStyle = Object.assign({
-      stroke: "black"
-    }, cursorComponent.props.style);
-
-    if (cursorDimension === "x" || cursorDimension === undefined) {
-      newElements.push( /*#__PURE__*/React.cloneElement(cursorComponent, {
-        key: "".concat(name, "-x-cursor"),
-        x1: cursorCoordinates.x,
-        x2: cursorCoordinates.x,
-        y1: padding.top,
-        y2: height || 0 - padding.bottom,
-        style: cursorStyle
-      }));
-    }
+    var _super = _createSuper(VictoryCursorContainer);
 
-    if (cursorDimension === "y" || cursorDimension === undefined) {
-      newElements.push( /*#__PURE__*/React.cloneElement(cursorComponent, {
-        key: "".concat(name, "-y-cursor"),
-        x1: padding.left,
-        x2: width || 0 - padding.right,
-        y1: cursorCoordinates.y,
-        y2: cursorCoordinates.y,
-        style: cursorStyle
-      }));
+    function VictoryCursorContainer() {
+      _classCallCheck(this, VictoryCursorContainer);
+
+      return _super.apply(this, arguments);
     }
 
-    return newElements;
-  };
-
-  return {
-    props: props,
-    children: [].concat(_toConsumableArray(React.Children.toArray(children)), _toConsumableArray(getCursorElements()))
-  };
-};
-export var VictoryCursorContainer = function (initialProps) {
-  var _useVictoryCursorCont = useVictoryCursorContainer(initialProps),
-      props = _useVictoryCursorCont.props,
-      children = _useVictoryCursorCont.children;
-
-  return /*#__PURE__*/React.createElement(VictoryContainer, props, children);
-};
-VictoryCursorContainer.role = "container";
-
-VictoryCursorContainer.defaultEvents = function (initialProps) {
-  var props = _objectSpread(_objectSpread({}, VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS), initialProps);
-
-  var createEventHandler = function (handler, disabled) {
-    return (// eslint-disable-next-line max-params
-      function (event, targetProps, eventKey, context) {
-        return disabled || props.disable ? {} : handler(event, _objectSpread(_objectSpread({}, props), targetProps), eventKey, context);
+    _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;
       }
-    );
-  };
-
-  return [{
-    target: "parent",
-    eventHandlers: {
-      onMouseLeave: createEventHandler(CursorHelpers.onMouseLeave),
-      onMouseMove: createEventHandler(CursorHelpers.onMouseMove),
-      onTouchMove: createEventHandler(CursorHelpers.onMouseMove)
-    }
-  }];
-};
+    }, {
+      key: "getCursorLabelOffset",
+      value: function getCursorLabelOffset(props) {
+        var cursorLabelOffset = props.cursorLabelOffset;
+
+        if (typeof cursorLabelOffset === "number") {
+          return {
+            x: cursorLabelOffset,
+            y: cursorLabelOffset
+          };
+        }
+
+        return cursorLabelOffset;
+      }
+    }, {
+      key: "getPadding",
+      value: function getPadding(props) {
+        if (props.padding === undefined) {
+          var child = props.children.find(function (c) {
+            return _isObject(c.props) && c.props.padding !== undefined;
+          });
+          return Helpers.getPadding(child.props);
+        }
+
+        return Helpers.getPadding(props);
+      }
+    }, {
+      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.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)
+        };
+
+        if (cursorLabel) {
+          var labelProps = _defaults({
+            active: true
+          }, cursorLabelComponent.props, {
+            x: cursorCoordinates.x + cursorLabelOffset.x,
+            y: cursorCoordinates.y + cursorLabelOffset.y,
+            datum: cursorValue,
+            active: true,
+            key: "".concat(name, "-cursor-label")
+          });
+
+          if (Helpers.isTooltip(cursorLabelComponent)) {
+            var tooltipTheme = theme && theme.tooltip || {};
+            labelProps = _defaults({}, labelProps, tooltipTheme);
+          }
+
+          newElements.push( /*#__PURE__*/React.cloneElement(cursorLabelComponent, _defaults({}, labelProps, {
+            text: Helpers.evaluateProp(cursorLabel, labelProps)
+          })));
+        }
+
+        var cursorStyle = Object.assign({
+          stroke: "black"
+        }, cursorComponent.props.style);
+
+        if (cursorDimension === "x" || cursorDimension === undefined) {
+          newElements.push( /*#__PURE__*/React.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.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.Children.toArray(props.children)), _toConsumableArray(this.getCursorElements(props)));
+      }
+    }]);
+
+    return VictoryCursorContainer;
+  }(Base), _class.displayName = "VictoryCursorContainer", _class.defaultProps = _objectSpread(_objectSpread({}, VictoryContainer.defaultProps), {}, {
+    cursorLabelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
+    cursorLabelOffset: {
+      x: 5,
+      y: -10
+    },
+    cursorComponent: /*#__PURE__*/React.createElement(LineSegment, null)
+  }), _class.defaultEvents = function (props) {
+    return [{
+      target: "parent",
+      eventHandlers: {
+        onMouseLeave: function (evt, targetProps) {
+          return props.disable ? {} : CursorHelpers.onMouseLeave(evt, targetProps);
+        },
+        onTouchCancel: function () {
+          return [];
+        },
+        onMouseMove: function (evt, targetProps) {
+          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+        },
+        onTouchMove: function (evt, targetProps) {
+          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+        }
+      }
+    }];
+  }, _class;
+}
+export var VictoryCursorContainer = cursorContainerMixin(VictoryContainer);

package/lib/cursor-helpers.d.ts

@@ -1,33 +1,33 @@
-/// <reference types="lodash" />
-import { Selection } from "victory-core";
-declare class CursorHelpersClass {
-    getDimension(props: any): any;
-    withinBounds(point: any, bounds: any): boolean;
-    private handleMouseMove;
-    onMouseMove: import("lodash").DebouncedFunc<(evt: any, targetProps: any) => {
-        target: string;
-        eventKey: string;
-        mutation: () => {
-            cursorValue: Selection.SVGCoordinateType | null;
-            parentSVG: any;
-        };
-    }[]>;
-    onMouseLeave: (evt: any, targetProps: any) => {
-        target: string;
-        eventKey: string;
-        mutation: () => {
-            cursorValue: Selection.SVGCoordinateType | null;
-            parentSVG: any;
-        };
-    }[];
-    onTouchEnd: (evt: any, targetProps: any) => {
-        target: string;
-        eventKey: string;
-        mutation: () => {
-            cursorValue: null;
-        };
-    }[];
-}
-export declare const CursorHelpers: CursorHelpersClass;
-export {};
+/// <reference types="lodash" />
+import { Selection } from "victory-core";
+declare class CursorHelpersClass {
+    getDimension(props: any): any;
+    withinBounds(point: any, bounds: any): boolean;
+    private handleMouseMove;
+    onMouseMove: import("lodash").DebouncedFunc<(evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: Selection.SVGCoordinateType | null;
+            parentSVG: any;
+        };
+    }[]>;
+    onMouseLeave: (evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: Selection.SVGCoordinateType | null;
+            parentSVG: any;
+        };
+    }[];
+    onTouchEnd: (evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: null;
+        };
+    }[];
+}
+export declare const CursorHelpers: CursorHelpersClass;
+export {};
 //# sourceMappingURL=cursor-helpers.d.ts.map

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./cursor-helpers";
-export * from "./victory-cursor-container";
+export * from "./cursor-helpers";
+export * from "./victory-cursor-container";
 //# sourceMappingURL=index.d.ts.map