@gravity-ui/charts 1.38.6 → 1.39.0

package/dist/cjs/components/ChartInner/utils/normalized-original-data.d.ts

@@ -0,0 +1,33 @@
+import type { ChartData } from '../../../types';
+export declare function getNormalizedXAxis(props: {
+    xAxis: ChartData['xAxis'];
+}): {
+    categories: string[] | undefined;
+    rangeSlider?: import("../../../types").ChartAxisRangeSlider;
+    crosshair?: import("../../../types").AxisCrosshair;
+    timestamps?: number[];
+    type?: import("../../../types").ChartAxisType;
+    labels?: import("../../../types").ChartAxisLabels;
+    lineColor?: string;
+    title?: import("../../../types").ChartAxisTitle;
+    min?: number;
+    max?: number;
+    grid?: {
+        enabled?: boolean;
+    };
+    ticks?: {
+        pixelInterval?: number;
+        interval?: number | string;
+    };
+    maxPadding?: number;
+    plotLines?: import("../../../types").AxisPlotLine[];
+    plotBands?: import("../../../types").AxisPlotBand[];
+    tickMarks?: import("../../../types").ChartAxisTickMarks;
+    visible?: boolean;
+    order?: "sortAsc" | "sortDesc" | "reverse";
+    startOnTick?: boolean;
+    endOnTick?: boolean;
+};
+export declare function getNormalizedYAxis(props: {
+    yAxis: ChartData['yAxis'];
+}): import("../../../types").ChartYAxis[] | undefined;

package/dist/cjs/components/ChartInner/utils/normalized-original-data.js

@@ -0,0 +1,21 @@
+import { getAxisCategories } from '../../../utils';
+export function getNormalizedXAxis(props) {
+    var _a;
+    let categories = (_a = props.xAxis) === null || _a === void 0 ? void 0 : _a.categories;
+    if (props.xAxis && props.xAxis.categories) {
+        categories = getAxisCategories(props.xAxis);
+    }
+    return Object.assign(Object.assign({}, props.xAxis), { categories });
+}
+export function getNormalizedYAxis(props) {
+    if (Array.isArray(props.yAxis) && props.yAxis.some((axis) => axis.categories)) {
+        return props.yAxis.map((axis) => {
+            let categories = axis.categories;
+            if (axis.categories) {
+                categories = getAxisCategories(axis);
+            }
+            return Object.assign(Object.assign({}, axis), { categories });
+        });
+    }
+    return props.yAxis;
+}

package/dist/cjs/{hooks/useChartOptions → components/ChartInner/utils}/title.d.ts

@@ -1,5 +1,5 @@
-import type { ChartData } from '../../types';
-import type { PreparedTitle } from './types';
+import type { PreparedTitle } from '../../../hooks/types';
+import type { ChartData } from '../../../types';
 export declare const getPreparedTitle: ({ title, }: {
     title: ChartData["title"];
 }) => PreparedTitle | undefined;

package/dist/{esm/hooks/useChartOptions → cjs/components/ChartInner/utils}/title.js

@@ -1,5 +1,5 @@
 import get from 'lodash/get';
