@techie_doubts/tui.chart.2026 4.6.1

package/dist/esm/helpers/axes.d.ts

@@ -0,0 +1,67 @@
+import { Options, Series, ChartOptionsUsingYAxis, Axes, ViewAxisLabel, RotationLabelData, InitAxisData, Categories, DefaultRadialAxisData, RadiusInfo, ScaleData } from "../../types/store/store";
+import { AxisTitle, Rect } from "../../types/options";
+import { Theme } from "../../types/theme";
+import { AxisDataParams } from "../store/axes";
+export declare function getAutoAdjustingInterval(count: number, axisWidth: number, categories?: string[]): number;
+export declare function isLabelAxisOnYAxis({ series, options, categories, }: {
+    series: Series;
+    options?: Options;
+    categories?: Categories;
+}): boolean;
+export declare function hasBoxTypeSeries(series: Series): boolean;
+export declare function isPointOnColumn(series: Series, options: Options): boolean;
+export declare function isSeriesUsingRadialAxes(series: Series): boolean;
+export declare function getAxisName(labelAxisOnYAxis: boolean, series: Series): {
+    valueAxisName: string;
+    labelAxisName: string;
+};
+export declare function getSizeKey(labelAxisOnYAxis: boolean): {
+    valueSizeKey: string;
+    labelSizeKey: string;
+};
+export declare function getLimitOnAxis(labels: string[]): {
+    min: number;
+    max: number;
+};
+export declare function hasSecondaryYAxis(options: ChartOptionsUsingYAxis): boolean;
+export declare function getYAxisOption(options: ChartOptionsUsingYAxis): {
+    yAxis: any;
+    secondaryYAxis: any;
+};
+export declare function getValueAxisName(options: ChartOptionsUsingYAxis, seriesName: string, valueAxisName: string): string;
+export declare function getValueAxisNames(options: Options, valueAxisName: string): string[];
+export declare function getAxisTheme(theme: Theme, name: string): any;
+export declare function hasAxesLayoutChanged(previousAxes: Axes, currentAxes: Axes): boolean;
+export declare function getRotatableOption(options: Options): boolean;
+declare type ViewAxisLabelParam = {
+    labels: string[];
+    pointOnColumn?: boolean;
+    labelDistance?: number;
+    scale?: ScaleData;
+    labelInterval: number;
+    tickDistance: number;
+    tickInterval: number;
+    tickCount: number;
+};
+export declare function getViewAxisLabels(axisData: ViewAxisLabelParam, axisSize: number): ViewAxisLabel[];
+export declare function makeTitleOption(title?: AxisTitle): {
+    text: string;
+    offsetX: number;
+    offsetY: number;
+} | undefined;
+export declare function getAxisFormatter(options: ChartOptionsUsingYAxis, axisName: string): any;
+export declare function getLabelsAppliedFormatter(labels: string[], options: Options, dateType: boolean, axisName: string): any[];
+export declare function makeRotationData(maxLabelWidth: number, maxLabelHeight: number, distance: number, rotatable: boolean, axisLayout: Rect): Required<RotationLabelData>;
+export declare function getMaxLabelSize(labels: string[], xMargin: number, font?: string): {
+    maxLabelWidth: number;
+    maxLabelHeight: number;
+};
+export declare function getLabelXMargin(axisName: string, options: Options): number;
+export declare function getInitAxisIntervalData(isLabelAxis: boolean, params: AxisDataParams): InitAxisData;
+export declare function getDefaultRadialAxisData(options: Options, plot: Rect, maxLabelWidth?: number, maxLabelHeight?: number, isLabelOnVerticalAxis?: boolean): DefaultRadialAxisData;
+export declare function getRadiusInfo(axisSize: number, radiusRange?: {
+    inner?: number | string;
+    outer?: number | string;
+}, count?: number): RadiusInfo;
+export declare function isDateType(options: Options, axisName: string): boolean;
+export {};

package/dist/esm/helpers/axes.js

