vccs 0.0.1 → 0.1.0

package/dist/state/tooltipSlice.d.ts

@@ -0,0 +1,204 @@
+import { AxisId } from './cartesianAxisSlice';
+import { ChartCoordinate, Coordinate, DataKey, NameType, Payload, TooltipTrigger, ValueType } from '../types';
+/**
+ * One Tooltip can display multiple TooltipPayloadEntries at a time.
+ */
+export type TooltipPayloadEntry = Payload<ValueType, NameType>;
+/**
+ * So what happens is that the tooltip payload is decided based on the available data, and the dataKey.
+ * The dataKey can either be defined on the graphical element (like Line, or Bar)
+ * or on the tooltip itself.
+ *
+ * The data can be defined in the chart element, or in the graphical item.
+ *
+ * So this type is all the settings, other than the data + dataKey complications.
+ */
+export type TooltipEntrySettings = Omit<TooltipPayloadEntry, 'payload' | 'value'> & {
+    nameKey: DataKey<any> | undefined;
+};
+/**
+ * This is what Tooltip renders.
+ */
+export type TooltipPayload = ReadonlyArray<TooltipPayloadEntry>;
+/**
+ * null means no active index
+ * string means: whichever index from the chart data it is.
+ * Different charts have different requirements on data shapes,
+ * and are also responsible for providing a function that will accept this index
+ * and return data.
+ */
+export type TooltipIndex = string | null;
+/**
+ * Different items have different data shapes so the state has no opinion on what the data shape should be;
+ * the only requirement is that the chart also provides a searcher function
+ * that accepts the data, and a key, and returns whatever the payload in Tooltip should be.
+ */
+export type TooltipPayloadSearcher<T = any, R = T> = (data: T, index: TooltipIndex, computedData?: unknown, nameKey?: DataKey<any>) => R | undefined;
+export type TooltipPayloadConfiguration = {
+    settings: TooltipEntrySettings;
+    /**
+     * This is the data that the item has provided, all of it mixed together.
+     * Later as user is interacting with the chart, a redux selector will use this
+     * data + activeIndex, pass it to the TooltipPayloadSearcher, and render the result in a Tooltip.
+     */
+    dataDefinedOnItem: unknown;
+    /**
+     * Opportunity for the graphical item to define its own Tooltip coordinates
+     * instead of relying on the axes.
+     *
+     * If undefined, then Recharts will use mouse interaction coordinates, or the axis coordinates,
+     * with some defaults (like, top/left of the chart).
+     */
+    positions: Record<NonNullable<TooltipIndex>, Coordinate> | ReadonlyArray<Coordinate> | undefined;
+};
+export type ActiveTooltipProps = {
+    activeIndex: TooltipIndex;
+    activeCoordinate: ChartCoordinate | undefined;
+};
+/**
+ * So this informs the "tooltip event type". Tooltip event type can be either "axis" or "item"
+ * and it is used for two things:
+ * 1. Sets the active area
+ * 2. Sets the background and cursor highlights
+ *
+ * Some charts only allow to have one type of tooltip event type, some allow both.
+ * Those charts that allow both will have one default, and the "shared" prop will be used to switch between them.
+ * Undefined means "use the chart default".
+ *
+ * Charts that only allow one tooltip event type, will ignore the shared prop.
+ */
+export type SharedTooltipSettings = boolean | undefined;
+export type TooltipSettingsState = {
+    shared: SharedTooltipSettings;
+    trigger: TooltipTrigger;
+    axisId: AxisId;
+    /**
+     * The `active` prop, despite its name, does not mean "always active".
+     * It means "active after user interaction has ended".
+     * By default, the tooltip is only active while the user is hovering over the chart.
+     * With `active=true`, the tooltip will remain visible after mouse leave event.
+     *
+     * If you want to see the "active before user interaction" settings, see `defaultIndex`.
+     *
+     * Undefined means "depends on user interactions".
+     */
+    active: boolean | undefined;
+    /**
+     * If you want to set the tooltip to be active before user interaction, you can set this property.
+     */
+    defaultIndex: TooltipIndex | undefined;
+};
+/**
+ * A generic state for user interaction with the chart.
+ * User interaction can come through multiple channels: mouse events, keyboard events, or hardcoded in props, or synchronised from other charts.
+ *
+ * Each of the interaction states is represented as TooltipInteractionState,
+ * and then the selectors and Tooltip will decide which of the interaction states to use.
+ */
+export type TooltipInteractionState = {
+    /**
+     * If user interaction is in progress or not.
+     * Why is this its own property? Why is this not computed from the index?
+     * Certainly if index !== -1 then the tooltip is active, right?
+     * Well not so fast. Recharts allows Tooltips can be set to `active=true`
+     * which means the tooltip remains displayed after the user stops interacting.
+     * - This implies that we cannot set index to <empty value> after interaction ends,
+     *   because the chart must remember the last position just in case the `active` prop on Tooltip is set to true.
+     */
+    active: boolean;
+    /**
+     * This is the current data index that is set for the chart.
+     * This can come from mouse events, keyboard events, or hardcoded in props
+     * in property `defaultIndex` on Tooltip.
+     */
+    index: TooltipIndex;
+    /**
+     * DataKey filter.
+     *
+     * In case of multiple graphical items, this is the dataKey that is set for the item.
+     * Very useful for `Tooltip.shared=false`, where activeIndex can display multiple values,
+     * but we only want to display one of them.
+     *
+     * If we want to interact with all the graphical items, then this is undefined.
+     * This is the case for eventTooltipType === 'axis' for example.
+     */
+    dataKey: DataKey<any> | undefined;
+    /**
+     * The Coordinate where user last interacted with the chart. This needs saved so we can continue to render the tooltip at that point.
+     * This is undefined on several occasions:
+     * - before the user started interacting with the chart,
+     * - when the chart is controlled programmatically through `defaultIndex` prop
+     * - when the chart is controlled using keyboard interactions
+     */
+    coordinate: Coordinate | undefined;
+};
+export type TooltipSyncState = TooltipInteractionState & {
+    /**
+     * Tooltip synchronization is a feature that allows multiple charts to share the same interaction state.
+     * This comes with one specialty - the syncMethod. `syncMethod=value` allows the user to synchronise charts
+     * based on the active label (which is rendered as the title of the Tooltip).
+     * To allow that, we need the label to be stored in the sync state.
+     */
+    label: string | undefined;
+};
+export declare const noInteraction: TooltipInteractionState;
+/**
+ * The tooltip interaction state stores:
+ *
+ * - Which graphical item is user interacting with at the moment,
+ * - which axis (or, which part of chart background) is user interacting with at the moment
+ * - The data that individual graphical items wish to be displayed in case the tooltip gets activated
+ */
+export type TooltipState = {
+    /**
+     * This is the state of interactions with individual graphical items.
+     */
+    itemInteraction: {
+        click: TooltipInteractionState;
+        /**
+         * Why is hover activation separate from click activation? Because they are independent:
+         * If a click is set, then mouseLeave should not clear it.
+         * - the opposite is technically true too - but it's difficult to click on things without also hovering.
+         */
+        hover: TooltipInteractionState;
+    };
+    /**
+     * This is the state of interaction with the bar background - which will get mapped
+     * to the axis index.
+     *
+     * Axis interaction is independent of item interaction so the state must also be independent.
+     */
+    axisInteraction: {
+        click: TooltipInteractionState;
+        hover: TooltipInteractionState;
+    };
+    keyboardInteraction: TooltipInteractionState;
+    /**
+     * This part of the state is the information coming from other charts.
+     * If there are two charts with the same syncId, events from one chart will be transferred
+     * to other charts. So this is what the other charts are reporting.
+     */
+    syncInteraction: TooltipSyncState;
+    /**
+     * One graphical item will have one configuration;
+     * hovering over multiple of them (for example with tooltipEventType===axis)
+     * may render multiple tooltip payloads.
+     */
+    tooltipItemPayloads: ReadonlyArray<TooltipPayloadConfiguration>;
+    /**
+     * Tooltip props or other settings that need redux access.
+     * This assumes that there is always only one Tooltip. In case we want to start supporting multiple Tooltips,
+     * we have to change this to an array - and update all the places reading this state too.
+     */
+    settings: TooltipSettingsState;
+};
+export declare const initialState: TooltipState;
+export type TooltipActionPayload = {
+    activeIndex: TooltipIndex;
+    activeDataKey: DataKey<any> | undefined;
+    activeCoordinate?: ChartCoordinate | undefined;
+};
+export declare const addTooltipEntrySettings: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipPayloadConfiguration, "tooltip/addTooltipEntrySettings">, removeTooltipEntrySettings: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipPayloadConfiguration, "tooltip/removeTooltipEntrySettings">, setTooltipSettingsState: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipSettingsState, "tooltip/setTooltipSettingsState">, setActiveMouseOverItemIndex: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipActionPayload, "tooltip/setActiveMouseOverItemIndex">, mouseLeaveItem: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"tooltip/mouseLeaveItem">, mouseLeaveChart: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"tooltip/mouseLeaveChart">, setActiveClickItemIndex: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipActionPayload, "tooltip/setActiveClickItemIndex">, setMouseOverAxisIndex: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipActionPayload, "tooltip/setMouseOverAxisIndex">, setMouseClickAxisIndex: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipActionPayload, "tooltip/setMouseClickAxisIndex">, setSyncInteraction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipSyncState, "tooltip/setSyncInteraction">, setKeyboardInteraction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TooltipActionPayload & {
+    active: boolean;
+}, "tooltip/setKeyboardInteraction">;
+export declare const tooltipReducer: import('@reduxjs/toolkit').Reducer<TooltipState>;

