victory-core 36.4.0 → 36.5.1

package/lib/victory-state/victory-provider.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VictoryProvider = VictoryProvider;
+exports.useData = useData;
+exports.useDomain = useDomain;
+exports.useScale = useScale;
+exports.useVictoryContext = useVictoryContext;
+exports.useVictoryProviderSync = useVictoryProviderSync;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useContextSelector = require("use-context-selector");
+
+var _getData = require("./helpers/get-data");
+
+var _getDomain = require("./helpers/get-domain");
+
+var _getRange = require("./helpers/get-range");
+
+var _getScale = require("./helpers/get-scale");
+
+var _excluded = ["children"];
+
+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 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; }
+
+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 _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; }
+
+var VictoryContext = (0, _useContextSelector.createContext)(null);
+
+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),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      props = _React$useState2[0],
+      setProps = _React$useState2[1];
+
+  var setChildProps = React.useCallback(function (id, newProps) {
+    setProps(function (prevProps) {
+      return _objectSpread(_objectSpread({}, prevProps), newProps);
+    });
+  }, []);
+  var data = React.useMemo(function () {
+    return (0, _getData.getData)(props);
+  }, [props]);
+  var domain = React.useMemo(function () {
+    return {
+      x: (0, _getDomain.getDomain)(props, "x"),
+      y: (0, _getDomain.getDomain)(props, "y")
+    };
+  }, [props]);
+  var range = React.useMemo(function () {
+    return {
+      x: (0, _getRange.getRange)(props, "x"),
+      y: (0, _getRange.getRange)(props, "y")
+    };
+  }, [props]);
+  var scale = React.useMemo(function () {
+    var xBaseScaleFn = (0, _getScale.getScale)(props, "x");
+    var yBaseScaleFn = (0, _getScale.getScale)(props, "y"); // @ts-expect-error: This is a valid scale function
+
+    var xScaleFn = xBaseScaleFn().domain(domain.x).range(range.x); // @ts-expect-error: This is a valid scale function
+
+    var yScaleFn = yBaseScaleFn().domain(domain.y).range(range.y);
+    return {
+      x: xScaleFn,
+      y: yScaleFn
+    };
+  }, [props, domain, range]);
+  var value = {
+    scale: scale,
+    data: data,
+    domain: domain,
+    setChildProps: setChildProps
+  };
+  return /*#__PURE__*/React.createElement(VictoryContext.Provider, {
+    value: value
+  }, children);
+}
+
+function useVictoryContext(selector) {
+  return (0, _useContextSelector.useContextSelector)(VictoryContext, function (context) {
+    if (!context) {
+      throw new Error("useVictoryContext must be used within a VictoryProvider");
+    }
+
+    return selector(context);
+  });
+}
+
+function useScale() {
+  return useVictoryContext(function (value) {
+    return value.scale;
+  });
+}
+
+function useData() {
+  return useVictoryContext(function (value) {
+    return value.data;
+  });
+}
+
+function useDomain() {
+  return useVictoryContext(function (value) {
+    return value.domain;
+  });
+} // This function keeps props in sync betwen the VictoryProvider and child components
+
+
+function useVictoryProviderSync(id, props) {
+  var setChildProps = useVictoryContext(function (value) {
+    return value.setChildProps;
+  });
+  React.useEffect(function () {
+    setChildProps(id, props);
+  }, []);
+  return props;
+}
+//# sourceMappingURL=victory-provider.js.map

package/lib/victory-theme/grayscale.d.ts

@@ -0,0 +1,3 @@
+import { VictoryThemeDefinition } from "./types";
+export declare const grayscale: VictoryThemeDefinition;
+//# sourceMappingURL=grayscale.d.ts.map

package/lib/victory-theme/grayscale.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.grayscale = void 0;
 
 var _assign2 = _interopRequireDefault(require("lodash/assign"));
 
