victory-core 36.6.3 → 36.6.6

package/es/index.d.ts

@@ -15,5 +15,4 @@ export * from "./victory-primitives";
 export { Border as Box } from "./victory-primitives";
 export type { BorderProps as BoxProps } from "./victory-primitives";
 export * from "./victory-util";
-export * from "./victory-state";
 //# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -13,5 +13,4 @@ export * from "./victory-portal/portal-context";
 export * from "./victory-portal/victory-portal";
 export * from "./victory-primitives";
 export { Border as Box } from "./victory-primitives";
-export * from "./victory-util";
-export * from "./victory-state";
+export * from "./victory-util";

package/es/types/callbacks.d.ts

@@ -34,5 +34,4 @@ export declare type VictoryOrientationCallback = (args: CallbackArgs) => Orienta
 export declare type NumberOrCallback = number | VictoryNumberCallback;
 export declare type PaddingOrCallback = number | BlockProps | VictoryPaddingCallback;
 export declare type OrientationOrCallback = OrientationTypes | VictoryOrientationCallback;
-export declare type ValueOrCallback<TValue> = TValue | ((args: CallbackArgs) => TValue);
 //# sourceMappingURL=callbacks.d.ts.map

package/es/types/prop-types.d.ts

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { ScaleLinear, ScaleLogarithmic, ScalePower, ScaleTime } from "victory-vendor/d3-scale";
 import { AnimationEasing, AnimationStyle } from "../victory-animation/victory-animation";
-import { StringOrNumberOrCallback } from "./callbacks";
+import { CallbackArgs, StringOrNumberOrCallback } from "./callbacks";
 export declare type AxisType = "x" | "y";
 export declare type DatumValue = number | string | Date | null | undefined;
 export declare type Datum = any;
@@ -10,7 +10,7 @@ export declare type ForAxes<T> = T | {
     y?: T;
 };
 export declare type ID = number | string;
-export declare type ValueOrAccessor<ValueType = unknown, PropsType = object> = ValueType | ((props: PropsType) => ValueType);
+export declare type ValueOrAccessor<ValueType, PropsType = CallbackArgs> = ValueType | ((props: PropsType) => ValueType);
 export declare type Tuple<T> = [T, T];
 export declare type ValueOrAxes<T> = T | ForAxes<T>;
 export declare type DomainPaddingPropType = ValueOrAxes<PaddingType>;
@@ -105,7 +105,7 @@ export declare type CategoryPropType = string[] | {
     x: string[];
     y: string[];
 };
-export declare type DataGetterPropType = ValueOrAccessor<string | string[] | number | number[]>;
+export declare type DataGetterPropType = ValueOrAccessor<string | string[] | number | number[], any>;
 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";

package/es/v37/clone.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+/**
+ * Syntax sugar for `React.cloneElement`, so that we can use JSX instead
+ *
+ * @example
+ *   // Before:
+ *   const children = React.cloneElement(props.groupComponent, { prop2 }, props.children);
+ *   return React.cloneElement(props.containerComponent, { prop1 }, children);
+ *
+ *   // After:
+ *   return (
+ *     <Clone element={props.containerComponent} prop1={prop1}>
+ *       <Clone element={props.groupComponent} prop2={prop2}>
+ *         {props.children}
+ *       </Clone>
+ *     </Clone>
+ *   );
+ */
+export declare const Clone: <TProps>(props: React.PropsWithChildren<{
+    element: React.ReactElement<TProps, string | React.JSXElementConstructor<any>>;
+    children?: React.ReactNode | React.ReactNode[];
+} & TProps>) => React.ReactElement<TProps, string | React.JSXElementConstructor<any>>;
+//# sourceMappingURL=clone.d.ts.map

package/es/v37/clone.js

