victory-core 36.5.0 → 36.5.3

package/lib/victory-state/helpers/get-scale.d.ts

@@ -0,0 +1,6 @@
+import { AxisType, D3ScaleFn } from "../../types/prop-types";
+import { VictoryProviderProps } from "../types";
+declare type ScaleProps = Pick<VictoryProviderProps, "data" | "scale">;
+export declare function getScale({ data, ...props }: ScaleProps, axis: AxisType): D3ScaleFn;
+export {};
+//# sourceMappingURL=get-scale.d.ts.map

package/lib/victory-state/helpers/get-scale.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getScale = getScale;
+
+var _d3Scale = require("victory-vendor/d3-scale");
+
+var Collection = _interopRequireWildcard(require("../../victory-util/collection"));
+
+var _typeHelpers = require("../../victory-util/type-helpers");
+
+var _getAxisData = require("./get-axis-data");
+
+var _excluded = ["data"];
+
+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; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+var DEFAULT_SCALE = _d3Scale.scaleLinear;
+
+function isD3Scale(scale) {
+  return (0, _typeHelpers.isFunction)(scale) && (0, _typeHelpers.isFunction)(scale().copy) && (0, _typeHelpers.isFunction)(scale().domain) && (0, _typeHelpers.isFunction)(scale().range);
+}
+
+function getD3ScaleFromString(scale) {
+  switch (scale) {
+    case "linear":
+      return _d3Scale.scaleLinear;
+
+    case "time":
+      return _d3Scale.scaleTime;
+
+    case "log":
+      return _d3Scale.scaleLog;
+
+    case "sqrt":
+      return _d3Scale.scaleSqrt;
+
+    default:
+      return DEFAULT_SCALE;
+  }
+}
+
+function getScale(_ref, axis) {
+  var _ref$data = _ref.data,
+      data = _ref$data === void 0 ? [] : _ref$data,
+      props = _objectWithoutProperties(_ref, _excluded);
+
+  var scale = (0, _typeHelpers.getValueForAxis)(props.scale, axis);
+
+  if (isD3Scale(scale)) {
+    return scale;
+  }
+
+  if (typeof scale === "string") {
+    return getD3ScaleFromString(scale);
+  }
+
+  var axisData = (0, _getAxisData.getAxisData)(data, axis);
+
+  if (Collection.containsDates(axisData)) {
+    return _d3Scale.scaleTime;
+  }
+
+  return DEFAULT_SCALE;
+}
+//# sourceMappingURL=get-scale.js.map

package/lib/victory-state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./victory-provider";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/lib/victory-state/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _victoryProvider = require("./victory-provider");
+
+Object.keys(_victoryProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _victoryProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _victoryProvider[key];
+    }
+  });
+});
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

