victory-core 36.3.2 → 36.5.0

package/src/victory-theme/victory-theme-definition.ts

@@ -0,0 +1,261 @@
+import * as React from "react";
+import { VictoryCommonThemeProps, VictoryDatableProps } from "../index";
+import { CallbackArgs, StringOrNumberOrCallback } from "../types";
+
+export type BlockProps = {
+  top?: number;
+  bottom?: number;
+  left?: number;
+  right?: number;
+};
+export type PaddingProps = number | BlockProps;
+export type OrientationTypes = "top" | "bottom" | "left" | "right";
+export type VictoryNumberCallback = (args: CallbackArgs) => number;
+export type VictoryPaddingCallback = (
+  args: CallbackArgs
+) => number | BlockProps;
+export type VictoryOrientationCallback = (
+  args: CallbackArgs
+) => OrientationTypes;
+export type NumberOrCallback = number | VictoryNumberCallback;
+export type PaddingOrCallback = number | BlockProps | VictoryPaddingCallback;
+export type OrientationOrCallback =
+  | OrientationTypes
+  | VictoryOrientationCallback;
+export type VictoryStyleObject = {
+  [K in keyof React.CSSProperties]: StringOrNumberOrCallback;
+};
+export type LabelProps = React.CSSProperties & {
+  angle?: number;
+  verticalAnchor?: VerticalAnchorType;
+};
+export 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 type TickProps = React.CSSProperties & { size?: number };
+export 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 type VerticalAnchorType = "start" | "middle" | "end";
+// #region Victory Theme
+// Note: Many SVG attributes are missed in CSSProperties interface
+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;
+}

package/src/victory-theme/victory-theme.tsx

@@ -0,0 +1,5 @@
+import { grayscale } from "./grayscale";
+import { material } from "./material";
+export * from "./victory-theme-definition";
+
+export const VictoryTheme = { grayscale, material };

package/src/victory-transition/{victory-transition.js → victory-transition.tsx}

@@ -1,14 +1,52 @@
 import React from "react";
 import PropTypes from "prop-types";
-import VictoryAnimation from "../victory-animation/victory-animation";
+import { VictoryAnimation } from "../victory-animation/victory-animation";
 import * as Collection from "../victory-util/collection";
 import * as Helpers from "../victory-util/helpers";
 import TimerContext from "../victory-util/timer-context";
 import * as Transitions from "../victory-util/transitions";
-import { defaults, isFunction, pick, isObject } from "lodash";
+import { defaults, isFunction, pick } from "lodash";
 import isEqual from "react-fast-compare";
+import Timer from "../victory-util/timer";
 
