victory-pie 36.8.2 → 36.8.4

package/es/helper-methods.d.ts

@@ -0,0 +1,14 @@
+export declare const getXOffsetMultiplayerByAngle: (angle: any) => number;
+export declare const getYOffsetMultiplayerByAngle: (angle: any) => number;
+export declare const getXOffset: (offset: any, angle: any) => number;
+export declare const getYOffset: (offset: any, angle: any) => number;
+export declare const getAverage: (array: any) => number;
+export declare const getLabelIndicatorPropsForLineSegment: (props: any, calculatedValues: any, labelProps: any) => {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    index: any;
+};
+export declare const getBaseProps: (initialProps: any, fallbackProps: any) => any;
+//# sourceMappingURL=helper-methods.d.ts.map

package/es/helper-methods.js

@@ -51,7 +51,7 @@ var getSlices = function (props, data) {
 var getCalculatedValues = function (props) {
   var colorScale = props.colorScale;
   var styleObject = Helpers.getDefaultStyles(props, "pie");
-  var style = Helpers.getStyles(props.style, styleObject, "auto", "100%");
+  var style = Helpers.getStyles(props.style, styleObject);
   var colors = Array.isArray(colorScale) ? colorScale : Style.getColorScale(colorScale);
   var padding = Helpers.getPadding(props);
   var defaultRadius = getRadius(props, padding);
@@ -92,10 +92,13 @@ var getLabelText = function (props, datum, index) {
   return checkForValidText(text);
 };
 
-var getLabelArc = function (radius, labelRadius, style) {
+var getLabelArc = function (labelRadius) {
+  return d3Shape.arc().outerRadius(labelRadius).innerRadius(labelRadius);
+};
+
+var getCalculatedLabelRadius = function (radius, labelRadius, style) {
   var padding = style && style.padding || 0;
-  var arcRadius = labelRadius || radius + padding;
-  return d3Shape.arc().outerRadius(arcRadius).innerRadius(arcRadius);
+  return labelRadius || radius + padding;
 };
 
 var getLabelPosition = function (arc, slice, position) {
@@ -200,7 +203,8 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
     labelRadius: labelRadius,
     text: text
   }, dataProps));
-  var labelArc = getLabelArc(defaultRadius, labelRadius, evaluatedStyle);
+  var calculatedLabelRadius = getCalculatedLabelRadius(defaultRadius, labelRadius, evaluatedStyle);
+  var labelArc = getLabelArc(calculatedLabelRadius);
   var position = getLabelPosition(labelArc, slice, labelPosition);
   var baseAngle = getBaseLabelAngle(slice, labelPosition, labelStyle);
   var labelAngle = getLabelAngle(baseAngle, labelPlacement);
@@ -221,7 +225,8 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
     y: Math.round(position[1]) + origin.y,
     textAnchor: textAnchor,
     verticalAnchor: verticalAnchor,
-    angle: labelAngle
+    angle: labelAngle,
+    calculatedLabelRadius: calculatedLabelRadius
   };
 
   if (!Helpers.isTooltip(labelComponent)) {
@@ -232,8 +237,57 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
   return _defaults({}, labelProps, Helpers.omit(tooltipTheme, ["style"]));
 };
 