@@ -0,0 +1,345 @@
+import { AxisType } from "../component/axis";
+import { divisors, makeTickPixelPositions, getTextHeight, getTextWidth, } from "./calculator";
+import { range, isString, isUndefined, isNumber, calculateSizeWithPercentString, includes, } from "./utils";
+import { ANGLE_CANDIDATES, calculateRotatedWidth, calculateRotatedHeight, } from "./geometric";
+import { getDateFormat, formatDate } from "./formatDate";
+import { calculateDegreeToRadian, DEGREE_360, DEGREE_0, initSectorOptions, getDefaultRadius, } from "./sector";
+import { DEFAULT_LABEL_TEXT } from "../brushes/label";
+import { getSemiCircleCenterY, getTotalAngle, isSemiCircle } from "./pieSeries";
+import { RadialAxisType } from "../store/radialAxes";
+function makeAdjustingIntervalInfo(blockCount, axisWidth, blockSize) {
+    let remainBlockCount;
+    let newBlockCount = Math.floor(axisWidth / blockSize);
+    let intervalInfo = null;
+    const interval = newBlockCount ? Math.floor(blockCount / newBlockCount) : blockCount;
+    if (interval > 1) {
+        // remainBlockCount : remaining block count after filling new blocks
+        // | | | | | | | | | | | |  - previous block interval
+        // |     |     |     |      - new block interval
+        //                   |*|*|  - remaining block
+        remainBlockCount = blockCount - interval * newBlockCount;
+        if (remainBlockCount >= interval) {
+            newBlockCount += Math.floor(remainBlockCount / interval);
+            remainBlockCount = remainBlockCount % interval;
+        }
+        intervalInfo = {
+            blockCount: newBlockCount,
+            remainBlockCount,
+            interval,
+        };
+    }
+    return intervalInfo;
+}
+export function getAutoAdjustingInterval(count, axisWidth, categories) {
+    var _a;
+    const autoInterval = {
+        MIN_WIDTH: 90,
+        MAX_WIDTH: 121,
+        STEP_SIZE: 5,
+    };
+    const LABEL_MARGIN = 5;
+    if ((_a = categories) === null || _a === void 0 ? void 0 : _a[0]) {
+        const categoryMinWidth = getTextWidth(categories[0]);
+        if (categoryMinWidth < axisWidth / count - LABEL_MARGIN) {
+            return 1;
+        }
+    }
+    let candidates = [];
+    divisors(count).forEach((interval) => {
+        const intervalWidth = (interval / count) * axisWidth;
+        if (intervalWidth >= autoInterval.MIN_WIDTH && intervalWidth <= autoInterval.MAX_WIDTH) {
+            candidates.push({ interval, blockCount: Math.floor(count / interval), remainBlockCount: 0 });
+        }
+    });
+    if (!candidates.length) {
+        const blockSizeRange = range(autoInterval.MIN_WIDTH, autoInterval.MAX_WIDTH, autoInterval.STEP_SIZE);
+        candidates = blockSizeRange.reduce((acc, blockSize) => {
+            const candidate = makeAdjustingIntervalInfo(count, axisWidth, blockSize);
+            return candidate ? [...acc, candidate] : acc;
+        }, []);
+    }
+    let tickInterval = 1;
+    if (candidates.length) {
+        const candidate = candidates.reduce((acc, cur) => (cur.blockCount > acc.blockCount ? cur : acc), { blockCount: 0, interval: 1 });
+        tickInterval = candidate.interval;
+    }
+    return tickInterval;
+}
+export function isLabelAxisOnYAxis({ series, options, categories, }) {
+    var _a, _b;
+    return (!!series.bar ||
+        !!series.radialBar ||
+        (!!series.gauge && Array.isArray(categories) && !categories.length) ||
+        (!!series.bullet && !((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.series) === null || _b === void 0 ? void 0 : _b.vertical)));
+}
+export function hasBoxTypeSeries(series) {
+    return !!series.column || !!series.bar || !!series.boxPlot || !!series.bullet;
+}
+export function isPointOnColumn(series, options) {
+    var _a;
+    if (hasBoxTypeSeries(series)) {
+        return true;
+    }
+    if (series.line || series.area) {
+        return Boolean((_a = options.xAxis) === null || _a === void 0 ? void 0 : _a.pointOnColumn);
+    }
+    return false;
+}
+export function isSeriesUsingRadialAxes(series) {
+    return !!series.radar || !!series.radialBar || !!series.gauge;
+}
+function getAxisNameUsingRadialAxes(labelAxisOnYAxis) {
+    return {
+        valueAxisName: labelAxisOnYAxis ? 'circularAxis' : 'verticalAxis',
+        labelAxisName: labelAxisOnYAxis ? 'verticalAxis' : 'circularAxis',
+    };
+}
+export function getAxisName(labelAxisOnYAxis, series) {
+    return isSeriesUsingRadialAxes(series)
+        ? getAxisNameUsingRadialAxes(labelAxisOnYAxis)
+        : {
+            valueAxisName: labelAxisOnYAxis ? 'xAxis' : 'yAxis',
+            labelAxisName: labelAxisOnYAxis ? 'yAxis' : 'xAxis',
+        };
+}
+export function getSizeKey(labelAxisOnYAxis) {
+    return {
+        valueSizeKey: labelAxisOnYAxis ? 'width' : 'height',
+        labelSizeKey: labelAxisOnYAxis ? 'height' : 'width',
+    };
+}
+export function getLimitOnAxis(labels) {
+    const values = labels.map((label) => Number(label));
+    return {
+        min: Math.min(...values),
+        max: Math.max(...values),
+    };
+}
+export function hasSecondaryYAxis(options) {
+    var _a;
+    return Array.isArray((_a = options) === null || _a === void 0 ? void 0 : _a.yAxis) && options.yAxis.length === 2;
+}
+export function getYAxisOption(options) {
+    var _a;
+    const secondaryYAxis = hasSecondaryYAxis(options);
+    return {
+        yAxis: secondaryYAxis ? options.yAxis[0] : (_a = options) === null || _a === void 0 ? void 0 : _a.yAxis,
+        secondaryYAxis: secondaryYAxis ? options.yAxis[1] : null,
+    };
+}
+export function getValueAxisName(options, seriesName, valueAxisName) {
+    var _a;
+    const { secondaryYAxis } = getYAxisOption(options);
+    return ((_a = secondaryYAxis) === null || _a === void 0 ? void 0 : _a.chartType) === seriesName ? 'secondaryYAxis' : valueAxisName;
+}
+export function getValueAxisNames(options, valueAxisName) {
+    if (includes([AxisType.X, AxisType.CIRCULAR, AxisType.VERTICAL], valueAxisName)) {
+        return [valueAxisName];
+    }
+    const optionsUsingYAxis = options;
+    const { yAxis, secondaryYAxis } = getYAxisOption(optionsUsingYAxis);
+    return secondaryYAxis
+        ? [yAxis.chartType, secondaryYAxis.chartType].map((seriesName, index) => seriesName
+            ? getValueAxisName(optionsUsingYAxis, seriesName, valueAxisName)
+            : ['yAxis', 'secondaryYAxis'][index])
+        : [valueAxisName];
+}
+export function getAxisTheme(theme, name) {
+    const { xAxis, yAxis, circularAxis } = theme;
+    let axisTheme;
+    if (name === AxisType.X) {
+        axisTheme = xAxis;
+    }
+    else if (Array.isArray(yAxis)) {
+        axisTheme = name === AxisType.Y ? yAxis[0] : yAxis[1];
+    }
+    else if (name === RadialAxisType.CIRCULAR) {
+        axisTheme = circularAxis;
+    }
+    else {
+        axisTheme = yAxis;
+    }
+    return axisTheme;
+}
+function getRotationDegree(distance, labelWidth, labelHeight, axisLayout) {
+    let degree = 0;
+    ANGLE_CANDIDATES.every((angle) => {
+        const compareWidth = calculateRotatedWidth(angle, labelWidth, labelHeight);
+        degree = angle;
+        return compareWidth > distance || compareWidth / 2 > axisLayout.x;
+    });
+    return distance < labelWidth || labelWidth / 2 > axisLayout.x ? degree : 0;
+}
+function hasYAxisMaxLabelLengthChanged(previousAxes, currentAxes, field) {
+    var _a, _b;
+    const prevYAxis = previousAxes[field];
+    const yAxis = currentAxes[field];
+    if (!prevYAxis && !yAxis) {
+        return false;
+    }
+    return ((_a = prevYAxis) === null || _a === void 0 ? void 0 : _a.maxLabelWidth) !== ((_b = yAxis) === null || _b === void 0 ? void 0 : _b.maxLabelWidth);
+}
+function hasYAxisTypeMaxLabelChanged(previousAxes, currentAxes) {
+    return (hasYAxisMaxLabelLengthChanged(previousAxes, currentAxes, 'yAxis') ||
+        hasYAxisMaxLabelLengthChanged(previousAxes, currentAxes, 'secondaryYAxis'));
+}
+function hasXAxisSizeChanged(previousAxes, currentAxes) {
+    const { maxHeight: prevMaxHeight } = previousAxes.xAxis;
+    const { maxHeight } = currentAxes.xAxis;
+    return prevMaxHeight !== maxHeight;
+}
+export function hasAxesLayoutChanged(previousAxes, currentAxes) {
+    return (hasYAxisTypeMaxLabelChanged(previousAxes, currentAxes) ||
+        hasXAxisSizeChanged(previousAxes, currentAxes));
+}
+export function getRotatableOption(options) {
+    var _a, _b, _c, _d;
+    return _d = (_c = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.xAxis) === null || _b === void 0 ? void 0 : _b.label) === null || _c === void 0 ? void 0 : _c.rotatable, (_d !== null && _d !== void 0 ? _d : true);
+}
+export function getViewAxisLabels(axisData, axisSize) {
+    var _a, _b, _c, _d;
+    const { labels, pointOnColumn, labelDistance, tickDistance, labelInterval, tickInterval, tickCount, scale, } = axisData;
+    let axisSizeAppliedRatio = axisSize;
+    let additional = 0;
+    let labelAdjustment = 0;
+    if (scale) {
+        const sizeRatio = (_b = (_a = scale) === null || _a === void 0 ? void 0 : _a.sizeRatio, (_b !== null && _b !== void 0 ? _b : 1));
+        const positionRatio = (_d = (_c = scale) === null || _c === void 0 ? void 0 : _c.positionRatio, (_d !== null && _d !== void 0 ? _d : 0));
+        axisSizeAppliedRatio = axisSize * sizeRatio;
+        additional = axisSize * positionRatio;
+    }
+    else {
+        const interval = labelInterval === tickInterval ? labelInterval : 1;
+        labelAdjustment = pointOnColumn ? ((labelDistance !== null && labelDistance !== void 0 ? labelDistance : tickDistance * interval)) / 2 : 0;
+    }
+    const relativePositions = makeTickPixelPositions(axisSizeAppliedRatio, tickCount, additional);
+    return labels.reduce((acc, text, index) => {
+        const offsetPos = relativePositions[index] + labelAdjustment;
+        const needRender = !(index % labelInterval) && offsetPos <= axisSize;
+        return needRender ? [...acc, { offsetPos, text }] : acc;
+    }, []);
+}
+export function makeTitleOption(title) {
+    if (isUndefined(title)) {
+        return title;
+    }
+    const defaultOption = { text: '', offsetX: 0, offsetY: 0 };
+    return isString(title) ? Object.assign(Object.assign({}, defaultOption), { text: title }) : Object.assign(Object.assign({}, defaultOption), title);
+}
+export function getAxisFormatter(options, axisName) {
+    var _a, _b, _c;
+    const axisOptions = Object.assign(Object.assign({}, getYAxisOption(options)), { xAxis: options.xAxis });
+    return _c = (_b = (_a = axisOptions[axisName]) === null || _a === void 0 ? void 0 : _a.label) === null || _b === void 0 ? void 0 : _b.formatter, (_c !== null && _c !== void 0 ? _c : ((value) => value));
+}
+export function getLabelsAppliedFormatter(labels, options, dateType, axisName) {
+    var _a, _b;
+    const dateFormatter = getDateFormat((_b = (_a = options) === null || _a === void 0 ? void 0 : _a[axisName]) === null || _b === void 0 ? void 0 : _b.date);
+    const formattedLabels = dateType && dateFormatter
+        ? labels.map((label) => formatDate(dateFormatter, new Date(label)))
+        : labels;
+    const formatter = getAxisFormatter(options, axisName);
+    return formattedLabels.map((label, index) => formatter(label, { index, labels, axisName }));
+}
+export function makeRotationData(maxLabelWidth, maxLabelHeight, distance, rotatable, axisLayout) {
+    const degree = getRotationDegree(distance, maxLabelWidth, maxLabelHeight, axisLayout);
+    if (!rotatable || degree === 0) {
+        return {
+            needRotateLabel: false,
+            radian: 0,
+            rotationHeight: maxLabelHeight,
+        };
+    }
+    return {
+        needRotateLabel: degree > 0,
+        radian: calculateDegreeToRadian(degree, 0),
+        rotationHeight: calculateRotatedHeight(degree, maxLabelWidth, maxLabelHeight),
+    };
+}
+export function getMaxLabelSize(labels, xMargin, font = DEFAULT_LABEL_TEXT) {
+    const maxLengthLabel = labels.reduce((acc, cur) => (acc.length > cur.length ? acc : cur), '');
+    return {
+        maxLabelWidth: getTextWidth(maxLengthLabel, font) + xMargin,
+        maxLabelHeight: getTextHeight(maxLengthLabel, font),
+    };
+}
+export function getLabelXMargin(axisName, options) {
+    var _a, _b, _c, _d;
+    if (axisName === 'xAxis') {
+        return 0;
+    }
+    const axisOptions = getYAxisOption(options);
+    return Math.abs((_d = (_c = (_b = (_a = axisOptions) === null || _a === void 0 ? void 0 : _a[axisName]) === null || _b === void 0 ? void 0 : _b.label) === null || _c === void 0 ? void 0 : _c.margin, (_d !== null && _d !== void 0 ? _d : 0)));
+}
+export function getInitAxisIntervalData(isLabelAxis, params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { axis, categories, layout, isCoordinateTypeChart } = params;
+    const tickInterval = (_b = (_a = axis) === null || _a === void 0 ? void 0 : _a.tick) === null || _b === void 0 ? void 0 : _b.interval;
+    const labelInterval = (_d = (_c = axis) === null || _c === void 0 ? void 0 : _c.label) === null || _d === void 0 ? void 0 : _d.interval;
+    const existIntervalOptions = isNumber(tickInterval) || isNumber(labelInterval);
+    const needAdjustInterval = isLabelAxis &&
+        !isNumber((_f = (_e = axis) === null || _e === void 0 ? void 0 : _e.scale) === null || _f === void 0 ? void 0 : _f.stepSize) &&
+        !params.shift &&
+        !existIntervalOptions &&
+        !isCoordinateTypeChart;
+    const initTickInterval = needAdjustInterval ? getInitTickInterval(categories, layout) : 1;
+    const initLabelInterval = needAdjustInterval ? initTickInterval : 1;
+    const axisData = {
+        tickInterval: (tickInterval !== null && tickInterval !== void 0 ? tickInterval : initTickInterval),
+        labelInterval: (labelInterval !== null && labelInterval !== void 0 ? labelInterval : initLabelInterval),
+    };
+    return axisData;
+}
+function getInitTickInterval(categories, layout) {
+    if (!categories || !layout) {
+        return 1;
+    }
+    const { width } = layout.xAxis;
+    const count = categories.length;
+    return getAutoAdjustingInterval(count, width, categories);
+}
+export function getDefaultRadialAxisData(options, plot, maxLabelWidth = 0, maxLabelHeight = 0, isLabelOnVerticalAxis = false) {
+    var _a;
+    const centerX = plot.width / 2;
+    if (isLabelOnVerticalAxis) {
+        const { startAngle, endAngle, clockwise } = initSectorOptions((_a = options) === null || _a === void 0 ? void 0 : _a.series);
+        const isSemiCircular = isSemiCircle(clockwise, startAngle, endAngle);
+        return {
+            isSemiCircular,
+            axisSize: getDefaultRadius(plot, isSemiCircular, maxLabelWidth, maxLabelHeight),
+            centerX,
+            centerY: isSemiCircular ? getSemiCircleCenterY(plot.height, clockwise) : plot.height / 2,
+            totalAngle: getTotalAngle(clockwise, startAngle, endAngle),
+            drawingStartAngle: startAngle,
+            clockwise,
+            startAngle,
+            endAngle,
+        };
+    }
+    return {
+        isSemiCircular: false,
+        axisSize: getDefaultRadius(plot, false, maxLabelWidth, maxLabelHeight),
+        centerX,
+        centerY: plot.height / 2,
+        totalAngle: DEGREE_360,
+        drawingStartAngle: DEGREE_0,
+        clockwise: true,
+        startAngle: DEGREE_0,
+        endAngle: DEGREE_360,
+    };
+}
+export function getRadiusInfo(axisSize, radiusRange, count = 1) {
+    var _a, _b, _c, _d;
+    const innerRadius = calculateSizeWithPercentString(axisSize, (_b = (_a = radiusRange) === null || _a === void 0 ? void 0 : _a.inner, (_b !== null && _b !== void 0 ? _b : 0)));
+    const outerRadius = calculateSizeWithPercentString(axisSize, (_d = (_c = radiusRange) === null || _c === void 0 ? void 0 : _c.outer, (_d !== null && _d !== void 0 ? _d : axisSize)));
+    return {
+        radiusRanges: makeTickPixelPositions(outerRadius - innerRadius, count, innerRadius)
+            .splice(innerRadius === 0 ? 1 : 0, count)
+            .reverse(),
+        innerRadius,
+        outerRadius,
+    };
+}
+export function isDateType(options, axisName) {
+    var _a;
+    return !!((_a = options[axisName]) === null || _a === void 0 ? void 0 : _a.date);
+}