package/dist/state/touchEventsMiddleware.d.ts

@@ -0,0 +1,2 @@
+export declare const touchEventAction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<TouchEvent, string>;
+export declare const touchEventMiddleware: import('@reduxjs/toolkit').ListenerMiddlewareInstance<unknown, import('@reduxjs/toolkit').ThunkDispatch<unknown, unknown, import('@reduxjs/toolkit').UnknownAction>, unknown>;

package/dist/state/utils/useReportScale.d.ts

@@ -0,0 +1 @@
+export declare function useReportScale(): import('vue').Ref<HTMLElement, HTMLElement>;

package/dist/synchronisation/syncSelectors.d.ts

@@ -0,0 +1,3 @@
+import { RechartsRootState } from '../state/store';
+import { TooltipSyncState } from '../state/tooltipSlice';
+export declare function selectSynchronisedTooltipState(state: RechartsRootState): TooltipSyncState;

package/dist/synchronisation/useChartSynchronisation.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { ChartCoordinate, TooltipEventType, TooltipIndex, TooltipTrigger } from '../types';
+export declare function useTooltipChartSynchronisation({ tooltipEventType, trigger, activeCoordinate, activeLabel, activeIndex, isTooltipActive, }: {
+    tooltipEventType: Ref<TooltipEventType | undefined>;
+    trigger: TooltipTrigger;
+    activeCoordinate: Ref<ChartCoordinate | undefined>;
+    activeLabel: Ref<string | number | undefined>;
+    activeIndex: Ref<TooltipIndex | undefined>;
+    isTooltipActive: Ref<boolean>;
+}): void;
+export declare function useBrushChartSynchronisation(): void;

