@gravity-ui/chartkit 5.17.1 → 5.18.0

package/build/plugins/d3/renderer/hooks/useShapes/bar-y/prepare-data.js

@@ -1,169 +0,0 @@
-import { ascending, descending, max, sort } from 'd3';
-import get from 'lodash/get';
-import { getDataCategoryValue, getLabelsSize } from '../../../utils';
-import { MIN_BAR_GAP, MIN_BAR_GROUP_GAP, MIN_BAR_WIDTH } from '../constants';
-const DEFAULT_LABEL_PADDING = 7;
-function groupByYValue(series, yAxis) {
-    const data = {};
-    series.forEach((s) => {
-        s.data.forEach((d) => {
-            const axisIndex = get(s, 'yAxis', 0);
-            const seriesYAxis = yAxis[axisIndex];
-            const categories = get(seriesYAxis, 'categories', []);
-            const key = seriesYAxis.type === 'category'
-                ? getDataCategoryValue({ axisDirection: 'y', categories, data: d })
-                : d.y;
-            if (key) {
-                if (!data[key]) {
-                    data[key] = {};
-                }
-                if (!data[key][s.stackId]) {
-                    data[key][s.stackId] = [];
-                }
-                data[key][s.stackId].push({ data: d, series: s });
-            }
-        });
-    });
-    return data;
-}
-function getBandWidth(series, yAxis, yScale) {
-    let bandWidth = Infinity;
-    if (yAxis[0].type === 'category') {
-        bandWidth = yScale.bandwidth();
-    }
-    else {
-        const scale = yScale;
-        const axisValues = series.reduce((acc, s) => {
-            s.data.forEach((dataItem) => acc.push(Number(dataItem.y)));
-            return acc;
-        }, []);
-        axisValues.sort().forEach((value, index) => {
-            if (index > 0 && value !== axisValues[index - 1]) {
-                const dist = scale(value) - scale(axisValues[index - 1]);
-                if (dist < bandWidth) {
-                    bandWidth = dist;
-                }
-            }
-        });
-    }
-    return bandWidth;
-}
-function setLabel(prepared) {
-    const dataLabels = prepared.series.dataLabels;
-    if (!dataLabels.enabled) {
-        return;
-    }
-    const data = prepared.data;
-    const content = String(data.label || data.x);
-    const { maxHeight: height, maxWidth: width } = getLabelsSize({
-        labels: [content],
-        style: dataLabels.style,
-        html: dataLabels.html,
-    });
-    const x = dataLabels.inside
-        ? prepared.x + prepared.width / 2
-        : prepared.x + prepared.width + DEFAULT_LABEL_PADDING;
-    const y = prepared.y + prepared.height / 2;
-    if (dataLabels.html) {
-        prepared.htmlElements.push({
-            x,
-            y: y - height / 2,
-            content,
-        });
-    }
-    else {
-        prepared.label = {
-            x,
-            y: y + height / 2,
-            text: content,
-            textAnchor: dataLabels.inside ? 'middle' : 'right',
-            style: dataLabels.style,
-            series: prepared.series,
-            size: { width, height },
-        };
-    }
-}
-export const prepareBarYData = (args) => {
-    const { series, seriesOptions, yAxis, xScale, yScale: [yScale], } = args;
-    const xLinearScale = xScale;
-    const plotWidth = xLinearScale(xLinearScale.domain()[1]);
-    const barMaxWidth = get(seriesOptions, 'bar-y.barMaxWidth');
-    const barPadding = get(seriesOptions, 'bar-y.barPadding');
-    const groupPadding = get(seriesOptions, 'bar-y.groupPadding');
-    const sortingOptions = get(seriesOptions, 'bar-y.dataSorting');
-    const comparator = (sortingOptions === null || sortingOptions === void 0 ? void 0 : sortingOptions.direction) === 'desc' ? descending : ascending;
-    const sortKey = (() => {
-        switch (sortingOptions === null || sortingOptions === void 0 ? void 0 : sortingOptions.key) {
-            case 'x': {
-                return 'data.x';
-            }
-            case 'name': {
-                return 'series.name';
-            }
-            default: {
-                return undefined;
-            }
-        }
-    })();
-    const groupedData = groupByYValue(series, yAxis);
-    const bandWidth = getBandWidth(series, yAxis, yScale);
-    const maxGroupSize = max(Object.values(groupedData), (d) => Object.values(d).length) || 1;
-    const groupGap = Math.max(bandWidth * groupPadding, MIN_BAR_GROUP_GAP);
-    const groupWidth = bandWidth - groupGap;
-    const rectGap = Math.max(bandWidth * barPadding, MIN_BAR_GAP);
-    const barHeight = Math.max(MIN_BAR_WIDTH, Math.min(groupWidth / maxGroupSize - rectGap, barMaxWidth));
-    const result = [];
-    Object.entries(groupedData).forEach(([yValue, val]) => {
-        const stacks = Object.values(val);
-        const currentBarHeight = barHeight * stacks.length + rectGap * (stacks.length - 1);
-        stacks.forEach((measureValues, groupItemIndex) => {
-            const base = xLinearScale(0);
-            let stackSum = base;
-            const stackItems = [];
-            const sortedData = sortKey
-                ? sort(measureValues, (a, b) => comparator(get(a, sortKey), get(b, sortKey)))
-                : measureValues;
-            sortedData.forEach(({ data, series: s }) => {
-                let center;
-                if (yAxis[0].type === 'category') {
-                    const bandScale = yScale;
-                    center = (bandScale(yValue) || 0) + bandWidth / 2;
-                }
-                else {
-                    const scale = yScale;
-                    center = scale(Number(yValue));
-                }
-                const y = center - currentBarHeight / 2 + (barHeight + rectGap) * groupItemIndex;
-                const xValue = Number(data.x);
-                const width = xValue > 0 ? xLinearScale(xValue) - base : base - xLinearScale(xValue);
-                const item = {
-                    x: xValue > 0 ? stackSum : stackSum - width,
-                    y,
-                    width,
-                    height: barHeight,
-                    color: data.color || s.color,
-                    opacity: get(data, 'opacity', null),
-                    data,
-                    series: s,
-                    htmlElements: [],
-                };
-                stackItems.push(item);
-                stackSum += width + 1;
-            });
-            if (series.some((s) => s.stacking === 'percent')) {
-                let acc = 0;
-                const ratio = plotWidth / (stackSum - stackItems.length);
-                stackItems.forEach((item) => {
-                    item.width = item.width * ratio;
-                    item.x = acc;
-                    acc += item.width;
-                });
-            }
-            result.push(...stackItems);
-        });
-    });
-    result.forEach((d) => {
-        setLabel(d);
-    });
-    return result;
-};

