@gravity-ui/charts 0.1.0

package/dist/cjs/hooks/useSeries/prepare-bar-y.js

@@ -0,0 +1,48 @@
+import get from 'lodash/get';
+import { getLabelsSize, getUniqId } from '../../utils';
+import { DEFAULT_DATALABELS_STYLE } from './constants';
+import { getSeriesStackId, prepareLegendSymbol } from './utils';
+function prepareDataLabels(series) {
+    var _a;
+    const enabled = get(series, 'dataLabels.enabled', false);
+    const style = Object.assign({}, DEFAULT_DATALABELS_STYLE, (_a = series.dataLabels) === null || _a === void 0 ? void 0 : _a.style);
+    const html = get(series, 'dataLabels.html', false);
+    const labels = enabled ? series.data.map((d) => String(d.label || d.x)) : [];
+    const { maxHeight = 0, maxWidth = 0 } = getLabelsSize({
+        labels,
+        style,
+        html,
+    });
+    const inside = series.stacking === 'percent' ? true : get(series, 'dataLabels.inside', false);
+    return {
+        enabled,
+        inside,
+        style,
+        maxHeight,
+        maxWidth,
+        html,
+    };
+}
+export function prepareBarYSeries(args) {
+    const { colorScale, series: seriesList, legend } = args;
+    return seriesList.map((series) => {
+        const name = series.name || '';
+        const color = series.color || colorScale(name);
+        return {
+            type: series.type,
+            color,
+            name,
+            id: getUniqId(),
+            visible: get(series, 'visible', true),
+            legend: {
+                enabled: get(series, 'legend.enabled', legend.enabled),
+                symbol: prepareLegendSymbol(series),
+            },
+            data: series.data,
+            stacking: series.stacking,
+            stackId: getSeriesStackId(series),
+            dataLabels: prepareDataLabels(series),
+            cursor: get(series, 'cursor', null),
+        };
+    }, []);
+}

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

@@ -0,0 +1,27 @@
+import type { ChartData } from '../../types';
+import type { PreparedAxis, PreparedChart } from '../useChartOptions/types';
+import type { LegendItem, PreparedLegend, PreparedSeries } from './types';
+export declare const getPreparedLegend: (args: {
+    legend: ChartData["legend"];
+    series: ChartData["series"]["data"];
+}) => PreparedLegend;
+export declare const getLegendComponents: (args: {
+    chartWidth: number;
+    chartHeight: number;
+    chartMargin: PreparedChart["margin"];
+    series: PreparedSeries[];
+    preparedLegend: PreparedLegend;
+    preparedYAxis: PreparedAxis[];
+}) => {
+    legendConfig: {
+        offset: {
+            left: number;
+            top: number;
+        };
+        pagination: {
+            limit: number;
+            maxPage: number;
+        } | undefined;
+    };
+    legendItems: LegendItem[][];
+};

package/dist/cjs/hooks/useSeries/prepare-legend.js