package/dist/esm/helpers/boxSeries.d.ts

@@ -0,0 +1,5 @@
+import { Nullable } from "../../types/components/series";
+export declare function calibrateDrawingValue(value: number, min: number, max: number): number;
+export declare function sumValuesBeforeIndex(values: number[], targetIndex: number, includeTarget?: boolean): number;
+export declare function outsideRange(values: number[], currentIndex: number, min: number, max: number): boolean;
+export declare function calibrateBoxStackDrawingValue(values: number[], currentIndex: number, min: number, max: number): Nullable<number>;

package/dist/esm/helpers/boxSeries.js

@@ -0,0 +1,71 @@
+function limitNegative(value, min, max) {
+    let result = value;
+    if (result >= max) {
+        return 0;
+    }
+    if (max < 0) {
+        result = Math.min(value - max, 0);
+    }
+    if (value < min) {
+        result -= value - min;
+    }
+    return result;
+}
+function limitPositive(value, min, max) {
+    let result = value;
+    if (min > 0) {
+        result = Math.max(value - min, 0);
+    }
+    if (value > max) {
+        result -= value - max;
+    }
+    return result;
+}
+export function calibrateDrawingValue(value, min, max) {
+    return value < 0 ? limitNegative(value, min, max) : limitPositive(value, min, max);
+}
+export function sumValuesBeforeIndex(values, targetIndex, includeTarget = false) {
+    const target = values[targetIndex];
+    return values.reduce((total, value, idx) => {
+        const isBefore = includeTarget ? idx <= targetIndex : idx < targetIndex;
+        const isSameSign = value * target >= 0;
+        return isBefore && isSameSign ? total + value : total;
+    }, 0);
+}
+export function outsideRange(values, currentIndex, min, max) {
+    const value = values[currentIndex];
+    const totalOfIndexBefore = sumValuesBeforeIndex(values, currentIndex, false);
+    const positive = value >= 0;
+    const negative = value < 0;
+    return ((positive && totalOfIndexBefore >= max) ||
+        (negative && totalOfIndexBefore <= min) ||
+        (currentIndex === 0 && positive && value < min) ||
+        (currentIndex === 0 && negative && value > max));
+}
+export function calibrateBoxStackDrawingValue(values, currentIndex, min, max) {
+    const totalOfIndexBefore = sumValuesBeforeIndex(values, currentIndex, false);
+    const totalOfValues = sumValuesBeforeIndex(values, currentIndex, true);
+    if (outsideRange(values, currentIndex, min, max)) {
+        return null;
+    }
+    if (currentIndex === 0) {
+        return calibrateDrawingValue(values[currentIndex], min, max);
+    }
+    if (totalOfIndexBefore < min && totalOfValues > max) {
+        return max - min;
+    }
+    let result = values[currentIndex];
+    if (totalOfValues > max) {
+        result = max - totalOfIndexBefore;
+    }
+    else if (totalOfValues < min) {
+        result = min - totalOfIndexBefore;
+    }
+    else if (totalOfIndexBefore < min) {
+        result = totalOfValues - min;
+    }
+    else if (totalOfIndexBefore > max) {
+        result = totalOfValues - max;
+    }
+    return result;
+}

