victory-core 36.5.0 → 36.5.1

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

@@ -0,0 +1,91 @@
+/**
+ * Returns a getDomain function
+ * @param {Function} getDomainFromDataFunction: a function that takes props and axis and
+ * returns a domain based on data
+ * @param {Function} formatDomainFunction: a function that takes domain, props, and axis and
+ * returns a formatted domain
+ * @returns {Function} a function that takes props and axis and returns a formatted domain
+ */
+export declare function createDomainFunction(getDomainFromDataFunction?: any, formatDomainFunction?: any): (props: any, axis: any) => any;
+/**
+ * Returns a formatted domain.
+ * @param {Array} domain: a domain in the form of a two element array
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} a domain in the form of a two element array
+ */
+export declare function formatDomain(domain: any, props: any, axis: any): any;
+/**
+ * Returns a domain for a given axis based on props, category, or data
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} the domain for the given axis
+ */
+export declare function getDomain(props: any, axis: any): any;
+/**
+ * Returns a domain based on categories if they exist
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @param {Array} categories: an array of categories corresponding to a given axis
+ * @returns {Array|undefined} returns a domain from categories or undefined
+ */
+export declare function getDomainFromCategories(props: any, axis: any, categories?: any): any[] | undefined;
+/**
+ * Returns a domain from a dataset for a given axis
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @param {Array} dataset: an array of data
+ * @returns {Array} the domain based on data
+ */
+export declare function getDomainFromData(props: any, axis: any, dataset: any): any[] | undefined;
+/**
+ * Returns a domain in the form of a two element array given a min and max value.
+ * @param {Number|Date} min: the props object
+ * @param {Number|Date} max: the current axis
+ * @returns {Array} the minDomain based on props
+ */
+export declare function getDomainFromMinMax(min: any, max: any): any[];
+/**
+ * Returns a the domain for a given axis if domain is given in props
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array|undefined} the domain based on props
+ */
+export declare function getDomainFromProps(props: any, axis: any): any;
+/**
+ * Returns a domain for a given axis. This method forces the domain to include
+ * zero unless the domain is explicitly specified in props.
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} the domain for the given axis
+ */
+export declare function getDomainWithZero(props: any, axis: any): any;
+/**
+ * Returns the maxDomain from props if it exists
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Number|Date|undefined} the maxDomain based on props
+ */
+export declare function getMaxFromProps(props: any, axis: any): any;
+/**
+ * Returns the minDomain from props if it exists
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Number|Date|undefined} the minDomain based on props
+ */
+export declare function getMinFromProps(props: any, axis: any): any;
+/**
+ * Returns a symmetrically padded domain for polar charts
+ * @param {Array} domain: the original domain
+ * @param {Array} values: a flat array of values corresponding to either tickValues, or data values
+ * for a given dimension i.e. only x values.
+ * @returns {Array} the symmetric domain
+ */
+export declare function getSymmetricDomain(domain: any, values: number[]): any[];
+/**
+ * Checks whether a given component can be used to calculate domain
+ * @param {Component} component: a React component instance
+ * @returns {Boolean} Returns true if the given component has a role included in the whitelist
+ */
+export declare function isDomainComponent(component: any): boolean;
+//# sourceMappingURL=domain.d.ts.map

package/es/victory-util/domain.js

@@ -56,8 +56,9 @@ function getDomainPadding(props, axis) {
 }
 
 function getFlatData(dataset, axis) {
+  var axisKey = "_".concat(axis);
   return _flatten(dataset).map(function (datum) {
-    return datum["_".concat(axis)] && datum["_".concat(axis)][1] !== undefined ? datum["_".concat(axis)][1] : datum["_".concat(axis)];
+    return datum[axisKey] && datum[axisKey][1] !== undefined ? datum[axisKey][1] : datum[axisKey];
   });
 }
 