package/lib/victory-state/types.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { D3ScaleFn, Datum, DomainTuple, RangeTuple, ScalePropType, ValueOrAxes } from "../types/prop-types";
+import { PaddingProps } from "../victory-theme/types";
+export interface VictoryCalculatedStateProps {
+    data?: Datum[];
+    domain?: ValueOrAxes<DomainTuple>;
+    height?: number;
+    includeZero?: boolean;
+    maxDomain?: ValueOrAxes<number>;
+    minDomain?: ValueOrAxes<number>;
+    padding?: PaddingProps;
+    range?: ValueOrAxes<RangeTuple>;
+    samples?: number;
+    scale?: ValueOrAxes<ScalePropType | D3ScaleFn>;
+    sortKey?: string;
+    sortOrder?: "ascending" | "descending";
+    width?: number;
+    x?: string;
+    y?: string;
+}
+export interface VictoryProviderProps extends VictoryCalculatedStateProps {
+    children?: React.ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/victory-state/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/victory-state/victory-provider.d.ts

@@ -0,0 +1,19 @@
+import { D3ScaleFn, DomainTuple, ForAxes } from "../types/prop-types";
+import { FormattedDatum } from "./helpers/get-data";
+import { VictoryCalculatedStateProps, VictoryProviderProps } from "./types";
+declare type ScaleType = Required<ForAxes<D3ScaleFn>>;
+declare type DomainType = Required<ForAxes<DomainTuple>>;
+export interface ContextType {
+    data: FormattedDatum[];
+    scale: ScaleType;
+    domain: DomainType;
+    setChildProps: (id: string, props: VictoryProviderProps) => void;
+}
+export declare function VictoryProvider({ children, ...initialProps }: VictoryProviderProps): JSX.Element;
+export declare function useVictoryContext<T>(selector: (value: ContextType) => T): T;
+export declare function useScale(): ScaleType;
+export declare function useData(): FormattedDatum[];
+export declare function useDomain(): DomainType;
+export declare function useVictoryProviderSync(id: string, props: VictoryCalculatedStateProps): VictoryCalculatedStateProps;
+export {};
+//# sourceMappingURL=victory-provider.d.ts.map

package/lib/victory-state/victory-provider.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VictoryProvider = VictoryProvider;
+exports.useData = useData;
+exports.useDomain = useDomain;
+exports.useScale = useScale;
+exports.useVictoryContext = useVictoryContext;
+exports.useVictoryProviderSync = useVictoryProviderSync;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _getData = require("./helpers/get-data");
+
+var _getDomain = require("./helpers/get-domain");
+
+var _getRange = require("./helpers/get-range");
+
+var _getScale = require("./helpers/get-scale");
+
+var _excluded = ["children"];
+
+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; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+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; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+var VictoryContext = /*#__PURE__*/(0, React.createContext)(null);
+
+function VictoryProvider(_ref) {
+  var children = _ref.children,
+      initialProps = _objectWithoutProperties(_ref, _excluded);
+
+  // We need to store the props in state so they can be overwritten by child components
+  var _React$useState = React.useState(initialProps),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      props = _React$useState2[0],
+      setProps = _React$useState2[1];
+
+  var setChildProps = React.useCallback(function (id, newProps) {
+    setProps(function (prevProps) {
+      return _objectSpread(_objectSpread({}, prevProps), newProps);
+    });
+  }, []);
+  var data = React.useMemo(function () {
+    return (0, _getData.getData)(props);
+  }, [props]);
+  var domain = React.useMemo(function () {
+    return {
+      x: (0, _getDomain.getDomain)(props, "x"),
+      y: (0, _getDomain.getDomain)(props, "y")
+    };
+  }, [props]);
+  var range = React.useMemo(function () {
+    return {
+      x: (0, _getRange.getRange)(props, "x"),
+      y: (0, _getRange.getRange)(props, "y")
+    };
+  }, [props]);
+  var scale = React.useMemo(function () {
+    var xBaseScaleFn = (0, _getScale.getScale)(props, "x");
+    var yBaseScaleFn = (0, _getScale.getScale)(props, "y"); // @ts-expect-error: This is a valid scale function
+
+    var xScaleFn = xBaseScaleFn().domain(domain.x).range(range.x); // @ts-expect-error: This is a valid scale function
+
+    var yScaleFn = yBaseScaleFn().domain(domain.y).range(range.y);
+    return {
+      x: xScaleFn,
+      y: yScaleFn
+    };
+  }, [props, domain, range]);
+  var value = {
+    scale: scale,
+    data: data,
+    domain: domain,
+    setChildProps: setChildProps
+  };
+  return /*#__PURE__*/React.createElement(VictoryContext.Provider, {
+    value: value
+  }, children);
+}
+
+function useVictoryContext(selector) {
+  var context = (0, React.useContext)(VictoryContext);
+
+  if (!context) {
+    throw new Error("useVictoryContext must be used within a VictoryProvider");
+  }
+
+  return selector(context);
+}
+
+function useScale() {
+  return useVictoryContext(function (value) {
+    return value.scale;
+  });
+}
+
+function useData() {
+  return useVictoryContext(function (value) {
+    return value.data;
+  });
+}
+
+function useDomain() {
+  return useVictoryContext(function (value) {
+    return value.domain;
+  });
+} // This function keeps props in sync betwen the VictoryProvider and child components
+
+
+function useVictoryProviderSync(id, props) {
+  var setChildProps = useVictoryContext(function (value) {
+    return value.setChildProps;
+  });
+  React.useEffect(function () {
+    setChildProps(id, props);
+  }, []);
+  return props;
+}
+//# sourceMappingURL=victory-provider.js.map

package/lib/victory-theme/grayscale.d.ts

@@ -1,2 +1,3 @@
-import { VictoryThemeDefinition } from "./victory-theme-definition";
+import { VictoryThemeDefinition } from "./types";
 export declare const grayscale: VictoryThemeDefinition;
+//# sourceMappingURL=grayscale.d.ts.map

package/lib/victory-theme/grayscale.js

@@ -265,4 +265,5 @@ var grayscale = {
     }
   }, baseProps)
 };