@@ -0,0 +1,32 @@
+var _excluded = ["children", "element"];
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import React from "react";
+/**
+ * Syntax sugar for `React.cloneElement`, so that we can use JSX instead
+ *
+ * @example
+ *   // Before:
+ *   const children = React.cloneElement(props.groupComponent, { prop2 }, props.children);
+ *   return React.cloneElement(props.containerComponent, { prop1 }, children);
+ *
+ *   // After:
+ *   return (
+ *     <Clone element={props.containerComponent} prop1={prop1}>
+ *       <Clone element={props.groupComponent} prop2={prop2}>
+ *         {props.children}
+ *       </Clone>
+ *     </Clone>
+ *   );
+ */
+
+export var Clone = function (props) {
+  var children = props.children,
+      element = props.element,
+      rest = _objectWithoutProperties(props, _excluded);
+
+  return /*#__PURE__*/React.cloneElement(element, rest, children);
+};

package/es/v37/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./victory-state";
+export * from "./clone";
+export * from "./with-normalized-props";
+export * from "./with-container";
+//# sourceMappingURL=index.d.ts.map

package/es/v37/index.js

@@ -0,0 +1,4 @@
+export * from "./victory-state";
+export * from "./clone";
+export * from "./with-normalized-props";
+export * from "./with-container";

package/es/v37/victory-state/helpers/get-axis-data.d.ts

@@ -0,0 +1,3 @@
+import { AxisType, Datum } from "../../../types/prop-types";
+export declare function getAxisData(data: Datum[], axis: AxisType): any;
+//# sourceMappingURL=get-axis-data.d.ts.map

package/es/{victory-state → v37/victory-state}/helpers/get-axis-data.js