package/dist/types/area.d.ts

@@ -0,0 +1,8 @@
+export type BaseValue = number | 'dataMin' | 'dataMax';
+export interface DataPoint {
+    [key: string]: number | string | Date | undefined;
+}
+export interface AreaChartData extends DataPoint {
+    value: number;
+    date?: Date | string;
+}

package/dist/types/axis.d.ts

@@ -0,0 +1,127 @@
+import { DataKey } from './common';
+import { RechartsScale, ScaleType } from './scale';
+import { TickFormatter, TicksSettings } from './tick';
+export type AxisId = string | number;
+export type AxisDomainType = 'number' | 'category';
+export type AxisDomainItem = string | number | ((d: number) => string | number) | 'auto' | 'dataMin' | 'dataMax';
+/**
+ * The domain of axis.
+ * This is the definition
+ *
+ * Numeric domain is always defined by an array of exactly two values, for the min and the max of the axis.
+ * Categorical domain is defined as array of all possible values.
+ *
+ * Can be specified in many ways:
+ * - array of numbers
+ * - with special strings like 'dataMin' and 'dataMax'
+ * - with special string math like 'dataMin - 100'
+ * - with keyword 'auto'
+ * - or a function
+ * - array of functions
+ * - or a combination of the above
+ */
+export type AxisDomain = ReadonlyArray<string> | ReadonlyArray<number> | Readonly<[AxisDomainItem, AxisDomainItem]> | (([dataMin, dataMax]: [number, number], allowDataOverflow: boolean) => [number, number]);
+/**
+ * Properties shared in X, Y, and Z axes
+ */
+export type BaseCartesianAxis = {
+    id?: AxisId;
+    scale: ScaleType | RechartsScale | undefined;
+    type: AxisDomainType;
+    /**
+     * The axis functionality is severely restricted without a dataKey
+     * - but there is still something left, and the prop is optional
+     * so this can also be undefined even in real charts.
+     * There are no defaults.
+     */
+    dataKey: DataKey<any> | undefined;
+    unit: string | undefined;
+    name: string | undefined;
+    allowDuplicatedCategory: boolean;
+    allowDataOverflow: boolean;
+    reversed: boolean;
+    includeHidden: boolean;
+    domain: AxisDomain | undefined;
+};
+export type AxisInterval = number | 'preserveStart' | 'preserveEnd' | 'preserveStartEnd' | 'equidistantPreserveStart' | 'equidistantPreserveEnd';
+/**
+ * These are the external props, visible for users as they set them using our public API.
+ * There is all sorts of internal computed things based on these, but they will come through selectors.
+ *
+ * Properties shared between X and Y axes
+ */
+export type CartesianAxisSettings = BaseCartesianAxis & TicksSettings & {
+    interval: AxisInterval;
+    mirror: boolean;
+    minTickGap: number;
+    angle: number;
+    hide: boolean;
+    tickFormatter: TickFormatter | undefined;
+};
+export type YAxisPadding = {
+    top?: number;
+    bottom?: number;
+} | 'gap' | 'no-gap';
+export type YAxisOrientation = 'left' | 'right';
+export type YAxisSettings = CartesianAxisSettings & {
+    padding: YAxisPadding;
+    width: number;
+    orientation: YAxisOrientation;
+};
+export type AxisRange = readonly [number, number];
+/**
+ * Z axis is special because it's never displayed. It controls the size of Scatter dots,
+ * but it never displays ticks anywhere.
+ */
+export type ZAxisSettings = BaseCartesianAxis & {
+    range: AxisRange;
+};
+export type XAxisPadding = {
+    left?: number;
+    right?: number;
+} | 'gap' | 'no-gap';
+export type XAxisOrientation = 'top' | 'bottom';
+export type XAxisSettings = CartesianAxisSettings & {
+    padding: XAxisPadding;
+    height: number;
+    orientation: XAxisOrientation;
+};
+export type AxisType = 'xAxis' | 'yAxis' | 'zAxis' | 'angleAxis' | 'radiusAxis';
+export interface XAxisProps {
+    xAxisId?: string | number;
+    dataKey?: string | number | ((row: any) => any);
+    type?: 'number' | 'category';
+    domain?: any[];
+    scale?: string | Function;
+    orientation?: 'top' | 'bottom';
+    height?: number;
+    padding?: {
+        left?: number;
+        right?: number;
+    } | 'gap' | 'no-gap';
+    mirror?: boolean;
+    hide?: boolean;
+    tick?: boolean | Function | any;
+    tickCount?: number;
+    tickFormatter?: (val: any, idx: number) => string;
+    allowDataOverflow?: boolean;
+    allowDuplicatedCategory?: boolean;
+    allowDecimals?: boolean;
+    includeHidden?: boolean;
+    name?: string;
+    unit?: string;
+    angle?: number;
+    minTickGap?: number;
+    label?: string | number | any;
+    className?: string;
+}
+/**
+ * NumberDomain is an evaluated {@link AxisDomain}.
+ * Unlike {@link AxisDomain}, it has no variety - it's a tuple of two number.
+ * This is after all the keywords and functions were evaluated and what is left is [min, max].
+ *
+ * Know that the min, max values are not guaranteed to be nice numbers - values like -Infinity or NaN are possible.
+ *
+ * There are also `category` axes that have different things than numbers in their domain.
+ */
+export type NumberDomain = [min: number, max: number];