-export var getBaseProps = function (props, fallbackProps) {
-  props = Helpers.modifyProps(props, fallbackProps, "pie");
+export var getXOffsetMultiplayerByAngle = function (angle) {
+  return Math.cos(angle - Helpers.degreesToRadians(90));
+};
+export var getYOffsetMultiplayerByAngle = function (angle) {
+  return Math.sin(angle - Helpers.degreesToRadians(90));
+};
+export var getXOffset = function (offset, angle) {
+  return offset * getXOffsetMultiplayerByAngle(angle);
+};
+export var getYOffset = function (offset, angle) {
+  return offset * getYOffsetMultiplayerByAngle(angle);
+};
+export var getAverage = function (array) {
+  return array.reduce(function (acc, cur) {
+    return acc + cur;
+  }, 0) / array.length;
+};
+export var getLabelIndicatorPropsForLineSegment = function (props, calculatedValues, labelProps) {
+  var innerRadius = props.innerRadius,
+      radius = props.radius,
+      _props$slice = props.slice,
+      startAngle = _props$slice.startAngle,
+      endAngle = _props$slice.endAngle,
+      labelIndicatorInnerOffset = props.labelIndicatorInnerOffset,
+      labelIndicatorOuterOffset = props.labelIndicatorOuterOffset,
+      index = props.index;
+  var height = calculatedValues.height,
+      width = calculatedValues.width;
+  var calculatedLabelRadius = labelProps.calculatedLabelRadius; // calculation
+
+  var middleRadius = getAverage([innerRadius, radius]);
+  var midAngle = getAverage([endAngle, startAngle]);
+  var centerX = width / 2;
+  var centerY = height / 2;
+  var innerOffset = middleRadius + labelIndicatorInnerOffset;
+  var outerOffset = calculatedLabelRadius - labelIndicatorOuterOffset;
+  var x1 = centerX + getXOffset(innerOffset, midAngle);
+  var y1 = centerY + getYOffset(innerOffset, midAngle);
+  var x2 = centerX + getXOffset(outerOffset, midAngle);
+  var y2 = centerY + getYOffset(outerOffset, midAngle);
+  var labelIndicatorProps = {
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    index: index
+  };
+  return _defaults({}, labelIndicatorProps);
+};
+export var getBaseProps = function (initialProps, fallbackProps) {
+  var props = Helpers.modifyProps(initialProps, fallbackProps, "pie");
   var calculatedValues = getCalculatedValues(props);
   var slices = calculatedValues.slices,
       style = calculatedValues.style,
@@ -250,7 +304,8 @@ export var getBaseProps = function (props, fallbackProps) {
       innerRadius = calculatedValues.innerRadius,
       cornerRadius = calculatedValues.cornerRadius,
       padAngle = calculatedValues.padAngle,
-      disableInlineStyles = calculatedValues.disableInlineStyles;
+      disableInlineStyles = calculatedValues.disableInlineStyles,
+      labelIndicator = calculatedValues.labelIndicator;
   var radius = props.radius || defaultRadius;
   var initialChildProps = {
     parent: {
@@ -291,6 +346,14 @@ export var getBaseProps = function (props, fallbackProps) {
     if (text !== undefined && text !== null || labels && (events || sharedEvents)) {
       var evaluatedText = Helpers.evaluateProp(text, dataProps);
       childProps[eventKey].labels = getLabelProps(evaluatedText, _assign({}, props, dataProps), calculatedValues);
+
+      if (labelIndicator) {
+        var labelProps = childProps[eventKey].labels;
+
+        if (labelProps.calculatedLabelRadius > radius) {
+          childProps[eventKey].labelIndicators = getLabelIndicatorPropsForLineSegment(_assign({}, props, dataProps), calculatedValues, labelProps);
+        }
+      }
     }
 
     return childProps;

package/es/index.d.ts

@@ -1,83 +1,3 @@
-import * as React from "react";
-import {
-  CategoryPropType,
-  ColorScalePropType,
-  DataGetterPropType,
-  EventPropTypeInterface,
-  StringOrCallback,
-  NumberOrCallback,
-  OriginType,
-  SliceNumberOrCallback,
-  StringOrNumberOrCallback,
-  VictoryCommonProps,
-  VictoryLabelableProps,
-  VictoryMultiLabelableProps,
-  VictoryStyleInterface,
-} from "victory-core";
-
-export type VictorySliceLabelPositionType =
-  | "startAngle"
-  | "centroid"
-  | "endAngle";
-export type VictorySliceLabelPlacementType =
-  | "vertical"
-  | "parallel"
-  | "perpendicular";
-export type VictorySliceTTargetType = "data" | "labels" | "parent";
-
-export interface SliceProps extends VictoryCommonProps {
-  ariaLabel?: StringOrCallback;
-  cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
-  datum?: any;
-  innerRadius?: NumberOrCallback;
-  padAngle?: SliceNumberOrCallback<SliceProps, "padAngle">;
-  pathComponent?: React.ReactElement;
-  pathFunction?: (props: SliceProps) => string;
-  radius?: SliceNumberOrCallback<SliceProps, "radius">;
-  slice?: {
-    startAngle?: number;
-    endAngle?: number;
-    padAngle?: number;
-    data?: any[];
-  };
-  sliceEndAngle?: SliceNumberOrCallback<SliceProps, "sliceEndAngle">;
-  sliceStartAngle?: SliceNumberOrCallback<SliceProps, "sliceStartAngle">;
-  style?: VictoryStyleInterface;
-  tabIndex?: NumberOrCallback;
-}
-
-export class Slice extends React.Component<SliceProps, any> {}
-
-export interface VictoryPieProps
-  extends Omit<VictoryCommonProps, "polar">,
-    VictoryLabelableProps,
-    VictoryMultiLabelableProps {
-  categories?: CategoryPropType;
-  colorScale?: ColorScalePropType;
-  cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
-  data?: any[];
-  dataComponent?: React.ReactElement;
-  endAngle?: number;
-  events?: EventPropTypeInterface<
-    VictorySliceTTargetType,
-    StringOrNumberOrCallback | string[] | number[]
-  >[];
-  eventKey?: StringOrNumberOrCallback;
-  innerRadius?: NumberOrCallback;
-  labelPlacement?:
-    | VictorySliceLabelPlacementType
-    | ((props: SliceProps) => VictorySliceLabelPlacementType);
-  labelPosition?:
-    | VictorySliceLabelPositionType
-    | ((props: SliceProps) => VictorySliceLabelPositionType);
-  labelRadius?: number | ((props: SliceProps) => number);
-  origin?: OriginType;
-  padAngle?: NumberOrCallback;
-  radius?: NumberOrCallback;
-  startAngle?: number;
-  style?: VictoryStyleInterface;
-  x?: DataGetterPropType;
-  y?: DataGetterPropType;
-}
-
-export class VictoryPie extends React.Component<VictoryPieProps, any> {}
+export * from "./victory-pie";
+export * from "./slice";
+//# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -1,2 +1,2 @@
-export { default as VictoryPie } from "./victory-pie";
-export { default as Slice } from "./slice";
+export * from "./victory-pie";
+export * from "./slice";

package/es/slice.d.ts

@@ -0,0 +1,62 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { NumberOrCallback, SliceNumberOrCallback, StringOrCallback, VictoryCommonProps, VictoryStyleInterface } from "victory-core";
+export declare type VictorySliceLabelPositionType = "startAngle" | "centroid" | "endAngle";
+export declare type VictorySliceLabelPlacementType = "vertical" | "parallel" | "perpendicular";
+export declare type VictorySliceTTargetType = "data" | "labels" | "parent";
+export interface SliceProps extends VictoryCommonProps {
+    ariaLabel?: StringOrCallback;
+    cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
+    datum?: any;
+    innerRadius?: NumberOrCallback;
+    padAngle?: SliceNumberOrCallback<SliceProps, "padAngle">;
+    pathComponent?: React.ReactElement;
+    pathFunction?: (props: SliceProps) => string;
+    radius?: SliceNumberOrCallback<SliceProps, "radius">;
+    slice?: {
+        startAngle?: number;
+        endAngle?: number;
+        padAngle?: number;
+        data?: any[];
+    };
+    sliceEndAngle?: SliceNumberOrCallback<SliceProps, "sliceEndAngle">;
+    sliceStartAngle?: SliceNumberOrCallback<SliceProps, "sliceStartAngle">;
+    style?: VictoryStyleInterface;
+    tabIndex?: NumberOrCallback;
+    role?: string;
+    shapeRendering?: string;
+}
+export declare const Slice: {
+    (initialProps: SliceProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+    propTypes: {
+        cornerRadius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        datum: PropTypes.Requireable<object>;
+        innerRadius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        padAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        pathComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        pathFunction: PropTypes.Requireable<(...args: any[]) => any>;
+        radius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        slice: PropTypes.Requireable<object>;
+        sliceEndAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        sliceStartAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        active?: React.Validator<boolean | null | undefined> | undefined;
+        ariaLabel?: React.Validator<StringOrCallback | null | undefined> | undefined;
+        className?: React.Validator<string | null | undefined> | undefined;
+        clipPath?: React.Validator<string | null | undefined> | undefined;
+        data?: React.Validator<any> | undefined;
+        desc?: React.Validator<string | Function | null | undefined> | undefined;
+        disableInlineStyles?: React.Validator<boolean | null | undefined> | undefined;
+        events?: React.Validator<object | null | undefined> | undefined;
+        id?: React.Validator<string | number | Function | null | undefined> | undefined;
+        index?: React.Validator<string | number | null | undefined> | undefined;
+        origin?: React.Validator<import("victory-core").OriginType | null | undefined> | undefined;
+        polar?: React.Validator<boolean | null | undefined> | undefined;
+        role?: React.Validator<string | null | undefined> | undefined;
+        scale?: React.Validator<any> | undefined;
+        shapeRendering?: React.Validator<string | null | undefined> | undefined;
+        style?: React.Validator<any> | undefined;
+        tabIndex?: React.Validator<NumberOrCallback | null | undefined> | undefined;
+        transform?: React.Validator<string | null | undefined> | undefined;
+    };
+};
+//# sourceMappingURL=slice.d.ts.map

package/es/slice.js

@@ -84,9 +84,8 @@ var defaultProps = {
   role: "presentation",
   shapeRendering: "auto"
 };
-
-var Slice = function (props) {
-  props = evaluateProps(_objectSpread(_objectSpread({}, defaultProps), props));
+export var Slice = function (initialProps) {
+  var props = evaluateProps(_objectSpread(_objectSpread({}, defaultProps), initialProps));
   var defaultTransform = props.origin ? "translate(".concat(props.origin.x, ", ").concat(props.origin.y, ")") : undefined;
   return /*#__PURE__*/React.cloneElement(props.pathComponent, _objectSpread(_objectSpread({}, props.events), {}, {
     "aria-label": props.ariaLabel,
@@ -100,7 +99,6 @@ var Slice = function (props) {
     tabIndex: props.tabIndex
   }));
 };
-
 Slice.propTypes = _objectSpread(_objectSpread({}, CommonProps.primitiveProps), {}, {
   cornerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
   datum: PropTypes.object,
@@ -112,5 +110,4 @@ Slice.propTypes = _objectSpread(_objectSpread({}, CommonProps.primitiveProps), {
   slice: PropTypes.object,
   sliceEndAngle: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
   sliceStartAngle: PropTypes.oneOfType([PropTypes.number, PropTypes.func])
-});
-export default Slice;
+});

package/es/victory-pie.d.ts

@@ -0,0 +1,117 @@
+import React from "react";
+import { Data, ColorScalePropType, EventPropTypeInterface, NumberOrCallback, OriginType, SliceNumberOrCallback, StringOrNumberOrCallback, VictoryCommonProps, VictoryLabelableProps, VictoryMultiLabelableProps, VictoryStyleInterface, EventsMixinClass, VictoryDatableProps } from "victory-core";
+import { SliceProps, VictorySliceTTargetType, VictorySliceLabelPlacementType, VictorySliceLabelPositionType } from "./slice";
+export interface VictoryPieProps extends Omit<VictoryCommonProps, "polar">, VictoryDatableProps, VictoryLabelableProps, VictoryMultiLabelableProps {
+    colorScale?: ColorScalePropType;
+    cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
+    endAngle?: number;
+    events?: EventPropTypeInterface<VictorySliceTTargetType, StringOrNumberOrCallback | string[] | number[]>[];
+    eventKey?: StringOrNumberOrCallback;
+    innerRadius?: NumberOrCallback;
+    labelIndicator?: boolean | React.ReactElement;
+    labelIndicatorInnerOffset?: number;
+    labelIndicatorOuterOffset?: number;
+    labelPlacement?: VictorySliceLabelPlacementType | ((props: SliceProps) => VictorySliceLabelPlacementType);
+    labelPosition?: VictorySliceLabelPositionType | ((props: SliceProps) => VictorySliceLabelPositionType);
+    labelIndicatorComponent?: React.ReactElement;
+    labelRadius?: number | ((props: SliceProps) => number);
+    origin?: OriginType;
+    padAngle?: NumberOrCallback;
+    radius?: NumberOrCallback;
+    startAngle?: number;
+    style?: VictoryStyleInterface;
+}
+interface VictoryPieBase extends EventsMixinClass<VictoryPieProps> {
+}
+declare class VictoryPieBase extends React.Component<VictoryPieProps> {
+    static animationWhitelist: (keyof VictoryPieProps)[];
+    static displayName: string;
+    static role: string;
+    static defaultTransitions: {
+        onExit: {
+            duration: number;
+            before: () => {
+                _y: number;
+                label: string;
+            };
+        };
+        onEnter: {
+            duration: number;
+            before: () => {
+                _y: number;
+                label: string;
+            };
+            after: (datum: any) => {
+                y_: any;
+                label: any;
+            };
+        };
+    };
+    static defaultProps: VictoryPieProps;
+    static getBaseProps: (props: VictoryPieProps) => any;
+    static getData: typeof Data.getData;
+    static expectedComponents: (keyof VictoryPieProps)[];
+    shouldAnimate(): boolean;
+    renderComponents(props: VictoryPieProps, shouldRenderDatum?: (datum: any) => boolean): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    render(): React.ReactElement;
+}
+export declare const VictoryPie: {
+    new (props: import("victory-core").EventMixinCommonProps): {
+        state: {};
+        getEventState: (eventKey: string | number, namespace: string, childType?: string | undefined) => any;
+        getScopedEvents: (events: any, namespace: any, childType: any, baseProps: any) => {};
+        getEvents: (p: any, target: any, eventKey: any) => any;
+        externalMutations: {} | undefined;
+        calculatedState: {};
+        globalEvents: {};
+        prevGlobalEventKeys: string[];
+        boundGlobalEvents: {};
+        shouldComponentUpdate(nextProps: import("victory-core").EventMixinCommonProps): boolean;
+        componentDidMount(): void;
+        componentDidUpdate(prevProps: any): void;
+        componentWillUnmount(): void;
+        addGlobalListener(key: any): void;
+        removeGlobalListener(key: any): void;
+        getStateChanges(props: any): {};
+        applyExternalMutations(props: any, externalMutations: any): void;
+        getCalculatedValues(props: any): import("victory-core").EventMixinCalculatedValues;
+        getExternalMutations(props: import("victory-core").EventMixinCommonProps): {} | undefined;
+        cacheValues(obj: any): void;
+        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
+        getAllEvents(props: any): any;
+        getComponentProps(component: React.ReactNode, type: string, index: string | number): any;
+        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+        animateComponent(props: import("victory-core").EventMixinCommonProps, defaultAnimationWhitelist: string[]): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+        renderContinuousData(props: import("victory-core").EventMixinCommonProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+        renderData(props: any, shouldRenderDatum?: ((datum: any) => boolean) | undefined): React.DetailedReactHTMLElement<any, HTMLElement>;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("victory-core").EventMixinCommonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<import("victory-core").EventMixinCommonProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("victory-core").EventMixinCommonProps>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        componentEvents: import("victory-core/lib/victory-util/events").ComponentEvent[];
+        getSharedEventState: (key: string, value: string) => unknown;
+        baseProps: Record<string, object>;
+        dataKeys: string[];
+        hasEvents: unknown;
+        events: unknown;
+    };
+    getBaseProps?(props: import("victory-core").EventMixinCommonProps): Record<string, object>;
+    role?: string | undefined;
+    expectedComponents?: string[] | undefined;
+    getChildren?: ((props: import("victory-core").EventMixinCommonProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: import("victory-core").EventMixinCommonProps | undefined) => void) | undefined;
+    animationWhitelist?: string[] | undefined;
+} & typeof VictoryPieBase;
+export {};
+//# sourceMappingURL=victory-pie.d.ts.map