@@ -122,7 +123,9 @@ function padDomain(domain, props, axis) {
   if (addsQuadrants && singleQuadrantDomainPadding !== false) {
     // Naive initial padding calculation
     var initialPadding = {
+      // @ts-expect-error `max/min` might be dates
       left: Math.abs(max - min) * padding.left / rangeExtent,
+      // @ts-expect-error `max/min` might be dates
       right: Math.abs(max - min) * padding.right / rangeExtent
     }; // Adjust the domain by the initial padding
 
@@ -406,4 +409,5 @@ export function isDomainComponent(component) {
 
   var whitelist = ["area", "axis", "bar", "boxplot", "candlestick", "errorbar", "group", "histogram", "line", "pie", "scatter", "stack", "voronoi"];
   return _includes(whitelist, role);
-}
+}
+//# sourceMappingURL=domain.js.map

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

@@ -0,0 +1,65 @@
+/// <reference types="react" />
+import type { EventMixinCalculatedValues } from "./add-events";
+declare type ComponentEventKey = string | number;
+export interface ComponentEvent {
+    target?: "parent" | string;
+    eventKey?: ComponentEventKey | ComponentEventKey[];
+    eventHandlers: ComponentEventHandlers;
+}
+export declare type ComponentEventName = `on${Capitalize<string>}`;
+export interface ComponentEventHandlers {
+    [k: ComponentEventName]: ComponentEventHandler;
+}
+export declare type ComponentEventHandler = (evt: React.SyntheticEvent, childProps: unknown, eventKey: ComponentEventKey, eventName: ComponentEventName) => UpdatedProps;
+export declare type UpdatedProps = any;
+interface ComponentWithEvents extends EventMixinCalculatedValues {
+    state: any;
+    setState: any;
+}
+export declare function getEvents(this: ComponentWithEvents, props: any, target: any, eventKey: any, getScopedEvents: any): any;
+export declare function getScopedEvents(this: ComponentWithEvents, events: any, namespace: any, childType: any, baseProps: any): {};
+export declare function getPartialEvents(events: ComponentEventHandlers, eventKey: ComponentEventKey, childProps: unknown): PartialEvents;
+export interface PartialEvents {
+    [eventName: ComponentEventName]: (evt: React.SyntheticEvent) => UpdatedProps;
+}
+export declare function getEventState(this: ComponentWithEvents, eventKey: ComponentEventKey, namespace: string, childType?: string): any;
+/**
+ * Returns a set of all mutations for shared events
+ *
+ * @param  {Array} mutations an array of mutations objects
+ * @param  {Object} baseProps an object that describes all props for children of VictorySharedEvents
+ * @param  {Object} baseState an object that describes state for children of VictorySharedEvents
+ * @param  {Array} childNames an array of childNames
+ *
+ * @return {Object} a object describing all mutations for VictorySharedEvents
+ */
+export declare function getExternalMutationsWithChildren(mutations: any, baseProps: any, baseState: any, childNames: any): any;
+/**
+ * Returns a set of all mutations for a component
+ *
+ * @param  {Array} mutations an array of mutations objects
+ * @param  {Object} baseProps a props object (scoped to a childName when used by shared events)
+ * @param  {Object} baseState a state object (scoped to a childName when used by shared events)
+ * @param  {String} childName an optional childName
+ *
+ * @return {Object} a object describing mutations for a given component
+ */
+export declare function getExternalMutations(mutations: any, baseProps: any, baseState: any, childName?: any): {};
+/**
+ * Returns a set of mutations for a particular element given scoped baseProps and baseState
+ *
+ * @param  {Array} mutations an array of mutations objects
+ * @param  {Object} baseProps a props object (scoped the element specified by the identifier)
+ * @param  {Object} baseState a state object (scoped the element specified by the identifier)
+ * @param  {Object} identifier { eventKey, target, childName }
+ *
+ * @return {Object | undefined} a object describing mutations for a given element, or undefined
+ */
+export declare function getExternalMutation(mutations: any, baseProps: any, baseState: any, identifier: any): any;
+export declare function getComponentEvents(props: any, components: any): any;
+export declare function getGlobalEventNameFromKey(key: any): any;
+export declare const getGlobalEvents: (events: any) => Partial<any>;
+export declare const omitGlobalEvents: (events: any) => Partial<any>;
+export declare const emulateReactEvent: (event: any) => any;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/es/victory-util/events.js

@@ -23,15 +23,16 @@ 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; }
 
 var GLOBAL_EVENT_REGEX = /^onGlobal(.*)$/;
