@evergis/charts 3.1.6 → 3.1.7

package/dist/src/charts/BarChart/draw.d.ts

@@ -0,0 +1,2 @@
+import { BarChartProps } from './types';
+export declare const draw: (node: HTMLElement | null, props: BarChartProps) => void;

package/dist/src/charts/BarChart/drawGrid/index.d.ts

@@ -0,0 +1,2 @@
+import { DrawGridProps } from './types';
+export declare const drawGrid: ({ svg, yScale, xScale, yTicksCount, drawGridX, drawGridY, }: DrawGridProps) => void;

package/dist/src/charts/BarChart/drawGrid/types.d.ts

@@ -0,0 +1,8 @@
+import { BarChartProps } from '../types';
+import * as d3 from 'd3';
+export type DrawGridProps = {
+    svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+    yScale: d3.ScaleLinear<number, number>;
+    xScale: d3.ScaleBand<string>;
+    yTicksCount: number;
+} & Pick<BarChartProps, 'drawGridX' | 'drawGridY'>;

package/dist/src/charts/BarChart/drawLines/index.d.ts

@@ -0,0 +1,13 @@
+import { DrawLinesProps } from './types';
+import * as d3 from 'd3';
+export declare const barChartLinesClassNames: {
+    barChartLinesGlobal: string;
+    barChartLine: string;
+    barChartAreasGlobal: string;
+    barChartArea: string;
+};
+export declare const drawLines: ({ svg, lineData, min, yScale, xScale, curve, stackedLine, }: DrawLinesProps) => {
+    areasSelection: any;
+    linesSelection: any;
+    area: d3.Area<[number, number]>;
+};

package/dist/src/charts/BarChart/drawLines/types.d.ts

@@ -0,0 +1,9 @@
+import { BarChartProps, BarChartLineData } from '../types';
+import * as d3 from 'd3';
+export type DrawLinesProps = {
+    min: number;
+    svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+    yScale: d3.ScaleLinear<number, number>;
+    xScale: d3.ScaleBand<string>;
+    lineData: BarChartLineData[];
+} & Pick<BarChartProps, 'stackedLine' | 'curve'>;

package/dist/src/charts/BarChart/drawTooltip/getLabel.d.ts

@@ -0,0 +1,2 @@
+import { BarChartLabelPosition } from '../types';
+export declare const getLabel: (labelPosition: BarChartLabelPosition) => import('styled-components').StyledComponent<"div", any, {}, never>;

package/dist/src/charts/BarChart/drawTooltip/getLabelY.d.ts

@@ -0,0 +1,2 @@
+import { BarChartLabelPosition, BarChartMarshalledGroup } from '../types';
+export declare const getLabelY: (labelPosition: BarChartLabelPosition, y2: number, item: BarChartMarshalledGroup) => number;

package/dist/src/charts/BarChart/drawTooltip/index.d.ts

@@ -0,0 +1,2 @@
+import { DrawTooltipProps } from './types';
+export declare const drawTooltip: ({ svg, node, data, marshalledData, xScale, yScale, renderTooltip, labelPosition, marginTop, renderLabel, barWidth, barPadding, dynamicTooltipEnable, hideTooltipGroupName, tooltipY, tooltipBind, lineData, formatTooltipValue, formatTooltipName, tooltipYDomain, setTooltipPosition, onLabelItem, isBarTooltip, bars, tooltipRoot, tooltipClassName, onBarClick, onBarHover, }: DrawTooltipProps) => void;

package/dist/src/charts/BarChart/drawTooltip/types.d.ts

@@ -0,0 +1,12 @@
+import { BarChartMarshalledGroup, BarChartProps } from '../types';
+import * as d3 from 'd3';
+export type DrawTooltipProps = {
+    svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+    node: HTMLElement;
+    yScale: d3.ScaleLinear<number, number>;
+    xScale: d3.ScaleBand<string>;
+    marshalledData: BarChartMarshalledGroup[][];
+    marginTop: number;
+    barWidth: number;
+    bars: d3.Selection<SVGGElement, BarChartMarshalledGroup[], SVGGElement, unknown>;
+} & Pick<BarChartProps, 'renderTooltip' | 'labelPosition' | 'renderLabel' | 'dynamicTooltipEnable' | 'hideTooltipGroupName' | 'tooltipY' | 'tooltipBind' | 'lineData' | 'formatTooltipValue' | 'formatTooltipName' | 'tooltipYDomain' | 'data' | 'barPadding' | 'setTooltipPosition' | 'onLabelItem' | 'isBarTooltip' | 'tooltipRoot' | 'tooltipClassName' | 'onBarClick' | 'onBarHover'>;

