@gravity-ui/charts 1.32.1 → 1.34.0

package/dist/cjs/hooks/useAxisScales/x-scale.d.ts

@@ -0,0 +1,15 @@
+import type { PreparedAxis, PreparedSeries, RangeSliderState } from '../../hooks';
+import type { ChartAxis, ChartSeries } from '../../types';
+export declare function getXMaxDomainResult(args: {
+    xMaxDomain: number;
+    xMaxProps?: number;
+    xMaxRangeSlider?: number;
+    xMaxZoom?: number;
+}): number;
+export declare function createXScale(args: {
+    axis: PreparedAxis | ChartAxis;
+    boundsWidth: number;
+    series: (PreparedSeries | ChartSeries)[];
+    rangeSliderState?: RangeSliderState;
+    zoomStateX?: [number, number];
+}): import("d3-scale").ScaleBand<string> | import("d3-scale").ScaleLinear<number, number, never> | import("d3-scale").ScaleTime<number, number, never> | undefined;

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

@@ -0,0 +1,247 @@
+import { extent, scaleBand, scaleLinear, scaleLog, scaleUtc } from 'd3';
+import get from 'lodash/get';
+import { DEFAULT_AXIS_TYPE, SERIES_TYPE } from '../../constants';
+import { getAxisCategories, getDefaultMaxXAxisValue, getDefaultMinXAxisValue, getDomainDataXBySeries, } from '../../utils';
+import { getBandSize } from '../utils/get-band-size';
+import { checkIsPointDomain, filterCategoriesByVisibleSeries, getMinMaxPropsOrState, hasOnlyMarkerSeries, validateArrayData, } from './utils';
+const X_AXIS_ZOOM_PADDING = 0.02;
+function calculateXAxisPadding(series) {
+    let result = 0;
+    series.forEach((s) => {
+        var _a, _b;
+        switch (s.type) {
+            case 'bar-y': {
+                // Since labels can be located to the right of the bar, need to add an additional space
+                const inside = get(s, 'dataLabels.inside');
+                if (!inside) {
+                    const labelsMaxWidth = get(s, 'dataLabels.maxWidth', 0) + ((_b = (_a = s.dataLabels) === null || _a === void 0 ? void 0 : _a.padding) !== null && _b !== void 0 ? _b : 0);
+                    result = Math.max(result, labelsMaxWidth);
+                }
+                break;
+            }
+        }
+    });
+    return result;
+}
+function isSeriesWithXAxisOffset(series) {
+    const types = [SERIES_TYPE.Heatmap, SERIES_TYPE.BarX];
+    return series.some((s) => types.includes(s.type));
+}
+export function getXMaxDomainResult(args) {
+    const { xMaxDomain, xMaxProps, xMaxRangeSlider, xMaxZoom } = args;
+    let xMaxDomainResult = xMaxDomain;
+    // When xMaxRangeSlider is provided, we use it directly without considering xMaxDomain.
+    // This is intentional: the range slider needs to display the chart's maxPadding area,
+    // which would be clipped if we constrained it to xMaxDomain.
+    if (typeof xMaxRangeSlider === 'number') {
+        xMaxDomainResult = xMaxRangeSlider;
+    }
+    else if (typeof xMaxZoom === 'number' && xMaxZoom < xMaxDomain) {
+        xMaxDomainResult = xMaxZoom;
+    }
+    else if (typeof xMaxProps === 'number' && xMaxProps < xMaxDomain) {
+        xMaxDomainResult = xMaxProps;
+    }
+    return xMaxDomainResult;
+}
+function getXScaleRange({ boundsWidth, hasZoomX }) {
+    const xAxisZoomPadding = boundsWidth * X_AXIS_ZOOM_PADDING;
+    const xRange = [0, boundsWidth];
+    const xRangeZoom = [0 + xAxisZoomPadding, boundsWidth - xAxisZoomPadding];
+    const range = hasZoomX ? xRangeZoom : xRange;
+    return range;
+}
+// eslint-disable-next-line complexity
+export function createXScale(args) {
+    const { axis, boundsWidth, series, rangeSliderState, zoomStateX } = args;
+    const [xMinPropsOrState, xMaxPropsOrState] = getMinMaxPropsOrState({
+        axis,
+        maxValues: [zoomStateX === null || zoomStateX === void 0 ? void 0 : zoomStateX[1], rangeSliderState === null || rangeSliderState === void 0 ? void 0 : rangeSliderState.max],
+        minValues: [zoomStateX === null || zoomStateX === void 0 ? void 0 : zoomStateX[0], rangeSliderState === null || rangeSliderState === void 0 ? void 0 : rangeSliderState.min],
+    });
+    const xType = get(axis, 'type', DEFAULT_AXIS_TYPE);
+    const hasZoomX = Boolean(zoomStateX);
+    let xCategories = get(axis, 'categories');
+    if (rangeSliderState && xCategories) {
+        xCategories = getAxisCategories({
+            categories: xCategories,
+            min: rangeSliderState.min,
+            max: rangeSliderState.max,
+            order: axis.order,
+        });
+    }
+    const maxPadding = get(axis, 'maxPadding', 0);
+    const xAxisMaxPadding = boundsWidth * maxPadding + calculateXAxisPadding(series);
+    const range = getXScaleRange({
+        boundsWidth,
+        hasZoomX,
+    });
+    switch (axis.order) {
+        case 'sortDesc':
+        case 'reverse': {
+            range.reverse();
+        }
+    }
+    switch (xType) {
+        case 'linear':
+        case 'logarithmic': {
+            const domainData = getDomainDataXBySeries(series);
+            const { hasNumberAndNullValues, hasOnlyNullValues } = validateArrayData(domainData);
+            if (hasOnlyNullValues || domainData.length === 0) {
+                return undefined;
+            }
+            if (series.some((s) => s.type === 'bar-y' && s.stacking === 'percent')) {
+                return scaleLinear().domain([0, 100]).range(range);
+            }
+            if (hasNumberAndNullValues) {
+                const [xMinDomain, xMaxDomain] = extent(domainData);
+                const isPointDomain = hasOnlyMarkerSeries(series)
+                    ? checkIsPointDomain([xMinDomain, xMaxDomain])
+                    : false;
+                let xMin;
+                let xMax;
+                if (typeof xMinPropsOrState === 'number' && !isPointDomain) {
+                    xMin = xMinPropsOrState;
+                }
+                else if (xType === 'logarithmic') {
+                    xMin = xMinDomain;
+                }
+                else {
+                    const xMinDefault = getDefaultMinXAxisValue(series);
+                    xMin = xMinDefault !== null && xMinDefault !== void 0 ? xMinDefault : xMinDomain;
+                }
+                if (typeof xMaxPropsOrState === 'number' && !isPointDomain) {
+                    xMax = xMaxPropsOrState;
+                }
+                else {
+                    const xMaxDefault = getDefaultMaxXAxisValue(series);
+                    xMax =
+                        typeof xMaxDefault === 'number'
+                            ? Math.max(xMaxDefault, xMaxDomain)
+                            : xMaxDomain;
+                }
+                const scaleFn = xType === 'logarithmic' ? scaleLog : scaleLinear;
+                const scale = scaleFn().domain([xMin, xMax]).range(range);
+                let offsetMin = 0;
+                let offsetMax = xAxisMaxPadding;
+                const hasOffset = isSeriesWithXAxisOffset(series);
+                if (hasOffset) {
+                    if (domainData.length > 1) {
+                        const bandWidth = getBandSize({
+                            scale: scale,
+                            domain: domainData,
+                        });
+                        offsetMin += bandWidth / 2;
+                        offsetMax += bandWidth / 2;
+                    }
+                }
+                const isMinSpecified = typeof get(axis, 'min') === 'number' && !zoomStateX;
+                const isMaxSpecified = typeof get(axis, 'max') === 'number' && !zoomStateX;
+                const domainOffsetMin = isMinSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMin) - scale.invert(0));
+                const domainOffsetMax = isMaxSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMax) - scale.invert(0));
+                // 10 is the default value for the number of ticks. Here, to preserve the appearance of a series with a small number of points
+                const nicedDomain = scale.copy().nice(Math.max(10, domainData.length)).domain();
+                scale.domain([xMin - domainOffsetMin, xMax + domainOffsetMax]);
+                const startOnTick = get(axis, 'startOnTick', true);
+                const endOnTick = get(axis, 'endOnTick', true);
+                if (!hasZoomX && !hasOffset && nicedDomain.length === 2) {
+                    const domainWithOffset = scale.domain();
+                    scale.domain([
+                        startOnTick
+                            ? Math.min(nicedDomain[0], domainWithOffset[0])
+                            : domainWithOffset[0],
+                        endOnTick
+                            ? Math.max(nicedDomain[1], domainWithOffset[1])
+                            : domainWithOffset[1],
+                    ]);
+                }
+                return scale;
+            }
+            break;
+        }
+        case 'category': {
+            if (xCategories) {
+                const filteredCategories = filterCategoriesByVisibleSeries({
+                    axisDirection: 'x',
+                    categories: xCategories,
+                    series: series,
+                });
+                const xScale = scaleBand().domain(filteredCategories).range([0, boundsWidth]);
+                if (xScale.step() / 2 < xAxisMaxPadding) {
+                    xScale.range(range);
+                }
+                return xScale;
+            }
+            break;
+        }
+        case 'datetime': {
+            let domain = null;
+            const domainData = get(axis, 'timestamps') || getDomainDataXBySeries(series);
+            const { hasNumberAndNullValues, hasOnlyNullValues } = validateArrayData(domainData);
+            if (hasOnlyNullValues || domainData.length === 0) {
+                return undefined;
+            }
+            if (hasNumberAndNullValues) {
+                const [xMinTimestamp, xMaxTimestamp] = extent(domainData);
+                const isPointDomain = checkIsPointDomain([xMinTimestamp, xMaxTimestamp]);
+                const xMin = typeof xMinPropsOrState === 'number' &&
+                    xMinPropsOrState > xMinTimestamp &&
+                    !isPointDomain
+                    ? xMinPropsOrState
+                    : xMinTimestamp;
+                const xMax = getXMaxDomainResult({
+                    xMaxDomain: xMaxTimestamp,
+                    xMaxProps: get(axis, 'max'),
+                    xMaxRangeSlider: rangeSliderState === null || rangeSliderState === void 0 ? void 0 : rangeSliderState.max,
+                    xMaxZoom: zoomStateX === null || zoomStateX === void 0 ? void 0 : zoomStateX[1],
+                });
+                domain = [xMin, xMax];
+                const scale = scaleUtc().domain(domain).range(range);
+                let offsetMin = 0;
+                let offsetMax = xAxisMaxPadding;
+                const hasOffset = isSeriesWithXAxisOffset(series);
+                if (hasOffset) {
+                    if (domainData.length > 1) {
+                        const bandWidth = getBandSize({
+                            scale: scale,
+                            domain: domainData,
+                        });
+                        offsetMin += bandWidth / 2;
+                        offsetMax += bandWidth / 2;
+                    }
+                }
+                const isMinSpecified = typeof get(axis, 'min') === 'number' && !zoomStateX;
+                const isMaxSpecified = typeof get(axis, 'max') === 'number' && !zoomStateX;
+                const domainOffsetMin = isMinSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMin).getTime() - scale.invert(0).getTime());
+                const domainOffsetMax = isMaxSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMax).getTime() - scale.invert(0).getTime());
+                // 10 is the default value for the number of ticks. Here, to preserve the appearance of a series with a small number of points
+                const nicedDomain = scale.copy().nice(Math.max(10, domainData.length)).domain();
+                scale.domain([xMin - domainOffsetMin, xMax + domainOffsetMax]);
+                const startOnTick = get(axis, 'startOnTick', true);
+                const endOnTick = get(axis, 'endOnTick', true);
+                if (!hasZoomX && !hasOffset && nicedDomain.length === 2) {
+                    const domainWithOffset = scale.domain();
+                    scale.domain([
+                        startOnTick
+                            ? Math.min(Number(nicedDomain[0]), Number(domainWithOffset[0]))
+                            : Number(domainWithOffset[0]),
+                        endOnTick
+                            ? Math.max(Number(nicedDomain[1]), Number(domainWithOffset[1]))
+                            : Number(domainWithOffset[1]),
+                    ]);
+                }
+                return scale;
+            }
+            break;
+        }
+    }
+    throw new Error('Failed to create xScale');
+}