@@ -0,0 +1,144 @@
+import { select } from 'd3';
+import clone from 'lodash/clone';
+import get from 'lodash/get';
+import merge from 'lodash/merge';
+import { CONTINUOUS_LEGEND_SIZE, legendDefaults } from '../../constants';
+import { getDefaultColorStops, getDomainForContinuousColorScale, getHorisontalSvgTextHeight, getLabelsSize, } from '../../utils';
+import { getBoundsWidth } from '../useChartDimensions';
+import { getYAxisWidth } from '../useChartDimensions/utils';
+export const getPreparedLegend = (args) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { legend, series } = args;
+    const enabled = Boolean(typeof (legend === null || legend === void 0 ? void 0 : legend.enabled) === 'boolean' ? legend === null || legend === void 0 ? void 0 : legend.enabled : series.length > 1);
+    const defaultItemStyle = clone(legendDefaults.itemStyle);
+    const itemStyle = get(legend, 'itemStyle');
+    const computedItemStyle = merge(defaultItemStyle, itemStyle);
+    const lineHeight = getHorisontalSvgTextHeight({ text: 'Tmp', style: computedItemStyle });
+    const legendType = get(legend, 'type', 'discrete');
+    const isTitleEnabled = Boolean((_a = legend === null || legend === void 0 ? void 0 : legend.title) === null || _a === void 0 ? void 0 : _a.text);
+    const titleMargin = isTitleEnabled ? get(legend, 'title.margin', 4) : 0;
+    const titleStyle = Object.assign({ fontSize: '12px', fontWeight: 'bold' }, get(legend, 'title.style'));
+    const titleText = isTitleEnabled ? get(legend, 'title.text', '') : '';
+    const titleHeight = isTitleEnabled
+        ? getLabelsSize({ labels: [titleText], style: titleStyle }).maxHeight
+        : 0;
+    const ticks = {
+        labelsMargin: 4,
+        labelsLineHeight: 12,
+    };
+    const colorScale = {
+        colors: [],
+        domain: [],
+        stops: [],
+    };
+    let height = 0;
+    if (enabled) {
+        height += titleHeight + titleMargin;
+        if (legendType === 'continuous') {
+            height += CONTINUOUS_LEGEND_SIZE.height;
+            height += ticks.labelsLineHeight + ticks.labelsMargin;
+            colorScale.colors = (_c = (_b = legend === null || legend === void 0 ? void 0 : legend.colorScale) === null || _b === void 0 ? void 0 : _b.colors) !== null && _c !== void 0 ? _c : [];
+            colorScale.stops =
+                (_e = (_d = legend === null || legend === void 0 ? void 0 : legend.colorScale) === null || _d === void 0 ? void 0 : _d.stops) !== null && _e !== void 0 ? _e : getDefaultColorStops(colorScale.colors.length);
+            colorScale.domain =
+                (_g = (_f = legend === null || legend === void 0 ? void 0 : legend.colorScale) === null || _f === void 0 ? void 0 : _f.domain) !== null && _g !== void 0 ? _g : getDomainForContinuousColorScale({ series });
+        }
+        else {
+            height += lineHeight;
+        }
+    }
+    const legendWidth = get(legend, 'width', CONTINUOUS_LEGEND_SIZE.width);
+    return {
+        align: get(legend, 'align', legendDefaults.align),
+        enabled,
+        height,
+        itemDistance: get(legend, 'itemDistance', legendDefaults.itemDistance),
+        itemStyle: computedItemStyle,
+        lineHeight,
+        margin: get(legend, 'margin', legendDefaults.margin),
+        type: legendType,
+        title: {
+            enable: isTitleEnabled,
+            text: titleText,
+            margin: titleMargin,
+            style: titleStyle,
+            height: titleHeight,
+        },
+        width: legendWidth,
+        ticks,
+        colorScale,
+    };
+};
+const getFlattenLegendItems = (series) => {
+    return series.reduce((acc, s) => {
+        const legendEnabled = get(s, 'legend.enabled', true);
+        if (legendEnabled) {
+            acc.push(Object.assign(Object.assign({}, s), { symbol: s.legend.symbol }));
+        }
+        return acc;
+    }, []);
+};
+const getGroupedLegendItems = (args) => {
+    const { maxLegendWidth, items, preparedLegend } = args;
+    const result = [[]];
+    let textWidthsInLine = [0];
+    let lineIndex = 0;
+    items.forEach((item) => {
+        select(document.body)
+            .append('text')
+            .text(item.name)
+            .style('font-size', preparedLegend.itemStyle.fontSize)
+            .each(function () {
+            const resultItem = clone(item);
+            const textWidth = this.getBoundingClientRect().width;
+            resultItem.textWidth = textWidth;
+            textWidthsInLine.push(textWidth);
+            const textsWidth = textWidthsInLine.reduce((acc, width) => acc + width, 0);
+            result[lineIndex].push(resultItem);
+            const symbolsWidth = result[lineIndex].reduce((acc, { symbol }) => {
+                return acc + symbol.width + symbol.padding;
+            }, 0);
+            const distancesWidth = (result[lineIndex].length - 1) * preparedLegend.itemDistance;
+            const isOverfilled = maxLegendWidth < textsWidth + symbolsWidth + distancesWidth;
+            if (isOverfilled) {
+                result[lineIndex].pop();
+                lineIndex += 1;
+                textWidthsInLine = [textWidth];
+                const nextLineIndex = lineIndex;
+                result[nextLineIndex] = [];
+                result[nextLineIndex].push(resultItem);
+            }
+        })
+            .remove();
+    });
+    return result;
+};
+export const getLegendComponents = (args) => {
+    const { chartWidth, chartHeight, chartMargin, series, preparedLegend, preparedYAxis } = args;
+    const maxLegendWidth = getBoundsWidth({ chartWidth, chartMargin, preparedYAxis });
+    const maxLegendHeight = (chartHeight - chartMargin.top - chartMargin.bottom - preparedLegend.margin) / 2;
+    const flattenLegendItems = getFlattenLegendItems(series);
+    const items = getGroupedLegendItems({
+        maxLegendWidth,
+        items: flattenLegendItems,
+        preparedLegend,
+    });
+    let pagination;
+    if (preparedLegend.type === 'discrete') {
+        let legendHeight = preparedLegend.lineHeight * items.length;
+        if (maxLegendHeight < legendHeight) {
+            // extra line for paginator
+            const limit = Math.floor(maxLegendHeight / preparedLegend.lineHeight) - 1;
+            const maxPage = Math.ceil(items.length / limit);
+            pagination = { limit, maxPage };
+            legendHeight = maxLegendHeight;
+        }
+        preparedLegend.height = legendHeight;
+    }
+    const top = chartHeight - chartMargin.bottom - preparedLegend.height;
+    const offset = {
+        left: chartMargin.left + getYAxisWidth(preparedYAxis[0]),
+        top,
+    };
+    return { legendConfig: { offset, pagination }, legendItems: items };
+};

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

