@gravity-ui/charts 0.1.0

package/dist/esm/utils/chart/get-closest-data.js

@@ -0,0 +1,172 @@
+import { Delaunay, bisector, sort } from 'd3';
+import get from 'lodash/get';
+import groupBy from 'lodash/groupBy';
+function getClosestPointsByXValue(x, y, points) {
+    var _a, _b, _c, _d;
+    const sorted = sort(points, (p) => p.x);
+    const closestXIndex = bisector((p) => p.x).center(sorted, x);
+    if (closestXIndex === -1) {
+        return [];
+    }
+    const closestX = sorted[closestXIndex].x;
+    const closestPoints = sort(points.filter((p) => p.x === closestX), (p) => p.y0);
+    let closestYIndex = -1;
+    if (y < ((_a = closestPoints[0]) === null || _a === void 0 ? void 0 : _a.y0)) {
+        closestYIndex = 0;
+    }
+    else if (y > ((_b = closestPoints[closestPoints.length - 1]) === null || _b === void 0 ? void 0 : _b.y1)) {
+        closestYIndex = closestPoints.length - 1;
+    }
+    else {
+        closestYIndex = closestPoints.findIndex((p) => y > p.y0 && y < p.y1);
+        if (closestYIndex === -1) {
+            const sortedY = sort(closestPoints.map((p, index) => ({ index, y: p.y1 + (p.y0 - p.y1) / 2 })), (p) => p.y);
+            const sortedYIndex = bisector((p) => p.y).center(sortedY, y);
+            closestYIndex = (_d = (_c = sortedY[sortedYIndex]) === null || _c === void 0 ? void 0 : _c.index) !== null && _d !== void 0 ? _d : -1;
+        }
+    }
+    return closestPoints.map((p, i) => ({
+        data: p.data,
+        series: p.series,
+        closest: i === closestYIndex,
+    }));
+}
+function getSeriesType(shapeData) {
+    return get(shapeData, 'series.type') || get(shapeData, 'point.series.type');
+}
+export function getClosestPoints(args) {
+    const { position, shapesData } = args;
+    const [pointerX, pointerY] = position;
+    const result = [];
+    const groups = groupBy(shapesData, getSeriesType);
+    Object.entries(groups).forEach(([seriesType, list]) => {
+        var _a, _b;
+        switch (seriesType) {
+            case 'bar-x': {
+                const points = list.map((d) => ({
+                    data: d.data,
+                    series: d.series,
+                    x: d.x + d.width / 2,
+                    y0: d.y,
+                    y1: d.y + d.height,
+                }));
+                result.push(...getClosestPointsByXValue(pointerX, pointerY, points));
+                break;
+            }
+            case 'waterfall': {
+                const points = list.map((d) => ({
+                    data: d.data,
+                    series: d.series,
+                    x: d.x + d.width / 2,
+                    y0: d.y,
+                    y1: d.y + d.height,
+                }));
+                result.push(...getClosestPointsByXValue(pointerX, pointerY, points));
+                break;
+            }
+            case 'area': {
+                const points = list.reduce((acc, d) => {
+                    Array.prototype.push.apply(acc, d.points.map((p) => ({
+                        data: p.data,
+                        series: p.series,
+                        x: p.x,
+                        y0: p.y0,
+                        y1: p.y,
+                    })));
+                    return acc;
+                }, []);
+                result.push(...getClosestPointsByXValue(pointerX, pointerY, points));
+                break;
+            }
+            case 'line': {
+                const points = list.reduce((acc, d) => {
+                    acc.push(...d.points.map((p) => ({
+                        data: p.data,
+                        series: p.series,
+                        x: p.x,
+                        y0: p.y,
+                        y1: p.y,
+                    })));
+                    return acc;
+                }, []);
+                result.push(...getClosestPointsByXValue(pointerX, pointerY, points));
+                break;
+            }
+            case 'bar-y': {
+                const points = list;
+                const sorted = sort(points, (p) => p.y);
+                const closestYIndex = bisector((p) => p.y).center(sorted, pointerY);
+                let closestPoints = [];
+                let closestXIndex = -1;
+                if (closestYIndex !== -1) {
+                    const closestY = sorted[closestYIndex].y;
+                    closestPoints = sort(points.filter((p) => p.y === closestY), (p) => p.x);
+                    const lastPoint = closestPoints[closestPoints.length - 1];
+                    if (pointerX < ((_a = closestPoints[0]) === null || _a === void 0 ? void 0 : _a.x)) {
+                        closestXIndex = 0;
+                    }
+                    else if (lastPoint && pointerX > lastPoint.x + lastPoint.width) {
+                        closestXIndex = closestPoints.length - 1;
+                    }
+                    else {
+                        closestXIndex = closestPoints.findIndex((p) => pointerX > p.x && pointerX < p.x + p.width);
+                    }
+                }
+                result.push(...closestPoints.map((p, i) => ({
+                    data: p.data,
+                    series: p.series,
+                    closest: i === closestXIndex,
+                })));
+                break;
+            }
+            case 'scatter': {
+                const points = list;
+                const delaunayX = Delaunay.from(points, (d) => d.point.x, (d) => d.point.y);
+                const closestPoint = points[delaunayX.find(pointerX, pointerY)];
+                if (closestPoint) {
+                    result.push({
+                        data: closestPoint.point.data,
+                        series: closestPoint.point.series,
+                        closest: true,
+                    });
+                }
+                break;
+            }
+            case 'pie': {
+                const points = list.map((d) => d.segments).flat();
+                const closestPoint = points.find((p) => {
+                    const { center, radius } = p.data.pie;
+                    const x = pointerX - center[0];
+                    const y = pointerY - center[1];
+                    let angle = Math.atan2(y, x) + 0.5 * Math.PI;
+                    angle = angle < 0 ? Math.PI * 2 + angle : angle;
+                    const polarRadius = Math.sqrt(x * x + y * y);
+                    return angle >= p.startAngle && angle <= p.endAngle && polarRadius < radius;
+                });
+                if (closestPoint) {
+                    result.push({
+                        data: closestPoint.data.series.data,
+                        series: closestPoint.data.series,
+                        closest: true,
+                    });
+                }
+                break;
+            }
+            case 'treemap': {
+                const data = list;
+                const closestPoint = (_b = data[0]) === null || _b === void 0 ? void 0 : _b.leaves.find((l) => {
+                    return (pointerX >= l.x0 && pointerX <= l.x1 && pointerY >= l.y0 && pointerY <= l.y1);
+                });
+                if (closestPoint) {
+                    result.push({
+                        data: closestPoint.data,
+                        series: data[0].series,
+                        closest: true,
+                    });
+                }
+                break;
+            }
+        }
+    });
+    return result;
+}