package/dist/src/charts/BarChart/getBars/index.d.ts

@@ -0,0 +1,3 @@
+import { BarChartMarshalledGroup } from '../types';
+import { GetBarsProps } from './types';
+export declare const getBars: ({ groups, barWidth }: GetBarsProps) => import('d3-selection').Selection<SVGRectElement | import('d3-selection').BaseType, BarChartMarshalledGroup, SVGGElement, BarChartMarshalledGroup[]>;

package/dist/src/charts/BarChart/getBars/types.d.ts

@@ -0,0 +1,6 @@
+import { BarChartMarshalledGroup } from '../types';
+import * as d3 from 'd3';
+export type GetBarsProps = {
+    groups: d3.Selection<SVGGElement, BarChartMarshalledGroup[], SVGGElement, unknown>;
+    barWidth: number;
+};

package/dist/src/charts/BarChart/getDomain.d.ts

@@ -0,0 +1,5 @@
+import { BarChartProps } from './types';
+export declare const getDomain: ({ data, minDomainValue, maxDomainValue, }: Pick<BarChartProps, "data" | "minDomainValue" | "maxDomainValue">) => {
+    min: number;
+    max: number;
+};

package/dist/src/charts/BarChart/hooks/useSelection.d.ts

@@ -0,0 +1,2 @@
+import { BarChartProps } from '../types';
+export declare const useSelection: (node: HTMLElement | null, props: BarChartProps) => void;

package/dist/src/charts/BarChart/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../node_modules/@types/react';
+import { BarChartProps } from './types';
+export declare const BarChart: FC<BarChartProps>;

package/dist/src/charts/BarChart/marshaling.d.ts

@@ -0,0 +1,2 @@
+import { BarChartMarshalledGroup, BarChartMarshaling } from './types';
+export declare const marshaling: ({ data, yScale, xScale, barWidth, barPadding, colors, marginTop, }: BarChartMarshaling) => BarChartMarshalledGroup[][];

package/dist/src/charts/BarChart/resizeBarWidth/index.d.ts

@@ -0,0 +1,2 @@
+import { ResizeBarWidthProps } from './types';
+export declare const resizeBarWidth: ({ data, range, barWidth, barPadding, sectionPadding, }: ResizeBarWidthProps) => number;

package/dist/src/charts/BarChart/resizeBarWidth/types.d.ts

@@ -0,0 +1,5 @@
+import { BarChartProps } from '../types';
+export type ResizeBarWidthProps = {
+    range: number[];
+    barWidth: number;
+} & Pick<BarChartProps, 'data' | 'barPadding' | 'sectionPadding'>;

package/dist/src/charts/BarChart/styled.d.ts

@@ -0,0 +1,37 @@
+import { JSXElementConstructor } from '../../../node_modules/@types/react';
+export declare const barChartClassNames: {
+    barChartLinesGlobal: string;
+    barChartLine: string;
+    barChartAreasGlobal: string;
+    barChartArea: string;
+    barChartLabelContainer: string;
+    barChartLabelFlex: string;
+    barChartLabel: string;
+    barChartMouseRect: string;
+    barChartMouseContainer: string;
+    barChartTooltipFlex: string;
+    barChartMouseTooltip: string;
+    barChartTooltip: string;
+    barChartTooltipItem: string;
+    barChartTooltipColFlex: string;
+    barChartTooltipGroupName: string;
+    barChartColorBox: string;
+    barChartColorLine: string;
+    barChartTooltipName: string;
+    barChartTooltipValue: string;
+    barChartBarGlobal: string;
+    barChartYScaleGlobal: string;
+    barChartYAxis: string;
+    barChartXAxis: string;
+    barChartYAxisZeroTick: string;
+    barChartGridGlobal: string;
+    barChartGridLineX: string;
+    barChartGridLineXZero: string;
+    barChartGridLineYZero: string;
+    barChartGridLineY: string;
+    barChartSelection: string;
+};
+export declare const SvgWrapper: import('styled-components').StyledComponent<"div", any, {
+    selectable?: boolean;
+}, never>;
+export declare const TooltipStyles: JSXElementConstructor<any>;