@@ -0,0 +1,22 @@
+import type { ScaleOrdinal } from 'd3';
+import { DashStyle } from '../../constants';
+import type { ChartSeriesOptions, LineSeries } from '../../types';
+import type { PreparedLegend, PreparedLineSeries } from './types';
+export declare const DEFAULT_LEGEND_SYMBOL_SIZE = 16;
+export declare const DEFAULT_LINE_WIDTH = 1;
+export declare const DEFAULT_DASH_STYLE = DashStyle.Solid;
+export declare const DEFAULT_MARKER: {
+    enabled: boolean;
+    symbol: `${import("../../constants").SymbolType}`;
+    borderColor: string;
+    borderWidth: number;
+    radius: number;
+};
+type PrepareLineSeriesArgs = {
+    colorScale: ScaleOrdinal<string, string>;
+    series: LineSeries[];
+    seriesOptions?: ChartSeriesOptions;
+    legend: PreparedLegend;
+};
+export declare function prepareLineSeries(args: PrepareLineSeriesArgs): PreparedLineSeries[];
+export {};

package/dist/cjs/hooks/useSeries/prepare-line.js

@@ -0,0 +1,82 @@
+import get from 'lodash/get';
+import merge from 'lodash/merge';
+import { DashStyle, LineCap } from '../../constants';
+import { getUniqId } from '../../utils';
+import { DEFAULT_DATALABELS_PADDING, DEFAULT_DATALABELS_STYLE, DEFAULT_HALO_OPTIONS, DEFAULT_LEGEND_SYMBOL_PADDING, DEFAULT_POINT_MARKER_OPTIONS, } from './constants';
+export const DEFAULT_LEGEND_SYMBOL_SIZE = 16;
+export const DEFAULT_LINE_WIDTH = 1;
+export const DEFAULT_DASH_STYLE = DashStyle.Solid;
+export const DEFAULT_MARKER = Object.assign(Object.assign({}, DEFAULT_POINT_MARKER_OPTIONS), { enabled: false });
+function prepareLinecap(dashStyle, series, seriesOptions) {
+    const defaultLineCap = dashStyle === DashStyle.Solid ? LineCap.Round : LineCap.None;
+    const lineCapFromSeriesOptions = get(seriesOptions, 'line.linecap', defaultLineCap);
+    return get(series, 'linecap', lineCapFromSeriesOptions);
+}
+function prepareLineLegendSymbol(series, seriesOptions) {
+    var _a;
+    const symbolOptions = ((_a = series.legend) === null || _a === void 0 ? void 0 : _a.symbol) || {};
+    const defaultLineWidth = get(seriesOptions, 'line.lineWidth', DEFAULT_LINE_WIDTH);
+    return {
+        shape: 'path',
+        width: (symbolOptions === null || symbolOptions === void 0 ? void 0 : symbolOptions.width) || DEFAULT_LEGEND_SYMBOL_SIZE,
+        padding: (symbolOptions === null || symbolOptions === void 0 ? void 0 : symbolOptions.padding) || DEFAULT_LEGEND_SYMBOL_PADDING,
+        strokeWidth: get(series, 'lineWidth', defaultLineWidth),
+    };
+}
+function prepareMarker(series, seriesOptions) {
+    var _a;
+    const seriesHoverState = get(seriesOptions, 'line.states.hover');
+    const markerNormalState = Object.assign({}, DEFAULT_MARKER, (_a = seriesOptions === null || seriesOptions === void 0 ? void 0 : seriesOptions.line) === null || _a === void 0 ? void 0 : _a.marker, series.marker);
+    const hoveredMarkerDefaultOptions = {
+        enabled: true,
+        radius: markerNormalState.radius,
+        borderWidth: 1,
+        borderColor: '#ffffff',
+        halo: DEFAULT_HALO_OPTIONS,
+    };
+    return {
+        states: {
+            normal: markerNormalState,
+            hover: merge(hoveredMarkerDefaultOptions, seriesHoverState === null || seriesHoverState === void 0 ? void 0 : seriesHoverState.marker),
+        },
+    };
+}
+export function prepareLineSeries(args) {
+    const { colorScale, series: seriesList, seriesOptions, legend } = args;
+    const defaultLineWidth = get(seriesOptions, 'line.lineWidth', DEFAULT_LINE_WIDTH);
+    const defaultDashStyle = get(seriesOptions, 'line.dashStyle', DEFAULT_DASH_STYLE);
+    return seriesList.map((series) => {
+        var _a, _b;
+        const id = getUniqId();
+        const name = series.name || '';
+        const color = series.color || colorScale(name);
+        const dashStyle = get(series, 'dashStyle', defaultDashStyle);
+        const prepared = {
+            type: series.type,
+            color,
+            lineWidth: get(series, 'lineWidth', defaultLineWidth),
+            name,
+            id,
+            visible: get(series, 'visible', true),
+            legend: {
+                enabled: get(series, 'legend.enabled', legend.enabled),
+                symbol: prepareLineLegendSymbol(series, seriesOptions),
+            },
+            data: series.data,
+            dataLabels: {
+                enabled: ((_a = series.dataLabels) === null || _a === void 0 ? void 0 : _a.enabled) || false,
+                style: Object.assign({}, DEFAULT_DATALABELS_STYLE, (_b = series.dataLabels) === null || _b === void 0 ? void 0 : _b.style),
+                padding: get(series, 'dataLabels.padding', DEFAULT_DATALABELS_PADDING),
+                allowOverlap: get(series, 'dataLabels.allowOverlap', false),
+                html: get(series, 'dataLabels.html', false),
+            },
+            marker: prepareMarker(series, seriesOptions),
+            dashStyle: dashStyle,
+            linecap: prepareLinecap(dashStyle, series, seriesOptions),
+            opacity: get(series, 'opacity', null),
+            cursor: get(series, 'cursor', null),
+            yAxis: get(series, 'yAxis', 0),
+        };
+        return prepared;
+    }, []);
+}

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

