victory-core 36.3.2 → 36.5.0

package/lib/victory-util/types.d.ts

@@ -0,0 +1,188 @@
+import * as React from "react";
+import { OriginType } from "../victory-label/victory-label";
+import { NumberOrCallback, PaddingProps, VictoryThemeDefinition } from "../victory-theme/victory-theme";
+import { StringOrCallback, StringOrNumberOrCallback } from "../types";
+import { AnimationEasing, AnimationStyle } from "../victory-animation/victory-animation";
+export declare type StringOrNumberOrList = string | number | (string | number)[];
+export interface AnimatePropTypeInterface {
+    duration?: number;
+    onEnd?: () => void;
+    onExit?: {
+        duration?: number;
+        before?: (datum: any) => AnimationStyle;
+    };
+    onEnter?: {
+        duration?: number;
+        before?: (datum: any) => AnimationStyle;
+        after?: (datum: any) => AnimationStyle;
+    };
+    onLoad?: {
+        duration?: number;
+        before?: (datum: any) => AnimationStyle;
+        after?: (datum: any) => AnimationStyle;
+    };
+    easing?: AnimationEasing;
+    animationWhitelist?: string[];
+}
+export interface EventCallbackInterface<TTarget, TEventKey> {
+    childName?: string | string[];
+    target?: TTarget;
+    eventKey?: TEventKey;
+    mutation: (props: any) => any;
+    callback?: (props: any) => any;
+}
+export interface EventPropTypeInterface<TTarget, TEventKey> {
+    childName?: string | Array<StringOrNumberOrCallback>;
+    target: TTarget;
+    eventKey?: TEventKey;
+    eventHandlers: {
+        [key: string]: {
+            (event: React.SyntheticEvent<any>, props?: any): EventCallbackInterface<TTarget, TEventKey>;
+        } | {
+            (event: React.SyntheticEvent<any>, props?: any): EventCallbackInterface<TTarget, TEventKey>[];
+        } | {
+            (event: React.SyntheticEvent<any>, props?: any): void;
+        };
+    };
+}
+export declare type DomainTuple = [number, number] | [Date, Date];
+export declare type DomainPropObjectType = {
+    x?: DomainTuple;
+    y: DomainTuple;
+} | {
+    x: DomainTuple;
+    y?: DomainTuple;
+};
+export declare type DomainPropType = DomainPropObjectType | DomainTuple;
+export declare type PaddingType = number | [number, number];
+export declare type DomainPaddingPropType = PaddingType | {
+    x?: PaddingType;
+    y?: PaddingType;
+};
+export declare type RangeTuple = [number, number];
+export declare type RangePropType = RangeTuple | {
+    x?: RangeTuple;
+    y?: RangeTuple;
+};
+/**
+ * D3 scale function shape. Don"t want to introduce typing dependency to d3
+ */
+export interface D3Scale {
+    (input: string | number): number;
+    domain: () => any;
+    range: () => any;
+    copy: () => any;
+}
+export declare type ScalePropType = "linear" | "time" | "log" | "sqrt";
+export declare type CategoryPropType = string[] | {
+    x: string[];
+} | {
+    y: string[];
+} | {
+    x: string[];
+    y: string[];
+};
+export declare type DataGetterPropType = number | string | string[] | {
+    (data: any): number | string | string[];
+} | Function;
+export declare type InterpolationPropType = "basis" | "basisClosed" | "basisOpen" | "bundle" | "cardinal" | "cardinalClosed" | "cardinalOpen" | "catmullRom" | "catmullRomClosed" | "catmullRomOpen" | "linear" | "linearClosed" | "monotoneX" | "monotoneY" | "natural" | "radial" | "step" | "stepAfter" | "stepBefore";
+export declare type ColorScalePropType = "grayscale" | "qualitative" | "heatmap" | "warm" | "cool" | "red" | "green" | "blue" | string[];
+export declare type SortOrderPropType = "ascending" | "descending";
+export declare type SVGCoordinateType = {
+    x: number;
+    y: number;
+};
+export interface VictoryCommonThemeProps {
+    animate?: boolean | AnimatePropTypeInterface;
+    colorScale?: ColorScalePropType;
+    containerComponent?: React.ReactElement;
+    domainPadding?: DomainPaddingPropType;
+    externalEventMutations?: EventCallbackInterface<string | string[], StringOrNumberOrList>[];
+    groupComponent?: React.ReactElement;
+    height?: number;
+    horizontal?: boolean;
+    maxDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    minDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    name?: string;
+    origin?: OriginType;
+    padding?: PaddingProps;
+    polar?: boolean;
+    range?: RangePropType;
+    scale?: ScalePropType | D3Scale | {
+        x?: ScalePropType | D3Scale;
+        y?: ScalePropType | D3Scale;
+    };
+    sharedEvents?: {
+        events: any[];
+        getEventState: Function;
+    };
+    singleQuadrantDomainPadding?: boolean | {
+        x?: boolean;
+        y?: boolean;
+    };
+    standalone?: boolean;
+    width?: number;
+}
+export interface VictoryCommonProps extends VictoryCommonThemeProps {
+    theme?: VictoryThemeDefinition;
+}
+export interface VictoryCommonPrimitiveProps {
+    active?: boolean;
+    ariaLabel?: StringOrCallback;
+    className?: string;
+    clipPath?: string;
+    data?: any;
+    desc?: string | Function;
+    disableInlineStyles?: boolean;
+    events?: object;
+    id?: number | string | Function;
+    index?: number | string;
+    origin?: OriginType;
+    polar?: boolean;
+    role?: string;
+    scale?: any;
+    shapeRendering?: string;
+    style?: any;
+    tabIndex?: NumberOrCallback;
+    transform?: string;
+}
+export interface VictoryDatableProps {
+    categories?: CategoryPropType;
+    data?: any[];
+    dataComponent?: React.ReactElement;
+    domain?: DomainPropType;
+    domainPadding?: DomainPaddingPropType;
+    samples?: number;
+    sortKey?: DataGetterPropType;
+    sortOrder?: SortOrderPropType;
+    x?: DataGetterPropType;
+    y?: DataGetterPropType;
+    y0?: DataGetterPropType;
+}
+export interface VictoryLabelableProps {
+    labelComponent?: React.ReactElement;
+}
+export interface VictoryMultiLabelableProps extends VictoryLabelableProps {
+    labels?: string[] | number[] | {
+        (data: any): string | string[] | number | number[] | null;
+    };
+}
+export interface VictorySingleLabelableProps extends VictoryLabelableProps {
+    label?: string | {
+        (data: any): string | number | null;
+    };
+}
+export interface TextSizeStyleInterface {
+    angle?: number;
+    characterConstant?: string;
+    fontFamily?: string;
+    fontSize?: number | string;
+    letterSpacing?: string;
+    lineHeight?: number;
+}