package/dist/esm/helpers/calculator.d.ts

@@ -0,0 +1,19 @@
+import { ValueEdge, LabelAxisData } from "../../types/store/store";
+import { BezierPoint, Point } from "../../types/options";
+export declare function getTextWidth(text: string, font?: string): number;
+export declare function getTextHeight(text: string, font?: string): number;
+export declare function getFontHeight(font?: string): number;
+export declare function getAxisLabelAnchorPoint(labelHeight: number): number;
+export declare function add(a: number, b: number): number;
+export declare function multiply(a: number, b: number): number;
+export declare function divide(a: number, b: number): number;
+export declare function sum(values: number[]): number;
+export declare function divisors(value: number): number[];
+export declare function makeLabelsFromLimit(limit: ValueEdge, stepSize: number, isDateType?: boolean): string[];
+export declare function makeTickPixelPositions(size: number, count: number, additionalPosition?: number, remainLastBlockIntervalPosition?: number): number[];
+export declare function crispPixel(pixel: number, thickness?: number): number;
+export declare function setSplineControlPoint(points: (BezierPoint | null)[]): void;
+export declare function getValueRatio(value: number, { min, max }: ValueEdge): number;
+export declare function getDistance(point1: Point, point2: Point): number;
+export declare function getMaxLengthLabelWidth(labels: string[]): number;
+export declare function getXPosition(axisData: LabelAxisData, offsetSize: number, value: number | string | Date, dataIndex: number): any;

