@gravity-ui/charts 1.33.0 → 1.34.0

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

@@ -1,473 +1,12 @@
 import React from 'react';
-import { extent, scaleBand, scaleLinear, scaleLog, scaleUtc } from 'd3';
 import get from 'lodash/get';
 import { getTickValues } from '../../components/AxisY/utils';
-import { DEFAULT_AXIS_TYPE, SERIES_TYPE } from '../../constants';
-import { CHART_SERIES_WITH_VOLUME_ON_Y_AXIS, getAxisCategories, getAxisHeight, getDataCategoryValue, getDefaultMaxXAxisValue, getDefaultMinXAxisValue, getDomainDataXBySeries, getDomainDataYBySeries, getOnlyVisibleSeries, isAxisRelatedSeries, isSeriesWithCategoryValues, } from '../../utils';
-import { getBandSize } from '../utils/get-band-size';
-import { checkIsPointDomain, clusterYAxes, getDomainSyncedToPrimaryTicks, getMinMaxPropsOrState, getXMaxDomainResult, hasOnlyMarkerSeries, } from './utils';
-const X_AXIS_ZOOM_PADDING = 0.02;
-function validateArrayData(data) {
-    let hasNumberAndNullValues;
-    let hasOnlyNullValues;
-    for (const d of data) {
-        const isNumber = typeof d === 'number';
-        const isNull = d === null;
-        hasNumberAndNullValues =
-            typeof hasNumberAndNullValues === 'undefined'
-                ? isNumber || isNull
-                : hasNumberAndNullValues && (isNumber || isNull);
-        hasOnlyNullValues =
-            typeof hasOnlyNullValues === 'undefined' ? isNull : hasOnlyNullValues && isNull;
-        if (!hasNumberAndNullValues) {
-            break;
-        }
-    }
-    return { hasNumberAndNullValues, hasOnlyNullValues };
-}
-function filterCategoriesByVisibleSeries(args) {
-    const { axisDirection, categories, series } = args;
-    const visibleCategories = new Set();
-    series.forEach((s) => {
-        if (isSeriesWithCategoryValues(s)) {
-            s.data.forEach((d) => {
-                visibleCategories.add(getDataCategoryValue({ axisDirection, categories, data: d }));
-            });
-        }
-    });
-    const filteredCategories = categories.filter((c) => visibleCategories.has(c));
-    return filteredCategories.length > 0 ? filteredCategories : categories;
-}
-// 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));
-}
-// eslint-disable-next-line complexity
-export function createYScale(args) {
-    const { axis, boundsHeight, series, primaryTickPositions, 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);
-                if (primaryTickPositions) {
-                    const syncedDomain = getDomainSyncedToPrimaryTicks({
-                        primaryTickPositions,
-                        range,
-                        scaleFn,
-                        secondaryDomain: scale.domain(),
-                    });
-                    scale.domain(syncedDomain);
-                }
-                else {
-                    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]);
-                }
-                // 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, domain.length)).domain();
-                const startOnTick = get(axis, 'startOnTick', false);
-                const endOnTick = get(axis, 'endOnTick', false);
-                const hasOffset = isSeriesWithYAxisOffset(series);
-                if (!zoomStateY && !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 (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');
-}
-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));
-}
-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');
-}
+import { getAxisHeight, getOnlyVisibleSeries, isAxisRelatedSeries } from '../../utils';
+import { clusterYAxes } from './utils';
+import { createXScale } from './x-scale';
+import { createYScale } from './y-scale';
+export { createXScale } from './x-scale';
+export { createYScale } from './y-scale';
 const createScales = (args) => {
     const { boundsWidth, boundsHeight, isRangeSlider, rangeSliderState, series, split, xAxis, yAxis, zoomState, } = args;
     let visibleSeries = getOnlyVisibleSeries(series);
@@ -479,29 +18,31 @@ const createScales = (args) => {
     const yScale = clusterYAxes(yAxis).reduce((acc, cluster) => {
         var _a, _b;
         const [primaryAxis, secondaryAxis] = cluster;
-        const mainAxisSeries = series.filter((s) => {
+        const primaryAxisSeries = series.filter((s) => {
             const seriesAxisIndex = get(s, 'yAxis', 0);
             return seriesAxisIndex === index;
         });
-        const visiblePrimaryAxisSeries = getOnlyVisibleSeries(mainAxisSeries);
+        const visiblePrimaryAxisSeries = getOnlyVisibleSeries(primaryAxisSeries);
         const primaryAxisScale = createYScale({
             axis: primaryAxis,
             boundsHeight: axisHeight,
-            series: visiblePrimaryAxisSeries.length ? visiblePrimaryAxisSeries : mainAxisSeries,
+            series: visiblePrimaryAxisSeries.length
+                ? visiblePrimaryAxisSeries
+                : primaryAxisSeries,
             zoomStateY: (_a = zoomState === null || zoomState === void 0 ? void 0 : zoomState.y) === null || _a === void 0 ? void 0 : _a[index],
         });
         acc.push(primaryAxisScale);
         index += 1;
-        let primaryTickPositions;
+        let primaryTicksCount;
         if (primaryAxisScale && secondaryAxis && !isRangeSlider) {
-            primaryTickPositions = getTickValues({
+            primaryTicksCount = getTickValues({
                 axis: primaryAxis,
                 scale: primaryAxisScale,
                 labelLineHeight: primaryAxis.labels.lineHeight,
                 series: visiblePrimaryAxisSeries.length
                     ? visiblePrimaryAxisSeries
-                    : mainAxisSeries,
-            }).map((t) => t.y);
+                    : primaryAxisSeries,
+            }).length;
         }
         const secondAxisSeries = series.filter((s) => {
             const seriesAxisIndex = get(s, 'yAxis', 0);
@@ -512,7 +53,8 @@ const createScales = (args) => {
             ? createYScale({
                 axis: secondaryAxis,
                 boundsHeight: axisHeight,
-                primaryTickPositions,
+                primaryAxis,
+                primaryTicksCount,
                 series: visibleSecondAxisSeries.length
                     ? visibleSecondAxisSeries
                     : secondAxisSeries,

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

@@ -1,6 +1,6 @@
-import type { scaleLinear } from 'd3';
 import type { PreparedAxis, PreparedSeries, PreparedYAxis } from '../../hooks';
 import type { ChartAxis, ChartSeries } from '../../types';
+import type { AxisDirection } from '../../utils';
 type OptionalNumber = number | undefined;
 export declare function getMinMaxPropsOrState(args: {
     axis: PreparedAxis | ChartAxis;
@@ -17,17 +17,14 @@ export declare function getMinMaxPropsOrState(args: {
  */
 export declare function checkIsPointDomain(domain: [number, number]): boolean;
 export declare function hasOnlyMarkerSeries(series: (PreparedSeries | ChartSeries)[]): boolean;
-export declare function getXMaxDomainResult(args: {
-    xMaxDomain: number;
-    xMaxProps?: number;
-    xMaxRangeSlider?: number;
-    xMaxZoom?: number;
-}): number;
 export declare function clusterYAxes(yAxes: PreparedYAxis[]): [PreparedYAxis, PreparedYAxis?][];
-export declare function getDomainSyncedToPrimaryTicks(args: {
-    primaryTickPositions: number[];
-    range: [number, number];
-    scaleFn: typeof scaleLinear;
-    secondaryDomain: number[];
-}): [number, number];
+export declare function validateArrayData(data: unknown[]): {
+    hasNumberAndNullValues: boolean | undefined;
+    hasOnlyNullValues: boolean | undefined;
+};
+export declare function filterCategoriesByVisibleSeries(args: {
+    axisDirection: AxisDirection;
+    categories: string[];
+    series: (PreparedSeries | ChartSeries)[];
+}): string[];
 export {};

package/dist/cjs/hooks/useAxisScales/utils.js

@@ -1,6 +1,6 @@
-import { ticks } from 'd3';
 import get from 'lodash/get';
 import { SERIES_TYPE } from '../../constants';
+import { getDataCategoryValue, isSeriesWithCategoryValues } from '../../utils';
 const MARKER_SERIES_TYPES = [SERIES_TYPE.Area, SERIES_TYPE.Line, SERIES_TYPE.Scatter];
 function getNormilizedMinMax(args) {
     const { maxValues, minValues } = args;
@@ -33,23 +33,6 @@ export function checkIsPointDomain(domain) {
 export function hasOnlyMarkerSeries(series) {
     return series.every((s) => MARKER_SERIES_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;
-}
 export function clusterYAxes(yAxes) {
     if (yAxes.length <= 1) {
         return yAxes.map((axis) => [axis]);
@@ -75,51 +58,34 @@ export function clusterYAxes(yAxes) {
         return [cluster[0], cluster[1]];
     });
 }
-export function getDomainSyncedToPrimaryTicks(args) {
-    const { primaryTickPositions, range, scaleFn, secondaryDomain } = args;
-    const [dMin, dMax] = secondaryDomain;
-    const primaryPosBottom = primaryTickPositions[0];
-    const primaryPosTop = primaryTickPositions[primaryTickPositions.length - 1];
-    let secondaryTicks = ticks(dMin, dMax, primaryTickPositions.length);
-    let originalStep = 0;
-    if (typeof secondaryTicks[0] === 'number' && typeof secondaryTicks[1] === 'number') {
-        originalStep = secondaryTicks[1] - secondaryTicks[0];
-    }
-    let i = 1;
-    while (secondaryTicks.length > primaryTickPositions.length) {
-        secondaryTicks = ticks(dMin, dMax, primaryTickPositions.length - i);
-        i += 1;
-    }
-    let step = originalStep;
-    if (typeof secondaryTicks[0] === 'number' && typeof secondaryTicks[1] === 'number') {
-        step = secondaryTicks[1] - secondaryTicks[0];
-    }
-    let ticksCountDiff = primaryTickPositions.length - 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;
+export function validateArrayData(data) {
+    let hasNumberAndNullValues;
+    let hasOnlyNullValues;
+    for (const d of data) {
+        const isNumber = typeof d === 'number';
+        const isNull = d === null;
+        hasNumberAndNullValues =
+            typeof hasNumberAndNullValues === 'undefined'
+                ? isNumber || isNull
+                : hasNumberAndNullValues && (isNumber || isNull);
+        hasOnlyNullValues =
+            typeof hasOnlyNullValues === 'undefined' ? isNull : hasOnlyNullValues && isNull;
+        if (!hasNumberAndNullValues) {
+            break;
         }
-        ticksCountDiff -= 1;
-    }
-    let tmpScale = scaleFn()
-        .domain([secondaryTicks[0], secondaryTicks[secondaryTicks.length - 1]])
-        .range([primaryPosBottom, primaryPosTop]);
-    let dNewMin = tmpScale.invert(range[0]);
-    let dNewMax = tmpScale.invert(range[1]);
-    if (dNewMin < dMin) {
-        secondaryTicks = secondaryTicks.map((st) => st + step);
-        tmpScale = scaleFn()
-            .domain([secondaryTicks[0], secondaryTicks[secondaryTicks.length - 1]])
-            .range([primaryPosBottom, primaryPosTop]);
-        dNewMin = tmpScale.invert(range[0]);
-        dNewMax = tmpScale.invert(range[1]);
     }
-    return [dNewMin, dNewMax];
+    return { hasNumberAndNullValues, hasOnlyNullValues };
+}
+export function filterCategoriesByVisibleSeries(args) {
+    const { axisDirection, categories, series } = args;
+    const visibleCategories = new Set();
+    series.forEach((s) => {
+        if (isSeriesWithCategoryValues(s)) {
+            s.data.forEach((d) => {
+                visibleCategories.add(getDataCategoryValue({ axisDirection, categories, data: d }));
+            });
+        }
+    });
+    const filteredCategories = categories.filter((c) => visibleCategories.has(c));
+    return filteredCategories.length > 0 ? filteredCategories : categories;
 }