package/lib/victory-util/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/victory-util/user-props.js

@@ -3,17 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSafeUserProps = void 0;
+exports.withSafeUserProps = exports.getSafeUserProps = void 0;
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+var React = _interopRequireWildcard(require("react"));
 
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+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 _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; }
 
@@ -68,6 +80,21 @@ var testIfSafeProp = function (key) {
   if (doesPropStartWith(key) || isExactMatch(key)) return true;
   return false;
 };
+/**
+ * Gets the value from props if a function value is provided
+ * @param {any} value: maybe function value
+ * @param {Object} props: props object
+ * @returns {any} newValue
+ */
+
+
+var getValue = function (value, props) {
+  if (typeof value === "function") {
+    return value(props);
+  }
+
+  return value;
+};
 /**
  * getSafeUserProps - function that takes in a props object and removes any
  * key-value entries that do not match filter strings in the USER_PROPS_SAFELIST
@@ -86,7 +113,27 @@ var getSafeUserProps = function (props) {
         key = _ref2[0];
 
     return testIfSafeProp(key);
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        value = _ref4[1];
+
+    return [key, getValue(value, props)];
   }));
 };
+/**
+ * Wraps a component and adds safe user props
+ *
+ * @param {ReactNode} component: parent component
+ * @param {Object} props: props to be filtered
+ * @returns {ReactNode} modified component
+ */
+
+
+exports.getSafeUserProps = getSafeUserProps;
+
+var withSafeUserProps = function (component, props) {
+  return /*#__PURE__*/React.cloneElement(component, getSafeUserProps(props));
+};
 