package/dist/types/bar.d.ts

@@ -0,0 +1,51 @@
+import { Coordinate } from './common';
+import { CartesianViewBox } from '../cartesian/type';
+export type BarPositionPosition = {
+    /**
+     * Offset is returned always from zero position.
+     * So in a way it's "absolute".
+     *
+     * NOT inbetween bars, but always from zero.
+     */
+    offset: number;
+    /**
+     * Size of the bar.
+     * This will be usually a number.
+     * But if the input data is not well-formed, undefined or NaN will be on the output too.
+     */
+    size: number | undefined | typeof NaN;
+};
+export type RectRadius = [number, number, number, number];
+export type AnimationEasing = 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'linear';
+interface RectangleProps {
+    className?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    radius?: number | RectRadius;
+    isAnimationActive?: boolean;
+    isUpdateAnimationActive?: boolean;
+    animationBegin?: number;
+    animationDuration?: number;
+    animationEasing?: AnimationEasing;
+}
+export interface BarRectangleItem extends RectangleProps {
+    value?: number | [number, number];
+    /** the original data entry */
+    payload?: any;
+    /** the coordinate of background rectangle */
+    background?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+    /** Chart range coordinate of the baseValue of the first bar in a stack. */
+    stackedBarStart: number;
+    tooltipPosition: Coordinate;
+    /** The chart's full plotting area viewBox, used by LabelList for text wrapping calculations */
+    parentViewBox?: CartesianViewBox;
+}
+export type ErrorBarDirection = 'x' | 'y';
+export {};