package/dist/src/charts/BarChart/types.d.ts

@@ -0,0 +1,148 @@
+import { CSSProperties, PropsWithChildren, ReactNode } from '../../../node_modules/@types/react';
+import { Margin } from '../../common/types/margin';
+import * as d3 from "d3";
+export type BarChartData = {
+    groupName: string | number;
+    [key: string]: any;
+} | Record<string, {
+    [key: string]: number;
+}>;
+export type LegendItemsGroupedStackedBarChart = {
+    [key: string]: string;
+};
+export type BarChartColors = {
+    [key: string]: string;
+};
+export type BarChartLabelPosition = "top" | "center" | "bottom";
+export type BarChartLabelSetTooltipPosition = (position: {
+    tooltip: d3.Selection<HTMLDivElement, unknown, null, undefined>;
+    left: number;
+    top: number;
+    svgWidth: number;
+}) => void;
+export interface BarChartMarker {
+    label: string;
+    value: number;
+    color?: string;
+    lineColor?: string;
+    className?: string;
+    horizontal?: boolean;
+    line?: boolean;
+    align?: "center" | "left" | "right";
+}
+export interface BarChartProps extends PropsWithChildren {
+    className?: string;
+    style?: CSSProperties;
+    data: BarChartData[];
+    markers?: BarChartMarker[];
+    lineData?: BarChartLineData[];
+    colors: BarChartColors;
+    margin?: Margin;
+    barWidth?: number;
+    barPadding?: number;
+    setTooltipPosition?: BarChartLabelSetTooltipPosition | boolean;
+    sectionPadding?: number | undefined;
+    width?: number;
+    height?: number;
+    yAxisPadding?: number;
+    xAxisPadding?: number;
+    drawGridY?: boolean;
+    drawGridX?: boolean;
+    customYScale?: (yScale: (value: number) => number) => void;
+    customXScale?: (xScale: d3.ScaleBand<string>) => void;
+    customYAxisLeft?: (yAxisLeft: d3.Axis<d3.NumberValue>) => void;
+    customXAxisBottom?: (xAxisBottom: d3.Axis<string>, props: {
+        node: HTMLElement;
+        labels: string[];
+    }) => void;
+    customYAxis?: (yAxis: d3.Selection<SVGGElement, unknown, null, undefined>) => void;
+    customXAxis?: (xAxis: d3.Selection<SVGGElement, unknown, null, undefined>) => void;
+    customBars?: (args: {
+        bars: d3.Selection<Element | d3.EnterElement | Document | Window | SVGRectElement | null, BarChartMarshalledGroup, SVGGElement, BarChartMarshalledGroup[]> | d3.Transition<Element | d3.EnterElement | Document | Window | SVGPathElement | null, BarChartMarshalledGroup, SVGGElement, BarChartMarshalledGroup[]>;
+        yScale: (value: number) => number;
+        lines: null | {
+            linesSelection: d3.Selection<Element | d3.EnterElement | Document | Window | SVGPathElement | null, BarChartLineData, SVGGElement, unknown> | null;
+            areasSelection: d3.Selection<Element | d3.EnterElement | Document | Window | SVGPathElement | null, BarChartLineData, SVGGElement, unknown> | null;
+            area: d3.Area<[number, number]> | null;
+        };
+        lineData?: BarChartLineData[];
+        marshalledData: BarChartMarshalledGroup[][];
+    }) => void;
+    minValue?: number;
+    maxValue?: number;
+    minDomainValue?: number | undefined;
+    maxDomainValue?: number | undefined;
+    minValuesLine?: number;
+    dynamicTooltipEnable?: boolean;
+    hideTooltipGroupName?: boolean;
+    renderTooltip?: (group: BarChartMergedData, position?: {
+        tooltip: d3.Selection<HTMLDivElement, unknown, null, undefined>;
+        left: number;
+        top: number;
+        svgWidth: number;
+    }, barWidth?: number) => ReactNode;
+    labelPosition?: BarChartLabelPosition;
+    renderLabel?: (item: BarChartMarshalledGroup & {
+        barWidth: number;
+    }) => ReactNode;
+    tooltipY?: number | undefined;
+    tooltipBind?: boolean;
+    stackedLine?: boolean;
+    curve?: d3.CurveFactory;
+    formatTooltipName?: (name: number | string) => number | string | ReactNode;
+    formatTooltipValue?: (value: number, name?: string) => number | string | ReactNode;
+    tooltipYDomain?: ((data: {
+        data: BarChartMarshalledGroup[][];
+        lineData?: BarChartLineData[];
+        yScale: (value: number) => number;
+    }) => number[]) | null;
+    marshalledMap?: (data: BarChartMarshalledGroup[][]) => BarChartMarshalledGroup[][];
+    drawBars?: (prop: {
+        groups: d3.Selection<SVGGElement, BarChartMarshalledGroup[], SVGGElement, unknown>;
+        yScale: (value: number) => number;
+        marshalledData: BarChartMarshalledGroup[][];
+        barWidth: number;
+    }) => d3.Selection<Element | d3.EnterElement | Document | Window | SVGRectElement | null, BarChartMarshalledGroup, SVGGElement, BarChartMarshalledGroup[]> | d3.Transition<Element | d3.EnterElement | Document | Window | SVGPathElement | null, BarChartMarshalledGroup, SVGGElement, BarChartMarshalledGroup[]>;
+    customize?: (args: {
+        svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+        marshalledData: BarChartMarshalledGroup[][];
+        yScale: (value: number) => number;
+        xScale: d3.ScaleBand<string>;
+        lineData?: BarChartLineData[];
+    }) => void;
+    onLabelItem?: (data: BarChartMarshalledGroup[]) => BarChartMarshalledGroup[];
+    isBarTooltip?: boolean;
+    xScaleItemWidth?: number;
+    tooltipRoot?: Element;
+    tooltipClassName?: string;
+    selectable?: boolean;
+    onSelect?: (value: [number, number]) => void;
+    onBarClick?: (group: BarChartMarshalledGroup) => void;
+    onBarHover?: (group?: BarChartMarshalledGroup) => void;
+}
+export type BarChartMergedData = (BarChartMarshalledGroup & BarChartLineData & {
+    groupName: string;
+})[];
+export type BarChartMarshaling = {
+    yScale: (value: number) => number;
+    xScale: d3.ScaleBand<string>;
+    marginTop?: number;
+} & Pick<BarChartProps, "barPadding" | "barWidth" | "data" | "colors">;
+export type BarChartMarshalledGroup = {
+    x: number;
+    y: number;
+    height: number;
+    color: string;
+    value: number;
+    groupName?: string;
+    name: string;
+    stackIndex: number;
+    groupIndex: number;
+};
+export type BarChartLineData = {
+    lineType: "line" | "area";
+    name: string;
+    values: (number | null)[];
+    stroke?: string;
+    fill?: string;
+};