@@ -0,0 +1,3 @@
+import type { ChartSeriesOptions } from '../../types';
+import type { PreparedSeriesOptions } from './types';
+export declare const getPreparedOptions: (options?: ChartSeriesOptions) => PreparedSeriesOptions;

package/dist/cjs/hooks/useSeries/prepare-options.js

@@ -0,0 +1,5 @@
+import merge from 'lodash/merge';
+import { seriesOptionsDefaults } from '../../constants';
+export const getPreparedOptions = (options) => {
+    return merge({}, seriesOptionsDefaults, options);
+};

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

@@ -0,0 +1,9 @@
+import type { ChartSeriesOptions, PieSeries } from '../../types';
+import type { PreparedLegend, PreparedSeries } from './types';
+type PreparePieSeriesArgs = {
+    series: PieSeries;
+    seriesOptions?: ChartSeriesOptions;
+    legend: PreparedLegend;
+};
+export declare function preparePieSeries(args: PreparePieSeriesArgs): PreparedSeries[];
+export {};

package/dist/cjs/hooks/useSeries/prepare-pie.js

@@ -0,0 +1,62 @@
+import { scaleOrdinal } from 'd3';
+import get from 'lodash/get';
+import { DEFAULT_PALETTE } from '../../constants';
+import { getUniqId } from '../../utils';
+import { DEFAULT_DATALABELS_PADDING, DEFAULT_DATALABELS_STYLE } from './constants';
+import { prepareLegendSymbol } from './utils';
+export function preparePieSeries(args) {
+    const { series, seriesOptions, legend } = args;
+    const dataNames = series.data.map((d) => d.name);
+    const colorScale = scaleOrdinal(dataNames, DEFAULT_PALETTE);
+    const stackId = getUniqId();
+    const seriesHoverState = get(seriesOptions, 'pie.states.hover');
+    const preparedSeries = series.data.map((dataItem, i) => {
+        var _a, _b, _c;
+        const result = {
+            type: 'pie',
+            data: dataItem,
+            dataLabels: {
+                enabled: get(series, 'dataLabels.enabled', true),
+                style: Object.assign({}, DEFAULT_DATALABELS_STYLE, (_a = series.dataLabels) === null || _a === void 0 ? void 0 : _a.style),
+                padding: get(series, 'dataLabels.padding', DEFAULT_DATALABELS_PADDING),
+                allowOverlap: get(series, 'dataLabels.allowOverlap', false),
+                connectorPadding: get(series, 'dataLabels.connectorPadding', 5),
+                connectorShape: get(series, 'dataLabels.connectorShape', 'polyline'),
+                distance: get(series, 'dataLabels.distance', 25),
+                connectorCurve: get(series, 'dataLabels.connectorCurve', 'basic'),
+                html: get(series, 'dataLabels.html', false),
+            },
+            label: dataItem.label,
+            value: dataItem.value,
+            visible: typeof dataItem.visible === 'boolean' ? dataItem.visible : true,
+            name: dataItem.name,
+            id: `Series ${i}`,
+            color: dataItem.color || colorScale(dataItem.name),
+            legend: {
+                enabled: get(series, 'legend.enabled', legend.enabled),
+                symbol: prepareLegendSymbol(series),
+            },
+            center: series.center || ['50%', '50%'],
+            borderColor: series.borderColor || '',
+            borderRadius: (_b = series.borderRadius) !== null && _b !== void 0 ? _b : 0,
+            borderWidth: (_c = series.borderWidth) !== null && _c !== void 0 ? _c : 1,
+            radius: series.radius || '100%',
+            innerRadius: series.innerRadius || 0,
+            stackId,
+            states: {
+                hover: {
+                    halo: {
+                        enabled: get(seriesHoverState, 'halo.enabled', true),
+                        opacity: get(seriesHoverState, 'halo.opacity', 0.25),
+                        size: get(seriesHoverState, 'halo.size', 10),
+                    },
+                },
+            },
+            renderCustomShape: series.renderCustomShape,
+            opacity: get(dataItem, 'opacity', null),
+            cursor: get(series, 'cursor', null),
+        };
+        return result;
+    });
+    return preparedSeries;
+}

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