+
 /* Returns all own and shared events that should be attached to a single target element,
  * i.e. an individual bar specified by target: "data", eventKey: [index].
  * Returned events are scoped to the appropriate state. Either that of the component itself
  * (i.e. VictoryBar) in the case of own events, or that of the parent component
  * (i.e. VictoryChart) in the case of shared events
  */
-// eslint-disable-next-line max-params,no-shadow
-
-export function getEvents(props, target, eventKey, getScopedEvents) {
+// eslint-disable-next-line max-params
+export function getEvents(props, target, eventKey, // eslint-disable-next-line no-shadow
+getScopedEvents) {
   var _this = this;
 
   // Returns all events that apply to a particular target element
@@ -254,24 +255,27 @@ export function getScopedEvents(events, namespace, childType, baseProps) {
     return memo;
   }, {});
 }
-/* Returns a partially applied event handler for a specific target element
+/*
+ * Returns a partially applied event handler for a specific target element
  * This allows event handlers to have access to props controlling each element
  */
 
 export function getPartialEvents(events, eventKey, childProps) {
-  return events ? _keys(events).reduce(function (memo, eventName) {
+  if (!events) return {};
+  return _keys(events).reduce(function (memo, eventName) {
     var appliedEvent = function (evt) {
       return events[eventName](evt, childProps, eventKey, eventName);
     };
 
     memo[eventName] = appliedEvent;
     return memo;
-  }, {}) : {};
+  }, {});
 }
+
 /* Returns the property of the state object corresponding to event changes for
  * a particular element
  */
-
+// eslint-disable-next-line max-params
 export function getEventState(eventKey, namespace, childType) {
   // Mandatory usage: `getEventState.bind(this)`
   // eslint-disable-next-line no-invalid-this
@@ -455,4 +459,5 @@ export var emulateReactEvent = function (event) {
   return _assign(event, {
     nativeEvent: event
   });
-};
+};
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1,61 @@
+import React from "react";
+/**
+ * creates an object with some keys excluded
+ * replacement for lodash.omit for performance. does not mimic the entire lodash.omit api
+ * @param {Object} originalObject: created object will be based on this object
+ * @param {Array<String>} ks: an array of keys to omit from the new object
+ * @returns {Object} new object with same properties as originalObject
+ */
+export declare function omit<T, Keys extends keyof T>(originalObject: T, ks?: Array<Keys>): Omit<T, Keys>;
+export declare function getPoint(datum: any): any;
+export declare function scalePoint(props: any, datum: any): {
+    x: any;
+    x0: any;
+    y: any;
+    y0: any;
+};
+export declare function getPadding(props: any, name?: string): {
+    top: any;
+    bottom: any;
+    left: any;
+    right: any;
+};
+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(prop: any, props: any): any;
+export declare function evaluateStyle(style: any, props: any): any;
+export declare function degreesToRadians(degrees: any): any;
+export declare function radiansToDegrees(radians: any): any;
+export declare function getRadius(props: any): number;
+export declare function getPolarOrigin(props: any): {
+    x: number;
+    y: number;
+};
+export declare function getRange(props: any, axis: any): any;
+export declare function createAccessor(key: any): (...args: any[]) => any;
+export declare function modifyProps(props: any, fallbackProps?: any, role?: any): any;
+/**
+ * Returns the given axis or the opposite axis when horizontal
+ * @param {string} axis: the given axis, either "x" pr "y"
+ * @param {Boolean} horizontal: true when the chart is flipped to the horizontal orientation
+ * @returns {String} the dimension appropriate for the axis given its props "x" or "y"
+ */
+export declare function getCurrentAxis(axis: any, horizontal: any): any;
+/**
+ * @param {Array} children: an array of child components
+ * @param {Function} iteratee: a function with arguments "child", "childName", and "parent"
+ * @param {Object} parentProps: props from the parent that are applied to children
+ * @param {any}  initialMemo: The object in which the iteration results are combined.
+ * @param {Function} combine: Combines the result of the iteratee with the current memo
+ *   to the memo for the next iteration step
+ * @returns {Array} returns an array of results from calling the iteratee on all nested children
+ */
+export declare function reduceChildren<TChildren extends React.ReactNode, TItem, TResult = TItem[]>(children: TChildren[], iteratee: (child: TChildren, childName: string, parent?: TChildren) => TItem | null, parentProps?: {}, initialMemo?: TResult, combine?: (memo: TResult, item: TItem) => TResult): TResult;
+/**
+ * @param {Object} props: the props object
+ * @returns {Boolean} returns true if the props object contains `horizontal: true` of if any
+ * children or nested children are horizontal
+ */
+export declare function isHorizontal(props: any): any;
+//# sourceMappingURL=helpers.d.ts.map