package/dist/src/charts/BubbleChart/bubbleChartDefaultProps.d.ts

@@ -0,0 +1,14 @@
+export declare const bubbleChartDefaultProps: {
+    height: number;
+    minSize: number;
+    maxSize: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    yAxisPadding: number;
+    xAxisPadding: number;
+    yScaleLabelPadding: number;
+};

package/dist/src/charts/BubbleChart/draw.d.ts

@@ -0,0 +1,2 @@
+import { BubbleChartProps } from './types';
+export declare const draw: (node: HTMLElement | null, props: BubbleChartProps) => void;

package/dist/src/charts/BubbleChart/drawGrid/index.d.ts

@@ -0,0 +1,2 @@
+import { DrawGridProps } from './types';
+export declare const drawGrid: ({ svg, yScale, xScale, yTicksCount, drawGridX, drawGridY, }: DrawGridProps) => void;

package/dist/src/charts/BubbleChart/drawGrid/types.d.ts

@@ -0,0 +1,8 @@
+import { BubbleChartProps } from '../types';
+import * as d3 from 'd3';
+export type DrawGridProps = {
+    svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+    yScale: d3.ScaleLinear<number, number>;
+    xScale: d3.ScaleLinear<number, number>;
+    yTicksCount: number;
+} & Pick<BubbleChartProps, 'drawGridX' | 'drawGridY'>;

package/dist/src/charts/BubbleChart/drawTooltip/index.d.ts

@@ -0,0 +1,2 @@
+import { DrawTooltipProps } from './types';
+export declare const drawTooltip: ({ bubbles, tooltipRoot, tooltipClassName, renderTooltip, }: DrawTooltipProps) => void;

package/dist/src/charts/BubbleChart/drawTooltip/styled.d.ts