package/dist/types/categorical.d.ts

@@ -0,0 +1,36 @@
+import { DataKey, LayoutType, Margin, StackOffsetType, SyncMethod } from './common';
+import { ExternalMouseEvents } from './event';
+export interface CategoricalChartProps extends Partial<ExternalMouseEvents> {
+    accessibilityLayer?: boolean;
+    barCategoryGap?: number | string;
+    barGap?: number | string;
+    barSize?: number | string;
+    children?: any;
+    class?: string;
+    compact?: boolean;
+    cx?: number | string;
+    cy?: number | string;
+    data?: any[];
+    dataKey?: DataKey<any>;
+    desc?: string;
+    endAngle?: number;
+    height?: number;
+    id?: string;
+    innerRadius?: number | string;
+    layout?: LayoutType;
+    margin?: Margin;
+    maxBarSize?: number;
+    outerRadius?: number | string;
+    reverseStackOrder?: boolean;
+    role?: string;
+    stackOffset?: StackOffsetType;
+    startAngle?: number;
+    style?: any;
+    syncId?: number | string;
+    syncMethod?: SyncMethod;
+    tabIndex?: number;
+    throttleDelay?: number;
+    title?: string;
+    width?: number;
+}
+export type CategoricalDomain = ReadonlyArray<number | string | Date>;

package/dist/types/common.d.ts

