victory-core 36.5.0 → 36.5.3

package/lib/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/lib/victory-util/domain.js

@@ -89,8 +89,9 @@ function getDomainPadding(props, axis) {
 }
 
 function getFlatData(dataset, axis) {
+  var axisKey = "_".concat(axis);
   return (0, _flatten2.default)(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];
   });
 }
 
@@ -153,7 +154,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
 
@@ -448,4 +451,5 @@ function isDomainComponent(component) {
 
   var whitelist = ["area", "axis", "bar", "boxplot", "candlestick", "errorbar", "group", "histogram", "line", "pie", "scatter", "stack", "voronoi"];
   return (0, _includes2.default)(whitelist, role);
-}
+}
+//# sourceMappingURL=domain.js.map

package/lib/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/lib/victory-util/events.js

@@ -51,15 +51,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
-
-function getEvents(props, target, eventKey, getScopedEvents) {
+// eslint-disable-next-line max-params
+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
@@ -283,26 +284,28 @@ 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
  */
 
 
 function getPartialEvents(events, eventKey, childProps) {
-  return events ? (0, _keys2.default)(events).reduce(function (memo, eventName) {
+  if (!events) return {};
+  return (0, _keys2.default)(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
 function getEventState(eventKey, namespace, childType) {
   // Mandatory usage: `getEventState.bind(this)`
   // eslint-disable-next-line no-invalid-this
@@ -497,4 +500,5 @@ var emulateReactEvent = function (event) {
   });
 };
 
-exports.emulateReactEvent = emulateReactEvent;
+exports.emulateReactEvent = emulateReactEvent;
+//# sourceMappingURL=events.js.map

package/lib/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/lib/victory-util/helpers.js

@@ -65,7 +65,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
@@ -78,6 +78,7 @@ 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;
     }
@@ -325,7 +326,9 @@ 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"];
 
@@ -367,7 +370,7 @@ 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
  */
 
 
@@ -390,4 +393,5 @@ function isHorizontal(props) {
   };
 
   return traverseChildren(_react.default.Children.toArray(props.children));
-}
+}
+//# sourceMappingURL=helpers.js.map

package/lib/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/lib/victory-util/hooks/index.js

@@ -18,4 +18,5 @@ Object.defineProperty(exports, "usePreviousProps", {
 
 var _usePreviousProps = require("./use-previous-props");
 
-var _useAnimationState = require("./use-animation-state");
+var _useAnimationState = require("./use-animation-state");
+//# sourceMappingURL=index.js.map

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

@@ -62,7 +62,7 @@ var useAnimationState = function () {
 
 
   var getAnimationProps = _react.default.useCallback(function (props, child, index) {
-    if (!props.animate) {
+    if (!(props !== null && props !== void 0 && props.animate)) {
       return child.props.animate;
     }
 
@@ -96,7 +96,7 @@ var useAnimationState = function () {
 
 
   var setAnimationState = _react.default.useCallback(function (props, nextProps) {
-    if (!props.animate) {
+    if (!props || !props.animate) {
       return;
     }
 
@@ -156,4 +156,5 @@ var useAnimationState = function () {
   };
 };
 
-exports.useAnimationState = useAnimationState;
+exports.useAnimationState = useAnimationState;
+//# sourceMappingURL=use-animation-state.js.map

package/lib/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/lib/victory-util/hooks/use-previous-props.js

@@ -3,20 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.usePreviousProps = void 0;
+exports.usePreviousProps = usePreviousProps;
 
 var _react = _interopRequireDefault(require("react"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var usePreviousProps = function (props) {
+function usePreviousProps(props) {
   var ref = _react.default.useRef();
 
   _react.default.useEffect(function () {
     ref.current = props;
   });
 
-  return ref.current || {};
-};
-
-exports.usePreviousProps = usePreviousProps;
+  return ref.current;
+}
+//# sourceMappingURL=use-previous-props.js.map

package/lib/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/lib/victory-util/immutable.js

@@ -40,12 +40,13 @@ function isMap(x) {
 }
 
 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/lib/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/lib/victory-util/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Axis: true,
+  Collection: true,
+  Data: true,
+  DefaultTransitions: true,
+  Domain: true,
+  Events: true,
+  Helpers: true,
+  Hooks: true,
+  Immutable: true,
+  LabelHelpers: true,
+  LineHelpers: true,
+  Log: true,
+  PointPathHelpers: true,
+  PropTypes: true,
+  Scale: true,
+  Selection: true,
+  Style: true,
+  TextSize: true,
+  Timer: true,
+  TimerContext: true,
+  Transitions: true,
+  UserProps: true,
+  Wrapper: true
+};
+exports.TextSize = exports.Style = exports.Selection = exports.Scale = exports.PropTypes = exports.PointPathHelpers = exports.Log = exports.LineHelpers = exports.LabelHelpers = exports.Immutable = exports.Hooks = exports.Helpers = exports.Events = exports.Domain = exports.DefaultTransitions = exports.Data = exports.Collection = exports.Axis = void 0;
+Object.defineProperty(exports, "Timer", {
+  enumerable: true,
+  get: function () {
+    return _timer.default;
+  }
+});
+Object.defineProperty(exports, "TimerContext", {
+  enumerable: true,
+  get: function () {
+    return _timerContext.default;
+  }
+});
+exports.Wrapper = exports.UserProps = exports.Transitions = void 0;
+
+var _addEvents = require("./add-events");
+
+Object.keys(_addEvents).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _addEvents[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _addEvents[key];
+    }
+  });
+});
+
+var _Axis = _interopRequireWildcard(require("./axis"));
+
+exports.Axis = _Axis;
+
+var _Collection = _interopRequireWildcard(require("./collection"));
+
+exports.Collection = _Collection;
+
+var _commonProps = require("./common-props");
+
+Object.keys(_commonProps).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _commonProps[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _commonProps[key];
+    }
+  });
+});
+
+var _Data = _interopRequireWildcard(require("./data"));
+
+exports.Data = _Data;
+
+var _DefaultTransitions = _interopRequireWildcard(require("./default-transitions"));
+
+exports.DefaultTransitions = _DefaultTransitions;
+
+var _Domain = _interopRequireWildcard(require("./domain"));
+
+exports.Domain = _Domain;
+
+var _Events = _interopRequireWildcard(require("./events"));
+
+exports.Events = _Events;
+
+var _Helpers = _interopRequireWildcard(require("./helpers"));
+
+exports.Helpers = _Helpers;
+
+var _Hooks = _interopRequireWildcard(require("./hooks"));
+
+exports.Hooks = _Hooks;
+
+var _Immutable = _interopRequireWildcard(require("./immutable"));
+
+exports.Immutable = _Immutable;
+
+var _LabelHelpers = _interopRequireWildcard(require("./label-helpers"));
+
+exports.LabelHelpers = _LabelHelpers;
+
+var _LineHelpers = _interopRequireWildcard(require("./line-helpers"));
+
+exports.LineHelpers = _LineHelpers;
+
+var _Log = _interopRequireWildcard(require("./log"));
+
+exports.Log = _Log;
+
+var _PointPathHelpers = _interopRequireWildcard(require("./point-path-helpers"));
+
+exports.PointPathHelpers = _PointPathHelpers;
+
+var _PropTypes = _interopRequireWildcard(require("./prop-types"));
+
+exports.PropTypes = _PropTypes;
+
+var _Scale = _interopRequireWildcard(require("./scale"));
+
+exports.Scale = _Scale;
+
+var _Selection = _interopRequireWildcard(require("./selection"));
+
+exports.Selection = _Selection;
+
+var _Style = _interopRequireWildcard(require("./style"));
+
+exports.Style = _Style;
+
+var _TextSize = _interopRequireWildcard(require("./textsize"));
+
+exports.TextSize = _TextSize;
+
+var _timer = _interopRequireDefault(require("./timer"));
+
+var _timerContext = _interopRequireDefault(require("./timer-context"));
+
+var _Transitions = _interopRequireWildcard(require("./transitions"));
+
+exports.Transitions = _Transitions;
+
+var _UserProps = _interopRequireWildcard(require("./user-props"));
+
+exports.UserProps = _UserProps;
+
+var _Wrapper = _interopRequireWildcard(require("./wrapper"));
+
+exports.Wrapper = _Wrapper;
+
+var _withContainer = require("./with-container");
+
+Object.keys(_withContainer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _withContainer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _withContainer[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+//# sourceMappingURL=index.js.map