-exports.getSafeUserProps = getSafeUserProps;
+exports.withSafeUserProps = withSafeUserProps;

package/lib/victory-util/wrapper.js

@@ -4,22 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addBinsToParentPropsIfHistogram = addBinsToParentPropsIfHistogram;
-exports.getDataFromChildren = getDataFromChildren;
+exports.getAllEvents = getAllEvents;
+exports.getCategories = getCategories;
+exports.getCategoryAndAxisStringsFromChildren = getCategoryAndAxisStringsFromChildren;
+exports.getChildStyle = getChildStyle;
+exports.getColor = getColor;
 exports.getData = getData;
-exports.getWidth = getWidth;
+exports.getDataFromChildren = getDataFromChildren;
 exports.getDefaultDomainPadding = getDefaultDomainPadding;
-exports.getDomainFromChildren = getDomainFromChildren;
 exports.getDomain = getDomain;
+exports.getDomainFromChildren = getDomainFromChildren;
 exports.getScale = getScale;
-exports.getAllEvents = getAllEvents;
-exports.getColor = getColor;
-exports.getStyle = getStyle;
-exports.getChildStyle = getChildStyle;
 exports.getStringsFromCategories = getStringsFromCategories;
-exports.getStringsFromData = getStringsFromData;
-exports.getCategoryAndAxisStringsFromChildren = getCategoryAndAxisStringsFromChildren;
 exports.getStringsFromChildren = getStringsFromChildren;
-exports.getCategories = getCategories;
+exports.getStringsFromData = getStringsFromData;
+exports.getStyle = getStyle;
+exports.getWidth = getWidth;
 
 var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
 
@@ -59,19 +59,27 @@ var Scale = _interopRequireWildcard(require("./scale"));
 
 var Log = _interopRequireWildcard(require("./log"));
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+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 _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+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 _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; 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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+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 _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; }
 
@@ -121,7 +129,7 @@ function addBinsToParentPropsIfHistogram(_ref) {
     }, []);
   }
 