package/dist/esm/helpers/calculator.js

@@ -0,0 +1,153 @@
+import { range, isInteger, isString, isNumber, isNull } from "./utils";
+import { DEFAULT_LABEL_TEXT } from "../brushes/label";
+import { TICK_SIZE } from "../brushes/axis";
+const LINE_HEIGHT_NORMAL = 1.2;
+const ctx = document.createElement('canvas').getContext('2d');
+export function getTextWidth(text, font = DEFAULT_LABEL_TEXT) {
+    ctx.font = font;
+    return Math.ceil(ctx.measureText(text).width);
+}
+/*
+ * Calculate height of canvas text
+ * https://developer.mozilla.org/en-US/docs/Web/API/TextMetrics
+ * */
+export function getTextHeight(text, font = DEFAULT_LABEL_TEXT) {
+    ctx.font = font;
+    const { actualBoundingBoxAscent, actualBoundingBoxDescent } = ctx.measureText(text);
+    const validActualBoundingBox = isNumber(actualBoundingBoxAscent) && isNumber(actualBoundingBoxDescent);
+    return validActualBoundingBox
+        ? Math.ceil(Math.abs(actualBoundingBoxAscent) + Math.abs(actualBoundingBoxDescent)) + 1
+        : getFontHeight(font);
+}
+export function getFontHeight(font = DEFAULT_LABEL_TEXT) {
+    const fontSize = font.match(/\d+(?=px)/);
+    return parseInt(String(Number(fontSize) * LINE_HEIGHT_NORMAL), 10);
+}
+export function getAxisLabelAnchorPoint(labelHeight) {
+    return crispPixel(TICK_SIZE * 2 + labelHeight / 2);
+}
+function getDecimalLength(value) {
+    var _a, _b;
+    return _b = (_a = String(value).split('.')[1]) === null || _a === void 0 ? void 0 : _a.length, (_b !== null && _b !== void 0 ? _b : 0);
+}
+function findMultipleNum(...args) {
+    const underPointLens = args.map((value) => getDecimalLength(value));
+    const underPointLen = Math.max(...underPointLens);
+    return Math.pow(10, underPointLen);
+}
+export function add(a, b) {
+    const multipleNum = findMultipleNum(a, b);
+    return (a * multipleNum + b * multipleNum) / multipleNum;
+}
+export function multiply(a, b) {
+    const multipleNum = findMultipleNum(a, b);
+    return (a * multipleNum * (b * multipleNum)) / (multipleNum * multipleNum);
+}
+export function divide(a, b) {
+    const multipleNum = findMultipleNum(a, b);
+    return (a * multipleNum) / (b * multipleNum);
+}
+export function sum(values) {
+    const copyArr = values.slice();
+    copyArr.unshift(0);
+    return copyArr.reduce((base, value) => add(parseFloat(String(base)), parseFloat(String(value))));
+}
+export function divisors(value) {
+    const result = [];
+    for (let a = 2, b; a * a <= value; a += 1) {
+        if (value % a === 0) {
+            b = value / a;
+            result.push(a);
+            if (b !== a) {
+                result.push(b);
+            }
+        }
+    }
+    return result.sort((prev, next) => prev - next);
+}
+export function makeLabelsFromLimit(limit, stepSize, isDateType) {
+    const multipleNum = findMultipleNum(stepSize);
+    const min = Math.round(limit.min * multipleNum);
+    const max = Math.round(limit.max * multipleNum);
+    const labels = range(min, max + 1, stepSize * multipleNum);
+    return labels.map((label) => {
+        return String(isDateType ? new Date(label) : label / multipleNum);
+    });
+}
+export function makeTickPixelPositions(size, count, additionalPosition = 0, remainLastBlockIntervalPosition = 0) {
+    let positions = [];
+    if (count > 0) {
+        positions = range(0, count).map((index) => {
+            const ratio = index === 0 ? 0 : index / (count - 1);
+            return ratio * size + additionalPosition;
+        });
+    }
+    if (remainLastBlockIntervalPosition) {
+        positions.push(remainLastBlockIntervalPosition);
+    }
+    return positions;
+}
+export function crispPixel(pixel, thickness = 1) {
+    const halfThickness = thickness / 2;
+    return thickness % 2
+        ? (isInteger(pixel) ? pixel : Math.round(pixel - halfThickness)) + halfThickness
+        : Math.round(pixel);
+}
+function getControlPoints(prev, cur, next) {
+    // http://scaledinnovation.com/analytics/splines/aboutSplines.html
+    const TENSION = 0.333;
+    const { x: x0, y: y0 } = prev;
+    const { x: x1, y: y1 } = cur;
+    const { x: x2, y: y2 } = next;
+    const d12 = getDistance(next, cur);
+    const d01 = getDistance(cur, prev);
+    const fa = (TENSION * d01) / (d01 + d12) || 0; // scaling factor for triangle Ta
+    const fb = (TENSION * d12) / (d01 + d12) || 0; // ditto for Tb, simplifies to fb=t-fa
+    return {
+        prev: {
+            x: x1 - fa * (x2 - x0),
+            y: y1 - fa * (y2 - y0),
+        },
+        next: { x: x1 + fb * (x2 - x0), y: y1 + fb * (y2 - y0) },
+    };
+}
+export function setSplineControlPoint(points) {
+    for (let i = 0, pointsSize = points.length, prev = points[0]; i < pointsSize; i += 1) {
+        const point = points[i];
+        if (isNull(point)) {
+            prev = points[i + 1];
+            continue;
+        }
+        const next = points[Math.min(i + 1, pointsSize - 1) % pointsSize];
+        if (prev && next) {
+            point.controlPoint = getControlPoints(prev, point, next);
+        }
+        prev = point;
+    }
+}
+export function getValueRatio(value, { min, max }) {
+    if (max === min) {
+        return 0;
+    }
+    return (value - min) / (max - min);
+}
+export function getDistance(point1, point2) {
+    return Math.sqrt(Math.pow((point2.x - point1.x), 2) + Math.pow((point2.y - point1.y), 2));
+}
+export function getMaxLengthLabelWidth(labels) {
+    const maxLengthLabel = labels.reduce((acc, cur) => (acc.length > cur.length ? acc : cur), '');
+    return getTextWidth(maxLengthLabel);
+}
+export function getXPosition(axisData, offsetSize, value, dataIndex) {
+    const { pointOnColumn, tickDistance, labelRange } = axisData;
+    let x;
+    if (labelRange) {
+        const xValue = isString(value) ? Number(new Date(value)) : Number(value);
+        const xValueRatio = getValueRatio(xValue, labelRange);
+        x = xValueRatio * offsetSize;
+    }
+    else {
+        x = tickDistance * dataIndex + (pointOnColumn ? tickDistance / 2 : 0);
+    }
+    return x;
+}