package/es/victory-util/helpers.js

@@ -33,7 +33,7 @@ function getPolarRange(props, axis) {
 
 /**
  * creates an object with some keys excluded
- * replacement for lodash.omit for performance. does not mimick the entire lodash.omit api
+ * replacement for lodash.omit for performance. does not mimic the entire lodash.omit api
  * @param {Object} originalObject: created object will be based on this object
  * @param {Array<String>} ks: an array of keys to omit from the new object
  * @returns {Object} new object with same properties as originalObject
@@ -46,6 +46,7 @@ export function omit(originalObject) {
   var newObject = {};
 
   for (var key in originalObject) {
+    // @ts-expect-error String is not assignable to Key
     if (ks.indexOf(key) >= 0) {
       continue;
     }
@@ -278,7 +279,9 @@ export function reduceChildren(children, iteratee) {
   var parentProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   var initialMemo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   var combine = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : function (memo, item) {
-    return memo.concat(item);
+    return (// @ts-expect-error These defaults are hard to type
+      memo.concat(item)
+    );
   };
   var sharedProps = ["data", "domain", "categories", "polar", "startAngle", "endAngle", "minDomain", "maxDomain", "horizontal"];
 
@@ -322,7 +325,7 @@ export function reduceChildren(children, iteratee) {
 /**
  * @param {Object} props: the props object
  * @returns {Boolean} returns true if the props object contains `horizontal: true` of if any
- * children or nested children are hoizontal
+ * children or nested children are horizontal
  */
 
 export function isHorizontal(props) {
@@ -344,4 +347,5 @@ export function isHorizontal(props) {
   };
 
   return traverseChildren(React.Children.toArray(props.children));
-}
+}
+//# sourceMappingURL=helpers.js.map

package/es/victory-util/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { usePreviousProps } from "./use-previous-props";
+export { useAnimationState } from "./use-animation-state";
+//# sourceMappingURL=index.d.ts.map

package/es/victory-util/hooks/index.js

@@ -1,2 +1,3 @@
 export { usePreviousProps } from "./use-previous-props";
-export { useAnimationState } from "./use-animation-state";
+export { useAnimationState } from "./use-animation-state";
+//# sourceMappingURL=index.js.map

package/es/victory-util/hooks/use-animation-state.js

@@ -133,4 +133,5 @@ export var useAnimationState = function () {
     setAnimationState: setAnimationState,
     getProps: getProps
   };
-};
+};
+//# sourceMappingURL=use-animation-state.js.map

package/es/victory-util/hooks/use-previous-props.d.ts

@@ -0,0 +1,2 @@
+export declare function usePreviousProps<T>(props: T): T | undefined;
+//# sourceMappingURL=use-previous-props.d.ts.map

package/es/victory-util/hooks/use-previous-props.js

@@ -1,8 +1,9 @@
 import React from "react";
-export var usePreviousProps = function (props) {
+export function usePreviousProps(props) {
   var ref = React.useRef();
   React.useEffect(function () {
     ref.current = props;
   });
-  return ref.current || {};
-};
+  return ref.current;
+}
+//# sourceMappingURL=use-previous-props.js.map

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