package/build/plugins/d3/renderer/hooks/useShapes/bar-y/types.d.ts

@@ -1,14 +0,0 @@
-import { TooltipDataChunkBarX } from '../../../../../../types';
-import { HtmlItem, LabelData } from '../../../types';
-import { PreparedBarYSeries } from '../../useSeries/types';
-export type PreparedBarYData = Omit<TooltipDataChunkBarX, 'series'> & {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-    opacity: number | null;
-    series: PreparedBarYSeries;
-    label?: LabelData;
-    htmlElements: HtmlItem[];
-};

package/build/plugins/d3/renderer/hooks/useShapes/bar-y/types.js

@@ -1 +0,0 @@
-export {};

package/build/plugins/d3/renderer/hooks/useShapes/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const MIN_BAR_WIDTH = 1;
-export declare const MIN_BAR_GAP = 1;
-export declare const MIN_BAR_GROUP_GAP = 1;

package/build/plugins/d3/renderer/hooks/useShapes/constants.js

@@ -1,3 +0,0 @@
-export const MIN_BAR_WIDTH = 1;
-export const MIN_BAR_GAP = 1;
-export const MIN_BAR_GROUP_GAP = 1;

package/build/plugins/d3/renderer/hooks/useShapes/index.d.ts

@@ -1,33 +0,0 @@
-import React from 'react';
-import { Dispatch } from 'd3';
-import type { PreparedSeries, PreparedSeriesOptions, PreparedSplit } from '../';
-import type { ChartScale } from '../useAxisScales';
-import type { PreparedAxis } from '../useChartOptions/types';
-import type { PreparedAreaData } from './area/types';
-import type { PreparedBarXData } from './bar-x';
-import type { PreparedBarYData } from './bar-y/types';
-import type { PreparedLineData } from './line/types';
-import type { PreparedPieData } from './pie/types';
-import type { PreparedScatterData } from './scatter/types';
-export type { PreparedBarXData } from './bar-x';
-export type { PreparedScatterData } from './scatter/types';
-import { PreparedWaterfallData } from './waterfall';
-import './styles.css';
-export type ShapeData = PreparedBarXData | PreparedBarYData | PreparedScatterData | PreparedLineData | PreparedPieData | PreparedAreaData | PreparedWaterfallData;
-type Args = {
-    boundsWidth: number;
-    boundsHeight: number;
-    dispatcher: Dispatch<object>;
-    series: PreparedSeries[];
-    seriesOptions: PreparedSeriesOptions;
-    xAxis: PreparedAxis;
-    yAxis: PreparedAxis[];
-    xScale?: ChartScale;
-    yScale?: ChartScale[];
-    split: PreparedSplit;
-    htmlLayout: HTMLElement | null;
-};
-export declare const useShapes: (args: Args) => {
-    shapes: React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-    shapesData: ShapeData[];
-};