-import { getHorizontalSvgTextHeight } from '../../utils';
+import { getHorizontalSvgTextHeight } from '../../../utils';
 const DEFAULT_TITLE_FONT_SIZE = '15px';
 const TITLE_PADDINGS = 8 * 2;
 export const getPreparedTitle = ({ title, }) => {

package/dist/cjs/components/ChartInner/utils/tooltip.d.ts

@@ -0,0 +1,8 @@
+import type { PreparedTooltip } from '../../../hooks/types';
+import type { ChartData, ChartSeries, ChartXAxis, ChartYAxis } from '../../../types';
+export declare const getPreparedTooltip: (args: {
+    tooltip: ChartData["tooltip"];
+    seriesData: ChartSeries[];
+    yAxes?: ChartYAxis[];
+    xAxis?: ChartXAxis;
+}) => PreparedTooltip;

package/dist/cjs/components/ChartInner/utils/tooltip.js

@@ -0,0 +1,7 @@
+import get from 'lodash/get';
+import { getDefaultTooltipHeaderFormat } from '../../../utils/chart/tooltip';
+export const getPreparedTooltip = (args) => {
+    var _a, _b;
+    const { tooltip, seriesData, yAxes, xAxis } = args;
+    return Object.assign(Object.assign({}, tooltip), { enabled: get(tooltip, 'enabled', true), throttle: (_a = tooltip === null || tooltip === void 0 ? void 0 : tooltip.throttle) !== null && _a !== void 0 ? _a : 0, headerFormat: (_b = tooltip === null || tooltip === void 0 ? void 0 : tooltip.headerFormat) !== null && _b !== void 0 ? _b : getDefaultTooltipHeaderFormat({ seriesData, yAxes, xAxis }) });
+};

package/dist/cjs/{hooks/useChartOptions → components/ChartInner/utils}/zoom.d.ts

@@ -1,6 +1,6 @@
-import type { ZoomType } from '../../constants';
-import type { ChartSeries, ChartZoom } from '../../types';
-import type { PreparedZoom } from './types';
+import type { ZoomType } from '../../../constants';
+import type { PreparedZoom } from '../../../hooks/types';
+import type { ChartSeries, ChartZoom } from '../../../types';
 export declare function getZoomType(args: {
     seriesData: ChartSeries[];
     zoomType?: ZoomType;

package/dist/{esm/hooks/useChartOptions → cjs/components/ChartInner/utils}/zoom.js

@@ -1,6 +1,6 @@
 import intersection from 'lodash/intersection';
 import merge from 'lodash/merge';
-import { SERIES_TYPE, ZOOM_TYPE, brushDefaults } from '../../constants';
+import { SERIES_TYPE, ZOOM_TYPE, brushDefaults } from '../../../constants';
 function mapSeriesTypeToZoomType(seriesType) {
     switch (seriesType) {
         case SERIES_TYPE.Area: {

package/dist/cjs/components/Legend/index.d.ts

@@ -5,7 +5,7 @@ import './styles.css';
 type Props = {
     chartSeries: PreparedSeries[];
     legend: PreparedLegend;
-    items: LegendItem[][];
+    items: LegendItem[][] | undefined;
     config: LegendConfig;
     htmlLayout: HTMLElement | null;
     onItemClick: OnLegendItemClick;

package/dist/cjs/components/Legend/index.js

@@ -130,7 +130,7 @@ function renderLegendSymbol(args) {
     });
 }
 export const Legend = (props) => {
-    const { chartSeries, legend, items, config, htmlLayout, onItemClick, onUpdate } = props;
+    const { chartSeries, legend, items = [], config, htmlLayout, onItemClick, onUpdate } = props;
     const ref = React.useRef(null);
     const [pageIndex, setPageIndex] = React.useState(0);
     React.useEffect(() => {

package/dist/cjs/hooks/index.d.ts

@@ -4,10 +4,7 @@ export * from './useAxisScales';
 export * from './useAxisScales/types';
 export * from './useBrush';
 export * from './useBrush/types';
-export * from './useChartDimensions';
-export * from './useChartOptions/types';
 export * from './useCrosshair';
-export * from './useNormalizedOriginalData';
 export * from './usePrevious';
 export * from './useRangeSlider';
 export * from './useRangeSlider/types';
@@ -17,6 +14,6 @@ export * from './useShapes';
 export * from './useSplit';
 export * from './useSplit/types';
 export * from './useTooltip';
-export * from './useYAxisLabelWidth';
 export * from './useZoom';
 export * from './useZoom/types';
+export * from './types';

package/dist/cjs/hooks/index.js

@@ -4,10 +4,7 @@ export * from './useAxisScales';
 export * from './useAxisScales/types';
 export * from './useBrush';
 export * from './useBrush/types';
-export * from './useChartDimensions';
-export * from './useChartOptions/types';
 export * from './useCrosshair';
-export * from './useNormalizedOriginalData';
 export * from './usePrevious';
 export * from './useRangeSlider';
 export * from './useRangeSlider/types';
@@ -17,6 +14,6 @@ export * from './useShapes';
 export * from './useSplit';
 export * from './useSplit/types';
 export * from './useTooltip';
-export * from './useYAxisLabelWidth';
 export * from './useZoom';
 export * from './useZoom/types';
+export * from './types';

package/dist/cjs/hooks/{useChartOptions/types.d.ts → types.d.ts}

@@ -1,4 +1,4 @@
-import type { ChartBrush, ChartData, ChartMargin, ChartZoom, DeepRequired } from '../../types';
+import type { ChartBrush, ChartData, ChartMargin, ChartZoom, DeepRequired } from '../types';
 export type PreparedZoom = DeepRequired<Omit<ChartZoom, 'enabled' | 'brush'>> & DeepRequired<{
     brush: ChartBrush;
 }>;

package/dist/cjs/hooks/useAxis/index.d.ts

@@ -1,6 +1,5 @@
-import React from 'react';
 import type { ChartXAxis, ChartYAxis, LegendConfig } from '../../types';
-import type { PreparedChart } from '../useChartOptions/types';
+import type { PreparedChart } from '../types';
 import type { PreparedLegend, PreparedSeries, PreparedSeriesOptions } from '../useSeries/types';
 import type { AxesState } from './types';
 interface UseAxesProps {
@@ -15,9 +14,45 @@ interface UseAxesProps {
     xAxis?: ChartXAxis;
     yAxis?: ChartYAxis[];
 }
-export declare function useAxis(props: UseAxesProps): {
-    setAxes: React.Dispatch<React.SetStateAction<AxesState>>;
+export declare function getAxes(props: UseAxesProps): Promise<{
     xAxis: import("./types").PreparedXAxis | null;
-    yAxis: import("./types").PreparedYAxis[];
-};
+    yAxis: (Omit<import("../../types").ChartAxis, "type" | "labels" | "plotLines" | "plotBands"> & {
+        type: import("../../types").ChartAxisType;
+        labels: Omit<import("../../types").ChartAxisLabels, "style" | "enabled" | "padding" | "autoRotation"> & Required<Pick<import("../../types").ChartAxisLabels, "margin" | "enabled" | "html" | "rotation" | "padding">> & {
+            style: import("../../types").BaseTextStyle;
+            rotation: number;
+            height: number;
+            width: number;
+            lineHeight: number;
+            maxWidth: number;
+        };
+        title: {
+            height: number;
+            width: number;
+            text: string;
+            margin: number;
+            style: import("../../types").BaseTextStyle;
+            align: import("../../types").ChartAxisTitleAlignment;
+            maxRowCount: number;
+            rotation: number;
+            maxWidth: number;
+            html: boolean;
+        };
+        min?: number;
+        grid: {
+            enabled: boolean;
+        };
+        maxPadding: number;
+        ticks: {
+            pixelInterval?: number;
+        };
+        tickMarks: import("./types").PreparedAxisTickMarks;
+        position: "left" | "right" | "top" | "bottom";
+        plotIndex: number;
+        plotLines: import("./types").PreparedAxisPlotLine[];
+        plotBands: import("./types").PreparedAxisPlotBand[];
+        crosshair: Required<import("../../types").AxisCrosshair>;
+    })[];
+}>;
+export declare function useAxis(props: UseAxesProps): AxesState;
 export {};

package/dist/cjs/hooks/useAxis/index.js

@@ -1,8 +1,52 @@
 import React from 'react';
 import isEqual from 'lodash/isEqual';
-import { getWidthOccupiedByYAxis } from '../useChartDimensions/utils';
+import { getWidthOccupiedByYAxis } from '../../utils';
 import { getPreparedXAxis } from './x-axis';
 import { getPreparedYAxis } from './y-axis';
+export async function getAxes(props) {
+    var _a, _b;
+    const { boundsHeight, height, preparedChart, legendConfig, preparedLegend, preparedSeries, width, xAxis, yAxis, } = props;
+    const seriesData = preparedSeries.filter((s) => s.visible);
+    const estimatedPreparedYAxis = await getPreparedYAxis({
+        height,
+        boundsHeight: height,
+        width,
+        seriesData,
+        yAxis,
+    });
+    const axesWidth = getWidthOccupiedByYAxis({ preparedAxis: estimatedPreparedYAxis });
+    const estimatedBoundsWidth = width - (axesWidth + preparedChart.margin.left + preparedChart.margin.right);
+    const preparedXAxis = await getPreparedXAxis({
+        xAxis,
+        width,
+        boundsWidth: estimatedBoundsWidth,
+        seriesData,
+    });
+    let estimatedBoundsHeight = boundsHeight !== null && boundsHeight !== void 0 ? boundsHeight : height;
+    if (preparedXAxis && typeof boundsHeight !== 'number') {
+        estimatedBoundsHeight =
+            height -
+                (preparedXAxis.title.height +
+                    preparedXAxis.title.margin +
+                    preparedXAxis.labels.margin +
+                    preparedXAxis.labels.height +
+                    (preparedXAxis.rangeSlider.enabled
+                        ? preparedXAxis.rangeSlider.height + preparedXAxis.rangeSlider.margin
+                        : 0) +
+                    ((_a = legendConfig === null || legendConfig === void 0 ? void 0 : legendConfig.height) !== null && _a !== void 0 ? _a : 0) +
+                    ((_b = preparedLegend === null || preparedLegend === void 0 ? void 0 : preparedLegend.margin) !== null && _b !== void 0 ? _b : 0) +
+                    preparedChart.margin.top +
+                    preparedChart.margin.bottom);
+    }
+    const preparedYAxis = await getPreparedYAxis({
+        height,
+        boundsHeight: estimatedBoundsHeight,
+        width,
+        seriesData,
+        yAxis,
+    });
+    return { xAxis: preparedXAxis, yAxis: preparedYAxis };
+}
 export function useAxis(props) {
     const { boundsHeight, height, preparedChart, legendConfig, preparedLegend, preparedSeries, preparedSeriesOptions, width, xAxis, yAxis, } = props;
     const [axesState, setAxes] = React.useState({ xAxis: null, yAxis: [] });
@@ -16,48 +60,19 @@ export function useAxis(props) {
             return;
         }
         (async function () {
-            var _a, _b;
             const currentRun = axesStateRunRef.current;
-            const seriesData = preparedSeries.filter((s) => s.visible);
-            const estimatedPreparedYAxis = await getPreparedYAxis({
+            const newStateValue = await getAxes({
+                boundsHeight,
                 height,
-                boundsHeight: height,
+                preparedChart,
+                legendConfig,
+                preparedLegend,
+                preparedSeries,
+                preparedSeriesOptions,
                 width,
-                seriesData,
-                yAxis,
-            });
-            const axesWidth = getWidthOccupiedByYAxis({ preparedAxis: estimatedPreparedYAxis });
-            const estimatedBoundsWidth = width - (axesWidth + preparedChart.margin.left + preparedChart.margin.right);
-            const preparedXAxis = await getPreparedXAxis({
                 xAxis,
-                width,
-                boundsWidth: estimatedBoundsWidth,
-                seriesData,
-            });
-            let estimatedBoundsHeight = boundsHeight !== null && boundsHeight !== void 0 ? boundsHeight : height;
-            if (preparedXAxis && typeof boundsHeight !== 'number') {
-                estimatedBoundsHeight =
-                    height -
-                        (preparedXAxis.title.height +
-                            preparedXAxis.title.margin +
-                            preparedXAxis.labels.margin +
-                            preparedXAxis.labels.height +
-                            (preparedXAxis.rangeSlider.enabled
-                                ? preparedXAxis.rangeSlider.height + preparedXAxis.rangeSlider.margin
-                                : 0) +
-                            ((_a = legendConfig === null || legendConfig === void 0 ? void 0 : legendConfig.height) !== null && _a !== void 0 ? _a : 0) +
-                            ((_b = preparedLegend === null || preparedLegend === void 0 ? void 0 : preparedLegend.margin) !== null && _b !== void 0 ? _b : 0) +
-                            preparedChart.margin.top +
-                            preparedChart.margin.bottom);
-            }
-            const preparedYAxis = await getPreparedYAxis({
-                height,
-                boundsHeight: estimatedBoundsHeight,
-                width,
-                seriesData,
                 yAxis,
             });
-            const newStateValue = { xAxis: preparedXAxis, yAxis: preparedYAxis };
             if (axesStateRunRef.current === currentRun) {
                 if (!isEqual(prevAxesStateValue.current, newStateValue)) {
                     setAxes(newStateValue);
@@ -69,7 +84,7 @@ export function useAxis(props) {
     }, [
         boundsHeight,
         height,
-        preparedChart.margin,
+        preparedChart,
         legendConfig,
         preparedLegend,
         preparedSeries,
@@ -81,10 +96,10 @@ export function useAxis(props) {
     const isAxesReady = axesStateReady.current;
     const result = React.useMemo(() => {
         if (isAxesReady) {
-            return Object.assign(Object.assign({}, axesState), { setAxes });
+            return axesState;
         }
         prevAxesStateValue.current = { xAxis: null, yAxis: [] };
-        return Object.assign(Object.assign({}, prevAxesStateValue.current), { setAxes });
+        return prevAxesStateValue.current;
     }, [isAxesReady, axesState]);
     return result;
 }

package/dist/cjs/hooks/useAxis/types.d.ts

@@ -1,4 +1,3 @@
-import type React from 'react';
 import type { DashStyle } from '../../constants';
 import type { AxisCrosshair, AxisPlotBand, BaseTextStyle, ChartAxis, ChartAxisLabels, ChartAxisRangeSlider, ChartAxisTitleAlignment, ChartAxisType, DeepRequired, MeaningfulAny, PlotLayerPlacement } from '../../types';
 type PreparedAxisLabels = Omit<ChartAxisLabels, 'enabled' | 'padding' | 'style' | 'autoRotation'> & Required<Pick<ChartAxisLabels, 'enabled' | 'padding' | 'margin' | 'rotation' | 'html'>> & {
@@ -80,5 +79,4 @@ export type AxesState = {
     xAxis: PreparedXAxis | null;
     yAxis: PreparedYAxis[];
 };
-export type SetAxes = React.Dispatch<React.SetStateAction<AxesState>>;
 export {};

package/dist/cjs/hooks/useAxis/y-axis.js

@@ -49,9 +49,7 @@ export const getPreparedYAxis = ({ height, boundsHeight, width, seriesData, yAxi
     if (!hasAxisRelatedSeries) {
         return Promise.resolve([]);
     }
-    return Promise.all(
-    // eslint-disable-next-line complexity
-    axisItems.map(async (axisItem, axisIndex) => {
+    return Promise.all(axisItems.map(async (axisItem, axisIndex) => {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         const plotIndex = get(axisItem, 'plotIndex', 0);
         const firstPlotAxis = !axisByPlot[plotIndex];

package/dist/cjs/hooks/useAxisScales/index.d.ts

@@ -17,6 +17,10 @@ type ReturnValue = {
     xScale?: ChartScale;
     yScale?: (ChartScale | undefined)[];
 };
+export declare const createScales: (args: Args) => {
+    xScale: import("d3-scale").ScaleLinear<number, number, never> | import("d3-scale").ScaleBand<string> | import("d3-scale").ScaleTime<number, number, never> | undefined;
+    yScale: (ChartScale | undefined)[];
+};
 /**
  * Uses to create scales for axis related series
  */

package/dist/cjs/hooks/useAxisScales/index.js

@@ -7,7 +7,7 @@ import { createXScale } from './x-scale';
 import { createYScale } from './y-scale';
 export { createXScale } from './x-scale';
 export { createYScale } from './y-scale';
-const createScales = (args) => {
+export const createScales = (args) => {
     const { boundsWidth, boundsHeight, isRangeSlider, rangeSliderState, series, split, xAxis, yAxis, zoomState, } = args;
     // For range slider: always use all series regardless of visibility so the slider domain
     // stays stable when the user hides/shows series via the legend.

package/dist/cjs/hooks/useAxisScales/x-scale.js

@@ -34,7 +34,6 @@ function getXScaleRange({ boundsWidth, hasZoomX }) {
     const range = hasZoomX ? xRangeZoom : xRange;
     return range;
 }
-// eslint-disable-next-line complexity
 export function createXScale(args) {
     const { axis, boundsWidth, series, rangeSliderState, zoomStateX } = args;
     const effectiveX = getEffectiveXRange(zoomStateX, rangeSliderState);

package/dist/cjs/hooks/useAxisScales/y-scale.js

@@ -117,7 +117,6 @@ function getDomainMaxAlignedToEndTick(args) {
     }
     return dNewMax;
 }
-// eslint-disable-next-line complexity
 export function createYScale(args) {
     const { axis, boundsHeight, series, primaryAxis, primaryTicksCount, zoomStateY } = args;
     const [yMinPropsOrState, yMaxPropsOrState] = getMinMaxPropsOrState({

package/dist/cjs/hooks/useCrosshair/index.d.ts

@@ -7,7 +7,7 @@ type Props = {
     height: number;
     xScale?: ChartScale;
     yScale?: (ChartScale | undefined)[];
-    split: PreparedSplit;
+    split: PreparedSplit | undefined;
     plotElement: SVGGElement | null;
     dispatcher: Dispatch<object>;
     boundsOffsetLeft: number;

package/dist/cjs/hooks/useRangeSlider/types.d.ts

@@ -1,8 +1,8 @@
 import type { ChartXAxis, ChartYAxis, LegendConfig } from '../../types';
+import type { PreparedChart } from '../types';
 import type { PreparedRangeSlider, PreparedXAxis, PreparedYAxis } from '../useAxis/types';
 import type { ChartScale } from '../useAxisScales/types';
 import type { BrushSelection, UseBrushProps } from '../useBrush/types';
-import type { PreparedChart } from '../useChartOptions/types';
 import type { PreparedLegend, PreparedSeries, PreparedSeriesOptions } from '../useSeries/types';
 export type RangeSliderState = {
     max: number;

package/dist/cjs/hooks/useRangeSlider/utils.d.ts

@@ -1,7 +1,7 @@
+import type { PreparedChart } from '../types';
 import type { PreparedRangeSlider } from '../useAxis/types';
 import type { ChartScale } from '../useAxisScales/types';
 import type { BrushSelection } from '../useBrush/types';
-import type { PreparedChart } from '../useChartOptions/types';
 import type { PreparedLegend } from '../useSeries/types';
 import type { RangeSliderState } from './types';
 export declare function getRangeSliderOffsetTop(args: {

package/dist/cjs/hooks/useSeries/index.d.ts

@@ -1,16 +1,12 @@
 import type { ChartData } from '../../types';
-import type { OnLegendItemClick, PreparedLegend, PreparedSeries } from './types';
-type Args = {
-    colors: string[];
-    legend: ChartData['legend'];
-    originalSeriesData: ChartData['series']['data'];
-    seriesData: ChartData['series']['data'];
-    seriesOptions: ChartData['series']['options'];
-    preparedLegend?: PreparedLegend;
-};
-export declare const useSeries: (args: Args) => {
-    preparedLegend: PreparedLegend | null;
+import type { PreparedLegend, PreparedSeries } from './types';
+export declare const getVisibleSeries: ({ preparedSeries, activeLegendItems, }: {
     preparedSeries: PreparedSeries[];
-    handleLegendItemClick: OnLegendItemClick;
-};
-export {};
+    activeLegendItems: string[];
+}) => PreparedSeries[];
+export declare const getPreparedSeries: ({ seriesData, seriesOptions, colors, preparedLegend, }: {
+    seriesData: ChartData["series"]["data"];
+    seriesOptions: ChartData["series"]["options"];
+    colors: string[];
+    preparedLegend?: PreparedLegend | null;
+}) => Promise<PreparedSeries[]>;

package/dist/cjs/hooks/useSeries/index.js

@@ -1,21 +1,15 @@
-import React from 'react';
 import { group, scaleOrdinal } from 'd3';
 import { getSeriesNames } from '../../utils';
-import { usePrevious } from '../usePrevious';
-import { getPreparedLegend } from './prepare-legend';
 import { prepareSeries } from './prepareSeries';
-import { getActiveLegendItems, getAllLegendItems } from './utils';
-const useVisibleSeries = ({ preparedSeries, activeLegendItems, }) => {
-    return React.useMemo(() => {
-        return preparedSeries.map((singleSeries) => {
-            if (singleSeries.legend.enabled) {
-                return Object.assign(Object.assign({}, singleSeries), { visible: activeLegendItems.includes(singleSeries.legend.groupId) });
-            }
-            return singleSeries;
-        });
-    }, [preparedSeries, activeLegendItems]);
+export const getVisibleSeries = ({ preparedSeries, activeLegendItems, }) => {
+    return preparedSeries.map((singleSeries) => {
+        if (singleSeries.legend.enabled) {
+            return Object.assign(Object.assign({}, singleSeries), { visible: activeLegendItems.includes(singleSeries.legend.groupId) });
+        }
+        return singleSeries;
+    });
 };
-const getPreparedSeries = async ({ seriesData, seriesOptions, colors, preparedLegend, }) => {
+export const getPreparedSeries = async ({ seriesData, seriesOptions, colors, preparedLegend, }) => {
     const seriesNames = getSeriesNames(seriesData);
     const colorScale = scaleOrdinal(seriesNames, colors);
     const groupedSeries = group(seriesData, (item) => item.type);
@@ -37,69 +31,3 @@ const getPreparedSeries = async ({ seriesData, seriesOptions, colors, preparedLe
     }
     return acc;
 };
-export const useSeries = (args) => {
-    const { legend, originalSeriesData, seriesData, seriesOptions, colors, preparedLegend: preparedLegendProps = null, } = args;
-    const [preparedLegend, setPreparedLegend] = React.useState(preparedLegendProps);
-    const legendRunRef = React.useRef(0);
-    React.useEffect(() => {
-        if (!preparedLegendProps) {
-            const currentRun = ++legendRunRef.current;
-            getPreparedLegend({ legend, series: seriesData }).then((value) => {
-                if (legendRunRef.current === currentRun) {
-                    setPreparedLegend(value);
-                }
-            });
-        }
-    }, [legend, preparedLegendProps, seriesData]);
-    const [preparedSeries, setPreparedSeries] = React.useState([]);
-    const [activeLegendItems, setActiveLegendItems] = React.useState(getActiveLegendItems(preparedSeries));
-    const seriesRunRef = React.useRef(0);
-    React.useEffect(() => {
-        const currentRun = ++seriesRunRef.current;
-        (async () => {
-            const items = await getPreparedSeries({
-                seriesData,
-                seriesOptions,
-                preparedLegend,
-                colors,
-            });
-            if (seriesRunRef.current === currentRun) {
-                setPreparedSeries(items);
-                setActiveLegendItems(getActiveLegendItems(items));
-            }
-        })();
-    }, [seriesData, seriesOptions, preparedLegend, colors]);
-    const prevOriginalSeriesData = usePrevious(originalSeriesData);
-    const chartSeries = useVisibleSeries({ preparedSeries, activeLegendItems });
-    const handleLegendItemClick = React.useCallback(({ id, metaKey }) => {
-        const allItems = getAllLegendItems(preparedSeries);
-        const onlyItemSelected = activeLegendItems.length === 1 && activeLegendItems.includes(id);
-        let nextActiveLegendItems;
-        if (metaKey && activeLegendItems.includes(id)) {
-            nextActiveLegendItems = activeLegendItems.filter((item) => item !== id);
-        }
-        else if (metaKey && !activeLegendItems.includes(id)) {
-            nextActiveLegendItems = activeLegendItems.concat(id);
-        }
-        else if (onlyItemSelected && allItems.length === 1) {
-            nextActiveLegendItems = [];
-        }
-        else if (onlyItemSelected) {
-            nextActiveLegendItems = allItems;
-        }
-        else {
-            nextActiveLegendItems = [id];
-        }
-        setActiveLegendItems(nextActiveLegendItems);
-    }, [preparedSeries, activeLegendItems]);
-    React.useEffect(() => {
-        if (prevOriginalSeriesData !== originalSeriesData) {
-            setActiveLegendItems(getActiveLegendItems(preparedSeries));
-        }
-    }, [originalSeriesData, prevOriginalSeriesData, preparedSeries]);
-    return {
-        preparedLegend,
-        preparedSeries: chartSeries,
-        handleLegendItemClick,
-    };
-};

package/dist/cjs/hooks/useSeries/prepare-area.d.ts

@@ -5,9 +5,9 @@ export declare const DEFAULT_LINE_WIDTH = 1;
 export declare const DEFAULT_MARKER: {
     enabled: boolean;
     symbol: `${import("../../constants").SymbolType}`;
-    radius: number;
-    borderWidth: number;
     borderColor: string;
+    borderWidth: number;
+    radius: number;
 };
 type PrepareAreaSeriesArgs = {
     colorScale: ScaleOrdinal<string, string>;

package/dist/cjs/hooks/useSeries/prepare-legend.d.ts

@@ -1,5 +1,5 @@
 import type { ChartData } from '../../types';
-import type { PreparedChart } from '../useChartOptions/types';
+import type { PreparedChart } from '../types';
 import type { LegendItem, PreparedLegend, PreparedSeries } from './types';
 export declare function getPreparedLegend(args: {
     legend: ChartData['legend'];

package/dist/cjs/hooks/useSeries/prepare-line.d.ts

@@ -7,9 +7,9 @@ export declare const DEFAULT_DASH_STYLE: "Solid";
 export declare const DEFAULT_MARKER: {
     enabled: boolean;
     symbol: `${import("../../constants").SymbolType}`;
-    radius: number;
-    borderWidth: number;
     borderColor: string;
+    borderWidth: number;
+    radius: number;
 };
 type PrepareLineSeriesArgs = {
     colorScale: ScaleOrdinal<string, string>;

package/dist/cjs/hooks/useSeries/prepare-radar.d.ts

@@ -10,8 +10,8 @@ export declare const DEFAULT_MARKER: {
     enabled: boolean;
     radius: number;
     symbol: `${import("../../constants").SymbolType}`;
-    borderWidth: number;
     borderColor: string;
+    borderWidth: number;
 };
 export declare function prepareRadarSeries(args: PrepareRadarSeriesArgs): PreparedRadarSeries[];
 export {};