@@ -0,0 +1,12 @@
+import type { Iterable, List, Map } from "immutable";
+export declare const IMMUTABLE_ITERABLE = "@@__IMMUTABLE_ITERABLE__@@";
+export declare const IMMUTABLE_RECORD = "@@__IMMUTABLE_RECORD__@@";
+export declare const IMMUTABLE_LIST = "@@__IMMUTABLE_LIST__@@";
+export declare const IMMUTABLE_MAP = "@@__IMMUTABLE_MAP__@@";
+export declare function isIterable(x: any): x is Iterable<unknown, unknown>;
+export declare function isRecord(x: any): x is Record<string, unknown>;
+export declare function isImmutable(x: any): x is Iterable<unknown, unknown> | Record<string, unknown>;
+export declare function isList(x: any): x is List<unknown>;
+export declare function isMap(x: any): x is Map<unknown, unknown>;
+export declare function shallowToJS(x: any, whitelist?: Record<string, boolean | unknown>): any;
+//# sourceMappingURL=immutable.d.ts.map

package/es/victory-util/immutable.js

@@ -18,12 +18,13 @@ export function isMap(x) {
   return !!(x && x[IMMUTABLE_MAP]);
 }
 export function shallowToJS(x, whitelist) {
-  return isIterable(x) ? x.reduce(function (prev, curr, key) {
+  return isIterable(x) ? x.reduce(function (result, curr, key) {
     if (whitelist && whitelist[key]) {
       curr = shallowToJS(curr);
     }
 
-    prev[key] = curr;
-    return prev;
+    result[key] = curr;
+    return result;
   }, isList(x) ? [] : {}) : x;
-}
+}
+//# sourceMappingURL=immutable.js.map

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

@@ -0,0 +1,29 @@
+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";
+//# sourceMappingURL=index.d.ts.map

package/es/victory-util/index.js

@@ -0,0 +1,48 @@
+export * from "./add-events";
+import * as _Axis from "./axis";
+export { _Axis as Axis };
+import * as _Collection from "./collection";
+export { _Collection as Collection };
+export * from "./common-props";
+import * as _Data from "./data";
+export { _Data as Data };
+import * as _DefaultTransitions from "./default-transitions";
+export { _DefaultTransitions as DefaultTransitions };
+import * as _Domain from "./domain";
+export { _Domain as Domain };
+import * as _Events from "./events";
+export { _Events as Events };
+import * as _Helpers from "./helpers";
+export { _Helpers as Helpers };
+import * as _Hooks from "./hooks";
+export { _Hooks as Hooks };
+import * as _Immutable from "./immutable";
+export { _Immutable as Immutable };
+import * as _LabelHelpers from "./label-helpers";
+export { _LabelHelpers as LabelHelpers };
+import * as _LineHelpers from "./line-helpers";
+export { _LineHelpers as LineHelpers };
+import * as _Log from "./log";
+export { _Log as Log };
+import * as _PointPathHelpers from "./point-path-helpers";
+export { _PointPathHelpers as PointPathHelpers };
+import * as _PropTypes from "./prop-types";
+export { _PropTypes as PropTypes };
+import * as _Scale from "./scale";
+export { _Scale as Scale };
+import * as _Selection from "./selection";
+export { _Selection as Selection };
+import * as _Style from "./style";
+export { _Style as Style };
+import * as _TextSize from "./textsize";
+export { _TextSize as TextSize };
+export { default as Timer } from "./timer";
+export { default as TimerContext } from "./timer-context";
+import * as _Transitions from "./transitions";
+export { _Transitions as Transitions };
+import * as _UserProps from "./user-props";
+export { _UserProps as UserProps };
+import * as _Wrapper from "./wrapper";
+export { _Wrapper as Wrapper };
+export * from "./with-container";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,27 @@
+export declare function getText(props: any, datum: any, index: any): any;
+export declare function getPolarTextAnchor(props: any, degrees: any): "end" | "start" | "middle";
+export declare function getPolarVerticalAnchor(props: any, degrees: any): "end" | "start" | "middle";
+export declare function getPolarAngle(props: any, baseAngle?: any): number;
+export declare function getDegrees(props: any, datum: any): number;
+export declare function getProps(props: any, index: any): {
+    angle: any;
+    data: any;
+    datum: any;
+    disableInlineStyles: any;
+    horizontal: any;
+    index: any;
+    polar: any;
+    scale: any;
+    labelPlacement: any;
+    text: any;
+    textAnchor: any;
+    verticalAnchor: any;
+    x: any;
+    y: any;
+    dx: number | undefined;
+    dy: number | undefined;
+    width: any;
+    height: any;
+    style: any;
+};
+//# sourceMappingURL=label-helpers.d.ts.map

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

@@ -232,4 +232,5 @@ export function getProps(props, index) {
 
   var tooltipTheme = theme && theme.tooltip || {};
   return _defaults({}, labelProps, Helpers.omit(tooltipTheme, ["style"]));
-}
+}
+//# sourceMappingURL=label-helpers.js.map

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