@@ -0,0 +1 @@
+export declare const Tooltip: import('styled-components').StyledComponent<"div", any, {}, never>;

package/dist/src/charts/BubbleChart/drawTooltip/types.d.ts

@@ -0,0 +1,4 @@
+import { BubbleChartCustomizeProps, BubbleChartProps } from '../types';
+export type DrawTooltipProps = {
+    bubbles: BubbleChartCustomizeProps['bubbles'];
+} & Pick<BubbleChartProps, 'tooltipRoot' | 'tooltipClassName' | 'renderTooltip'>;

package/dist/src/charts/BubbleChart/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../node_modules/@types/react';
+import { BubbleChartProps } from './types';
+export declare const BubbleChart: FC<BubbleChartProps>;

package/dist/src/charts/BubbleChart/styled.d.ts

@@ -0,0 +1,17 @@
+import { JSXElementConstructor } from '../../../node_modules/@types/react';
+export declare const bubbleChartClassNames: {
+    bubbleChartYAxis: string;
+    bubbleChartYAxisZeroTick: string;
+    bubbleChartXAxis: string;
+    bubbleChartGridGlobal: string;
+    bubbleChartGridLineX: string;
+    bubbleChartGridLineY: string;
+    bubbleChartCircle: string;
+    bubbleChartYScaleLabel: string;
+    bubbleChartTooltip: string;
+    bubbleChartTooltipContainer: string;
+    bubbleChartTooltipFlex: string;
+    bubbleChartTip: string;
+};
+export declare const SvgWrapper: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const TooltipStyles: JSXElementConstructor<any>;

package/dist/src/charts/BubbleChart/types.d.ts

@@ -0,0 +1,55 @@
+import { CSSProperties, PropsWithChildren } from '../../../node_modules/@types/react';
+import { Margin } from '../../common/types/margin';
+import * as d3 from "d3";
+export type BubbleChartData = {
+    xValue: number;
+    yValue: number;
+    sizeValue: number;
+    color?: string;
+    stroke?: string;
+    style?: string;
+    name?: string;
+};
+export type RenderTooltipProps = {
+    data: BubbleChartData;
+    circle: SVGCircleElement;
+    tooltip: d3.Selection<HTMLDivElement, unknown, d3.BaseType, any>;
+};
+export type BubbleChartCustomizeProps = {
+    svg: d3.Selection<SVGSVGElement, unknown, null, undefined>;
+    yScale: d3.ScaleLinear<number, number>;
+    xScale: d3.ScaleLinear<number, number>;
+    sizeScale: d3.ScaleLinear<number, number>;
+    bubbles: d3.Selection<SVGCircleElement, BubbleChartData, SVGGElement, unknown>;
+};
+export interface BubbleChartProps extends PropsWithChildren {
+    className?: string;
+    style?: CSSProperties;
+    width?: number;
+    height?: number;
+    margin?: Margin;
+    data: BubbleChartData[];
+    xAxisPadding?: number;
+    yAxisPadding?: number;
+    customYScale?: (yScale: (value: number) => number) => void;
+    customYAxisLeft?: (yAxisLeft: d3.Axis<d3.NumberValue>) => void;
+    customYAxis?: (yAxis: d3.Selection<SVGGElement, unknown, null, undefined>) => void;
+    customXScale?: (xScale: d3.ScaleLinear<number, number, number>) => void;
+    customXAxis?: (xAxis: d3.Selection<SVGGElement, unknown, null, undefined>) => void;
+    minSize?: number;
+    maxSize?: number;
+    minYValue?: number;
+    maxYValue?: number;
+    drawGridY?: boolean;
+    drawGridX?: boolean;
+    scaleLog?: boolean;
+    xScaleItemWidth?: number;
+    bubbleStyle?: string;
+    customize?: (props: BubbleChartCustomizeProps) => void;
+    yScaleLabel?: string;
+    yScaleLabelPadding?: number;
+    enableTooltip?: boolean;
+    tooltipRoot?: Element;
+    tooltipClassName?: string;
+    renderTooltip?: (props: RenderTooltipProps) => void;
+}

package/dist/src/charts/BubbleChart/unmount.d.ts

@@ -0,0 +1 @@
+export declare const unmount: (tooltipRoot?: Element) => void;

package/dist/src/charts/CalendarChart/draw.d.ts

@@ -0,0 +1,2 @@
+import { CalendarChartProps } from './types';
+export declare const draw: (node: HTMLElement | null, props: CalendarChartProps) => void;