-exports.grayscale = grayscale;
+exports.grayscale = grayscale;
+//# sourceMappingURL=grayscale.js.map

package/lib/victory-theme/material.d.ts

@@ -1,2 +1,3 @@
-import { VictoryThemeDefinition } from "./victory-theme-definition";
+import { VictoryThemeDefinition } from "./types";
 export declare const material: VictoryThemeDefinition;
+//# sourceMappingURL=material.d.ts.map

package/lib/victory-theme/material.js

@@ -292,4 +292,5 @@ var material = {
     }
   }, baseProps)
 };
-exports.material = material;
+exports.material = material;
+//# sourceMappingURL=material.js.map

package/{es/victory-theme/victory-theme-definition.d.ts → lib/victory-theme/types.d.ts}

@@ -1,6 +1,6 @@
 import * as React from "react";
-import { VictoryCommonThemeProps, VictoryDatableProps } from "../index";
-import { CallbackArgs, StringOrNumberOrCallback } from "../types";
+import { VictoryCommonThemeProps, VictoryDatableProps } from "../victory-util/common-props";
+import { NumberOrCallback, OrientationOrCallback, PaddingOrCallback, StringOrNumberOrCallback } from "../types/callbacks";
 export declare type BlockProps = {
     top?: number;
     bottom?: number;
@@ -9,12 +9,6 @@ export declare type BlockProps = {
 };
 export declare type PaddingProps = number | BlockProps;
 export declare type OrientationTypes = "top" | "bottom" | "left" | "right";
-export declare type VictoryNumberCallback = (args: CallbackArgs) => number;
-export declare type VictoryPaddingCallback = (args: CallbackArgs) => number | BlockProps;
-export declare type VictoryOrientationCallback = (args: CallbackArgs) => OrientationTypes;
-export declare type NumberOrCallback = number | VictoryNumberCallback;
-export declare type PaddingOrCallback = number | BlockProps | VictoryPaddingCallback;
-export declare type OrientationOrCallback = OrientationTypes | VictoryOrientationCallback;
 export declare type VictoryStyleObject = {
     [K in keyof React.CSSProperties]: StringOrNumberOrCallback;
 };
@@ -242,3 +236,4 @@ export interface VictoryThemeDefinition {
         };
     } & VictoryCommonThemeProps & VictoryDatableProps;
 }
+//# sourceMappingURL=types.d.ts.map

package/lib/victory-theme/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/victory-theme/victory-theme.d.ts

@@ -1,5 +1,6 @@
-export * from "./victory-theme-definition";
+export * from "./types";
 export declare const VictoryTheme: {
-    grayscale: import("./victory-theme-definition").VictoryThemeDefinition;
-    material: import("./victory-theme-definition").VictoryThemeDefinition;
+    grayscale: import("./types").VictoryThemeDefinition;
+    material: import("./types").VictoryThemeDefinition;
 };
+//# sourceMappingURL=victory-theme.d.ts.map

package/lib/victory-theme/victory-theme.js

@@ -12,16 +12,16 @@ var _grayscale = require("./grayscale");
 
 var _material = require("./material");
 
-var _victoryThemeDefinition = require("./victory-theme-definition");
+var _types = require("./types");
 
-Object.keys(_victoryThemeDefinition).forEach(function (key) {
+Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _victoryThemeDefinition[key]) return;
+  if (key in exports && exports[key] === _types[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _victoryThemeDefinition[key];
+      return _types[key];
     }
   });
 });