@@ -0,0 +1,5 @@
+import * as d3Shape from "victory-vendor/d3-shape";
+export declare type CurveName = "basis" | "cardinal" | "bumpX" | "bumpY" | "bundle" | "catmullRom" | "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "natural";
+export declare const getInterpolationFunction: (props: any) => any;
+export declare const getLineFunction: (props: any) => d3Shape.LineRadial<[number, number]> | d3Shape.Line<[number, number]>;
+//# sourceMappingURL=line-helpers.d.ts.map

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

@@ -33,13 +33,31 @@ var toNewName = function (interpolation) {
   return "curve".concat(capitalize(interpolation));
 };
 
+var toNewNameClosed = function (interpolation) {
+  return "".concat(toNewName(interpolation), "Closed");
+};
+
+export var getInterpolationFunction = function (props) {
+  var interpolation = props.interpolation;
+
+  if (typeof interpolation === "function") {
+    return interpolation;
+  }
+
+  if (typeof interpolation === "string") {
+    var polar = props.polar,
+        _props$openCurve = props.openCurve,
+        openCurve = _props$openCurve === void 0 ? !polar : _props$openCurve;
+    var interpolationName = !openCurve ? toNewNameClosed(interpolation) : toNewName(interpolation);
+    return d3Shape[interpolationName];
+  }
+
+  return d3Shape.curveLinear;
+};
 export var getLineFunction = function (props) {
   var polar = props.polar,
       scale = props.scale,
       horizontal = props.horizontal;
-  var defaultOpenCurve = polar ? false : true;
-  var openCurve = props.openCurve === undefined ? defaultOpenCurve : props.openCurve;
-  var interpolationFunction = typeof props.interpolation === "function" && props.interpolation;
-  var interpolationName = typeof props.interpolation === "string" && (!openCurve ? "".concat(toNewName(props.interpolation), "Closed") : toNewName(props.interpolation));
-  return polar ? d3Shape.lineRadial().defined(defined).curve(interpolationFunction || d3Shape[interpolationName]).angle(getAngleAccessor(scale)).radius(getYAccessor(scale)) : d3Shape.line().defined(defined).curve(interpolationFunction || d3Shape[interpolationName]).x(horizontal ? getYAccessor(scale) : getXAccessor(scale)).y(horizontal ? getXAccessor(scale) : getYAccessor(scale));
-};
+  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));
+};
+//# sourceMappingURL=line-helpers.js.map

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

@@ -0,0 +1,2 @@
+export declare function warn(message: string): void;
+//# sourceMappingURL=log.d.ts.map

package/es/victory-util/log.js

@@ -8,4 +8,5 @@ export function warn(message) {
       console.warn(message);
     }
   }
-}
+}
+//# sourceMappingURL=log.js.map

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

@@ -7,3 +7,4 @@ export declare function plus(x: number, y: number, size: number): string;
 export declare function cross(x: number, y: number, size: number): string;
 export declare function minus(x: number, y: number, size: number): string;
 export declare function star(x: number, y: number, size: number): string;
+//# sourceMappingURL=point-path-helpers.d.ts.map

package/es/victory-util/point-path-helpers.js

@@ -68,4 +68,5 @@ export function star(x, y, size) {
   });
 
   return "M ".concat(starCoords.join("L"), " z");
-}
+}
+//# sourceMappingURL=point-path-helpers.js.map