package/dist/cjs/hooks/useAxisScales/y-scale.d.ts

@@ -0,0 +1,10 @@
+import type { PreparedAxis, PreparedSeries } from '../../hooks';
+import type { ChartSeries } from '../../types';
+export declare function createYScale(args: {
+    axis: PreparedAxis;
+    boundsHeight: number;
+    series: PreparedSeries[] | ChartSeries[];
+    primaryAxis?: PreparedAxis;
+    primaryTicksCount?: number;
+    zoomStateY?: [number, number];
+}): import("d3-scale").ScaleBand<string> | import("d3-scale").ScaleLinear<number, number, never> | import("d3-scale").ScaleTime<number, number, never> | undefined;

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

@@ -0,0 +1,299 @@
+import { extent, scaleBand, scaleLinear, scaleLog, scaleUtc, tickStep, ticks } from 'd3';
+import get from 'lodash/get';
+import { getTickValues } from '../../components/AxisY/utils';
+import { SERIES_TYPE } from '../../constants';
+import { CHART_SERIES_WITH_VOLUME_ON_Y_AXIS, getDomainDataYBySeries, shouldSyncAxisWithPrimary, } from '../../utils';
+import { getBandSize } from '../utils/get-band-size';
+import { checkIsPointDomain, filterCategoriesByVisibleSeries, getMinMaxPropsOrState, hasOnlyMarkerSeries, validateArrayData, } from './utils';
+// axis is validated in `validation/index.ts`, so the value of `axis.type` is definitely valid.
+// eslint-disable-next-line consistent-return
+function getYScaleRange(args) {
+    const { axis, boundsHeight } = args;
+    switch (axis.type) {
+        case 'datetime':
+        case 'linear':
+        case 'logarithmic': {
+            const range = [boundsHeight, 0];
+            switch (axis.order) {
+                case 'sortDesc':
+                case 'reverse': {
+                    range.reverse();
+                }
+            }
+            return range;
+        }
+        case 'category': {
+            return [boundsHeight, 0];
+        }
+    }
+}
+function isSeriesWithYAxisOffset(series) {
+    const types = [SERIES_TYPE.BarY, SERIES_TYPE.Heatmap];
+    return series.some((s) => types.includes(s.type));
+}
+function getDomainSyncedToPrimaryTicks(args) {
+    const { primaryTicksCount, scale, yMin, yMax } = args;
+    const [dMin, dMax] = scale.domain();
+    let secondaryTicks = ticks(dMin, dMax, primaryTicksCount);
+    let i = 1;
+    // Need to reduce the number of ticks to primaryTicksCount - 2, so that we can later
+    // add one tick each at the top and bottom edges of the chart
+    while (secondaryTicks.length > primaryTicksCount - 2) {
+        secondaryTicks = ticks(dMin, dMax, primaryTicksCount - i);
+        if (secondaryTicks.length === 0) {
+            secondaryTicks = ticks(dMin, dMax, primaryTicksCount - i + 1);
+            break;
+        }
+        i += 1;
+    }
+    const step = tickStep(dMin, dMax, secondaryTicks.length);
+    let ticksCountDiff = primaryTicksCount - secondaryTicks.length;
+    let deltaMin = Math.abs(dMin - secondaryTicks[0]);
+    let deltaMax = Math.abs(dMax - secondaryTicks[secondaryTicks.length - 1]);
+    while (ticksCountDiff > 0) {
+        if (deltaMin > deltaMax) {
+            secondaryTicks.unshift(secondaryTicks[0] - step);
+            deltaMin -= step;
+        }
+        else {
+            secondaryTicks.push(secondaryTicks[secondaryTicks.length - 1] + step);
+            deltaMax -= step;
+        }
+        ticksCountDiff -= 1;
+    }
+    if (secondaryTicks[secondaryTicks.length - 1] < yMax) {
+        secondaryTicks[secondaryTicks.length - 1] += step;
+    }
+    if (secondaryTicks[0] > yMin) {
+        secondaryTicks[0] -= step;
+    }
+    return [secondaryTicks[0], secondaryTicks[secondaryTicks.length - 1]];
+}
+function getDomainMinAlignedToStartTick(args) {
+    var _a, _b;
+    const { axis, range, scale, series } = args;
+    const [dMin, dMax] = scale.domain();
+    const tickValues = getTickValues({
+        axis,
+        scale,
+        labelLineHeight: axis.labels.lineHeight,
+        series,
+    });
+    const isStartOnTick = tickValues[0].y === range[0];
+    let dNewMin = dMin;
+    if (!isStartOnTick) {
+        let step;
+        if (typeof ((_a = tickValues[0]) === null || _a === void 0 ? void 0 : _a.value) === 'number' && typeof ((_b = tickValues[1]) === null || _b === void 0 ? void 0 : _b.value) === 'number') {
+            step = tickValues[1].value - tickValues[0].value;
+        }
+        else {
+            step = tickStep(dMin, dMax, 1);
+        }
+        dNewMin = tickValues[0].value - step;
+    }
+    return dNewMin;
+}
+function getDomainMaxAlignedToEndTick(args) {
+    var _a, _b;
+    const { axis, range, scale, series } = args;
+    const [dMin, dMax] = scale.domain();
+    const tickValues = getTickValues({
+        axis,
+        scale,
+        labelLineHeight: axis.labels.lineHeight,
+        series,
+    });
+    const isEndOnTick = tickValues[tickValues.length - 1].y === range[1];
+    let dNewMax = dMax;
+    if (!isEndOnTick) {
+        let step;
+        if (typeof ((_a = tickValues[0]) === null || _a === void 0 ? void 0 : _a.value) === 'number' && typeof ((_b = tickValues[1]) === null || _b === void 0 ? void 0 : _b.value) === 'number') {
+            step = tickValues[1].value - tickValues[0].value;
+        }
+        else {
+            step = tickStep(dMin, dMax, 1);
+        }
+        dNewMax = tickValues[tickValues.length - 1].value + step;
+    }
+    return dNewMax;
+}
+// eslint-disable-next-line complexity
+export function createYScale(args) {
+    const { axis, boundsHeight, series, primaryAxis, primaryTicksCount, zoomStateY } = args;
+    const [yMinPropsOrState, yMaxPropsOrState] = getMinMaxPropsOrState({
+        axis,
+        maxValues: [zoomStateY === null || zoomStateY === void 0 ? void 0 : zoomStateY[1]],
+        minValues: [zoomStateY === null || zoomStateY === void 0 ? void 0 : zoomStateY[0]],
+    });
+    const yCategories = get(axis, 'categories');
+    const yTimestamps = get(axis, 'timestamps');
+    const range = getYScaleRange({ axis, boundsHeight });
+    switch (axis.type) {
+        case 'linear':
+        case 'logarithmic': {
+            const domain = getDomainDataYBySeries(series);
+            const { hasNumberAndNullValues, hasOnlyNullValues } = validateArrayData(domain);
+            if (hasOnlyNullValues || domain.length === 0) {
+                return undefined;
+            }
+            if (series.some((s) => (s.type === 'bar-x' || s.type === 'area') && s.stacking === 'percent')) {
+                return scaleLinear().domain([0, 100]).range(range);
+            }
+            if (hasNumberAndNullValues) {
+                const [yMinDomain, yMaxDomain] = extent(domain);
+                const isPointDomain = hasOnlyMarkerSeries(series)
+                    ? checkIsPointDomain([yMinDomain, yMaxDomain])
+                    : false;
+                const yMin = typeof yMinPropsOrState === 'number' && !isPointDomain
+                    ? yMinPropsOrState
+                    : yMinDomain;
+                let yMax;
+                if (typeof yMaxPropsOrState === 'number' && !isPointDomain) {
+                    yMax = yMaxPropsOrState;
+                }
+                else {
+                    const hasSeriesWithVolumeOnYAxis = series.some((s) => CHART_SERIES_WITH_VOLUME_ON_Y_AXIS.includes(s.type));
+                    yMax = hasSeriesWithVolumeOnYAxis ? Math.max(yMaxDomain, 0) : yMaxDomain;
+                }
+                const scaleFn = axis.type === 'logarithmic' ? scaleLog : scaleLinear;
+                let scale = scaleFn().domain([yMin, yMax]).range(range);
+                let offsetMin = 0;
+                // We should ignore padding if we are drawing only one point on the plot.
+                let offsetMax = yMin === yMax ? 0 : boundsHeight * axis.maxPadding;
+                if (isSeriesWithYAxisOffset(series)) {
+                    if (domain.length > 1) {
+                        const bandWidth = getBandSize({
+                            scale: scale,
+                            domain: domain,
+                        });
+                        offsetMin += bandWidth / 2;
+                        offsetMax += bandWidth / 2;
+                    }
+                }
+                const isMinSpecified = typeof get(axis, 'min') === 'number' && !zoomStateY;
+                const isMaxSpecified = typeof get(axis, 'max') === 'number' && !zoomStateY;
+                const domainOffsetMin = isMinSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMin) - scale.invert(0));
+                const domainOffsetMax = isMaxSpecified
+                    ? 0
+                    : Math.abs(scale.invert(offsetMax) - scale.invert(0));
+                scale = scale.domain([yMin - domainOffsetMin, yMax + domainOffsetMax]);
+                const startOnTick = get(axis, 'startOnTick', false);
+                const endOnTick = get(axis, 'endOnTick', false);
+                const shouldBeSyncedWithPrimary = primaryAxis
+                    ? shouldSyncAxisWithPrimary(axis, primaryAxis)
+                    : false;
+                if (shouldBeSyncedWithPrimary &&
+                    typeof primaryTicksCount === 'number' &&
+                    primaryTicksCount >= 2) {
+                    const newDomain = getDomainSyncedToPrimaryTicks({
+                        scale,
+                        primaryTicksCount,
+                        yMin,
+                        yMax,
+                    });
+                    scale.domain(newDomain);
+                }
+                if (startOnTick && (!primaryAxis || !shouldBeSyncedWithPrimary)) {
+                    const [_, dMax] = scale.domain();
+                    const dNewMin = getDomainMinAlignedToStartTick({ axis, range, scale, series });
+                    scale.domain([dNewMin, dMax]);
+                }
+                if (endOnTick && (!primaryAxis || !shouldBeSyncedWithPrimary)) {
+                    const [dMin, _] = scale.domain();
+                    const dNewMax = getDomainMaxAlignedToEndTick({ axis, range, scale, series });
+                    scale.domain([dMin, dNewMax]);
+                }
+                return scale;
+            }
+            break;
+        }
+        case 'category': {
+            if (yCategories) {
+                const filteredCategories = filterCategoriesByVisibleSeries({
+                    axisDirection: 'y',
+                    categories: yCategories,
+                    series: series,
+                });
+                return scaleBand().domain(filteredCategories).range(range);
+            }
+            break;
+        }
+        case 'datetime': {
+            if (yTimestamps) {
+                const [yMinTimestamp, yMaxTimestamp] = extent(yTimestamps);
+                const isPointDomain = hasOnlyMarkerSeries(series)
+                    ? checkIsPointDomain([yMinTimestamp, yMaxTimestamp])
+                    : false;
+                const yMin = typeof yMinPropsOrState === 'number' &&
+                    !isPointDomain &&
+                    yMinPropsOrState > yMinTimestamp
+                    ? yMinPropsOrState
+                    : yMinTimestamp;
+                const yMax = typeof yMaxPropsOrState === 'number' &&
+                    !isPointDomain &&
+                    yMaxPropsOrState < yMaxTimestamp
+                    ? yMaxPropsOrState
+                    : yMaxTimestamp;
+                const scale = scaleUtc().domain([yMin, yMax]).range(range);
+                const startOnTick = get(axis, 'startOnTick', true);
+                const endOnTick = get(axis, 'endOnTick', true);
+                if (startOnTick || endOnTick) {
+                    const nicedDomain = scale.copy().nice().domain();
+                    return scale.domain([
+                        startOnTick ? Number(nicedDomain[0]) : yMin,
+                        endOnTick ? Number(nicedDomain[1]) : yMax,
+                    ]);
+                }
+                return scale;
+            }
+            else {
+                const domain = getDomainDataYBySeries(series);
+                const { hasNumberAndNullValues, hasOnlyNullValues } = validateArrayData(domain);
+                if (hasOnlyNullValues || domain.length === 0) {
+                    return undefined;
+                }
+                if (hasNumberAndNullValues) {
+                    const [yMinTimestamp, yMaxTimestamp] = extent(domain);
+                    const isPointDomain = hasOnlyMarkerSeries(series)
+                        ? checkIsPointDomain([yMinTimestamp, yMaxTimestamp])
+                        : false;
+                    const yMin = typeof yMinPropsOrState === 'number' &&
+                        !isPointDomain &&
+                        yMinPropsOrState > yMinTimestamp
+                        ? yMinPropsOrState
+                        : yMinTimestamp;
+                    const yMax = typeof yMaxPropsOrState === 'number' &&
+                        !isPointDomain &&
+                        yMaxPropsOrState < yMaxTimestamp
+                        ? yMaxPropsOrState
+                        : yMaxTimestamp;
+                    const scale = scaleUtc().domain([yMin, yMax]).range(range);
+                    let offsetMin = 0;
+                    let offsetMax = boundsHeight * axis.maxPadding;
+                    if (isSeriesWithYAxisOffset(series)) {
+                        if (Object.keys(domain).length > 1) {
+                            const bandWidth = getBandSize({
+                                scale: scale,
+                                domain: domain,
+                            });
+                            offsetMin += bandWidth / 2;
+                            offsetMax += bandWidth / 2;
+                        }
+                    }
+                    const isMinSpecified = typeof get(axis, 'min') === 'number' && !zoomStateY;
+                    const isMaxSpecified = typeof get(axis, 'max') === 'number' && !zoomStateY;
+                    const domainOffsetMin = isMinSpecified
+                        ? 0
+                        : Math.abs(scale.invert(offsetMin).getTime() - scale.invert(0).getTime());
+                    const domainOffsetMax = isMaxSpecified
+                        ? 0
+                        : Math.abs(scale.invert(offsetMax).getTime() - scale.invert(0).getTime());
+                    return scale.domain([yMin - domainOffsetMin, yMax + domainOffsetMax]);
+                }
+            }
+        }
+    }
+    throw new Error('Failed to create yScale');
+}

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