@@ -49,7 +49,7 @@ var centeredLabelStyles = (0, _assign2.default)({
 
 var strokeLinecap = "round";
 var strokeLinejoin = "round";
-var _default = {
+var grayscale = {
   area: (0, _assign2.default)({
     style: {
       data: {
@@ -265,4 +265,5 @@ var _default = {
     }
   }, baseProps)
 };
-exports.default = _default;
+exports.grayscale = grayscale;
+//# sourceMappingURL=grayscale.js.map

package/lib/victory-theme/material.d.ts

@@ -0,0 +1,3 @@
+import { VictoryThemeDefinition } from "./types";
+export declare const material: VictoryThemeDefinition;
+//# sourceMappingURL=material.d.ts.map

package/lib/victory-theme/material.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.material = void 0;
 
 var _assign2 = _interopRequireDefault(require("lodash/assign"));
 
@@ -59,7 +59,7 @@ var centeredLabelStyles = (0, _assign2.default)({
 var strokeDasharray = "10, 5";
 var strokeLinecap = "round";
 var strokeLinejoin = "round";
-var _default = {
+var material = {
   area: (0, _assign2.default)({
     style: {
       data: {
@@ -292,4 +292,5 @@ var _default = {
     }
   }, baseProps)
 };
-exports.default = _default;
+exports.material = material;
+//# sourceMappingURL=material.js.map

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

@@ -0,0 +1,239 @@
+import * as React from "react";
+import { VictoryCommonThemeProps, VictoryDatableProps } from "../victory-util/common-props";
+import { NumberOrCallback, OrientationOrCallback, PaddingOrCallback, StringOrNumberOrCallback } from "../types/callbacks";
+export declare type BlockProps = {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+};
+export declare type PaddingProps = number | BlockProps;
+export declare type OrientationTypes = "top" | "bottom" | "left" | "right";
+export declare type VictoryStyleObject = {
+    [K in keyof React.CSSProperties]: StringOrNumberOrCallback;
+};
+export declare type LabelProps = React.CSSProperties & {
+    angle?: number;
+    verticalAnchor?: VerticalAnchorType;
+};
+export declare type VictoryLabelStyleObject = {
+    [K in keyof LabelProps]: StringOrNumberOrCallback;
+};
+/**
+ * Style interface used in components/themeing
+ */
+export interface VictoryStyleInterface {
+    parent?: VictoryStyleObject;
+    data?: VictoryStyleObject;
+    labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    border?: VictoryStyleObject;
+}
+export declare type TickProps = React.CSSProperties & {
+    size?: number;
+};
+export declare type VictoryTickStyleObject = {
+    [K in keyof TickProps]: StringOrNumberOrCallback;
+};
+export interface VictoryAxisCommonProps {
+    axisComponent?: React.ReactElement;
+    axisLabelComponent?: React.ReactElement;
+    axisValue?: number | string | object | Date;
+    dependentAxis?: boolean;
+    disableInlineStyles?: boolean;
+    gridComponent?: React.ReactElement;
+    invertAxis?: boolean;
+    style?: {
+        parent?: VictoryStyleObject;
+        axis?: VictoryStyleObject;
+        axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        grid?: VictoryStyleObject;
+        ticks?: VictoryTickStyleObject;
+        tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    };
+    tickComponent?: React.ReactElement;
+    tickCount?: number;
+    tickLabelComponent?: React.ReactElement;
+    tickFormat?: any[] | {
+        (tick: any, index: number, ticks: any[]): string | number;
+    };
+    tickValues?: any[];
+}
+export declare type VerticalAnchorType = "start" | "middle" | "end";
+export interface VictoryThemeDefinition {
+    area?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    axis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+    } & VictoryCommonThemeProps;
+    bar?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    boxplot?: {
+        style?: {
+            max?: VictoryStyleObject;
+            maxLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            median?: VictoryStyleObject;
+            medianLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            min?: VictoryStyleObject;
+            minLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            q1?: VictoryStyleObject;
+            q1Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            q3?: VictoryStyleObject;
+            q3Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        boxWidth?: number;
+    } & VictoryCommonThemeProps;
+    candlestick?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        candleColors?: {
+            positive?: string;
+            negative?: string;
+        };
+    } & VictoryCommonThemeProps;
+    chart?: VictoryCommonThemeProps;
+    dependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+        orientation?: OrientationTypes;
+    } & VictoryCommonThemeProps;
+    errorbar?: {
+        borderWidth?: number;
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    group?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    histogram?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    independentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+        orientation?: OrientationTypes;
+    } & VictoryCommonThemeProps;
+    legend?: {
+        gutter?: number | BlockProps;
+        rowGutter?: number | BlockProps;
+        orientation?: string;
+        titleOrientation?: string;
+        style?: {
+            data?: VictoryStyleObject & {
+                type?: string;
+            };
+            border?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            title?: VictoryLabelStyleObject;
+        };
+        itemsPerRow?: number;
+        x?: number;
+        y?: number;
+        centerTitle?: boolean;
+        borderPadding?: number | BlockProps;
+    } & VictoryCommonThemeProps;
+    line?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    pie?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    polarAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    polarDependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    polarIndependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    scatter?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    stack?: VictoryCommonThemeProps;
+    tooltip?: {
+        style?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        flyoutStyle?: VictoryStyleObject;
+        cornerRadius?: NumberOrCallback;
+        pointerLength?: NumberOrCallback;
+        flyoutPadding?: PaddingOrCallback;
+        flyoutWidth?: NumberOrCallback;
+        flyoutHeight?: NumberOrCallback;
+        orientation?: OrientationOrCallback;
+        pointerOrientation?: OrientationOrCallback;
+    };
+    voronoi?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            flyout?: VictoryStyleObject;
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/victory-theme/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/victory-theme/victory-theme.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export declare const VictoryTheme: {
+    grayscale: import("./types").VictoryThemeDefinition;
+    material: import("./types").VictoryThemeDefinition;
+};
+//# sourceMappingURL=victory-theme.d.ts.map

package/lib/victory-theme/victory-theme.js

@@ -3,16 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+var _exportNames = {
+  VictoryTheme: true
+};
+exports.VictoryTheme = void 0;
 
-var _material = _interopRequireDefault(require("./material"));
+var _grayscale = require("./grayscale");
 
-var _grayscale = _interopRequireDefault(require("./grayscale"));
+var _material = require("./material");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _types = require("./types");
 
-var _default = {
-  material: _material.default,
-  grayscale: _grayscale.default
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var VictoryTheme = {
+  grayscale: _grayscale.grayscale,
+  material: _material.material
 };
-exports.default = _default;
+exports.VictoryTheme = VictoryTheme;
+//# sourceMappingURL=victory-theme.js.map

package/lib/victory-transition/victory-transition.d.ts

@@ -0,0 +1,60 @@
+import React from "react";
+import PropTypes from "prop-types";
+import TimerContext from "../victory-util/timer-context";
+import Timer from "../victory-util/timer";
+declare type VictoryTransitionChild = React.ReactElement<{
+    polar?: boolean;
+    domain?: number[] | {
+        x: number[];
+        y: number[];
+    };
+    groupComponent?: React.ReactElement;
+}, {
+    new (props: any): React.Component<any, any>;
+    continuous?: boolean;
+}>;
+interface VictoryTransitionProps {
+    animate?: boolean | any;
+    animationWhitelist?: string[];
+    children: VictoryTransitionChild;
+}
+interface VictoryTransitionState {
+    oldProps?: VictoryTransitionProps | null;
+    nextProps?: VictoryTransitionProps;
+    nodesShouldLoad?: boolean;
+    nodesDoneLoad?: boolean;
+    nodesWillExit?: boolean;
+    nodesWillEnter?: boolean;
+    nodesShouldEnter?: boolean;
+    childrenTransitions?: unknown;
+}
+export interface VictoryTransition {
+    context: React.ContextType<typeof TimerContext>;
+}
+export declare class VictoryTransition extends React.Component<VictoryTransitionProps, VictoryTransitionState> {
+    static displayName: string;
+    static propTypes: {
+        animate: PropTypes.Requireable<boolean | object>;
+        animationWhitelist: PropTypes.Requireable<any[]>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static contextType: React.Context<{
+        transitionTimer: Timer;
+        animationTimer: Timer;
+    }>;
+    private continuous;
+    private timer;
+    private transitionProps;
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: VictoryTransitionProps): boolean;
+    componentWillUnmount(): void;
+    private getTransitionState;
+    private getDomainFromChildren;
+    pickProps(): Readonly<VictoryTransitionProps>;
+    private pickDomainProps;
+    getClipWidth(props: any, child: any): any;
+    render(): JSX.Element;
+}
+export {};
+//# sourceMappingURL=victory-transition.d.ts.map