package/dist/esm/utils/chart/index.d.ts

@@ -0,0 +1,78 @@
+import type { AxisDomain } from 'd3';
+import type { PreparedAxis } from '../../hooks';
+import type { BaseTextStyle, ChartSeries, ChartSeriesData } from '../../types';
+export * from './math';
+export * from './text';
+export * from './time';
+export * from './axis';
+export * from './labels';
+export * from './legend';
+export * from './symbol';
+export * from './series';
+export * from './color';
+export declare const CHART_SERIES_WITH_VOLUME_ON_Y_AXIS: ChartSeries['type'][];
+export declare const CHART_SERIES_WITH_VOLUME_ON_X_AXIS: ChartSeries['type'][];
+export type AxisDirection = 'x' | 'y';
+type UnknownSeries = {
+    type: ChartSeries['type'];
+    data: unknown;
+};
+/**
+ * Checks whether the series should be drawn with axes.
+ *
+ * @param series - The series object to check.
+ * @returns `true` if the series should be drawn with axes, `false` otherwise.
+ */
+export declare function isAxisRelatedSeries(series: UnknownSeries): boolean;
+export declare function isSeriesWithNumericalXValues(series: UnknownSeries): series is {
+    type: ChartSeries['type'];
+    data: {
+        x: number;
+    }[];
+};
+export declare function isSeriesWithNumericalYValues(series: UnknownSeries): series is {
+    type: ChartSeries['type'];
+    data: {
+        y: number;
+    }[];
+};
+export declare function isSeriesWithCategoryValues(series: UnknownSeries): series is {
+    type: ChartSeries['type'];
+    data: {
+        category: string;
+    }[];
+};
+export declare const getDomainDataXBySeries: (series: UnknownSeries[]) => unknown[];
+export declare function getDefaultMaxXAxisValue(series: UnknownSeries[]): 0 | undefined;
+export declare const getDomainDataYBySeries: (series: UnknownSeries[]) => unknown[];
+export declare const getSeriesNames: (series: ChartSeries[]) => string[];
+export declare const getOnlyVisibleSeries: <T extends {
+    visible: boolean;
+}>(series: T[]) => T[];
+export declare const parseTransformStyle: (style: string | null) => {
+    x?: number;
+    y?: number;
+};
+export declare const formatAxisTickLabel: (args: {
+    axis: PreparedAxis;
+    value: AxisDomain;
+    step?: number;
+}) => string;
+/**
+ * Calculates the height of a text element in a horizontal SVG layout.
+ *
+ * @param {Object} args - The arguments for the function.
+ * @param {string} args.text - The text to be measured.
+ * @param {Partial<BaseTextStyle>} args.style - Optional style properties for the text element.
+ * @return {number} The height of the text element.
+ */
+export declare const getHorisontalSvgTextHeight: (args: {
+    text: string;
+    style?: Partial<BaseTextStyle>;
+}) => number;
+export declare const getDataCategoryValue: (args: {
+    axisDirection: AxisDirection;
+    categories: string[];
+    data: ChartSeriesData;
+}) => string;
+export declare function getClosestPointsRange(axis: PreparedAxis, points: AxisDomain[]): number | undefined;