-  return _objectSpread({}, parentProps, {
+  return _objectSpread(_objectSpread({}, parentProps), {}, {
     bins: childBins
   });
 }
@@ -157,7 +165,7 @@ function getDataFromChildren(props, childComponents) {
     if (!Data.isDataComponent(child)) {
       return null;
     } else if (child.type && (0, _isFunction2.default)(child.type.getData)) {
-      child = parent ? _react.default.cloneElement(child, parent.props) : child;
+      child = parent ? /*#__PURE__*/_react.default.cloneElement(child, parent.props) : child;
       childData = child.type.getData(childProps);
     } else {
       childData = Data.getData(childProps);
@@ -309,8 +317,8 @@ function getDomain(props, axis, childComponents) {
     var dataset = (props.data || props.y) && Data.getData(props);
     var dataDomain = dataset ? Domain.getDomainFromData(props, axis, dataset) : [];
     var childDomain = getDomainFromChildren(props, axis, childComponents);
-    var min = minDomain || Collection.getMinValue(_toConsumableArray(dataDomain).concat(_toConsumableArray(childDomain)));
-    var max = maxDomain || Collection.getMaxValue(_toConsumableArray(dataDomain).concat(_toConsumableArray(childDomain)));
+    var min = minDomain || Collection.getMinValue([].concat(_toConsumableArray(dataDomain), _toConsumableArray(childDomain)));
+    var max = maxDomain || Collection.getMaxValue([].concat(_toConsumableArray(dataDomain), _toConsumableArray(childDomain)));
     domain = Domain.getDomainFromMinMax(min, max);
   }
 
@@ -470,7 +478,7 @@ function getCategoryAndAxisStringsFromChildren(props, axis, childComponents) {
   var axisComponent = Axis.getAxisComponent(childComponents, axis);
   var axisStrings = axisComponent ? Data.getStringsFromAxes(axisComponent.props, axis) : [];
   var categoryStrings = categories || getStringsFromCategories(childComponents, axis);
-  return (0, _uniq2.default)((0, _flatten2.default)(_toConsumableArray(categoryStrings).concat(_toConsumableArray(axisStrings))));
+  return (0, _uniq2.default)((0, _flatten2.default)([].concat(_toConsumableArray(categoryStrings), _toConsumableArray(axisStrings))));
 }
 
 function getStringsFromChildren(props, childComponents) {
@@ -479,8 +487,8 @@ function getStringsFromChildren(props, childComponents) {
   var yStrings = getCategoryAndAxisStringsFromChildren(props, "y", childComponents);
   var dataStrings = getStringsFromData(childComponents);
   return {
-    x: (0, _uniq2.default)((0, _flatten2.default)(_toConsumableArray(xStrings).concat(_toConsumableArray(dataStrings.x)))),
-    y: (0, _uniq2.default)((0, _flatten2.default)(_toConsumableArray(yStrings).concat(_toConsumableArray(dataStrings.y))))
+    x: (0, _uniq2.default)((0, _flatten2.default)([].concat(_toConsumableArray(xStrings), _toConsumableArray(dataStrings.x)))),
+    y: (0, _uniq2.default)((0, _flatten2.default)([].concat(_toConsumableArray(yStrings), _toConsumableArray(dataStrings.y))))
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-core",
-  "version": "36.3.2",
+  "version": "36.5.0",
   "description": "Victory Core",
   "keywords": [
     "data visualization",
@@ -19,24 +19,17 @@
   "author": "Formidable",
   "license": "MIT",
   "dependencies": {
-    "d3-ease": "^1.0.0",
-    "d3-interpolate": "^1.1.1",
-    "d3-scale": "^1.0.0",
-    "d3-shape": "^1.2.0",
-    "d3-timer": "^1.0.0",
     "lodash": "^4.17.21",
-    "prop-types": "^15.5.8",
-    "react-fast-compare": "^2.0.0"
-  },
-  "resolutions": {
-    "d3-interpolate/d3-color": "^3.0.0"
+    "prop-types": "^15.8.1",
+    "react-fast-compare": "^3.2.0",
+    "victory-vendor": "^36.5.0"
   },
   "peerDependencies": {
-    "react": "^16.6.0 || ^17.0.0"
+    "react": ">=16.6.0"
   },
   "scripts": {
     "version": "yarn run nps build-libs && nps build-dists"
   },
   "sideEffects": false,
-  "gitHead": "18895d1290245732d14332bbbda10336032c9aab"
+  "gitHead": "7cecba921f751c3decc8215f7e866f51d11203c1"
 }

package/src/index.ts

@@ -0,0 +1,42 @@
+// This rule doesn't play well with namespaced exports
+/* eslint-disable import/export */
+export * from "./victory-accessible-group/victory-accessible-group";
+export * from "./victory-animation/victory-animation";
+export * from "./victory-container/victory-container";
+export * from "./victory-label/victory-label";
+export * from "./victory-transition/victory-transition";
+export * from "./victory-clip-container/victory-clip-container";
+export * from "./victory-theme/victory-theme";
+export * from "./victory-portal/portal";
+export * from "./victory-portal/portal-context";
+export * from "./victory-portal/victory-portal";
+export * from "./victory-primitives";
+export { Border as Box } from "./victory-primitives";
+
+// victory-util:
+export { default as addEvents } from "./victory-util/add-events";
+export * as Collection from "./victory-util/collection";
+export * as Data from "./victory-util/data";
+export * as DefaultTransitions from "./victory-util/default-transitions";
+export * as Domain from "./victory-util/domain";
+export * as Events from "./victory-util/events";
+export * as Helpers from "./victory-util/helpers";
+export * as Immutable from "./victory-util/immutable";
+export * as LabelHelpers from "./victory-util/label-helpers";
+export * as Log from "./victory-util/log";
+export * as PropTypes from "./victory-util/prop-types";
+export * as Scale from "./victory-util/scale";
+export * as Selection from "./victory-util/selection";
+export * as Style from "./victory-util/style";
+export * as TextSize from "./victory-util/textsize";
+export * as Transitions from "./victory-util/transitions";
+export * as UserProps from "./victory-util/user-props";
+export * as CommonProps from "./victory-util/common-props";
+export * as Wrapper from "./victory-util/wrapper";
+export * as Axis from "./victory-util/axis";
+export * as Hooks from "./victory-util/hooks";
+export * as LineHelpers from "./victory-util/line-helpers";
+export { default as Timer } from "./victory-util/timer";
+export * as PointPathHelpers from "./victory-util/point-path-helpers";
+export { default as TimerContext } from "./victory-util/timer-context";
+export * from "./victory-util/types";

package/src/types.ts

@@ -0,0 +1,45 @@
+/**
+ * This is the first parameter of a callback when a callback is used to
+ * resolve the value of a property instead of a concrete value.
+ *
+ * Note that additional properties here like `scale`, `x`, `y`, etc are resolved
+ * values of properties from the VictoryXXXProps for each component.
+ */
+import type { D3Scale } from "./victory-util/types";
+
+export interface CallbackArgs {
+  active?: boolean;
+  data?: any;
+  datum?: any;
+  horizontal?: boolean;
+  index: number | string;
+  x?: number;
+  y?: number;
+  scale?: {
+    x?: D3Scale;
+    y?: D3Scale;
+  };
+  tick?: any;
+  ticks?: any;
+  text?: any;
+}
+
+export type VictoryStringOrNumberCallback = (
+  args: CallbackArgs
+) => string | number;
+export type VictoryStringCallback = (args: CallbackArgs) => string;
+export type StringOrNumberOrCallback =
+  | string
+  | number
+  | VictoryStringOrNumberCallback;
+export type StringOrCallback = string | VictoryStringCallback;
+
+export type SliceNumberOrCallback<
+  T,
+  P extends string | number | symbol = never
+> = number | ((props: Omit<T, P>) => number);
+
+export type CoordinatesPropType = {
+  x: number;
+  y: number;
+};

package/src/victory-accessible-group/{victory-accessible-group.js → victory-accessible-group.tsx}

@@ -1,7 +1,16 @@
 import React from "react";
 import PropTypes from "prop-types";
 
-class VictoryAccessibleGroup extends React.Component {
+export interface VictoryAccessibleGroupProps {
+  desc?: string;
+  "aria-describedby"?: string;
+  "aria-label"?: string;
+  children?: React.ReactElement | React.ReactElement[];
+  className?: string;
+  tabIndex?: number;
+}
+
+export class VictoryAccessibleGroup extends React.Component<VictoryAccessibleGroupProps> {
   static displayName = "VictoryAccessibleGroup";
   static propTypes = {
     "aria-describedby": PropTypes.string,
@@ -46,5 +55,3 @@ class VictoryAccessibleGroup extends React.Component {
     );
   }
 }
-
-export default VictoryAccessibleGroup;

package/src/victory-animation/{util.js → util.ts}

@@ -1,4 +1,4 @@
-import { interpolate } from "d3-interpolate";
+import { interpolate } from "victory-vendor/d3-interpolate";
 import { isPlainObject, orderBy } from "lodash";
 
 export const isInterpolatable = function (obj) {
@@ -82,8 +82,8 @@ export const interpolateFunction = function (a, b) {
     if (t >= 1) {
       return b;
     }
-    return function () {
-      /* eslint-disable no-invalid-this */
+    return function (this: unknown) {
+      /* eslint-disable no-invalid-this, prefer-rest-params */
       const aval = typeof a === "function" ? a.apply(this, arguments) : a;
       const bval = typeof b === "function" ? b.apply(this, arguments) : b;
       return interpolate(aval, bval)(t);
@@ -182,7 +182,7 @@ export const interpolateString = function (a, b) {
  * @param {any} b - End value.
  * @returns {Function|undefined} An interpolation function, if necessary.
  */
-export const victoryInterpolator = function (a, b) {
+export const victoryInterpolator = function <T>(a: T, b: T): (t: number) => T {
   // If the values are strictly equal, or either value is not interpolatable,
   // just use either the start value `a` or end value `b` at every step, as
   // there is no reasonable in-between value.
@@ -193,6 +193,7 @@ export const victoryInterpolator = function (a, b) {
     return interpolateFunction(a, b);
   }
   if (isPlainObject(a) || isPlainObject(b)) {
+    // @ts-expect-error These generics are tough, but they work ok?
     return interpolateObject(a, b);
   }
   if (typeof a === "string" || typeof b === "string") {