-export default class VictoryTransition extends React.Component {
+type VictoryTransitionChild = React.ReactElement<
+  // Props:
+  {
+    polar?: boolean;
+    domain?: number[] | { x: number[]; y: number[] };
+    groupComponent?: React.ReactElement;
+  },
+  // Type:
+  {
+    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 class VictoryTransition extends React.Component<
+  VictoryTransitionProps,
+  VictoryTransitionState
+> {
   static displayName = "VictoryTransition";
 
   static propTypes = {
@@ -18,6 +56,9 @@ export default class VictoryTransition extends React.Component {
   };
 
   static contextType = TimerContext;
+  private continuous: boolean;
+  private timer: Timer;
+  private transitionProps: any;
 
   constructor(props, context) {
     super(props, context);
@@ -28,7 +69,6 @@ export default class VictoryTransition extends React.Component {
     const child = this.props.children;
     const polar = child.props.polar;
     this.continuous = !polar && child.type && child.type.continuous === true;
-    this.getTransitionState = this.getTransitionState.bind(this);
     this.timer = this.context.transitionTimer;
   }
 
@@ -36,7 +76,7 @@ export default class VictoryTransition extends React.Component {
     this.setState({ nodesShouldLoad: true }); //eslint-disable-line react/no-did-mount-set-state
   }
 
-  shouldComponentUpdate(nextProps) {
+  shouldComponentUpdate(nextProps: VictoryTransitionProps) {
     if (!isEqual(this.props, nextProps)) {
       this.timer.bypassAnimation();
       this.setState(this.getTransitionState(this.props, nextProps), () =>
@@ -50,7 +90,10 @@ export default class VictoryTransition extends React.Component {
     this.timer.stop();
   }
 
-  getTransitionState(props, nextProps) {
+  private getTransitionState(
+    props: VictoryTransitionProps,
+    nextProps: VictoryTransitionProps
+  ): VictoryTransitionState {
     const { animate } = props;
     if (!animate) {
       return {};
@@ -78,7 +121,10 @@ export default class VictoryTransition extends React.Component {
     }
   }
 
-  getDomainFromChildren(props, axis) {
+  private getDomainFromChildren(
+    props: VictoryTransitionProps,
+    axis: "x" | "y"
+  ) {
     const getChildDomains = (children) => {
       return children.reduce((memo, child) => {
         if (child.type && isFunction(child.type.getDomain)) {
@@ -94,8 +140,10 @@ export default class VictoryTransition extends React.Component {
       }, []);
     };
 
-    const child = React.Children.toArray(props.children)[0];
-    const childProps = child.props || {};
+    const child = React.Children.toArray(
+      props.children
+    )[0] as VictoryTransitionChild;
+    const childProps: any = child.props || {};
     const domain = Array.isArray(childProps.domain)
       ? childProps.domain
       : childProps.domain && childProps.domain[axis];
@@ -121,10 +169,10 @@ export default class VictoryTransition extends React.Component {
       : this.props;
   }
 
-  pickDomainProps(props) {
-    const parentState = isObject(props.animate) && props.animate.parentState;
+  private pickDomainProps(props: VictoryTransitionProps) {
+    const parentState = props.animate?.parentState;
     if (parentState && parentState.nodesWillExit) {
-      return this.continous || parentState.continuous
+      return this.continuous || parentState.continuous
         ? parentState.nextProps || this.state.nextProps || props
         : props;
     }
@@ -146,13 +194,14 @@ export default class VictoryTransition extends React.Component {
 
   render() {
     const props = this.pickProps();
-    const getTransitionProps =
-      isObject(this.props.animate) && this.props.animate.getTransitions
-        ? this.props.animate.getTransitions
-        : Transitions.getTransitionPropsFactory(props, this.state, (newState) =>
-            this.setState(newState)
-          );
-    const child = React.Children.toArray(props.children)[0];
+    const getTransitionProps = this.props.animate?.getTransitions
+      ? this.props.animate.getTransitions
+      : Transitions.getTransitionPropsFactory(props, this.state, (newState) =>
+          this.setState(newState)
+        );
+    const child = React.Children.toArray(
+      props.children
+    )[0] as VictoryTransitionChild;
     const transitionProps = getTransitionProps(child);
     this.transitionProps = transitionProps;
     const domain = {

package/src/victory-util/add-events.js

@@ -13,8 +13,12 @@ import {
 } from "lodash";
 import * as Events from "./events";
 import isEqual from "react-fast-compare";
-import VictoryTransition from "../victory-transition/victory-transition";
-import * as UserProps from "../victory-util/user-props";
+import { VictoryTransition } from "../victory-transition/victory-transition";
+
+// DISCLAIMER:
+// This file is not currently tested, and it is first on the list of files
+// to refactor in our current refactoring effort. Please do not make changes
+// to this file without manual testing and/or refactoring and adding tests.
 
 const datumHasXandY = (datum) => {
   return !isNil(datum._x) && !isNil(datum._y);
@@ -330,7 +334,6 @@ export default (WrappedComponent, options) => {
 
     renderData(props, shouldRenderDatum = datumHasXandY) {
       const { dataComponent, labelComponent, groupComponent } = props;
-      const userProps = UserProps.getSafeUserProps(props);
       const dataComponents = this.dataKeys.reduce(
         (validDataComponents, _dataKey, index) => {
           const dataProps = this.getComponentProps(
@@ -363,8 +366,7 @@ export default (WrappedComponent, options) => {
         .filter(Boolean);
 
       const children = [...dataComponents, ...labelComponents];
-      const group = React.cloneElement(groupComponent, userProps, children);
-      return this.renderContainer(group, children);
+      return this.renderContainer(groupComponent, children);
     }
   };
 };

package/src/victory-util/axis.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 import React from "react";
 import {
   assign,
@@ -239,6 +238,9 @@ export function getTickFormat(props, scale) {
   const stringMap = props.stringMap && props.stringMap[axis];
   if (!tickFormat) {
     const defaultTickFormat = getDefaultTickFormat(props);
+    // If there is no user-provided tick format, we use d3's tickFormat function
+    // by default. This changed the default formatting for some scale types when
+    // we upgraded to d3-scale@4..
     const scaleTickFormat =
       scale.tickFormat && isFunction(scale.tickFormat)
         ? scale.tickFormat()

package/src/victory-util/collection.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 
 function isNonEmptyArray(collection) {

package/src/victory-util/common-props.js

@@ -120,7 +120,7 @@ export const baseProps = {
   ),
   externalEventMutations: PropTypes.arrayOf(
     PropTypes.shape({
-      callback: PropTypes.function,
+      callback: PropTypes.func,
       childName: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
       eventKey: PropTypes.oneOfType([
         PropTypes.array,
@@ -130,7 +130,7 @@ export const baseProps = {
         ]),
         PropTypes.string
       ]),
-      mutation: PropTypes.function,
+      mutation: PropTypes.func,
       target: PropTypes.oneOfType([PropTypes.string, PropTypes.array])
     })
   ),

package/src/victory-util/data.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import React from "react";
 import {

package/src/victory-util/default-transitions.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 export function continuousTransitions() {
   return {
     onLoad: {

package/src/victory-util/domain.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import React from "react";
 import {

package/src/victory-util/events.js

@@ -1,4 +1,4 @@
-/* eslint-disable func-style,no-use-before-define */
+/* eslint-disable no-use-before-define */
 import {
   assign,
   isEmpty,

package/src/victory-util/helpers.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import React from "react";
 import { defaults, isFunction, property, pick, assign, keys } from "lodash";

package/src/victory-util/immutable.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 export const IMMUTABLE_ITERABLE = "@@__IMMUTABLE_ITERABLE__@@";
 export const IMMUTABLE_RECORD = "@@__IMMUTABLE_RECORD__@@";
 export const IMMUTABLE_LIST = "@@__IMMUTABLE_LIST__@@";

package/src/victory-util/label-helpers.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import * as Helpers from "./helpers";
 import { defaults } from "lodash";

package/src/victory-util/line-helpers.js

@@ -1,4 +1,4 @@
-import * as d3Shape from "d3-shape";
+import * as d3Shape from "victory-vendor/d3-shape";
 
 const defined = (d) => {
   const y = d._y1 !== undefined ? d._y1 : d._y;

package/src/victory-util/log.js

@@ -2,7 +2,6 @@
 /* eslint-disable no-console */
 
 // TODO: Use "warning" npm module like React is switching to.
-// eslint-disable-next-line func-style
 export function warn(message) {
   if (process.env.NODE_ENV !== "production") {
     if (console && console.warn) {

package/src/victory-util/point-path-helpers.ts

@@ -0,0 +1,119 @@
+/*eslint no-magic-numbers: ["error", { "ignore": [0, 1, 2, 2.5, 3] }]*/
+import { range } from "lodash";
+
+export function circle(x: number, y: number, size: number) {
+  return `M ${x}, ${y}
+      m ${-size}, 0
+      a ${size}, ${size} 0 1,0 ${size * 2},0
+      a ${size}, ${size} 0 1,0 ${-size * 2},0`;
+}
+
+export function square(x: number, y: number, size: number) {
+  const baseSize = 0.87 * size; // eslint-disable-line no-magic-numbers
+  const x0 = x - baseSize;
+  const y1 = y + baseSize;
+  const distance = x + baseSize - x0;
+  return `M ${x0}, ${y1}
+      h${distance}
+      v-${distance}
+      h-${distance}
+      z`;
+}
+
+export function diamond(x: number, y: number, size: number) {
+  const baseSize = 0.87 * size; // eslint-disable-line no-magic-numbers
+  const length = Math.sqrt(2 * (baseSize * baseSize));
+  return `M ${x}, ${y + length}
+      l ${length}, -${length}
+      l -${length}, -${length}
+      l -${length}, ${length}
+      l ${length}, ${length}
+      z`;
+}
+
+export function triangleDown(x: number, y: number, size: number) {
+  const height = (size / 2) * Math.sqrt(3);
+  const x0 = x - size;
+  const x1 = x + size;
+  const y0 = y - size;
+  const y1 = y + height;
+  return `M ${x0}, ${y0}
+      L ${x1}, ${y0}
+      L ${x}, ${y1}
+      z`;
+}
+
+export function triangleUp(x: number, y: number, size: number) {
+  const height = (size / 2) * Math.sqrt(3);
+  const x0 = x - size;
+  const x1 = x + size;
+  const y0 = y - height;
+  const y1 = y + size;
+  return `M ${x0}, ${y1}
+      L ${x1}, ${y1}
+      L ${x}, ${y0}
+      z`;
+}
+
+export function plus(x: number, y: number, size: number) {
+  const baseSize = 1.1 * size; // eslint-disable-line no-magic-numbers
+  const distance = baseSize / 1.5; // eslint-disable-line no-magic-numbers
+  return `
+      M ${x - distance / 2}, ${y + baseSize}
+      v-${distance}
+      h-${distance}
+      v-${distance}
+      h${distance}
+      v-${distance}
+      h${distance}
+      v${distance}
+      h${distance}
+      v${distance}
+      h-${distance}
+      v${distance}
+      z`;
+}
+
+export function cross(x: number, y: number, size: number) {
+  const baseSize = 0.8 * size; // eslint-disable-line no-magic-numbers
+  const distance = baseSize / 1.5; // eslint-disable-line no-magic-numbers
+  return `
+      M ${x - distance / 2}, ${y + baseSize + distance}
+      v-${distance * 2}
+      h-${distance}
+      v-${distance}
+      h${distance}
+      v-${distance}
+      h${distance}
+      v${distance}
+      h${distance}
+      v${distance}
+      h-${distance}
+      v${distance * 2}
+      z`;
+}
+
+export function minus(x: number, y: number, size: number) {
+  const baseSize = 1.1 * size; // eslint-disable-line no-magic-numbers
+  const lineHeight = baseSize - baseSize * 0.3; // eslint-disable-line no-magic-numbers
+  const x0 = x - baseSize;
+  const y1 = y + lineHeight / 2;
+  const distance = x + baseSize - x0;
+  return `M ${x0}, ${y1}
+      h${distance}
+      v-${lineHeight}
+      h-${distance}
+      z`;
+}
+
+export function star(x: number, y: number, size: number) {
+  const baseSize = 1.35 * size; // eslint-disable-line no-magic-numbers
+  const angle = Math.PI / 5; // eslint-disable-line no-magic-numbers
+  // eslint-disable-next-line no-magic-numbers
+  const starCoords = range(10).map((index) => {
+    const length = index % 2 === 0 ? baseSize : baseSize / 2;
+    return `${length * Math.sin(angle * (index + 1)) + x},
+        ${length * Math.cos(angle * (index + 1)) + y}`;
+  });
+  return `M ${starCoords.join("L")} z`;
+}

package/src/victory-util/prop-types.js

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /*eslint no-magic-numbers: ["error", { "ignore": [-1, 0, 1, 2] }]*/
 import { isFunction, find, isRegExp } from "lodash";
 import * as Log from "./log";