package/dist/esm/utils/chart/index.js

@@ -0,0 +1,210 @@
+import { dateTime } from '@gravity-ui/date-utils';
+import { group, select } from 'd3';
+import get from 'lodash/get';
+import isNil from 'lodash/isNil';
+import { DEFAULT_AXIS_LABEL_FONT_SIZE } from '../../constants';
+import { getSeriesStackId } from '../../hooks/useSeries/utils';
+import { formatNumber, getNumberUnitRate } from '../../libs/format-number';
+import { getDefaultDateFormat } from './time';
+export * from './math';
+export * from './text';
+export * from './time';
+export * from './axis';
+export * from './labels';
+export * from './legend';
+export * from './symbol';
+export * from './series';
+export * from './color';
+const CHARTS_WITHOUT_AXIS = ['pie', 'treemap'];
+export const CHART_SERIES_WITH_VOLUME_ON_Y_AXIS = [
+    'bar-x',
+    'area',
+    'waterfall',
+];
+export const CHART_SERIES_WITH_VOLUME_ON_X_AXIS = ['bar-y'];
+/**
+ * Checks whether the series should be drawn with axes.
+ *
+ * @param series - The series object to check.
+ * @returns `true` if the series should be drawn with axes, `false` otherwise.
+ */
+export function isAxisRelatedSeries(series) {
+    return !CHARTS_WITHOUT_AXIS.includes(series.type);
+}
+export function isSeriesWithNumericalXValues(series) {
+    return isAxisRelatedSeries(series);
+}
+export function isSeriesWithNumericalYValues(series) {
+    return isAxisRelatedSeries(series);
+}
+export function isSeriesWithCategoryValues(series) {
+    return isAxisRelatedSeries(series);
+}
+function getDomainDataForStackedSeries(seriesList, keyAttr = 'x', valueAttr = 'y') {
+    const acc = [];
+    const stackedSeries = group(seriesList, getSeriesStackId);
+    Array.from(stackedSeries).forEach(([_stackId, seriesStack]) => {
+        const values = {};
+        seriesStack.forEach((singleSeries) => {
+            const data = new Map();
+            singleSeries.data.forEach((point) => {
+                const key = String(point[keyAttr]);
+                let value = 0;
+                if (valueAttr in point && typeof point[valueAttr] === 'number') {
+                    value = point[valueAttr];
+                }
+                if (data.has(key)) {
+                    value = Math.max(value, data.get(key));
+                }
+                data.set(key, value);
+            });
+            Array.from(data).forEach(([key, value]) => {
+                values[key] = (values[key] || 0) + value;
+            });
+        });
+        acc.push(...Object.values(values));
+    });
+    return acc;
+}
+export const getDomainDataXBySeries = (series) => {
+    const groupedSeries = group(series, (item) => item.type);
+    return Array.from(groupedSeries).reduce((acc, [type, seriesList]) => {
+        switch (type) {
+            case 'bar-y': {
+                acc.push(...getDomainDataForStackedSeries(seriesList, 'y', 'x'));
+                break;
+            }
+            default: {
+                seriesList.filter(isSeriesWithNumericalXValues).forEach((s) => {
+                    acc.push(...s.data.map((d) => d.x));
+                });
+            }
+        }
+        return acc;
+    }, []);
+};
+export function getDefaultMaxXAxisValue(series) {
+    if (series.some((s) => s.type === 'bar-y')) {
+        return 0;
+    }
+    return undefined;
+}
+export const getDomainDataYBySeries = (series) => {
+    const groupedSeries = group(series, (item) => item.type);
+    return Array.from(groupedSeries).reduce((acc, [type, seriesList]) => {
+        switch (type) {
+            case 'area':
+            case 'bar-x': {
+                acc.push(...getDomainDataForStackedSeries(seriesList));
+                break;
+            }
+            case 'waterfall': {
+                let yValue = 0;
+                seriesList.forEach((s) => {
+                    s.data.forEach((d) => {
+                        yValue += Number(d.y) || 0;
+                        acc.push(yValue);
+                    });
+                });
+                break;
+            }
+            default: {
+                seriesList.filter(isSeriesWithNumericalYValues).forEach((s) => {
+                    acc.push(...s.data.map((d) => d.y));
+                });
+            }
+        }
+        return acc;
+    }, []);
+};
+// Uses to get all series names array (except `pie` charts)
+export const getSeriesNames = (series) => {
+    return series.reduce((acc, s) => {
+        if ('name' in s && typeof s.name === 'string') {
+            acc.push(s.name);
+        }
+        return acc;
+    }, []);
+};
+export const getOnlyVisibleSeries = (series) => {
+    return series.filter((s) => s.visible);
+};
+export const parseTransformStyle = (style) => {
+    var _a;
+    if (!style) {
+        return {};
+    }
+    const stringifiedValue = ((_a = style.match(/\((.*?)\)/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+    const [xString, yString] = stringifiedValue.split(',');
+    const x = Number.isNaN(Number(xString)) ? undefined : Number(xString);
+    const y = Number.isNaN(Number(yString)) ? undefined : Number(yString);
+    return { x, y };
+};
+export const formatAxisTickLabel = (args) => {
+    const { axis, value, step } = args;
+    switch (axis.type) {
+        case 'category': {
+            return value;
+        }
+        case 'datetime': {
+            const date = value;
+            const format = axis.labels.dateFormat || getDefaultDateFormat(step);
+            return dateTime({ input: date }).format(format);
+        }
+        case 'linear':
+        default: {
+            const numberFormat = Object.assign({ unitRate: value && step ? getNumberUnitRate(step) : undefined }, axis.labels.numberFormat);
+            return formatNumber(value, numberFormat);
+        }
+    }
+};
+/**
+ * Calculates the height of a text element in a horizontal SVG layout.
+ *
+ * @param {Object} args - The arguments for the function.
+ * @param {string} args.text - The text to be measured.
+ * @param {Partial<BaseTextStyle>} args.style - Optional style properties for the text element.
+ * @return {number} The height of the text element.
+ */
+export const getHorisontalSvgTextHeight = (args) => {
+    var _a;
+    const { text, style } = args;
+    const container = select(document.body).append('svg');
+    const textSelection = container.append('text').text(text);
+    const fontSize = get(style, 'fontSize', DEFAULT_AXIS_LABEL_FONT_SIZE);
+    if (fontSize) {
+        textSelection.style('font-size', fontSize).style('alignment-baseline', 'after-edge');
+    }
+    const height = ((_a = textSelection.node()) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect().height) || 0;
+    container.remove();
+    return height;
+};
+const extractCategoryValue = (args) => {
+    const { axisDirection, categories, data } = args;
+    const dataCategory = get(data, axisDirection);
+    let categoryValue;
+    if ('category' in data && data.category) {
+        categoryValue = data.category;
+    }
+    if (typeof dataCategory === 'string') {
+        categoryValue = dataCategory;
+    }
+    if (typeof dataCategory === 'number') {
+        categoryValue = categories[dataCategory];
+    }
+    if (isNil(categoryValue)) {
+        throw new Error('It seems you are trying to get non-existing category value');
+    }
+    return categoryValue;
+};
+export const getDataCategoryValue = (args) => {
+    const { axisDirection, categories, data } = args;
+    const categoryValue = extractCategoryValue({ axisDirection, categories, data });
+    return categoryValue;
+};
+export function getClosestPointsRange(axis, points) {
+    if (axis.type === 'category') {
+        return undefined;
+    }
+    return points[1] - points[0];
+}

package/dist/esm/utils/chart/labels.d.ts

@@ -0,0 +1,6 @@
+import type { LabelData } from '../../types';
+export declare function getLeftPosition(label: LabelData): number;
+export declare function getOverlappingByX(rect1: LabelData, rect2: LabelData, gap?: number): number;
+export declare function getOverlappingByY(rect1: LabelData, rect2: LabelData, gap?: number): number;
+export declare function isLabelsOverlapping<T extends LabelData>(label1: T, label2: T, padding?: number): boolean;
+export declare function filterOverlappingLabels<T extends LabelData>(labels: T[]): T[];

package/dist/esm/utils/chart/labels.js

@@ -0,0 +1,44 @@
+import sortBy from 'lodash/sortBy';
+export function getLeftPosition(label) {
+    switch (label.textAnchor) {
+        case 'start': {
+            return label.x;
+        }
+        case 'middle': {
+            return label.x - label.size.width / 2;
+        }
+        case 'end': {
+            return label.x - label.size.width;
+        }
+        default: {
+            return label.x;
+        }
+    }
+}
+export function getOverlappingByX(rect1, rect2, gap = 0) {
+    const left1 = getLeftPosition(rect1);
+    const right1 = left1 + rect1.size.width;
+    const left2 = getLeftPosition(rect2);
+    const right2 = left2 + rect2.size.width;
+    return Math.max(0, Math.min(right1, right2) - Math.max(left1, left2) + gap);
+}
+export function getOverlappingByY(rect1, rect2, gap = 0) {
+    const top1 = rect1.y - rect1.size.height;
+    const bottom1 = rect1.y;
+    const top2 = rect2.y - rect2.size.height;
+    const bottom2 = rect2.y;
+    return Math.max(0, Math.min(bottom1, bottom2) - Math.max(top1, top2) + gap);
+}
+export function isLabelsOverlapping(label1, label2, padding = 0) {
+    return Boolean(getOverlappingByX(label1, label2, padding) && getOverlappingByY(label1, label2, padding));
+}
+export function filterOverlappingLabels(labels) {
+    const result = [];
+    const sorted = sortBy(labels, (d) => d.y, getLeftPosition);
+    sorted.forEach((label) => {
+        if (!result.some((l) => isLabelsOverlapping(label, l))) {
+            result.push(label);
+        }
+    });
+    return result;
+}

package/dist/esm/utils/chart/legend.d.ts

@@ -0,0 +1,8 @@
+import type { Selection } from 'd3';
+export declare function createGradientRect(container: Selection<SVGGElement, unknown, null, undefined>, args: {
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    interpolator: (value: number) => string;
+}): Selection<SVGImageElement, unknown, null, undefined>;

package/dist/esm/utils/chart/legend.js

@@ -0,0 +1,23 @@
+export function createGradientRect(container, args) {
+    const { x = 0, y = 0, width, height, interpolator } = args;
+    const n = 256;
+    const canvas = document.createElement('canvas');
+    canvas.width = n;
+    canvas.height = 1;
+    const context = canvas.getContext('2d');
+    if (!context) {
+        throw Error("Couldn't get canvas context");
+    }
+    for (let i = 0, j = n - 1; i < n; ++i) {
+        context.fillStyle = interpolator(i / j);
+        context.fillRect(i, 0, 1, height);
+    }
+    return container
+        .append('image')
+        .attr('preserveAspectRatio', 'none')
+        .attr('height', height)
+        .attr('width', width)
+        .attr('x', x)
+        .attr('y', y)
+        .attr('xlink:href', canvas.toDataURL());
+}

package/dist/esm/utils/chart/math.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Calculates a numeric property based on the given arguments.
+ *
+ * @param {Object} args - The arguments for the calculation.
+ * @param {string | number | null} args.value - The value to calculate the property for.
+ * @param {number} args.base - The base value to use in the calculation.
+ * @return {number | undefined} The calculated numeric property, or undefined if the value is invalid.
+ * @example
+ * const result1 = calculateNumericProperty({value: 1});
+ * console.log(result1); // Output: 1
+ * const result2 = calculateNumericProperty({value: '10px'});
+ * console.log(result2); // Output: 10
+ * const result3 = calculateNumericProperty({value: '50%', base: 200});
+ * console.log(result3); // Output: 100
+ * const result4 = calculateNumericProperty({value: '50%'});
+ * console.log(result4); // Output: undefined
+ * const result5 = calculateNumericProperty({value: 'invalid_value'});
+ * console.log(result5); // Output: undefined
+ */
+export declare const calculateNumericProperty: (args: {
+    value?: string | number | null;
+    base?: number;
+}) => number | undefined;
+export declare function calculateCos(deg: number, precision?: number): number;
+export declare function calculateSin(deg: number, precision?: number): number;

package/dist/esm/utils/chart/math.js

@@ -0,0 +1,51 @@
+import isNil from 'lodash/isNil';
+const isStringValueInPercent = (value = '') => {
+    return value.endsWith('%') && !Number.isNaN(Number.parseFloat(value));
+};
+const isStringValueInPixel = (value = '') => {
+    return value.endsWith('px') && !Number.isNaN(Number.parseFloat(value));
+};
+/**
+ * Calculates a numeric property based on the given arguments.
+ *
+ * @param {Object} args - The arguments for the calculation.
+ * @param {string | number | null} args.value - The value to calculate the property for.
+ * @param {number} args.base - The base value to use in the calculation.
+ * @return {number | undefined} The calculated numeric property, or undefined if the value is invalid.
+ * @example
+ * const result1 = calculateNumericProperty({value: 1});
+ * console.log(result1); // Output: 1
+ * const result2 = calculateNumericProperty({value: '10px'});
+ * console.log(result2); // Output: 10
+ * const result3 = calculateNumericProperty({value: '50%', base: 200});
+ * console.log(result3); // Output: 100
+ * const result4 = calculateNumericProperty({value: '50%'});
+ * console.log(result4); // Output: undefined
+ * const result5 = calculateNumericProperty({value: 'invalid_value'});
+ * console.log(result5); // Output: undefined
+ */
+export const calculateNumericProperty = (args) => {
+    const { value = '', base } = args;
+    if (isNil(value)) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        if (isStringValueInPercent(value) && typeof base === 'number') {
+            const fraction = Number.parseFloat(value) / 100;
+            return base * fraction;
+        }
+        if (isStringValueInPixel(value)) {
+            return Number.parseFloat(value);
+        }
+        return undefined;
+    }
+    return value;
+};
+export function calculateCos(deg, precision = 2) {
+    const factor = Math.pow(10, precision);
+    return Math.floor(Math.cos((Math.PI / 180) * deg) * factor) / factor;
+}
+export function calculateSin(deg, precision = 2) {
+    const factor = Math.pow(10, precision);
+    return Math.floor(Math.sin((Math.PI / 180) * deg) * factor) / factor;
+}

package/dist/esm/utils/chart/series/index.d.ts

@@ -0,0 +1 @@
+export * from './waterfall';

package/dist/esm/utils/chart/series/index.js

@@ -0,0 +1 @@
+export * from './waterfall';

package/dist/esm/utils/chart/series/waterfall.d.ts

@@ -0,0 +1,4 @@
+import type { PreparedWaterfallSeries } from '../../../hooks';
+import type { WaterfallSeriesData } from '../../../types';
+export declare function getWaterfallPointColor(point: WaterfallSeriesData, series: PreparedWaterfallSeries): string;
+export declare function getWaterfallPointSubtotal(point: WaterfallSeriesData, series: PreparedWaterfallSeries): number | null;

package/dist/esm/utils/chart/series/waterfall.js

@@ -0,0 +1,25 @@
+export function getWaterfallPointColor(point, series) {
+    if (point.color) {
+        return point.color;
+    }
+    if (point.total) {
+        return series.color;
+    }
+    if (Number(point.y) > 0) {
+        return series.positiveColor;
+    }
+    return series.negativeColor;
+}
+export function getWaterfallPointSubtotal(point, series) {
+    const pointIndex = series.data.indexOf(point);
+    if (pointIndex === -1) {
+        return null;
+    }
+    return series.data.reduce((sum, d, index) => {
+        if (index <= pointIndex) {
+            const value = d.total ? 0 : Number(d.y);
+            return sum + value;
+        }
+        return sum;
+    }, 0);
+}

package/dist/esm/utils/chart/symbol.d.ts

@@ -0,0 +1,3 @@
+import { SymbolType } from '../../constants';
+export declare const getSymbolType: (index: number) => SymbolType;
+export declare const getSymbol: (symbolType: `${SymbolType}`) => import("d3-shape").SymbolType;