@@ -0,0 +1,11 @@
+import type { ScaleOrdinal } from 'd3';
+import type { ChartSeriesOptions, ScatterSeries } from '../../types';
+import type { PreparedLegend, PreparedScatterSeries } from './types';
+interface PrepareScatterSeriesArgs {
+    colorScale: ScaleOrdinal<string, string>;
+    series: ScatterSeries[];
+    legend: PreparedLegend;
+    seriesOptions?: ChartSeriesOptions;
+}
+export declare function prepareScatterSeries(args: PrepareScatterSeriesArgs): PreparedScatterSeries[];
+export {};

package/dist/cjs/hooks/useSeries/prepare-scatter.js

@@ -0,0 +1,46 @@
+import get from 'lodash/get';
+import merge from 'lodash/merge';
+import { getSymbolType, getUniqId } from '../../utils';
+import { DEFAULT_HALO_OPTIONS, DEFAULT_POINT_MARKER_OPTIONS } from './constants';
+import { prepareLegendSymbol } from './utils';
+function prepareMarker(series, seriesOptions, index) {
+    const seriesHoverState = get(seriesOptions, 'scatter.states.hover');
+    const markerNormalState = Object.assign(Object.assign({}, DEFAULT_POINT_MARKER_OPTIONS), { enabled: true, symbol: series.symbolType || getSymbolType(index) });
+    const hoveredMarkerDefaultOptions = {
+        enabled: true,
+        radius: markerNormalState.radius,
+        borderWidth: 1,
+        borderColor: '#ffffff',
+        halo: DEFAULT_HALO_OPTIONS,
+    };
+    return {
+        states: {
+            normal: markerNormalState,
+            hover: merge(hoveredMarkerDefaultOptions, seriesHoverState === null || seriesHoverState === void 0 ? void 0 : seriesHoverState.marker),
+        },
+    };
+}
+export function prepareScatterSeries(args) {
+    const { colorScale, series, seriesOptions, legend } = args;
+    return series.map((s, index) => {
+        const id = getUniqId();
+        const name = 'name' in s && s.name ? s.name : '';
+        const symbolType = s.symbolType || getSymbolType(index);
+        const prepared = {
+            id,
+            type: s.type,
+            name,
+            color: get(s, 'color', colorScale(name)),
+            visible: get(s, 'visible', true),
+            legend: {
+                enabled: get(s, 'legend.enabled', legend.enabled),
+                symbol: prepareLegendSymbol(s, symbolType),
+            },
+            data: s.data,
+            marker: prepareMarker(s, seriesOptions, index),
+            cursor: get(s, 'cursor', null),
+            yAxis: get(s, 'yAxis', 0),
+        };
+        return prepared;
+    }, []);
+}

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