@@ -0,0 +1,129 @@
+import { TooltipPayload, TooltipPayloadSearcher } from '../state/tooltipSlice';
+import { TooltipEventType, TooltipIndex } from './tooltip';
+import { PropType, SVGAttributes } from 'vue';
+export type DataKey<T> = string | number | ((obj: T) => any);
+export interface Coordinate {
+    x: number;
+    y: number;
+}
+export interface ChartCoordinate extends Coordinate {
+    xAxis?: any;
+    yAxis?: any;
+    width?: any;
+    height?: any;
+    offset?: ChartOffset;
+    angle?: number;
+    radius?: number;
+    cx?: number;
+    cy?: number;
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+}
+export type LayoutType = 'horizontal' | 'vertical' | 'centric' | 'radial';
+export interface Margin {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export type StackOffsetType = 'sign' | 'expand' | 'none' | 'wiggle' | 'silhouette' | 'positive';
+export interface TickItem {
+    value?: any;
+    coordinate: number;
+    index?: number;
+    offset?: number;
+}
+export type SyncMethod = 'index' | 'value' | ((ticks: ReadonlyArray<TickItem>, data: MouseHandlerDataParam) => number);
+export type MouseHandlerDataParam = {
+    /**
+     * Index of the active tick in the current chart. Only works with number-indexed one-dimensional data charts,
+     * like Line, Area, Bar, Pie, etc.
+     *
+     * Doesn't work with two-dimensional data charts like Treemap, Sankey. But one day it will which is why the TooltipIndex type is here.
+     */
+    activeTooltipIndex: number | TooltipIndex | undefined;
+    isTooltipActive: boolean;
+    /**
+     * Exactly the same as activeTooltipIndex - this was also duplicated in recharts@2 so let's keep both properties for better backwards compatibility.
+     */
+    activeIndex: number | TooltipIndex | undefined;
+    activeLabel: string | undefined;
+    activeDataKey: DataKey<any> | undefined;
+    activeCoordinate: Coordinate | undefined;
+};
+export interface Padding {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+export interface ChartOffset {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    height: number;
+    width: number;
+    brushBottom: number;
+}
+export type ChartOffsetRequired = Required<ChartOffset>;
+export interface Size {
+    width: number;
+    height: number;
+}
+export type AnimationDuration = number;
+/**
+ * Coordinates relative to the top-left corner of the chart.
+ * Also include scale which means that a chart that's scaled will return the same coordinates as a chart that's not scaled.
+ */
+export interface ChartPointer {
+    chartX: number;
+    chartY: number;
+}
+export type IfOverflow = 'hidden' | 'visible' | 'discard' | 'extendDomain';
+export interface ScatterPointNode {
+    x?: number | string;
+    y?: number | string;
+    z?: number | string;
+}
+export interface ScatterPointItem {
+    cx: number | undefined;
+    cy: number | undefined;
+    x: number | undefined;
+    y: number | undefined;
+    size: number;
+    width: number;
+    height: number;
+    node: ScatterPointNode;
+    payload?: any;
+    tooltipPayload?: TooltipPayload;
+    tooltipPosition: Coordinate;
+}
+export interface CategoricalChartOptions {
+    chartName: string;
+    defaultTooltipEventType?: TooltipEventType;
+    validateTooltipEventTypes?: ReadonlyArray<TooltipEventType>;
+    defaultProps?: any;
+    tooltipPayloadSearcher: TooltipPayloadSearcher;
+}
+type UnwrapPropType<T> = T extends PropType<infer C> ? C : T;
+type VuePropField<P> = P extends {
+    type: infer T;
+} ? UnwrapPropType<T> : UnwrapPropType<P>;
+export type VuePropsToType<Props> = {
+    [K in keyof Props as Props[K] extends {
+        required: boolean;
+    } ? K : never]: VuePropField<Props[K]>;
+} & {
+    [K in keyof Props as Props[K] extends {
+        required: boolean;
+    } ? never : K]?: VuePropField<Props[K]>;
+};
+export type WithSVGProps<T> = VuePropsToType<T> & Omit<SVGAttributes, keyof T>;
+export type AllowInDimension = {
+    x?: boolean;
+    y?: boolean;
+};
+export {};

package/dist/types/event.d.ts

@@ -0,0 +1,16 @@
+import { MouseHandlerDataParam } from './common';
+export type CategoricalChartFunc = (nextState: MouseHandlerDataParam, event: Event) => void;
+export interface ExternalMouseEvents {
+    onClick: CategoricalChartFunc;
+    onMouseLeave: CategoricalChartFunc;
+    onMouseEnter: CategoricalChartFunc;
+    onMouseMove: CategoricalChartFunc;
+    onMouseDown: CategoricalChartFunc;
+    onMouseUp: CategoricalChartFunc;
+    onContextMenu: CategoricalChartFunc;
+    onDoubleClick: CategoricalChartFunc;
+    onTouchStart: CategoricalChartFunc;
+    onTouchMove: CategoricalChartFunc;
+    onTouchEnd: CategoricalChartFunc;
+}
+export declare const EventKeys: string[];

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './categorical';
+export * from './event';
+export * from './tooltip';

package/dist/types/legend.d.ts

@@ -0,0 +1 @@
+export type LegendType = 'circle' | 'cross' | 'diamond' | 'line' | 'plainline' | 'rect' | 'square' | 'star' | 'triangle' | 'wye' | 'none';

package/dist/types/offset.d.ts

@@ -0,0 +1,8 @@
+export type OffsetVertical = {
+    top: number;
+    bottom: number;
+};
+export type OffsetHorizontal = {
+    left: number;
+    right: number;
+};

package/dist/types/radar.d.ts

@@ -0,0 +1,28 @@
+import { DataKey } from '.';
+import { RechartsScale } from './scale';
+export type RadiusAxisForRadar = {
+    scale: RechartsScale;
+};
+export type AngleAxisForRadar = {
+    scale: RechartsScale;
+    type: 'number' | 'category';
+    dataKey: DataKey<any>;
+    cx: number;
+    cy: number;
+};
+export interface RadarPoint {
+    x: number;
+    y: number;
+    cx?: number;
+    cy?: number;
+    angle?: number;
+    radius?: number;
+    value?: number;
+    payload?: any;
+    name?: string;
+}
+export type RadarComposedData = {
+    points: RadarPoint[];
+    baseLinePoints: RadarPoint[];
+    isRange: boolean;
+};

package/dist/types/scale.d.ts

@@ -0,0 +1,11 @@
+export type ScaleType = 'auto' | 'linear' | 'pow' | 'sqrt' | 'log' | 'identity' | 'time' | 'band' | 'point' | 'ordinal' | 'quantile' | 'quantize' | 'utc' | 'sequential' | 'symlog' | 'threshold';
+/**
+ * A subset of d3-scale that Recharts is using
+ */
+export interface RechartsScale {
+    domain: (() => ReadonlyArray<unknown>) & ((newDomain: ReadonlyArray<unknown>) => this);
+    range: (() => ReadonlyArray<unknown>) & ((newRange: ReadonlyArray<unknown>) => this);
+    bandwidth?: () => number;
+    ticks?: (count: number) => any;
+    (args: any): number;
+}