package/dist/src/charts/CalendarChart/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../node_modules/@types/react';
+import { CalendarChartProps } from './types';
+export declare const CalendarChart: FC<CalendarChartProps>;

package/dist/src/charts/CalendarChart/styled.d.ts

@@ -0,0 +1,18 @@
+export declare const calendarChartClassNames: {
+    legendContainer: string;
+    legendTitle: string;
+    legendTick: string;
+    legendTickLine: string;
+    legendTickText: string;
+    calendarChart: string;
+    calendarYear: string;
+    calendarAxis: string;
+    calendarBody: string;
+    calendarHeader: string;
+    calendarYearTitle: string;
+    calendarWeekDay: string;
+    calendarMonth: string;
+    calendarDays: string;
+    calendarDay: string;
+};
+export declare const SvgWrapper: import('styled-components').StyledComponent<"div", any, {}, never>;

package/dist/src/charts/CalendarChart/types.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties, PropsWithChildren } from '../../../node_modules/@types/react';
+import { Interpolator } from '../../common/types/interpolator';
+import { GetLegendProps } from '../../helpers/getLegend/types';
+export type OnEachDay = (data: CalendarChartData, element: HTMLDivElement, color: string) => void;
+export interface CalendarChartProps extends PropsWithChildren {
+    className?: string;
+    style?: CSSProperties;
+    data: CalendarChartData[];
+    startSunday?: boolean;
+    weekdays?: string | string[];
+    cellOffset?: number;
+    cellSize?: number;
+    interpolator?: Interpolator;
+    monthSpacing?: number;
+    onEachDay?: OnEachDay;
+    colorRange?: [string, string];
+    legendProps?: GetLegendProps;
+}
+export type CalendarChartData = {
+    date: Date;
+    value: number;
+};

package/dist/src/charts/HorizontalBarChart/Bar/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../../node_modules/@types/react';
+import { BarProps } from './types';
+export declare const Bar: FC<BarProps>;

package/dist/src/charts/HorizontalBarChart/Bar/styled.d.ts

@@ -0,0 +1 @@
+export declare const BarStyled: import('styled-components').StyledComponent<"div", any, {}, never>;

package/dist/src/charts/HorizontalBarChart/Bar/types.d.ts

@@ -0,0 +1,11 @@
+import { HorizontalBarChartProps, HorizontalBarChartMarshalingData } from '../types';
+import { UseTooltip } from '../hooks/useTooltip/types';
+export type BarProps = Pick<HorizontalBarChartProps, 'withTooltip' | 'formatNativeTitle' | 'tooltipBind'> & {
+    bar: HorizontalBarChartMarshalingData;
+    mouseMove: UseTooltip[0];
+    mouseLeave: UseTooltip[1];
+    isFirstChild: boolean;
+    isLastChild: boolean;
+    isOnlyChild: boolean;
+    pointerEventsNone?: boolean;
+};

package/dist/src/charts/HorizontalBarChart/Tooltip/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../../node_modules/@types/react';
+import { TooltipProps } from './types';
+export declare const Tooltip: FC<TooltipProps>;

package/dist/src/charts/HorizontalBarChart/Tooltip/types.d.ts

@@ -0,0 +1,5 @@
+import { HorizontalBarChartMarshalingData, HorizontalBarChartProps } from '../types';
+export type TooltipProps = {
+    bars: HorizontalBarChartMarshalingData[];
+    className?: string;
+} & Pick<HorizontalBarChartProps, 'renderTooltip' | 'style'>;

package/dist/src/charts/HorizontalBarChart/XScale/hooks/useScale.d.ts

@@ -0,0 +1,2 @@
+import { HorizontalBarChartProps, HorizontalBarChartScaleItem } from '../../types';
+export declare const useScale: ({ maxValue, scaleTicks, scaleDomain, }: Pick<HorizontalBarChartProps, "maxValue" | "scaleTicks" | "scaleDomain">) => HorizontalBarChartScaleItem[];

package/dist/src/charts/HorizontalBarChart/XScale/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../../node_modules/@types/react';
+import { HorizontalBarChartProps } from '../types';
+export declare const XScale: FC<Pick<HorizontalBarChartProps, "maxValue" | "scaleTicks" | "renderTicks" | "scaleDomain">>;

package/dist/src/charts/HorizontalBarChart/XScale/styled.d.ts