@@ -0,0 +1,11 @@
+import type { ScaleOrdinal } from 'd3';
+import type { ChartSeriesOptions, TreemapSeries } from '../../types';
+import type { PreparedLegend, PreparedTreemapSeries } from './types';
+type PrepareTreemapSeriesArgs = {
+    colorScale: ScaleOrdinal<string, string>;
+    legend: PreparedLegend;
+    series: TreemapSeries[];
+    seriesOptions?: ChartSeriesOptions;
+};
+export declare function prepareTreemap(args: PrepareTreemapSeriesArgs): PreparedTreemapSeries[];
+export {};

package/dist/cjs/hooks/useSeries/prepare-treemap.js

@@ -0,0 +1,38 @@
+import get from 'lodash/get';
+import { LayoutAlgorithm } from '../../constants';
+import { getUniqId } from '../../utils';
+import { DEFAULT_DATALABELS_PADDING, DEFAULT_DATALABELS_STYLE } from './constants';
+import { prepareLegendSymbol } from './utils';
+export function prepareTreemap(args) {
+    const { colorScale, legend, series } = args;
+    return series.map((s) => {
+        var _a;
+        const id = getUniqId();
+        const name = s.name || '';
+        const color = s.color || colorScale(name);
+        const preparedSeries = {
+            color,
+            data: s.data,
+            dataLabels: {
+                enabled: get(s, 'dataLabels.enabled', true),
+                style: Object.assign({}, DEFAULT_DATALABELS_STYLE, (_a = s.dataLabels) === null || _a === void 0 ? void 0 : _a.style),
+                padding: get(s, 'dataLabels.padding', DEFAULT_DATALABELS_PADDING),
+                allowOverlap: get(s, 'dataLabels.allowOverlap', false),
+                html: get(s, 'dataLabels.html', false),
+                align: get(s, 'dataLabels.align', 'left'),
+            },
+            id,
+            type: s.type,
+            name,
+            visible: get(s, 'visible', true),
+            legend: {
+                enabled: get(s, 'legend.enabled', legend.enabled),
+                symbol: prepareLegendSymbol(s),
+            },
+            levels: s.levels,
+            layoutAlgorithm: get(s, 'layoutAlgorithm', LayoutAlgorithm.Binary),
+            cursor: get(s, 'cursor', null),
+        };
+        return preparedSeries;
+    });
+}

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

@@ -0,0 +1,10 @@
+import type { ScaleOrdinal } from 'd3';
+import type { WaterfallSeries } from '../../types';
+import type { PreparedLegend, PreparedSeries } from './types';
+type PrepareWaterfallSeriesArgs = {
+    colorScale: ScaleOrdinal<string, string>;
+    series: WaterfallSeries[];
+    legend: PreparedLegend;
+};
+export declare function prepareWaterfallSeries(args: PrepareWaterfallSeriesArgs): PreparedSeries[];
+export {};

package/dist/cjs/hooks/useSeries/prepare-waterfall.js