@@ -29,6 +29,8 @@ export declare function useNormalizedOriginalData(props: UseOriginalDataProps):
         plotBands?: import("../../types").AxisPlotBand[];
         visible?: boolean;
         order?: "sortAsc" | "sortDesc" | "reverse";
+        startOnTick?: boolean;
+        endOnTick?: boolean;
     };
     normalizedYAxis: import("../../types").ChartYAxis[] | undefined;
 };

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

@@ -40,6 +40,7 @@ export function useRangeSlider(props) {
     const { xScale, yScale } = useAxisScales({
         boundsHeight: preparedRangeSlider.height,
         boundsWidth,
+        isRangeSlider: true,
         series: preparedSeries,
         split: EMPTY_PREPARED_SPLIT,
         xAxis: preparedXAxis,

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

@@ -1,6 +1,6 @@
 import type { ChartXAxis, ChartYAxis } from '../../types';
 import type { PreparedRangeSlider, PreparedXAxis, PreparedYAxis } from '../useAxis/types';
-import type { ChartScale } from '../useAxisScales';
+import type { ChartScale } from '../useAxisScales/types';
 import type { BrushSelection, UseBrushProps } from '../useBrush/types';
 import type { PreparedChart } from '../useChartOptions/types';
 import type { PreparedLegend, PreparedSeries, PreparedSeriesOptions } from '../useSeries/types';

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

@@ -1,5 +1,5 @@
 import type { PreparedRangeSlider } from '../useAxis/types';
-import type { ChartScale } from '../useAxisScales';
+import type { ChartScale } from '../useAxisScales/types';
 import type { BrushSelection } from '../useBrush/types';
 import type { PreparedChart } from '../useChartOptions/types';
 import type { PreparedLegend } from '../useSeries/types';

package/dist/cjs/hooks/useShapes/area/prepare-data.d.ts

@@ -1,5 +1,5 @@
 import type { PreparedXAxis, PreparedYAxis } from '../../useAxis/types';
-import type { ChartScale } from '../../useAxisScales';
+import type { ChartScale } from '../../useAxisScales/types';
 import type { PreparedAreaSeries } from '../../useSeries/types';
 import type { PreparedSplit } from '../../useSplit/types';
 import type { PreparedAreaData } from './types';