victory-core 36.4.1 → 36.5.2

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

@@ -1,40 +1,43 @@
-/* eslint-disable func-style */
+import type { Iterable, Record, List, Map } from "immutable";
+
 export const IMMUTABLE_ITERABLE = "@@__IMMUTABLE_ITERABLE__@@";
 export const IMMUTABLE_RECORD = "@@__IMMUTABLE_RECORD__@@";
 export const IMMUTABLE_LIST = "@@__IMMUTABLE_LIST__@@";
 export const IMMUTABLE_MAP = "@@__IMMUTABLE_MAP__@@";
 
-export function isIterable(x) {
+export function isIterable(x): x is Iterable<unknown, unknown> {
   return !!(x && x[IMMUTABLE_ITERABLE]);
 }
 
-export function isRecord(x) {
+export function isRecord(x): x is Record<string, unknown> {
   return !!(x && x[IMMUTABLE_RECORD]);
 }
 
-export function isImmutable(x) {
+export function isImmutable(
+  x,
+): x is Iterable<unknown, unknown> | Record<string, unknown> {
   return isIterable(x) || isRecord(x);
 }
 
-export function isList(x) {
+export function isList(x): x is List<unknown> {
   return !!(x && x[IMMUTABLE_LIST]);
 }
 
-export function isMap(x) {
+export function isMap(x): x is Map<unknown, unknown> {
   return !!(x && x[IMMUTABLE_MAP]);
 }
 
-export function shallowToJS(x, whitelist) {
+export function shallowToJS(x, whitelist?: Record<string, boolean | unknown>) {
   return isIterable(x)
     ? x.reduce(
-        (prev, curr, key) => {
+        (result: any, curr: any, key: any) => {
           if (whitelist && whitelist[key]) {
             curr = shallowToJS(curr);
           }
-          prev[key] = curr;
-          return prev;
+          result[key] = curr;
+          return result;
         },
-        isList(x) ? [] : {}
+        isList(x) ? [] : {},
       )
     : x;
 }

package/src/victory-util/index.ts

@@ -0,0 +1,28 @@
+export * from "./add-events";
+export * as Axis from "./axis";
+export * as Collection from "./collection";
+export * from "./common-props";
+export * as Data from "./data";
+export * as DefaultTransitions from "./default-transitions";
+export * as Domain from "./domain";
+export * as Events from "./events";
+export * as Helpers from "./helpers";
+export * as Hooks from "./hooks";
+export * as Immutable from "./immutable";
+export * as LabelHelpers from "./label-helpers";
+export * as LineHelpers from "./line-helpers";
+export * as Log from "./log";
+export * as PointPathHelpers from "./point-path-helpers";
+export * as PropTypes from "./prop-types";
+export * as Scale from "./scale";
+export * as Selection from "./selection";
+export type { SVGCoordinateType, SVGCoordinateBounds } from "./selection";
+export * as Style from "./style";
+export * as TextSize from "./textsize";
+export type { TextSizeStyleInterface } from "./textsize";
+export { default as Timer } from "./timer";
+export { default as TimerContext } from "./timer-context";
+export * as Transitions from "./transitions";
+export * as UserProps from "./user-props";
+export * as Wrapper from "./wrapper";
+export * from "./with-container";

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

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import * as Helpers from "./helpers";
 import { defaults } from "lodash";
@@ -46,7 +45,7 @@ function getPadding(props, datum) {
   const sign = datum._y < 0 ? -1 : 1;
   return {
     x: horizontal ? sign * defaultPadding : 0,
-    y: horizontal ? 0 : -1 * sign * defaultPadding
+    y: horizontal ? 0 : -1 * sign * defaultPadding,
   };
 }
 
@@ -58,7 +57,7 @@ function getOffset(props, datum) {
 
   return {
     dx: padding.x,
-    dy: padding.y
+    dy: padding.y,
   };
 }
 
@@ -71,7 +70,7 @@ function getPosition(props, datum) {
     const polarPadding = getPolarPadding(props, datum);
     return {
       x: x + polarPadding.x,
-      y: y + polarPadding.y
+      y: y + polarPadding.y,
     };
   }
 }
@@ -84,7 +83,7 @@ function getPolarPadding(props, datum) {
   const angle = Helpers.degreesToRadians(degrees);
   return {
     x: padding * Math.cos(angle),
-    y: -padding * Math.sin(angle)
+    y: -padding * Math.sin(angle),
   };
 }
 
@@ -146,7 +145,7 @@ export function getPolarVerticalAnchor(props, degrees) {
   return orientation === "top" ? "end" : "start";
 }
 
-export function getPolarAngle(props, baseAngle) {
+export function getPolarAngle(props, baseAngle?) {
   const { labelPlacement, datum } = props;
   if (!labelPlacement || labelPlacement === "vertical") {
     return 0;
@@ -182,7 +181,7 @@ export function getProps(props, index) {
     height,
     theme,
     labelComponent,
-    disableInlineStyles
+    disableInlineStyles,
   } = props;
   const datum = data[index];
   const degrees = getDegrees(props, datum);
@@ -216,7 +215,7 @@ export function getProps(props, index) {
     dy,
     width,
     height,
-    style: style.labels
+    style: style.labels,
   };
   if (!Helpers.isTooltip(labelComponent)) {
     return labelProps;

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

@@ -0,0 +1,104 @@
+import * as d3Shape from "victory-vendor/d3-shape";
+
+const defined = (d) => {
+  const y = d._y1 !== undefined ? d._y1 : d._y;
+  return y !== null && y !== undefined && d._y0 !== null;
+};
+
+const getXAccessor = (scale) => {
+  return (d) => scale.x(d._x1 !== undefined ? d._x1 : d._x);
+};
+
+const getYAccessor = (scale) => {
+  return (d) => scale.y(d._y1 !== undefined ? d._y1 : d._y);
+};
+
+const getAngleAccessor = (scale) => {
+  return (d) => {
+    const x = scale.x(d._x1 !== undefined ? d._x1 : d._x);
+    return -1 * x + Math.PI / 2;
+  };
+};
+
+export type CurveName =
+  | "basis"
+  | "cardinal"
+  | "bumpX"
+  | "bumpY"
+  | "bundle"
+  | "catmullRom"
+  | "linear"
+  | "monotoneX"
+  | "monotoneY"
+  | "step"
+  | "stepAfter"
+  | "stepBefore"
+  | "natural";
+
+type ShapeMethod = keyof Pick<
+  typeof d3Shape,
+  | "curveBasis"
+  | "curveCardinal"
+  | "curveBumpX"
+  | "curveBumpY"
+  | "curveBundle"
+  | "curveCatmullRom"
+  | "curveLinear"
+  | "curveMonotoneX"
+  | "curveMonotoneY"
+  | "curveStep"
+  | "curveStepAfter"
+  | "curveStepBefore"
+  | "curveNatural"
+>;
+type ShapeMethodClosed = keyof Pick<
+  typeof d3Shape,
+  | "curveBasisClosed"
+  | "curveCardinalClosed"
+  | "curveLinearClosed"
+  | "curveCatmullRomClosed"
+>;
+
+const toNewName = (interpolation: CurveName) => {
+  // d3 shape changed the naming scheme for interpolators from "basis" -> "curveBasis" etc.
+  const capitalize = (s) => s && s[0].toUpperCase() + s.slice(1);
+  return `curve${capitalize(interpolation)}` as ShapeMethod;
+};
+const toNewNameClosed = (interpolation: CurveName) => {
+  return `${toNewName(interpolation)}Closed` as ShapeMethodClosed;
+};
+
+export const getInterpolationFunction = (props) => {
+  const { interpolation } = props;
+
+  if (typeof interpolation === "function") {
+    return interpolation;
+  }
+  if (typeof interpolation === "string") {
+    const { polar, openCurve = !polar } = props;
+    const interpolationName = !openCurve
+      ? toNewNameClosed(interpolation as CurveName)
+      : toNewName(interpolation as CurveName);
+
+    return d3Shape[interpolationName];
+  }
+
+  return d3Shape.curveLinear;
+};
+
+export const getLineFunction = (props) => {
+  const { polar, scale, horizontal } = props;
+  return polar
+    ? d3Shape
+        .lineRadial()
+        .defined(defined)
+        .curve(getInterpolationFunction(props))
+        .angle(getAngleAccessor(scale))
+        .radius(getYAccessor(scale))
+    : d3Shape
+        .line()
+        .defined(defined)
+        .curve(getInterpolationFunction(props))
+        .x(horizontal ? getYAccessor(scale) : getXAccessor(scale))
+        .y(horizontal ? getXAccessor(scale) : getYAccessor(scale));
+};

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

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

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`;
+}