@@ -0,0 +1,37 @@
+import get from 'lodash/get';
+import { DEFAULT_PALETTE } from '../../constants';
+import { getUniqId } from '../../utils';
+import { DEFAULT_DATALABELS_PADDING, DEFAULT_DATALABELS_STYLE } from './constants';
+import { prepareLegendSymbol } from './utils';
+export function prepareWaterfallSeries(args) {
+    const { colorScale, series: seriesList, legend } = args;
+    const [, negativeColor, positiveColor] = DEFAULT_PALETTE;
+    return seriesList.map((series) => {
+        var _a, _b, _c;
+        const name = series.name || '';
+        const color = series.color || colorScale(name);
+        const prepared = {
+            type: series.type,
+            color,
+            positiveColor: positiveColor,
+            negativeColor: negativeColor,
+            name,
+            id: getUniqId(),
+            visible: get(series, 'visible', true),
+            legend: {
+                enabled: get(series, 'legend.enabled', legend.enabled),
+                symbol: prepareLegendSymbol(series),
+            },
+            data: series.data,
+            dataLabels: {
+                enabled: ((_a = series.dataLabels) === null || _a === void 0 ? void 0 : _a.enabled) || false,
+                style: Object.assign({}, DEFAULT_DATALABELS_STYLE, (_b = series.dataLabels) === null || _b === void 0 ? void 0 : _b.style),
+                allowOverlap: ((_c = series.dataLabels) === null || _c === void 0 ? void 0 : _c.allowOverlap) || false,
+                padding: get(series, 'dataLabels.padding', DEFAULT_DATALABELS_PADDING),
+                html: get(series, 'dataLabels.html', false),
+            },
+            cursor: get(series, 'cursor', null),
+        };
+        return prepared;
+    }, []);
+}

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

@@ -0,0 +1,10 @@
+import type { ScaleOrdinal } from 'd3';
+import type { ChartSeries, ChartSeriesOptions } from '../../types';
+import type { PreparedLegend, PreparedSeries } from './types';
+export declare function prepareSeries(args: {
+    type: ChartSeries['type'];
+    series: ChartSeries[];
+    seriesOptions?: ChartSeriesOptions;
+    legend: PreparedLegend;
+    colorScale: ScaleOrdinal<string, string>;
+}): PreparedSeries[];

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

@@ -0,0 +1,65 @@
+import { ChartError } from '../../libs';
+import { prepareArea } from './prepare-area';
+import { prepareBarXSeries } from './prepare-bar-x';
+import { prepareBarYSeries } from './prepare-bar-y';
+import { prepareLineSeries } from './prepare-line';
+import { preparePieSeries } from './prepare-pie';
+import { prepareScatterSeries } from './prepare-scatter';
+import { prepareTreemap } from './prepare-treemap';
+import { prepareWaterfallSeries } from './prepare-waterfall';
+export function prepareSeries(args) {
+    const { type, series, seriesOptions, legend, colorScale } = args;
+    switch (type) {
+        case 'pie': {
+            return series.reduce((acc, singleSeries) => {
+                acc.push(...preparePieSeries({ series: singleSeries, seriesOptions, legend }));
+                return acc;
+            }, []);
+        }
+        case 'bar-x': {
+            return prepareBarXSeries({ series: series, legend, colorScale });
+        }
+        case 'bar-y': {
+            return prepareBarYSeries({ series: series, legend, colorScale });
+        }
+        case 'scatter': {
+            return prepareScatterSeries({ series: series, legend, colorScale });
+        }
+        case 'line': {
+            return prepareLineSeries({
+                series: series,
+                seriesOptions,
+                legend,
+                colorScale,
+            });
+        }
+        case 'area': {
+            return prepareArea({
+                series: series,
+                seriesOptions,
+                legend,
+                colorScale,
+            });
+        }
+        case 'treemap': {
+            return prepareTreemap({
+                series: series,
+                seriesOptions,
+                legend,
+                colorScale,
+            });
+        }
+        case 'waterfall': {
+            return prepareWaterfallSeries({
+                series: series,
+                legend,
+                colorScale,
+            });
+        }
+        default: {
+            throw new ChartError({
+                message: `Series type "${type}" does not support data preparation for series that do not support the presence of axes`,
+            });
+        }
+    }
+}