@@ -29,4 +29,5 @@ var VictoryTheme = {
   grayscale: _grayscale.grayscale,
   material: _material.material
 };
-exports.VictoryTheme = VictoryTheme;
+exports.VictoryTheme = VictoryTheme;
+//# sourceMappingURL=victory-theme.js.map

package/lib/victory-transition/victory-transition.d.ts

@@ -57,3 +57,4 @@ export declare class VictoryTransition extends React.Component<VictoryTransition
     render(): JSX.Element;
 }
 export {};
+//# sourceMappingURL=victory-transition.d.ts.map

package/lib/victory-transition/victory-transition.js

@@ -261,4 +261,5 @@ VictoryTransition.propTypes = {
   animationWhitelist: _propTypes.default.array,
   children: _propTypes.default.node
 };
-VictoryTransition.contextType = _timerContext.default;
+VictoryTransition.contextType = _timerContext.default;
+//# sourceMappingURL=victory-transition.js.map

package/lib/victory-util/add-events.d.ts

@@ -0,0 +1,106 @@
+import React from "react";
+import type { ComponentEvent } from "./events";
+import * as Events from "./events";
+import { VictoryCommonProps, VictoryDatableProps } from "./common-props";
+import { VictoryLabelableProps } from "../types/prop-types";
+export declare type MixinOptions = {
+    components?: Array<{
+        name: string;
+        index?: string;
+    }>;
+};
+export interface EventMixinCommonProps extends VictoryCommonProps, VictoryDatableProps, VictoryLabelableProps {
+}
+/**
+ * These methods will be implemented by the Mixin,
+ * and are accessible to the Wrapped Component.
+ *
+ * To make your Wrapped Component type-safe, use "interface merging" like so:
+ * @example
+ *    interface MyComponent extends EventsMixinClass<MyProps> {}
+ *    class MyComponent extends React.Component<MyProps> { ... }
+ */
+export interface EventsMixinClass<TProps> {
+    renderContainer(component: React.ReactElement, children: React.ReactElement[]): React.ReactElement;
+    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
+    getEventState: typeof Events.getEventState;
+    renderContinuousData(props: TProps): any;
+    animateComponent(props: TProps, defaultAnimationWhitelist: any): any;
+}
+/**
+ * These fields are calculated by the Mixin
+ */
+export interface EventMixinCalculatedValues {
+    componentEvents: Array<ComponentEvent>;
+    getSharedEventState: (key: string, value: string) => unknown;
+    baseProps: Record<string, object>;
+    dataKeys: string[];
+    hasEvents: unknown;
+    events: unknown;
+}
+/**
+ * This represents the class itself, including static fields
+ */
+export interface WrappedComponentClass<TProps> {
+    new (props: TProps): React.Component<TProps>;
+    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
+    role?: string;
+    expectedComponents?: string[];
+}
+export declare function addEvents<TBase extends WrappedComponentClass<TProps>, TProps extends EventMixinCommonProps>(WrappedComponent: TBase, options?: MixinOptions): {
+    new (props: TProps): {
+        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: TProps): 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): EventMixinCalculatedValues;
+        getExternalMutations(props: TProps): {} | undefined;
+        cacheValues(obj: any): void;
+        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
+        getAllEvents(props: any): any;
+        getComponentProps(component: any, type: any, index: any): any;
+        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+        animateComponent(props: TProps, defaultAnimationWhitelist: string[]): JSX.Element;
+        renderContinuousData(props: TProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+        renderData(props: any, shouldRenderDatum?: (datum: any) => boolean): React.DetailedReactHTMLElement<any, HTMLElement>;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<TProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+        componentEvents: ComponentEvent[];
+        getSharedEventState: (key: string, value: string) => unknown;
+        baseProps: Record<string, object>;
+        dataKeys: string[];
+        hasEvents: unknown;
+        events: unknown;
+    };
+    getBaseProps?(props: TProps): Record<string, object>;
+    role?: string | undefined;
+    expectedComponents?: string[] | undefined;
+} & TBase;
+//# sourceMappingURL=add-events.d.ts.map