@@ -0,0 +1,3 @@
+export declare const TickTd: import('styled-components').StyledComponent<"td", any, {}, never>;
+export declare const Ticks: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const Tick: import('styled-components').StyledComponent<"div", any, {}, never>;

package/dist/src/charts/HorizontalBarChart/hooks/useMarshaling.d.ts

@@ -0,0 +1,5 @@
+import { HorizontalBarChartProps, HorizontalBarChartMarshalingData } from '../types';
+export declare const useMarshaling: ({ data, fullExtent, maxValue, labels, }: Pick<HorizontalBarChartProps, "data" | "fullExtent" | "maxValue" | "labels">) => {
+    fullMax: number;
+    data: HorizontalBarChartMarshalingData[][];
+};

package/dist/src/charts/HorizontalBarChart/hooks/useStackWrapper.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, ReactNode } from '../../../../node_modules/@types/react';
+import { UseTooltip } from './useTooltip/types';
+import { HorizontalBarChartMarshalingData, HorizontalBarChartProps } from '../types';
+export declare const useStackWrapper: (stackedTooltip?: boolean) => (({ item, mouseMove, mouseLeave, tooltipBind, ...props }: {
+    style?: CSSProperties;
+    item: HorizontalBarChartMarshalingData[];
+    tooltipBind: HorizontalBarChartProps["tooltipBind"];
+    mouseMove: UseTooltip[0];
+    mouseLeave: UseTooltip[1];
+}) => import("react/jsx-runtime").JSX.Element) | (({ children }: {
+    children?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element);

package/dist/src/charts/HorizontalBarChart/hooks/useTooltip/index.d.ts

@@ -0,0 +1,3 @@
+import { HorizontalBarChartProps } from '../../types';
+import { UseTooltip } from './types';
+export declare const useTooltip: ({ renderTooltip, tooltipBind, tooltipStyle, tooltipRoot, tooltipClassName, hideTooltip, }: Pick<HorizontalBarChartProps, "renderTooltip" | "tooltipBind" | "tooltipStyle" | "tooltipRoot" | "tooltipClassName" | "hideTooltip">) => UseTooltip;

package/dist/src/charts/HorizontalBarChart/hooks/useTooltip/types.d.ts

@@ -0,0 +1,6 @@
+import { MouseEvent } from '../../../../../node_modules/@types/react';
+import { HorizontalBarChartMarshalingData } from '../../types';
+export type UseTooltip = [
+    (event: MouseEvent, bars: HorizontalBarChartMarshalingData[]) => void,
+    () => void
+];

package/dist/src/charts/HorizontalBarChart/index.d.ts

@@ -0,0 +1,3 @@
+import { FC } from '../../../node_modules/@types/react';
+import { HorizontalBarChartProps } from './types';
+export declare const HorizontalBarChart: FC<HorizontalBarChartProps>;

package/dist/src/charts/HorizontalBarChart/styled.d.ts

@@ -0,0 +1,30 @@
+export declare const horizontalBarChartClassNames: {
+    horizontalBarChartButtonTd: string;
+    horizontalBarChartLabelTd: string;
+    horizontalBarChartLabelCell: string;
+    horizontalBarChartBarTd: string;
+    horizontalBarChartBarFlex: string;
+    horizontalBarChartBar: string;
+    horizontalBarChartBarFirst: string;
+    horizontalBarChartBarLast: string;
+    horizontalBarChartBarOnly: string;
+    horizontalBarChartTooltipFlex: string;
+    horizontalBarChartStackWrapper: string;
+    horizontalBarChartTooltipContainer: string;
+    horizontalBarChartStackSumContainer: string;
+    horizontalBarChartStackSum: string;
+    horizontalBarChartXScaleTd: string;
+    horizontalBarChartXScaleTicks: string;
+    horizontalBarChartXScaleTick: string;
+    horizontalBarChartTooltipItem: string;
+    horizontalBarChartTooltipName: string;
+    horizontalBarChartTooltipValue: string;
+};
+export declare const Table: import('styled-components').StyledComponent<"table", any, {}, never>;
+export declare const LabelCell: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const BarFlex: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const BarsTd: import('styled-components').StyledComponent<"td", any, {}, never>;
+export declare const TooltipFlex: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const StackSumContainer: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const StackSum: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const StackWrapper: import('styled-components').StyledComponent<"div", any, {}, never>;