package/build/plugins/d3/renderer/hooks/useShapes/index.js

@@ -1,153 +0,0 @@
-import React from 'react';
-import { group } from 'd3';
-import { getOnlyVisibleSeries } from '../../utils';
-import { AreaSeriesShapes } from './area';
-import { prepareAreaData } from './area/prepare-data';
-import { BarXSeriesShapes, prepareBarXData } from './bar-x';
-import { BarYSeriesShapes, prepareBarYData } from './bar-y';
-import { LineSeriesShapes } from './line';
-import { prepareLineData } from './line/prepare-data';
-import { PieSeriesShapes } from './pie';
-import { preparePieData } from './pie/prepare-data';
-import { ScatterSeriesShape, prepareScatterData } from './scatter';
-import { TreemapSeriesShape } from './treemap';
-import { prepareTreemapData } from './treemap/prepare-data';
-import { WaterfallSeriesShapes, prepareWaterfallData } from './waterfall';
-import './styles.css';
-export const useShapes = (args) => {
-    const { boundsWidth, boundsHeight, dispatcher, series, seriesOptions, xAxis, xScale, yAxis, yScale, split, htmlLayout, } = args;
-    const shapesComponents = React.useMemo(() => {
-        const visibleSeries = getOnlyVisibleSeries(series);
-        const groupedSeries = group(visibleSeries, (item) => item.type);
-        const shapesData = [];
-        const shapes = Array.from(groupedSeries).reduce((acc, item) => {
-            const [seriesType, chartSeries] = item;
-            switch (seriesType) {
-                case 'bar-x': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareBarXData({
-                            series: chartSeries,
-                            seriesOptions,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                            boundsHeight,
-                        });
-                        acc.push(React.createElement(BarXSeriesShapes, { key: "bar-x", dispatcher: dispatcher, seriesOptions: seriesOptions, preparedData: preparedData, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'bar-y': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareBarYData({
-                            series: chartSeries,
-                            seriesOptions,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                        });
-                        acc.push(React.createElement(BarYSeriesShapes, { key: "bar-y", dispatcher: dispatcher, seriesOptions: seriesOptions, preparedData: preparedData, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'waterfall': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareWaterfallData({
-                            series: chartSeries,
-                            seriesOptions,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                        });
-                        acc.push(React.createElement(WaterfallSeriesShapes, { key: "waterfall", dispatcher: dispatcher, seriesOptions: seriesOptions, preparedData: preparedData, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'line': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareLineData({
-                            series: chartSeries,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                            split,
-                        });
-                        acc.push(React.createElement(LineSeriesShapes, { key: "line", dispatcher: dispatcher, seriesOptions: seriesOptions, preparedData: preparedData, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'area': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareAreaData({
-                            series: chartSeries,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                            boundsHeight,
-                        });
-                        acc.push(React.createElement(AreaSeriesShapes, { key: "area", dispatcher: dispatcher, seriesOptions: seriesOptions, preparedData: preparedData, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'scatter': {
-                    if (xScale && yScale) {
-                        const preparedData = prepareScatterData({
-                            series: chartSeries,
-                            xAxis,
-                            xScale,
-                            yAxis,
-                            yScale,
-                        });
-                        acc.push(React.createElement(ScatterSeriesShape, { key: "scatter", dispatcher: dispatcher, preparedData: preparedData, seriesOptions: seriesOptions, htmlLayout: htmlLayout }));
-                        shapesData.push(...preparedData);
-                    }
-                    break;
-                }
-                case 'pie': {
-                    const preparedData = preparePieData({
-                        series: chartSeries,
-                        boundsWidth,
-                        boundsHeight,
-                    });
-                    acc.push(React.createElement(PieSeriesShapes, { key: "pie", dispatcher: dispatcher, preparedData: preparedData, seriesOptions: seriesOptions, htmlLayout: htmlLayout }));
-                    shapesData.push(...preparedData);
-                    break;
-                }
-                case 'treemap': {
-                    const preparedData = prepareTreemapData({
-                        // We should have exactly one series with "treemap" type
-                        // Otherwise data validation should emit an error
-                        series: chartSeries[0],
-                        width: boundsWidth,
-                        height: boundsHeight,
-                    });
-                    acc.push(React.createElement(TreemapSeriesShape, { key: "treemap", dispatcher: dispatcher, preparedData: preparedData, seriesOptions: seriesOptions, htmlLayout: htmlLayout }));
-                    shapesData.push(preparedData);
-                }
-            }
-            return acc;
-        }, []);
-        return { shapes, shapesData };
-    }, [
-        boundsWidth,
-        boundsHeight,
-        dispatcher,
-        series,
-        seriesOptions,
-        xAxis,
-        xScale,
-        yAxis,
-        yScale,
-    ]);
-    return { shapes: shapesComponents.shapes, shapesData: shapesComponents.shapesData };
-};

package/build/plugins/d3/renderer/hooks/useShapes/line/index.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { Dispatch } from 'd3';
-import type { PreparedSeriesOptions } from '../../useSeries/types';
-import type { PreparedLineData } from './types';
-type Args = {
-    dispatcher: Dispatch<object>;
-    preparedData: PreparedLineData[];
-    seriesOptions: PreparedSeriesOptions;
-    htmlLayout: HTMLElement | null;
-};
-export declare const LineSeriesShapes: (args: Args) => React.JSX.Element;
-export {};

package/build/plugins/d3/renderer/hooks/useShapes/line/index.js

@@ -1,131 +0,0 @@
-import React from 'react';
-import { color, line as lineGenerator, select } from 'd3';
-import get from 'lodash/get';
-import { block } from '../../../../../../utils/cn';
-import { filterOverlappingLabels } from '../../../utils';
-import { HtmlLayer } from '../HtmlLayer';
-import { getMarkerHaloVisibility, getMarkerVisibility, renderMarker, selectMarkerHalo, selectMarkerSymbol, setMarker, } from '../marker';
-import { getLineDashArray, setActiveState } from '../utils';
-const b = block('d3-line');
-export const LineSeriesShapes = (args) => {
-    const { dispatcher, preparedData, seriesOptions, htmlLayout } = args;
-    const ref = React.useRef(null);
-    React.useEffect(() => {
-        var _a;
-        if (!ref.current) {
-            return () => { };
-        }
-        const svgElement = select(ref.current);
-        const hoverOptions = get(seriesOptions, 'line.states.hover');
-        const inactiveOptions = get(seriesOptions, 'line.states.inactive');
-        const line = lineGenerator()
-            .x((d) => d.x)
-            .y((d) => d.y);
-        svgElement.selectAll('*').remove();
-        const lineSelection = svgElement
-            .selectAll('path')
-            .data(preparedData)
-            .join('path')
-            .attr('d', (d) => line(d.points))
-            .attr('fill', 'none')
-            .attr('stroke', (d) => d.color)
-            .attr('stroke-width', (d) => d.width)
-            .attr('stroke-linejoin', (d) => d.linecap)
-            .attr('stroke-linecap', (d) => d.linecap)
-            .attr('stroke-dasharray', (d) => getLineDashArray(d.dashStyle, d.width))
-            .attr('opacity', (d) => d.opacity)
-            .attr('cursor', (d) => d.series.cursor);
-        let dataLabels = preparedData.reduce((acc, d) => {
-            return acc.concat(d.labels);
-        }, []);
-        if (!((_a = preparedData[0]) === null || _a === void 0 ? void 0 : _a.series.dataLabels.allowOverlap)) {
-            dataLabels = filterOverlappingLabels(dataLabels);
-        }
-        const labelsSelection = svgElement
-            .selectAll('text')
-            .data(dataLabels)
-            .join('text')
-            .text((d) => d.text)
-            .attr('class', b('label'))
-            .attr('x', (d) => d.x)
-            .attr('y', (d) => d.y)
-            .attr('text-anchor', (d) => d.textAnchor)
-            .style('font-size', (d) => d.style.fontSize)
-            .style('font-weight', (d) => d.style.fontWeight || null)
-            .style('fill', (d) => d.style.fontColor || null);
-        const markers = preparedData.reduce((acc, d) => acc.concat(d.markers), []);
-        const markerSelection = svgElement
-            .selectAll('marker')
-            .data(markers)
-            .join('g')
-            .call(renderMarker);
-        const hoverEnabled = hoverOptions === null || hoverOptions === void 0 ? void 0 : hoverOptions.enabled;
-        const inactiveEnabled = inactiveOptions === null || inactiveOptions === void 0 ? void 0 : inactiveOptions.enabled;
-        dispatcher.on('hover-shape.line', (data) => {
-            const selected = (data === null || data === void 0 ? void 0 : data.filter((d) => d.series.type === 'line')) || [];
-            const selectedDataItems = selected.map((d) => d.data);
-            const selectedSeriesIds = selected.map((d) => { var _a; return (_a = d.series) === null || _a === void 0 ? void 0 : _a.id; });
-            lineSelection.datum((d, index, list) => {
-                const elementSelection = select(list[index]);
-                const hovered = Boolean(hoverEnabled && selectedSeriesIds.includes(d.id));
-                if (d.hovered !== hovered) {
-                    d.hovered = hovered;
-                    elementSelection.attr('stroke', (d) => {
-                        var _a;
-                        const initialColor = d.color || '';
-                        if (d.hovered) {
-                            return (((_a = color(initialColor)) === null || _a === void 0 ? void 0 : _a.brighter(hoverOptions === null || hoverOptions === void 0 ? void 0 : hoverOptions.brightness).toString()) || initialColor);
-                        }
-                        return initialColor;
-                    });
-                }
-                return setActiveState({
-                    element: list[index],
-                    state: inactiveOptions,
-                    active: Boolean(!inactiveEnabled ||
-                        !selectedSeriesIds.length ||
-                        selectedSeriesIds.includes(d.id)),
-                    datum: d,
-                });
-            });
-            labelsSelection.datum((d, index, list) => {
-                return setActiveState({
-                    element: list[index],
-                    state: inactiveOptions,
-                    active: Boolean(!inactiveEnabled ||
-                        !selectedSeriesIds.length ||
-                        selectedSeriesIds.includes(d.series.id)),
-                    datum: d,
-                });
-            });
-            markerSelection.datum((d, index, list) => {
-                const elementSelection = select(list[index]);
-                const hovered = Boolean(hoverEnabled && selectedDataItems.includes(d.point.data));
-                if (d.hovered !== hovered) {
-                    d.hovered = hovered;
-                    elementSelection.attr('visibility', getMarkerVisibility(d));
-                    selectMarkerHalo(elementSelection).attr('visibility', getMarkerHaloVisibility);
-                    selectMarkerSymbol(elementSelection).call(setMarker, hovered ? 'hover' : 'normal');
-                }
-                if (d.point.series.marker.states.normal.enabled) {
-                    const isActive = Boolean(!inactiveEnabled ||
-                        !selectedSeriesIds.length ||
-                        selectedSeriesIds.includes(d.point.series.id));
-                    setActiveState({
-                        element: list[index],
-                        state: inactiveOptions,
-                        active: isActive,
-                        datum: d,
-                    });
-                }
-                return d;
-            });
-        });
-        return () => {
-            dispatcher.on('hover-shape.line', null);
-        };
-    }, [dispatcher, preparedData, seriesOptions]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement("g", { ref: ref, className: b() }),
-        React.createElement(HtmlLayer, { preparedData: preparedData, htmlLayout: htmlLayout })));
-};

package/build/plugins/d3/renderer/hooks/useShapes/line/prepare-data.d.ts

@@ -1,13 +0,0 @@
-import type { ChartScale } from '../../useAxisScales';
-import type { PreparedAxis } from '../../useChartOptions/types';
-import type { PreparedLineSeries } from '../../useSeries/types';
-import type { PreparedSplit } from '../../useSplit/types';
-import type { PreparedLineData } from './types';
-export declare const prepareLineData: (args: {
-    series: PreparedLineSeries[];
-    xAxis: PreparedAxis;
-    xScale: ChartScale;
-    yAxis: PreparedAxis[];
-    yScale: ChartScale[];
-    split: PreparedSplit;
-}) => PreparedLineData[];

package/build/plugins/d3/renderer/hooks/useShapes/line/prepare-data.js

@@ -1,91 +0,0 @@
-import { getLabelsSize, getLeftPosition } from '../../../utils';
-import { getXValue, getYValue } from '../utils';
-function getLabelData(point, series, xMax) {
-    const text = String(point.data.label || point.data.y);
-    const style = series.dataLabels.style;
-    const size = getLabelsSize({ labels: [text], style });
-    const labelData = {
-        text,
-        x: point.x,
-        y: point.y - series.dataLabels.padding,
-        style,
-        size: { width: size.maxWidth, height: size.maxHeight },
-        textAnchor: 'middle',
-        series: series,
-        active: true,
-    };
-    const left = getLeftPosition(labelData);
-    if (left < 0) {
-        labelData.x = labelData.x + Math.abs(left);
-    }
-    else {
-        const right = left + labelData.size.width;
-        if (right > xMax) {
-            labelData.x = labelData.x - xMax - right;
-        }
-    }
-    return labelData;
-}
-function getHtmlLabel(point, series, xMax) {
-    const content = String(point.data.label || point.data.y);
-    const size = getLabelsSize({ labels: [content], html: true });
-    return {
-        x: Math.min(xMax - size.maxWidth, Math.max(0, point.x)),
-        y: Math.max(0, point.y - series.dataLabels.padding - size.maxHeight),
-        content,
-    };
-}
-export const prepareLineData = (args) => {
-    const { series, xAxis, yAxis, xScale, yScale, split } = args;
-    const [_xMin, xRangeMax] = xScale.range();
-    const xMax = xRangeMax / (1 - xAxis.maxPadding);
-    return series.reduce((acc, s) => {
-        var _a;
-        const yAxisIndex = s.yAxis;
-        const seriesYAxis = yAxis[yAxisIndex];
-        const yAxisTop = ((_a = split.plots[seriesYAxis.plotIndex]) === null || _a === void 0 ? void 0 : _a.top) || 0;
-        const seriesYScale = yScale[s.yAxis];
-        const points = s.data.map((d) => ({
-            x: getXValue({ point: d, xAxis, xScale }),
-            y: yAxisTop + getYValue({ point: d, yAxis: seriesYAxis, yScale: seriesYScale }),
-            active: true,
-            data: d,
-            series: s,
-        }));
-        const htmlElements = [];
-        let labels = [];
-        if (s.dataLabels.enabled) {
-            if (s.dataLabels.html) {
-                htmlElements.push(...points.map((p) => getHtmlLabel(p, s, xMax)));
-            }
-            else {
-                labels = points.map((p) => getLabelData(p, s, xMax));
-            }
-        }
-        let markers = [];
-        if (s.marker.states.normal.enabled || s.marker.states.hover.enabled) {
-            markers = points.map((p) => ({
-                point: p,
-                active: true,
-                hovered: false,
-            }));
-        }
-        const result = {
-            points,
-            markers,
-            labels,
-            color: s.color,
-            width: s.lineWidth,
-            series: s,
-            hovered: false,
-            active: true,
-            id: s.id,
-            dashStyle: s.dashStyle,
-            linecap: s.linecap,
-            opacity: s.opacity,
-            htmlElements,
-        };
-        acc.push(result);
-        return acc;
-    }, []);
-};

package/build/plugins/d3/renderer/hooks/useShapes/line/types.d.ts

@@ -1,30 +0,0 @@
-import { DashStyle, LineCap } from '../../../../../../constants';
-import { LineSeriesData } from '../../../../../../types';
-import { HtmlItem, LabelData } from '../../../types';
-import { PreparedLineSeries } from '../../useSeries/types';
-export type PointData = {
-    x: number;
-    y: number;
-    data: LineSeriesData;
-    series: PreparedLineSeries;
-};
-export type MarkerData = {
-    point: PointData;
-    active: boolean;
-    hovered: boolean;
-};
-export type PreparedLineData = {
-    id: string;
-    points: PointData[];
-    markers: MarkerData[];
-    color: string;
-    width: number;
-    series: PreparedLineSeries;
-    hovered: boolean;
-    active: boolean;
-    labels: LabelData[];
-    dashStyle: DashStyle;
-    linecap: LineCap;
-    opacity: number | null;
-    htmlElements: HtmlItem[];
-};

package/build/plugins/d3/renderer/hooks/useShapes/line/types.js

@@ -1 +0,0 @@
-export {};