@@ -1,4 +1,4 @@
-import { isKeyValueObject } from "../../victory-util/type-helpers";
+import { isKeyValueObject } from "../../../victory-util/type-helpers";
 export function getAxisData(data, axis) {
   return data.reduce(function (acc, datum) {
     if (isKeyValueObject(datum)) {

package/es/{victory-state → v37/victory-state}/helpers/get-data.d.ts

@@ -1,4 +1,4 @@
-import { DatumValue } from "../../types/prop-types";
+import { DatumValue } from "../../../types/prop-types";
 import { VictoryProviderProps } from "../types";
 declare type DataProps = Pick<VictoryProviderProps, "data" | "x" | "y" | "sortKey" | "sortOrder" | "samples">;
 export interface FormattedDatum {

package/es/{victory-state → v37/victory-state}/helpers/get-data.js

@@ -20,7 +20,7 @@ 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; }
 
-import { isKeyValueObject } from "../../victory-util/type-helpers";
+import { isKeyValueObject } from "../../../victory-util/type-helpers";
 
 function getValue(datum, key) {
   if (typeof datum === "object") {

package/{lib → es/v37}/victory-state/helpers/get-domain.d.ts

@@ -1,5 +1,5 @@
 import { VictoryProviderProps } from "../types";
-import { AxisType, DomainTuple } from "../../types/prop-types";
+import { AxisType, DomainTuple } from "../../../types/prop-types";
 declare type DomainProps = Pick<VictoryProviderProps, "data" | "domain" | "maxDomain" | "minDomain" | "includeZero">;
 export declare function getDomain({ data, includeZero, ...props }: DomainProps, axis: AxisType): DomainTuple;
 export {};

package/es/{victory-state → v37/victory-state}/helpers/get-domain.js

@@ -18,7 +18,7 @@ function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) r
 
 import * as d3Array from "victory-vendor/d3-array";
 import { getAxisData } from "./get-axis-data";
-import { getValueForAxis, isDate, isTuple } from "../../victory-util/type-helpers";
+import { getValueForAxis, isDate, isTuple } from "../../../victory-util/type-helpers";
 // TODO: What should this default value be?
 var DEFAULT_MIN = 0;
 var DEFAULT_MAX = 1;

package/{lib → es/v37}/victory-state/helpers/get-range.d.ts

@@ -1,4 +1,4 @@
-import { AxisType } from "../../types/prop-types";
+import { AxisType } from "../../../types/prop-types";
 import { VictoryProviderProps } from "../types";
 declare type RangeProps = Pick<VictoryProviderProps, "range" | "padding" | "height" | "width">;
 export declare function getRange({ range, height, width, ...props }: RangeProps, axis: AxisType): number[];

package/es/{victory-state → v37/victory-state}/helpers/get-range.js

@@ -4,8 +4,8 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
-import { getPadding } from "../../victory-util/helpers";
-import { getValueForAxis, isTuple } from "../../victory-util/type-helpers";
+import { getPadding } from "../../../victory-util/helpers";
+import { getValueForAxis, isTuple } from "../../../victory-util/type-helpers";
 // TODO: Should we store these defaults somewhere?
 var DEFAULT_HEIGHT = 300;
 var DEFAULT_WIDTH = 450; // TODO: This does not include polar range

package/{lib → es/v37}/victory-state/helpers/get-scale.d.ts

@@ -1,4 +1,4 @@
-import { AxisType, D3ScaleFn } from "../../types/prop-types";
+import { AxisType, D3ScaleFn } from "../../../types/prop-types";
 import { VictoryProviderProps } from "../types";
 declare type ScaleProps = Pick<VictoryProviderProps, "data" | "scale">;
 export declare function getScale({ data, ...props }: ScaleProps, axis: AxisType): D3ScaleFn;

package/es/{victory-state → v37/victory-state}/helpers/get-scale.js

@@ -5,8 +5,8 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
 import { scaleLinear, scaleTime, scaleLog, scaleSqrt } from "victory-vendor/d3-scale";
-import * as Collection from "../../victory-util/collection";
-import { getValueForAxis, isFunction } from "../../victory-util/type-helpers";
+import * as Collection from "../../../victory-util/collection";
+import { getValueForAxis, isFunction } from "../../../victory-util/type-helpers";
 import { getAxisData } from "./get-axis-data";
 var DEFAULT_SCALE = scaleLinear;
 

package/es/v37/victory-state/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./victory-provider";
+export * from "./types";
+export * from "./with-victory-provider";
+//# sourceMappingURL=index.d.ts.map

package/es/{victory-state/index.d.ts → v37/victory-state/index.js}

@@ -1,3 +1,3 @@
 export * from "./victory-provider";
 export * from "./types";
-//# sourceMappingURL=index.d.ts.map
+export * from "./with-victory-provider";

package/{lib → es/v37}/victory-state/types.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { D3ScaleFn, Datum, DomainTuple, RangeTuple, ScalePropType, ValueOrAxes } from "../types/prop-types";
-import { PaddingProps } from "../victory-theme/types";
+import { D3ScaleFn, Datum, DomainTuple, RangeTuple, ScalePropType, ValueOrAxes } from "../../types/prop-types";
+import { PaddingProps } from "../../victory-theme/types";
 export interface VictoryCalculatedStateProps {
     data?: Datum[];
     domain?: ValueOrAxes<DomainTuple>;

package/{lib → es/v37}/victory-state/victory-provider.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { D3ScaleFn, DomainTuple, ForAxes } from "../types/prop-types";
+import { D3ScaleFn, DomainTuple, ForAxes } from "../../types/prop-types";
 import { FormattedDatum } from "./helpers/get-data";
 import { VictoryCalculatedStateProps, VictoryProviderProps } from "./types";
 declare type ScaleType = Required<ForAxes<D3ScaleFn>>;
@@ -8,13 +8,14 @@ export interface ContextType {
     data: FormattedDatum[];
     scale: ScaleType;
     domain: DomainType;
-    setChildProps: (id: string, props: VictoryProviderProps) => void;
+    updateChildProps: (id: symbol, props: VictoryProviderProps | null) => void;
 }
-export declare function VictoryProvider({ children, ...initialProps }: VictoryProviderProps): JSX.Element;
+export declare function VictoryProvider({ children, ...providerProps }: VictoryProviderProps): JSX.Element;
+export declare function useVictoryContextMaybe<T>(selector: (value: ContextType | null) => T): T;
 export declare function useVictoryContext<T>(selector: (value: ContextType) => T): T;
 export declare function useScale(): ScaleType;
 export declare function useData(): FormattedDatum[];
 export declare function useDomain(): DomainType;
-export declare function useVictoryProviderSync(id: string, props: VictoryCalculatedStateProps): VictoryCalculatedStateProps;
+export declare function useVictoryProviderSync(props: VictoryCalculatedStateProps): void;
 export {};
 //# sourceMappingURL=victory-provider.d.ts.map

package/es/{victory-state → v37/victory-state}/victory-provider.js

@@ -1,5 +1,9 @@
 var _excluded = ["children"];
 
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; 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; }
@@ -18,10 +22,6 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
 import * as React from "react";
 import { createContext, useContext } from "react";
 import { getData } from "./helpers/get-data";
@@ -29,21 +29,31 @@ import { getDomain } from "./helpers/get-domain";
 import { getRange } from "./helpers/get-range";
 import { getScale } from "./helpers/get-scale";
 var VictoryContext = /*#__PURE__*/createContext(null);
-export function VictoryProvider(_ref) {
-  var children = _ref.children,
-      initialProps = _objectWithoutProperties(_ref, _excluded);
 
-  // We need to store the props in state so they can be overwritten by child components
-  var _React$useState = React.useState(initialProps),
+function useNormalizedProps() {
+  var _React$useState = React.useState({}),
       _React$useState2 = _slicedToArray(_React$useState, 2),
-      props = _React$useState2[0],
-      setProps = _React$useState2[1];
+      collectedProps = _React$useState2[0],
+      setCollectedProps = _React$useState2[1];
 
-  var setChildProps = React.useCallback(function (id, newProps) {
-    setProps(function (prevProps) {
-      return _objectSpread(_objectSpread({}, prevProps), newProps);
+  var updateChildProps = React.useCallback(function (id, newProps) {
+    setCollectedProps(function (prev) {
+      var result = _objectSpread({}, prev);
+
+      if (newProps === null) {
+        delete result[id];
+      } else {
+        result[id] = newProps;
+      }
+
+      return result;
     });
-  }, []);
+  }, []); // TEMP: combine all props into a single result:
+  // TODO: instead, we should intelligently aggregate all these props
+
+  var props = Object.values(collectedProps).reduce(function (result, childProps) {
+    return Object.assign(result, childProps);
+  }, {});
   var data = React.useMemo(function () {
     return getData(props);
   }, [props]);
@@ -71,16 +81,31 @@ export function VictoryProvider(_ref) {
       y: yScaleFn
     };
   }, [props, domain, range]);
-  var value = {
-    scale: scale,
-    data: data,
-    domain: domain,
-    setChildProps: setChildProps
-  };
+  var normalizedProps = React.useMemo(function () {
+    return {
+      scale: scale,
+      data: data,
+      domain: domain,
+      updateChildProps: updateChildProps
+    };
+  }, [scale, data, domain, updateChildProps]);
+  return normalizedProps;
+}
+
+export function VictoryProvider(_ref) {
+  var children = _ref.children,
+      providerProps = _objectWithoutProperties(_ref, _excluded);
+
+  var value = useNormalizedProps(); // TODO: sync the providerProps
+
   return /*#__PURE__*/React.createElement(VictoryContext.Provider, {
     value: value
   }, children);
 }
+export function useVictoryContextMaybe(selector) {
+  var context = useContext(VictoryContext);
+  return selector(context);
+}
 export function useVictoryContext(selector) {
   var context = useContext(VictoryContext);
 
@@ -106,12 +131,18 @@ export function useDomain() {
   });
 } // This function keeps props in sync betwen the VictoryProvider and child components
 
-export function useVictoryProviderSync(id, props) {
-  var setChildProps = useVictoryContext(function (value) {
-    return value.setChildProps;
+export function useVictoryProviderSync(props) {
+  var updateChildProps = useVictoryContext(function (value) {
+    return value.updateChildProps;
   });
+
+  var _React$useState3 = React.useState(function () {
+    return Symbol("UniqueIdFor(VictoryProviderChild)");
+  }),
+      _React$useState4 = _slicedToArray(_React$useState3, 1),
+      myId = _React$useState4[0];
+
   React.useEffect(function () {
-    setChildProps(id, props);
-  }, []);
-  return props;
+    updateChildProps(myId, props);
+  }, [updateChildProps, props]);
 }

package/es/v37/victory-state/with-victory-provider.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { VictoryCommonProps } from "../../victory-util/common-props";
+/**
+ * Ensures the component is wrapped by a VictoryProvider, if not already.
+ */
+export declare function withVictoryProvider<TComp extends React.FC<TProps>, TProps extends React.PropsWithChildren<VictoryCommonProps>>(Comp: TComp): TComp;
+//# sourceMappingURL=with-victory-provider.d.ts.map

package/es/v37/victory-state/with-victory-provider.js

@@ -0,0 +1,43 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : 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); }
+
+import * as React from "react";
+import { useVictoryContextMaybe, VictoryProvider } from "./victory-provider";
+import { Clone } from "../clone";
+
+/* eslint-disable react/prop-types */
+
+/**
+ * Ensures the component is wrapped by a VictoryProvider, if not already.
+ */
+export function withVictoryProvider(Comp) {
+  var WithVictoryProvider = /*#__PURE__*/React.memo(function (props) {
+    var updateChildProps = useVictoryContextMaybe(function (value) {
+      return value === null || value === void 0 ? void 0 : value.updateChildProps;
+    });
+    var hasParentProvider = !!updateChildProps;
+    React.useEffect(function () {
+      if (!hasParentProvider) return;
+      var id = Symbol("WithVictoryProvider");
+      updateChildProps(id, props); // eslint-disable-next-line consistent-return
+
+      return function () {
+        return updateChildProps(id, null);
+      };
+    }); // @ts-expect-error "TProps not assignable to LibraryManagedAttributes"
+
+    var result = /*#__PURE__*/React.createElement(Comp, props, props.children);
+
+    if (!hasParentProvider) {
+      // Wrap with a parent Provider:
+      result = /*#__PURE__*/React.createElement(VictoryProvider, null, /*#__PURE__*/React.createElement(Clone, _extends({
+        element: props.containerComponent
+      }, props), result));
+    }
+
+    return result;
+  });
+  var name = Comp.displayName || Comp.name;
+  WithVictoryProvider.displayName = name ? "WithVictoryProvider(".concat(name, ")") : "WithVictoryProvider"; // @ts-expect-error "WithVictoryProvider does not overlap with TComp"
+
+  return WithVictoryProvider;
+}

package/es/{victory-util → v37}/with-container.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { VictoryProviderProps } from "../victory-state";
-import { VictoryCommonProps } from "./common-props";
+import { VictoryProviderProps } from "./victory-state";
+import { VictoryCommonProps } from "../victory-util/common-props";
 export declare function withContainer<Props extends VictoryCommonProps>(WrappedComponent: React.FC<Props>, initialProviderProps?: Partial<VictoryProviderProps>): React.FC<Props>;
 //# sourceMappingURL=with-container.d.ts.map

package/es/{victory-util → v37}/with-container.js

@@ -5,7 +5,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 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; }
 
 import React from "react";
-import { VictoryProvider } from "../victory-state";
+import { VictoryProvider } from "./victory-state";
 import { VictoryContainer } from "../victory-container/victory-container";
 var defaultProviderProps = {
   width: 450,

package/es/v37/with-normalized-props.d.ts

@@ -0,0 +1,17 @@
+import { VictoryCommonProps } from "../victory-util/common-props";
+import React from "react";
+import { VictoryProviderProps } from "./victory-state";
+declare type FC<TProps> = (props: TProps) => JSX.Element;
+export declare function withNormalizedProps<TProps extends React.PropsWithChildren<VictoryCommonProps>, TDefaultPropKeys extends keyof TProps>(config: {
+    displayName: string;
+    propTypes?: React.WeakValidationMap<Omit<TProps, keyof VictoryCommonProps>>;
+    defaultProps: Pick<TProps, TDefaultPropKeys>;
+    /** @deprecated */
+    initialProviderProps?: Partial<VictoryProviderProps>;
+}, WrappedComponent: React.FC<TProps>): FC<TProps> & {
+    displayName: string;
+    defaultProps: Pick<TProps, TDefaultPropKeys>;
+    propTypes: React.WeakValidationMap<Omit<TProps, keyof VictoryCommonProps>> | undefined;
+};
+export {};
+//# sourceMappingURL=with-normalized-props.d.ts.map

package/es/v37/with-normalized-props.js

@@ -0,0 +1,18 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : 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); }
+
+import React from "react";
+import { useVictoryContext, withVictoryProvider } from "./victory-state";
+export function withNormalizedProps(config, WrappedComponent) {
+  WrappedComponent.displayName = config.displayName;
+  var WithNormalizedProps = withVictoryProvider(function (props) {
+    var normalizedProps = useVictoryContext(function (v) {
+      return v;
+    });
+    return /*#__PURE__*/React.createElement(WrappedComponent, _extends({}, props, normalizedProps), props.children);
+  });
+  return Object.assign(WithNormalizedProps, {
+    displayName: "WithNormalizedProps(".concat(config.displayName),
+    defaultProps: config.defaultProps,
+    propTypes: config.propTypes
+  });
+}

package/es/victory-label/victory-label.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
-import { NumberOrCallback, StringOrCallback, StringOrNumberOrCallback, ValueOrCallback } from "../types/callbacks";
+import { NumberOrCallback, StringOrCallback, StringOrNumberOrCallback } from "../types/callbacks";
+import { ValueOrAccessor } from "../types/prop-types";
 import { PaddingProps, VerticalAnchorType, VictoryLabelStyleObject } from "../victory-theme/victory-theme";
 export declare type TextAnchorType = "start" | "middle" | "end" | "inherit";
 export declare type OriginType = {
@@ -34,11 +35,11 @@ export interface VictoryLabelProps {
     tabIndex?: NumberOrCallback;
     text?: string[] | StringOrNumberOrCallback;
     textComponent?: React.ReactElement;
-    textAnchor?: ValueOrCallback<TextAnchorType>;
+    textAnchor?: ValueOrAccessor<TextAnchorType>;
     title?: string;
-    transform?: ValueOrCallback<string | object>;
+    transform?: ValueOrAccessor<string | object>;
     tspanComponent?: React.ReactElement;
-    verticalAnchor?: ValueOrCallback<VerticalAnchorType>;
+    verticalAnchor?: ValueOrAccessor<VerticalAnchorType>;
     x?: number;
     y?: number;
     dx?: StringOrNumberOrCallback;

package/es/victory-util/helpers.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
-import { CallbackArgs, ValueOrCallback } from "../types/callbacks";
+import { CallbackArgs } from "../types/callbacks";
+import { ValueOrAccessor } from "../types/prop-types";
 /**
  * creates an object with some keys excluded
  * replacement for lodash.omit for performance. does not mimic the entire lodash.omit api
@@ -24,7 +25,7 @@ export declare function getPadding(props: any, name?: string): {
 export declare function isTooltip(component: any): boolean;
 export declare function getDefaultStyles(props: any, role: any): any;
 export declare function getStyles(style: any, defaultStyles: any): any;
-export declare function evaluateProp<TValue>(prop: ValueOrCallback<TValue>, props: CallbackArgs): TValue;
+export declare function evaluateProp<TValue>(prop: ValueOrAccessor<TValue, CallbackArgs>, props: CallbackArgs): TValue;
 export declare function evaluateStyle(style: any, props: any): any;
 export declare function degreesToRadians(degrees: any): any;
 export declare function radiansToDegrees(radians: any): any;