@gravity-ui/charts 1.16.0 → 1.17.0

package/dist/{esm/components/Axis → cjs/components/AxisX}/AxisX.js

@@ -1,23 +1,9 @@
 import React from 'react';
 import { line, select } from 'd3';
-import { block, formatAxisTickLabel, getAxisTitleRows, getBandsPosition, getClosestPointsRange, getLineDashArray, getMaxTickCount, getScaleTicks, getTicksCount, handleOverflowingText, } from '../../utils';
+import { block, getAxisTitleRows, getBandsPosition, getLabelFormatter, getLineDashArray, getMaxTickCount, getTicksCount, handleOverflowingText, } from '../../utils';
 import { axisBottom } from '../../utils/chart/axis-generators';
 import './styles.css';
 const b = block('axis');
-function getLabelFormatter({ axis, scale }) {
-    const ticks = getScaleTicks(scale);
-    const tickStep = getClosestPointsRange(axis, ticks);
-    return (value) => {
-        if (!axis.labels.enabled) {
-            return '';
-        }
-        return formatAxisTickLabel({
-            axis,
-            value,
-            step: tickStep,
-        });
-    };
-}
 export function getTitlePosition(args) {
     const { axis, width, rowCount } = args;
     if (rowCount < 1) {

package/dist/{esm/components/Axis → cjs/components/AxisY}/AxisY.d.ts

@@ -1,19 +1,11 @@
 import React from 'react';
-import type { ChartScale, PreparedAxis, PreparedSplit } from '../../hooks';
+import type { AxisYData } from './types';
 import './styles.css';
 interface Props {
-    axes: PreparedAxis[];
-    boundsOffsetTop: number;
-    boundsOffsetLeft: number;
-    scale: ChartScale[];
-    width: number;
-    height: number;
+    preparedAxisData: AxisYData;
     htmlLayout: HTMLElement | null;
-    split: PreparedSplit;
     plotBeforeRef?: React.MutableRefObject<SVGGElement | null>;
     plotAfterRef?: React.MutableRefObject<SVGGElement | null>;
-    bottomLimit?: number;
-    topLimit?: number;
 }
 export declare const AxisY: (props: Props) => React.JSX.Element;
 export {};

package/dist/cjs/components/AxisY/AxisY.js

@@ -0,0 +1,173 @@
+import React from 'react';
+import { line, select } from 'd3';
+import { HtmlLayer } from '../../hooks/useShapes/HtmlLayer';
+import { block, getLineDashArray } from '../../utils';
+import './styles.css';
+const b = block('y-axis');
+export const AxisY = (props) => {
+    const { htmlLayout, plotBeforeRef, plotAfterRef, preparedAxisData } = props;
+    const ref = React.useRef(null);
+    const lineGenerator = line();
+    const htmlLabels = preparedAxisData.ticks.map((d) => d.htmlLabel).filter(Boolean);
+    React.useEffect(() => {
+        if (!ref.current) {
+            return;
+        }
+        const svgElement = select(ref.current);
+        svgElement.selectAll('*').remove();
+        let plotBeforeContainer = null;
+        let plotAfterContainer = null;
+        const plotDataAttr = 'data-plot-y';
+        if (plotBeforeRef === null || plotBeforeRef === void 0 ? void 0 : plotBeforeRef.current) {
+            plotBeforeContainer = select(plotBeforeRef.current);
+            plotBeforeContainer.selectAll(`[${plotDataAttr}]`).remove();
+        }
+        if (plotAfterRef === null || plotAfterRef === void 0 ? void 0 : plotAfterRef.current) {
+            plotAfterContainer = select(plotAfterRef.current);
+            plotAfterContainer.selectAll(`[${plotDataAttr}]`).remove();
+        }
+        if (preparedAxisData.title) {
+            svgElement
+                .append('g')
+                .attr('class', b('title'))
+                .append('text')
+                .attr('text-anchor', 'start')
+                .style('dominant-baseline', 'text-after-edge')
+                .style('transform', `translate(${preparedAxisData.title.x}px, ${preparedAxisData.title.y}px) rotate(${preparedAxisData.title.rotate}deg) translate(0px, ${preparedAxisData.title.offset}px)`)
+                .attr('font-size', preparedAxisData.title.style.fontSize)
+                .selectAll('tspan')
+                .data(preparedAxisData.title.content)
+                .join('tspan')
+                .html((d) => d.text)
+                .attr('x', (d) => d.x)
+                .attr('y', (d) => d.y)
+                .attr('text-anchor', 'start');
+        }
+        svgElement
+            .append('path')
+            .attr('class', b('domain'))
+            .attr('d', lineGenerator([preparedAxisData.domain.start, preparedAxisData.domain.end]))
+            .style('stroke', preparedAxisData.domain.lineColor);
+        const tickClassName = b('tick');
+        const ticks = svgElement
+            .selectAll(`.${tickClassName}`)
+            .remove()
+            .data(preparedAxisData.ticks)
+            .join('g')
+            .attr('class', tickClassName);
+        const labelClassName = b('label');
+        ticks.each(function () {
+            var _a;
+            const tickSelection = select(this);
+            const tickData = tickSelection.datum();
+            if (tickData.line) {
+                tickSelection.append('path').attr('d', lineGenerator(tickData.line.points));
+            }
+            if (tickData.svgLabel) {
+                const label = tickData.svgLabel;
+                const textSelection = tickSelection.append('text');
+                if (label.title) {
+                    textSelection.append('title').html(label.title);
+                }
+                textSelection
+                    .selectAll('tspan')
+                    .data(label.content)
+                    .join('tspan')
+                    .html((d) => d.text)
+                    .attr('x', (d) => d.x)
+                    .attr('y', (d) => d.y)
+                    .attr('text-anchor', 'start')
+                    .attr('class', labelClassName)
+                    .style('dominant-baseline', 'text-before-edge')
+                    .style('font-size', label.style.fontSize)
+                    .style('fill', (_a = label.style.fontColor) !== null && _a !== void 0 ? _a : '');
+            }
+        });
+        if (preparedAxisData.plotBands.length > 0) {
+            const plotBandDataAttr = `data-plot-y-band-${preparedAxisData.id}`;
+            const setPlotBands = (plotContainer, plotBands) => {
+                if (!plotContainer || !plotBands.length) {
+                    return;
+                }
+                const plotBandsSelection = plotContainer
+                    .selectAll(`[${plotBandDataAttr}]`)
+                    .remove()
+                    .data(plotBands)
+                    .join('g')
+                    .attr(plotDataAttr, 1)
+                    .attr(plotBandDataAttr, 1)
+                    .style('transform', (d) => `translate(${d.x}px, ${d.y}px)`);
+                plotBandsSelection
+                    .append('rect')
+                    .attr('width', (d) => d.width)
+                    .attr('height', (d) => d.height)
+                    .attr('fill', (d) => d.color)
+                    .attr('opacity', (d) => d.opacity);
+                plotBandsSelection.each(function () {
+                    var _a, _b;
+                    const plotBandSelection = select(this);
+                    const band = plotBandSelection.datum();
+                    const label = band.label;
+                    if (label) {
+                        plotBandSelection
+                            .append('text')
+                            .html(label.text)
+                            .style('fill', (_a = label.style.fontColor) !== null && _a !== void 0 ? _a : '')
+                            .style('font-size', label.style.fontSize)
+                            .style('font-weight', (_b = label.style.fontWeight) !== null && _b !== void 0 ? _b : '')
+                            .style('dominant-baseline', 'text-before-edge')
+                            .attr('x', label.x)
+                            .attr('y', label.y);
+                    }
+                });
+            };
+            setPlotBands(plotBeforeContainer, preparedAxisData.plotBands.filter((item) => item.layerPlacement === 'before'));
+            setPlotBands(plotAfterContainer, preparedAxisData.plotBands.filter((item) => item.layerPlacement === 'after'));
+        }
+        if (preparedAxisData.plotLines.length > 0) {
+            const plotLineDataAttr = `data-plot-y-line-${preparedAxisData.id}`;
+            const setPlotLines = (plotContainer, plotLines) => {
+                if (!plotContainer || !plotLines.length) {
+                    return;
+                }
+                const plotLinesSelection = plotContainer
+                    .selectAll(`[${plotLineDataAttr}]`)
+                    .remove()
+                    .data(plotLines)
+                    .join('g')
+                    .attr(plotDataAttr, 1)
+                    .attr(plotLineDataAttr, 1)
+                    .style('transform', (d) => `translate(${d.x}px, ${d.y}px)`);
+                plotLinesSelection
+                    .append('path')
+                    .attr('d', (d) => lineGenerator(d.points))
+                    .attr('stroke', (d) => d.color)
+                    .attr('stroke-width', (d) => d.lineWidth)
+                    .attr('stroke-dasharray', (d) => getLineDashArray(d.dashStyle, d.lineWidth))
+                    .attr('opacity', (d) => d.opacity);
+                plotLinesSelection.each(function () {
+                    var _a, _b;
+                    const itemSelection = select(this);
+                    const plotLine = itemSelection.datum();
+                    const label = plotLine.label;
+                    if (label) {
+                        itemSelection
+                            .append('text')
+                            .text(label.text)
+                            .style('fill', (_a = label.style.fontColor) !== null && _a !== void 0 ? _a : '')
+                            .style('font-size', label.style.fontSize)
+                            .style('font-weight', (_b = label.style.fontWeight) !== null && _b !== void 0 ? _b : '')
+                            .style('dominant-baseline', 'text-before-edge')
+                            .attr('x', label.x)
+                            .attr('y', label.y);
+                    }
+                });
+            };
+            setPlotLines(plotBeforeContainer, preparedAxisData.plotLines.filter((item) => item.layerPlacement === 'before'));
+            setPlotLines(plotAfterContainer, preparedAxisData.plotLines.filter((item) => item.layerPlacement === 'after'));
+        }
+    }, [lineGenerator, plotAfterRef, plotBeforeRef, preparedAxisData]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(HtmlLayer, { preparedData: { htmlElements: htmlLabels }, htmlLayout: htmlLayout }),
+        React.createElement("g", { ref: ref, className: b() })));
+};

package/dist/cjs/components/AxisY/prepare-axis-data.d.ts

@@ -0,0 +1,9 @@
+import type { ChartScale, PreparedAxis, PreparedSplit } from '../../hooks';
+import type { AxisYData } from './types';
+export declare function prepareAxisData({ axis, split, scale, width, height, }: {
+    axis: PreparedAxis;
+    split: PreparedSplit;
+    scale: ChartScale;
+    width: number;
+    height: number;
+}): Promise<AxisYData>;

package/dist/cjs/components/AxisY/prepare-axis-data.js

@@ -0,0 +1,306 @@
+import { getUniqId } from '@gravity-ui/uikit';
+import { calculateCos, calculateSin, getBandsPosition, getLabelFormatter, getLabelsSize, getTextSizeFn, getTextWithElipsis, wrapText, } from '../../utils';
+import { getTickValues } from './utils';
+async function getSvgAxisLabel({ getTextSize, text, axis, top, left, labelMaxHeight, }) {
+    var _a;
+    const originalTextSize = await getTextSize(text);
+    // Currently, a preliminary label calculation is used to build the chart - we cannot exceed it here.
+    // Therefore, we rely on a pre-calculated number instead of the current maximum label width.
+    const labelMaxWidth = axis.labels.width; //axis.labels.maxWidth;
+    const size = originalTextSize;
+    const content = [];
+    // Warp label text only for categories - it will look strange for numbers or dates.
+    if (originalTextSize.width > labelMaxWidth && axis.type === 'category') {
+        const textRows = await wrapText({
+            text,
+            style: axis.labels.style,
+            width: labelMaxWidth,
+            getTextSize,
+        });
+        let topOffset = top;
+        let newLabelWidth = 0;
+        let newLabelHeight = 0;
+        for (let textRowIndex = 0; textRowIndex < textRows.length; textRowIndex++) {
+            const textRow = textRows[textRowIndex];
+            let textSize = await getTextSize(textRow.text);
+            if (newLabelHeight + textSize.height <= labelMaxHeight) {
+                newLabelWidth = Math.max(newLabelWidth, textSize.width);
+                newLabelHeight += textSize.height;
+                let rowText = textRow.text.trim();
+                if (textRowIndex < textRows.length - 1) {
+                    const nextTextRow = textRows[textRowIndex + 1];
+                    if (newLabelHeight + (await getTextSize(nextTextRow.text)).height >
+                        labelMaxHeight) {
+                        rowText = textRow.text + nextTextRow.text;
+                    }
+                }
+                textSize = await getTextSize(rowText);
+                if (textSize.width > labelMaxWidth) {
+                    rowText = await getTextWithElipsis({
+                        text: rowText,
+                        getTextWidth: async (str) => (await getTextSize(str)).width,
+                        maxWidth: labelMaxWidth,
+                    });
+                    textSize = await getTextSize(rowText);
+                }
+                const x = axis.position === 'left'
+                    ? left - textSize.width - axis.labels.margin
+                    : left + axis.labels.margin;
+                content.push({
+                    text: rowText,
+                    x,
+                    y: topOffset,
+                    size: textSize,
+                });
+                topOffset += textSize.height;
+            }
+        }
+        content.forEach((row) => {
+            row.y -= newLabelHeight / 2;
+        });
+        size.width = newLabelWidth;
+        size.height = newLabelHeight;
+    }
+    else {
+        const x = axis.position === 'left'
+            ? left - size.width - axis.labels.margin
+            : left + axis.labels.margin;
+        content.push({
+            text,
+            x,
+            y: Math.max(0, top - size.height / 2),
+            size,
+        });
+    }
+    const svgLabel = {
+        title: content.length > 1 || ((_a = content[0]) === null || _a === void 0 ? void 0 : _a.text) !== text ? text : undefined,
+        content: content,
+        style: axis.labels.style,
+        size: size,
+    };
+    return svgLabel;
+}
+// eslint-disable-next-line complexity
+export async function prepareAxisData({ axis, split, scale, width, height, }) {
+    var _a, _b, _c;
+    const axisPlotTopPosition = ((_a = split.plots[axis.plotIndex]) === null || _a === void 0 ? void 0 : _a.top) || 0;
+    const axisHeight = ((_b = split.plots[axis.plotIndex]) === null || _b === void 0 ? void 0 : _b.height) || height;
+    const domainX = axis.position === 'left' ? 0 : width;
+    const domain = {
+        start: [domainX, axisPlotTopPosition],
+        end: [domainX, axisPlotTopPosition + axisHeight],
+        lineColor: (_c = axis.lineColor) !== null && _c !== void 0 ? _c : '',
+    };
+    const ticks = [];
+    const getTextSize = getTextSizeFn({ style: axis.labels.style });
+    const labelLineHeight = (await getTextSize('Tmp')).height;
+    const values = getTickValues({ scale, axis, labelLineHeight });
+    const labelMaxHeight = values.length > 1 ? values[0].y - values[1].y - axis.labels.padding * 2 : axisHeight;
+    const labelFormatter = getLabelFormatter({ axis, scale });
+    for (let i = 0; i < values.length; i++) {
+        const tickValue = values[i];
+        const y = axisPlotTopPosition + tickValue.y;
+        let svgLabel = null;
+        let htmlLabel = null;
+        if (axis.labels.enabled) {
+            if (axis.labels.html) {
+                const content = String(tickValue.value);
+                const labelSize = await getLabelsSize({
+                    labels: [content],
+                    html: true,
+                    style: axis.labels.style,
+                });
+                const size = { width: labelSize.maxWidth, height: labelSize.maxHeight };
+                const left = domainX;
+                const top = y;
+                const x = axis.position === 'left'
+                    ? left - size.width - axis.labels.margin
+                    : left + axis.labels.margin;
+                htmlLabel = {
+                    content,
+                    x,
+                    y: top - size.height / 2,
+                    size,
+                    style: axis.labels.style,
+                };
+            }
+            else {
+                const text = labelFormatter(tickValue.value);
+                svgLabel = await getSvgAxisLabel({
+                    getTextSize,
+                    text,
+                    axis,
+                    top: y,
+                    left: domainX,
+                    labelMaxHeight,
+                });
+            }
+        }
+        const tickLine = axis.grid.enabled
+            ? {
+                points: [
+                    [0, y],
+                    [width, y],
+                ],
+            }
+            : null;
+        ticks.push({
+            line: tickLine,
+            svgLabel,
+            htmlLabel,
+        });
+    }
+    let labelsWidth = ticks.reduce((acc, item) => { var _a, _b, _c, _d; return Math.max(acc, (_d = (_b = (_a = item.svgLabel) === null || _a === void 0 ? void 0 : _a.size.width) !== null && _b !== void 0 ? _b : (_c = item.htmlLabel) === null || _c === void 0 ? void 0 : _c.size.width) !== null && _d !== void 0 ? _d : 0); }, 0);
+    labelsWidth = Math.min(axis.labels.width, labelsWidth);
+    let title = null;
+    if (axis.title.text) {
+        const getTitleTextSize = getTextSizeFn({ style: axis.title.style });
+        const rotateAngle = axis.position === 'left' ? -90 : 90;
+        const sin = Math.abs(calculateSin(rotateAngle));
+        const cos = Math.abs(calculateCos(rotateAngle));
+        const titleContent = [];
+        const titleMaxWidth = sin * axisHeight;
+        if (axis.title.maxRowCount > 1) {
+            const titleTextRows = await wrapText({
+                text: axis.title.text,
+                style: axis.title.style,
+                width: titleMaxWidth,
+                getTextSize: getTitleTextSize,
+            });
+            for (let i = 0; i < axis.title.maxRowCount && i < titleTextRows.length; i++) {
+                const textRow = titleTextRows[i];
+                const textRowContent = textRow.text.trim();
+                const textRowSize = await getTitleTextSize(textRowContent);
+                titleContent.push({
+                    text: textRowContent,
+                    x: 0,
+                    y: textRow.y,
+                    size: textRowSize,
+                });
+            }
+        }
+        else {
+            const text = await getTextWithElipsis({
+                text: axis.title.text,
+                maxWidth: titleMaxWidth,
+                getTextWidth: async (s) => (await getTitleTextSize(s)).width,
+            });
+            titleContent.push({
+                text,
+                x: 0,
+                y: 0,
+                size: await getTitleTextSize(text),
+            });
+        }
+        const originalTextSize = titleContent.reduce((acc, item) => {
+            acc.width = Math.max(acc.width, item.size.width);
+            acc.height += item.size.height;
+            return acc;
+        }, { width: 0, height: 0 });
+        const rotatedTitleSize = {
+            width: sin * originalTextSize.height + cos * originalTextSize.width,
+            height: sin * originalTextSize.width + cos * originalTextSize.height,
+        };
+        const bottom = Math.max(0, calculateSin(rotateAngle) * originalTextSize.width);
+        let y = 0;
+        switch (axis.title.align) {
+            case 'left': {
+                y = -bottom + axisHeight;
+                break;
+            }
+            case 'center': {
+                y = -bottom + axisHeight / 2 + rotatedTitleSize.height / 2;
+                break;
+            }
+            case 'right': {
+                y = -bottom + rotatedTitleSize.height;
+                break;
+            }
+        }
+        const left = Math.min(0, calculateCos(rotateAngle) * originalTextSize.width);
+        const x = axis.position === 'left'
+            ? -left - labelsWidth - axis.labels.margin - axis.title.margin
+            : -left + width + labelsWidth + axis.labels.margin + axis.title.margin;
+        title = {
+            content: titleContent,
+            style: axis.title.style,
+            size: rotatedTitleSize,
+            x: x,
+            y: axisPlotTopPosition + y,
+            rotate: rotateAngle,
+            offset: -(originalTextSize.height / titleContent.length) * (titleContent.length - 1),
+        };
+    }
+    const plotBands = [];
+    axis.plotBands.forEach((plotBand) => {
+        var _a, _b;
+        const axisScale = scale;
+        const { from, to } = getBandsPosition({
+            band: plotBand,
+            axisScale,
+            axis: 'y',
+        });
+        const halfBandwidth = ((_b = (_a = axisScale.bandwidth) === null || _a === void 0 ? void 0 : _a.call(axisScale)) !== null && _b !== void 0 ? _b : 0) / 2;
+        const startPos = halfBandwidth + Math.min(from, to);
+        const endPos = Math.min(Math.abs(to - from), axisHeight - Math.min(from, to));
+        const top = Math.max(0, startPos);
+        plotBands.push({
+            layerPlacement: plotBand.layerPlacement,
+            x: 0,
+            y: axisPlotTopPosition + top,
+            width,
+            height: Math.min(endPos, axisHeight),
+            color: plotBand.color,
+            opacity: plotBand.opacity,
+            label: plotBand.label.text
+                ? {
+                    text: plotBand.label.text,
+                    style: plotBand.label.style,
+                    x: plotBand.label.padding,
+                    y: plotBand.label.padding,
+                }
+                : null,
+        });
+    });
+    const plotLines = [];
+    for (let i = 0; i < axis.plotLines.length; i++) {
+        const plotLine = axis.plotLines[i];
+        const axisScale = scale;
+        const plotLineValue = Number(axisScale(plotLine.value));
+        const points = [
+            [0, plotLineValue],
+            [width, plotLineValue],
+        ];
+        let label = null;
+        if (plotLine.label.text) {
+            const getTitleTextSize = getTextSizeFn({ style: plotLine.label.style });
+            const size = await getTitleTextSize(plotLine.label.text);
+            label = {
+                text: plotLine.label.text,
+                style: plotLine.label.style,
+                x: plotLine.label.padding,
+                y: Math.max(0, plotLineValue - size.height - plotLine.label.padding),
+            };
+        }
+        plotLines.push({
+            layerPlacement: plotLine.layerPlacement,
+            x: 0,
+            y: axisPlotTopPosition,
+            width,
+            color: plotLine.color,
+            opacity: plotLine.opacity,
+            label,
+            points,
+            lineWidth: plotLine.width,
+            dashStyle: plotLine.dashStyle,
+        });
+    }
+    return {
+        id: getUniqId(),
+        title,
+        ticks,
+        domain,
+        plotBands,
+        plotLines,
+    };
+}

package/dist/cjs/components/AxisY/styles.css

@@ -0,0 +1,15 @@
+.gcharts-y-axis__domain {
+  stroke: var(--g-color-line-generic-active);
+}
+.gcharts-y-axis__label {
+  fill: var(--g-color-text-secondary);
+  stroke: none;
+  dominant-baseline: text-after-edge;
+}
+.gcharts-y-axis__tick {
+  stroke: var(--g-color-line-generic);
+}
+.gcharts-y-axis__title {
+  dominant-baseline: text-after-edge;
+  fill: var(--g-color-text-secondary);
+}

package/dist/cjs/components/AxisY/types.d.ts

@@ -0,0 +1,81 @@
+import type { DashStyle } from 'src/constants';
+import type { BaseTextStyle, HtmlItem, PlotLayerPlacement } from '../../types';
+export type TextRowData = {
+    text: string;
+    x: number;
+    y: number;
+    size: {
+        width: number;
+        height: number;
+    };
+};
+export type AxisSvgLabelData = {
+    content: TextRowData[];
+    title?: string;
+    style: BaseTextStyle;
+    size: {
+        width: number;
+        height: number;
+    };
+};
+export type AxisTickLine = {
+    points: [number, number][];
+};
+export type AxisTickData = {
+    line: AxisTickLine | null;
+    svgLabel: AxisSvgLabelData | null;
+    htmlLabel: HtmlItem | null;
+};
+export type AxisTitleData = {
+    content: TextRowData[];
+    style: BaseTextStyle;
+    size: {
+        width: number;
+        height: number;
+    };
+    x: number;
+    y: number;
+    rotate: number;
+    offset: number;
+};
+export type AxisPlotLineLabel = {
+    text: string;
+    style: BaseTextStyle;
+    x: number;
+    y: number;
+};
+export type AxisPlotLineData = {
+    layerPlacement: PlotLayerPlacement;
+    x: number;
+    y: number;
+    width: number;
+    points: [number, number][];
+    color: string;
+    lineWidth: number;
+    opacity: number;
+    label: AxisPlotLineLabel | null;
+    dashStyle: DashStyle;
+};
+export type AxisPlotBandData = {
+    layerPlacement: PlotLayerPlacement;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    opacity: number;
+    label: AxisPlotLineLabel | null;
+};
+export type AxisDomainData = {
+    start: [number, number];
+    end: [number, number];
+    lineColor: string;
+};
+export type AxisYData = {
+    id: string;
+    title: AxisTitleData | null;
+    domain: AxisDomainData;
+    ticks: AxisTickData[];
+    plotLines: AxisPlotLineData[];
+    plotBands: AxisPlotBandData[];
+};

package/dist/cjs/components/AxisY/types.js

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

package/dist/cjs/components/AxisY/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ChartScale, PreparedAxis } from '../../hooks';
+export declare function getTickValues({ scale, axis, labelLineHeight, }: {
+    scale: ChartScale;
+    axis: PreparedAxis;
+    labelLineHeight: number;
+}): {
+    y: number;
+    value: number | Date;
+}[] | {
+    y: number;
+    value: string;
+}[];