@techie_doubts/tui.chart.2026 4.6.1

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

@@ -0,0 +1,15 @@
+import { PieSeriesType } from "../../types/options";
+import { TooltipData } from "../../types/components/tooltip";
+import { RawSeries, OptionsWithDataLabels } from "../../types/store/store";
+export declare function hasClockwiseSemiCircle(clockwise: boolean, startAngle: number, endAngle: number): boolean;
+export declare function hasCounterClockwiseSemiCircle(clockwise: boolean, startAngle: number, endAngle: number): boolean;
+export declare function getRadius(defaultRadius: number, radius: string | number): number;
+export declare function getTotalAngle(clockwise: boolean, startAngle: number, endAngle: number): number;
+export declare function isSemiCircle(clockwise: boolean, startAngle: number, endAngle: number): boolean;
+export declare function getSemiCircleCenterY(rectHeight: number, clockwise: boolean): number;
+export declare function makePieTooltipData(seriesRawData: PieSeriesType[], category?: string): TooltipData[];
+export declare function hasNestedPieSeries(series: RawSeries): boolean;
+export declare function getNestedPieChartAliasNames(series: RawSeries): string[];
+export declare function pieTooltipLabelFormatter(percentValue: number): string;
+export declare function hasOuterDataLabel(options: OptionsWithDataLabels, series: RawSeries): boolean;
+export declare function hasOuterPieSeriesName(options: OptionsWithDataLabels, series: RawSeries): boolean;

package/dist/esm/helpers/pieSeries.js

@@ -0,0 +1,72 @@
+import { getPercentageValue, isString, isNull } from "./utils";
+import { DEGREE_NEGATIVE_90, DEGREE_90, DEGREE_180, DEGREE_NEGATIVE_180, DEGREE_360, DEGREE_0, } from "./sector";
+const semiCircleCenterYRatio = {
+    COUNTER_CLOCKWISE: 0.1,
+    CLOCKWISE: 1,
+};
+export function hasClockwiseSemiCircle(clockwise, startAngle, endAngle) {
+    return (clockwise &&
+        ((startAngle >= DEGREE_NEGATIVE_90 && endAngle <= DEGREE_90) ||
+            (startAngle >= DEGREE_90 && endAngle <= DEGREE_180)));
+}
+export function hasCounterClockwiseSemiCircle(clockwise, startAngle, endAngle) {
+    return (!clockwise &&
+        ((startAngle >= DEGREE_NEGATIVE_180 && endAngle <= DEGREE_90) ||
+            (startAngle <= DEGREE_90 && endAngle >= DEGREE_NEGATIVE_90)));
+}
+export function getRadius(defaultRadius, radius) {
+    return isString(radius)
+        ? Number(((defaultRadius * getPercentageValue(radius)) / 100).toFixed(2))
+        : radius;
+}
+export function getTotalAngle(clockwise, startAngle, endAngle) {
+    const diffAngle = endAngle - startAngle;
+    const absDiff = Math.abs(diffAngle);
+    const needSubstractAngle = (diffAngle > DEGREE_0 && absDiff !== DEGREE_360 && !clockwise) ||
+        (diffAngle < DEGREE_0 && absDiff !== DEGREE_360 && clockwise);
+    return needSubstractAngle ? DEGREE_360 - absDiff : absDiff;
+}
+export function isSemiCircle(clockwise, startAngle, endAngle) {
+    return (getTotalAngle(clockwise, startAngle, endAngle) <= DEGREE_180 &&
+        (hasClockwiseSemiCircle(clockwise, startAngle, endAngle) ||
+            hasCounterClockwiseSemiCircle(clockwise, startAngle, endAngle)));
+}
+export function getSemiCircleCenterY(rectHeight, clockwise) {
+    return clockwise
+        ? rectHeight * semiCircleCenterYRatio.CLOCKWISE
+        : rectHeight * semiCircleCenterYRatio.COUNTER_CLOCKWISE;
+}
+export function makePieTooltipData(seriesRawData, category = '') {
+    return seriesRawData
+        .filter(({ data }) => !isNull(data))
+        .map(({ data, name, color, rootParentName }) => ({
+        label: name,
+        color: color,
+        value: data,
+        category,
+        rootParentName,
+        templateType: 'pie',
+    }));
+}
+export function hasNestedPieSeries(series) {
+    var _a;
+    return !!(series.pie && Array.isArray((_a = series.pie[0]) === null || _a === void 0 ? void 0 : _a.data));
+}
+export function getNestedPieChartAliasNames(series) {
+    return series.pie.map(({ name }) => name);
+}
+export function pieTooltipLabelFormatter(percentValue) {
+    const percentageString = percentValue.toFixed(2);
+    const percent = parseFloat(percentageString);
+    const needSlice = percentageString.length > 5;
+    return `${needSlice ? parseFloat(percentageString.substr(0, 4)) : String(percent)}%`;
+}
+export function hasOuterDataLabel(options, series) {
+    var _a, _b, _c;
+    return !!series.pie && ((_c = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.series) === null || _b === void 0 ? void 0 : _b.dataLabels) === null || _c === void 0 ? void 0 : _c.anchor) === 'outer';
+}
+export function hasOuterPieSeriesName(options, series) {
+    var _a, _b, _c, _d;
+    return (!!series.pie &&
+        ((_d = (_c = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.series) === null || _b === void 0 ? void 0 : _b.dataLabels) === null || _c === void 0 ? void 0 : _c.pieSeriesName) === null || _d === void 0 ? void 0 : _d.anchor) === 'outer');
+}

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

@@ -0,0 +1,2 @@
+import { PlotLine, PlotBand, GaugePlotBand } from "../../types/options";
+export declare function isExistPlotId<T extends PlotLine | PlotBand | GaugePlotBand>(plots: T[], data: T): boolean;

package/dist/esm/helpers/plot.js

@@ -0,0 +1,4 @@
+import { isUndefined } from "./utils";
+export function isExistPlotId(plots, data) {
+    return plots.some(({ id: bandId }) => !isUndefined(bandId) && !isUndefined(data.id) && bandId === data.id);
+}

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

@@ -0,0 +1 @@
+export declare function getRadialRadiusValues(labels: string[], size: number, deleteCount?: number): number[];

package/dist/esm/helpers/radarSeries.js

@@ -0,0 +1,7 @@
+export function getRadialRadiusValues(labels, size, deleteCount = 0) {
+    const result = labels.map((_, index) => (index / (labels.length - 1)) * size);
+    if (deleteCount) {
+        result.splice(result.length - deleteCount);
+    }
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import { RangeDataType, BoxSeriesDataType } from "../../types/options";
+import { TooltipDataValue } from "../../types/components/tooltip";
+export declare function isRangeValue<T>(value: unknown): value is RangeDataType<T>;
+export declare function isRangeData(data?: BoxSeriesDataType[] | TooltipDataValue): boolean;
+export declare function isZooming(categories: string[], zoomRange?: RangeDataType<number>): boolean;
+export declare function getDataInRange<T>(data: T[], range?: RangeDataType<number>): T[];

package/dist/esm/helpers/range.js

@@ -0,0 +1,16 @@
+import { getFirstValidValue } from "./utils";
+export function isRangeValue(value) {
+    return Array.isArray(value) && value.length === 2;
+}
+export function isRangeData(data) {
+    return Array.isArray(data) && isRangeValue(getFirstValidValue(data));
+}
+export function isZooming(categories, zoomRange) {
+    return !!(zoomRange && (zoomRange[0] !== 0 || zoomRange[1] !== categories.length - 1));
+}
+export function getDataInRange(data, range) {
+    if (!range) {
+        return data;
+    }
+    return data.slice(range[0], range[1] + 1);
+}

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

@@ -0,0 +1,37 @@
+import { BoxPlotResponderModel, BulletResponderModel, CircleModel, CircleResponderModel, HeatmapRectResponderModel, SectorResponderModel, RectResponderModel, TreemapRectResponderModel, ResponderModel, GroupedSectorResponderModel, GaugeResponderModel } from "../../types/components/series";
+import { LineTypeEventDetectType, Point, Rect } from "../../types/options";
+import { LabelAxisData } from "../../types/store/store";
+import { TooltipData } from "../../types/components/tooltip";
+export declare type RespondersThemeType = 'select' | 'hover';
+export interface SelectedSeriesEventModel {
+    models: ResponderModel[];
+    comparisonModel: ResponderModel[];
+    name: string;
+    eventDetectType?: LineTypeEventDetectType;
+    alias?: string;
+}
+export interface RectResponderInfoForCoordinateType {
+    x: number;
+    label: string;
+}
+export declare function isSameSeriesResponder({ models, comparisonModel, name, eventDetectType, }: SelectedSeriesEventModel): boolean | 0 | undefined;
+export declare function getNearestResponder(responders: CircleResponderModel[], mousePosition: Point, rect: Rect): CircleResponderModel[];
+export declare function makeRectResponderModel(rect: Rect, axis: LabelAxisData, categories: string[], vertical?: boolean): RectResponderModel[];
+export declare function makeRectResponderModelForCoordinateType(responderInfo: RectResponderInfoForCoordinateType[], rect: Rect): RectResponderModel[];
+export declare function makeTooltipCircleMap(seriesCircleModel: CircleModel[], tooltipDataArr: TooltipData[]): Record<string, CircleResponderModel[]>;
+export declare function getDeepestNode(responders: TreemapRectResponderModel[]): TreemapRectResponderModel[];
+export declare function isClickSameNameResponder<T extends HeatmapRectResponderModel | BulletResponderModel | GaugeResponderModel>(responders: T[], selectedSeries?: T[]): boolean | 0 | undefined;
+export declare function isClickSameCircleResponder(responders: CircleResponderModel[], selectedSeries?: CircleResponderModel[]): boolean;
+export declare function isClickSameDataResponder<T extends RectResponderModel | BoxPlotResponderModel | SectorResponderModel>(responders: T[], selectedSeries?: T[]): boolean;
+export declare function isClickSameLabelResponder(responders: TreemapRectResponderModel[], selectedSeries?: TreemapRectResponderModel[]): boolean | 0 | undefined;
+export declare function isClickSameGroupedRectResponder(responders: RectResponderModel[], selectedSeries?: RectResponderModel[]): boolean | 0 | undefined;
+export declare function isClickSameBoxPlotDataResponder(responders: BoxPlotResponderModel[], selectedSeries?: BoxPlotResponderModel[]): boolean;
+export declare function makeGroupedSectorResponderModel(radiusRanges: number[], renderOptions: {
+    centerX: number;
+    centerY: number;
+    angleRange: {
+        start: number;
+        end: number;
+    };
+    clockwise: boolean;
+}, categories: string[]): GroupedSectorResponderModel[];

package/dist/esm/helpers/responders.js

@@ -0,0 +1,197 @@
+import { getDistance } from "./calculator";
+import { range } from "./utils";
+import { getRadiusRanges } from "./sector";
+// eslint-disable-next-line complexity
+export function isSameSeriesResponder({ models, comparisonModel, name, eventDetectType, }) {
+    switch (name) {
+        case 'heatmap':
+            return isClickSameNameResponder(models, comparisonModel);
+        case 'bullet':
+            return eventDetectType === 'grouped'
+                ? isClickSameGroupedRectResponder(models, comparisonModel)
+                : isClickSameNameResponder(models, comparisonModel);
+        case 'radar':
+        case 'bubble':
+        case 'scatter':
+        case 'area':
+        case 'line':
+            return isClickSameCircleResponder(models, comparisonModel);
+        case 'pie':
+            return isClickSameDataResponder(models, comparisonModel);
+        case 'column':
+        case 'bar':
+            return eventDetectType === 'grouped'
+                ? isClickSameGroupedRectResponder(models, comparisonModel)
+                : isClickSameDataResponder(models, comparisonModel);
+        case 'boxPlot':
+            return eventDetectType === 'grouped'
+                ? isClickSameDataResponder(models, comparisonModel)
+                : isClickSameBoxPlotDataResponder(models, comparisonModel);
+        case 'treemap':
+            return isClickSameLabelResponder(models, comparisonModel);
+        case 'gauge':
+            return isClickSameNameResponder(models, comparisonModel);
+        default:
+            return false;
+    }
+}
+export function getNearestResponder(responders, mousePosition, rect) {
+    let minDistance = Infinity;
+    let result = [];
+    responders.forEach((responder) => {
+        const { x, y, radius } = responder;
+        const responderPoint = { x: x + rect.x, y: y + rect.y };
+        const distance = getDistance(responderPoint, mousePosition);
+        if (minDistance > distance) {
+            minDistance = distance;
+            result = [responder];
+        }
+        else if (minDistance === distance) {
+            if (result.length && result[0].radius > radius) {
+                result = [responder];
+            }
+            else {
+                result.push(responder);
+            }
+        }
+    });
+    return result;
+}
+export function makeRectResponderModel(rect, axis, categories, vertical = true) {
+    const { pointOnColumn, tickDistance, rectResponderCount } = axis;
+    const { width, height } = rect;
+    const halfDetectAreaIndex = pointOnColumn ? [] : [0, rectResponderCount - 1];
+    const halfSize = tickDistance / 2;
+    return range(0, rectResponderCount).map((index) => {
+        const half = halfDetectAreaIndex.includes(index);
+        const size = half ? halfSize : tickDistance;
+        let startPos = 0;
+        if (index !== 0) {
+            startPos += pointOnColumn ? tickDistance * index : halfSize + tickDistance * (index - 1);
+        }
+        return {
+            type: 'rect',
+            y: vertical ? 0 : startPos,
+            height: vertical ? height : size,
+            x: vertical ? startPos : 0,
+            width: vertical ? size : width,
+            index,
+            label: categories[index],
+        };
+    });
+}
+export function makeRectResponderModelForCoordinateType(responderInfo, rect) {
+    const { width, height } = rect;
+    let startPos = 0;
+    return responderInfo
+        .sort((a, b) => a.x - b.x)
+        .reduce((acc, model, index) => {
+        const { x, label } = model;
+        const next = responderInfo[index + 1];
+        const endPos = next ? (next.x + x) / 2 : width;
+        const rectResponderModel = {
+            type: 'rect',
+            x: startPos,
+            y: 0,
+            width: endPos - startPos,
+            height,
+            label,
+            index,
+        };
+        startPos = endPos;
+        return [...acc, rectResponderModel];
+    }, []);
+}
+export function makeTooltipCircleMap(seriesCircleModel, tooltipDataArr) {
+    const dataMap = tooltipDataArr.reduce((acc, cur) => {
+        const { index, seriesIndex } = cur;
+        if (!acc[seriesIndex]) {
+            acc[seriesIndex] = [];
+        }
+        acc[seriesIndex][index] = cur;
+        return acc;
+    }, []);
+    return seriesCircleModel.reduce((acc, model) => {
+        const { seriesIndex, index } = model;
+        const data = dataMap[seriesIndex][index];
+        const { category } = data;
+        if (!category) {
+            return acc;
+        }
+        if (!acc[category]) {
+            acc[category] = [];
+        }
+        acc[category].push(Object.assign(Object.assign({}, model), { data }));
+        return acc;
+    }, {});
+}
+export function getDeepestNode(responders) {
+    return responders.reduce((acc, responder) => {
+        if (!acc.length || responder.depth > acc[0].depth) {
+            return [responder];
+        }
+        return acc;
+    }, []);
+}
+export function isClickSameNameResponder(responders, selectedSeries) {
+    var _a;
+    return (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length) && responders[0].name === selectedSeries[0].name);
+}
+export function isClickSameCircleResponder(responders, selectedSeries) {
+    var _a;
+    let same = false;
+    if (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length) && responders.length === selectedSeries.length) {
+        same = responders.reduce((acc, cur, idx) => {
+            return (acc &&
+                cur.seriesIndex === selectedSeries[idx].seriesIndex &&
+                cur.index === selectedSeries[idx].index);
+        }, true);
+    }
+    return same;
+}
+export function isClickSameDataResponder(responders, selectedSeries) {
+    var _a;
+    let same = false;
+    if (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length) && responders.length === selectedSeries.length) {
+        same = responders.reduce((acc, cur, idx) => {
+            var _a, _b, _c, _d;
+            return (acc &&
+                ((_a = cur.data) === null || _a === void 0 ? void 0 : _a.label) === ((_b = selectedSeries[idx].data) === null || _b === void 0 ? void 0 : _b.label) &&
+                ((_c = cur.data) === null || _c === void 0 ? void 0 : _c.category) === ((_d = selectedSeries[idx].data) === null || _d === void 0 ? void 0 : _d.category));
+        }, true);
+    }
+    return same;
+}
+export function isClickSameLabelResponder(responders, selectedSeries) {
+    var _a;
+    return (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length) && responders[0].label === selectedSeries[0].label);
+}
+export function isClickSameGroupedRectResponder(responders, selectedSeries) {
+    var _a;
+    return (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length) && responders[0].index === selectedSeries[0].index);
+}
+export function isClickSameBoxPlotDataResponder(responders, selectedSeries) {
+    var _a, _b, _c, _d, _e;
+    let same = false;
+    if (responders.length && ((_a = selectedSeries) === null || _a === void 0 ? void 0 : _a.length)) {
+        const { type, data } = responders[0];
+        same =
+            type === selectedSeries[0].type &&
+                ((_b = data) === null || _b === void 0 ? void 0 : _b.label) === ((_c = selectedSeries[0].data) === null || _c === void 0 ? void 0 : _c.label) &&
+                ((_d = data) === null || _d === void 0 ? void 0 : _d.category) === ((_e = selectedSeries[0].data) === null || _e === void 0 ? void 0 : _e.category);
+    }
+    return same;
+}
+export function makeGroupedSectorResponderModel(radiusRanges, renderOptions, categories) {
+    const { centerX, centerY, angleRange: { start, end }, clockwise, } = renderOptions;
+    return getRadiusRanges(radiusRanges, 0).map((radius, index) => ({
+        type: 'sector',
+        x: centerX,
+        y: centerY,
+        degree: { start, end },
+        radius,
+        name: categories[index],
+        clockwise,
+        index,
+    }));
+}

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

@@ -0,0 +1,55 @@
+import { Point, PieSeriesOptions, Rect, DataLabelAnchor, RadialBarSeriesOptions } from "../../types/options";
+import { SectorModel, RadiusRange } from "../../types/components/series";
+import { RadialDataLabel, RadialAnchor } from "../../types/components/dataLabels";
+export declare const DEGREE_180 = 180;
+export declare const DEGREE_NEGATIVE_180 = -180;
+export declare const DEGREE_360 = 360;
+export declare const DEGREE_0 = 0;
+export declare const DEGREE_NEGATIVE_90 = -90;
+export declare const DEGREE_90 = 90;
+declare type RadialPositionParam = {
+    anchor: DataLabelAnchor;
+    x: number;
+    y: number;
+    radius: {
+        inner: number;
+        outer: number;
+    };
+    degree: {
+        start: number;
+        end: number;
+    };
+    drawingStartAngle?: number;
+};
+export declare function makeAnchorPositionParam(anchor: DataLabelAnchor, model: SectorModel | RadialDataLabel): {
+    radius: {
+        inner: number;
+        outer: number;
+    };
+    x: number;
+    y: number;
+    degree: {
+        start: number;
+        end: number;
+    };
+    drawingStartAngle?: number | undefined;
+    anchor: DataLabelAnchor;
+};
+export declare function calculateDegreeToRadian(degree: number, drawingStartAngle?: number): number;
+export declare function calculateRadianToDegree(radian: number, drawingStartAngle?: number): number;
+export declare function getRadialAnchorPosition(param: RadialPositionParam): Point;
+export declare function getRadialPosition(x: number, y: number, r: number, radian: number): {
+    x: number;
+    y: number;
+};
+export declare function withinRadian(clockwise: boolean, startDegree: number, endDegree: number, currentDegree: number): boolean;
+export declare function initSectorOptions(options?: PieSeriesOptions | RadialBarSeriesOptions): {
+    clockwise: boolean;
+    startAngle: number;
+    endAngle: number;
+};
+export declare function getDefaultRadius({ width, height }: Rect, isSemiCircular?: boolean, maxLabelWidth?: number, maxLabelHeight?: number): number;
+export declare function getRadialLabelAlign(model: Pick<RadialDataLabel, 'totalAngle' | 'degree' | 'drawingStartAngle'>, anchor: RadialAnchor, needCalculateByHalf?: boolean): "left" | "center" | "right";
+export declare function getRadiusRanges(radiusRanges: number[], padding: number): RadiusRange[];
+export declare function calculateValidAngle(angle: number): number;
+export {};

package/dist/esm/helpers/sector.js

@@ -0,0 +1,117 @@
+import { pick } from "./utils";
+export const DEGREE_180 = 180;
+export const DEGREE_NEGATIVE_180 = -180;
+export const DEGREE_360 = 360;
+export const DEGREE_0 = 0;
+export const DEGREE_NEGATIVE_90 = -90;
+export const DEGREE_90 = 90;
+const MINIMUM_RADIUS = 10;
+export function makeAnchorPositionParam(anchor, model) {
+    return Object.assign({ anchor }, pick(model, 'x', 'y', 'radius', 'degree', 'drawingStartAngle'));
+}
+export function calculateDegreeToRadian(degree, drawingStartAngle = DEGREE_NEGATIVE_90) {
+    let result = 0;
+    if (degree % DEGREE_360 === 0) {
+        result = (Math.PI / DEGREE_180) * drawingStartAngle;
+    }
+    else if (degree >= 0) {
+        result = (Math.PI / DEGREE_180) * (degree + drawingStartAngle);
+    }
+    return result;
+}
+export function calculateRadianToDegree(radian, drawingStartAngle = DEGREE_NEGATIVE_90) {
+    return ((radian * DEGREE_180) / Math.PI - drawingStartAngle + DEGREE_360) % DEGREE_360;
+}
+export function getRadialAnchorPosition(param) {
+    const { anchor, x, y, radius: { inner, outer }, degree: { start, end }, drawingStartAngle = DEGREE_NEGATIVE_90, } = param;
+    const halfDegree = start + (end - start) / 2;
+    const radian = calculateDegreeToRadian(halfDegree, drawingStartAngle);
+    const r = anchor === 'outer' ? outer : (outer + inner) / 2;
+    return getRadialPosition(x, y, r, radian);
+}
+export function getRadialPosition(x, y, r, radian) {
+    return { x: Math.round(x + r * Math.cos(radian)), y: Math.round(y + r * Math.sin(radian)) };
+}
+export function withinRadian(clockwise, startDegree, endDegree, currentDegree) {
+    return clockwise
+        ? startDegree <= currentDegree && endDegree >= currentDegree
+        : startDegree >= currentDegree && endDegree <= currentDegree;
+}
+export function initSectorOptions(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const clockwise = (_b = (_a = options) === null || _a === void 0 ? void 0 : _a.clockwise, (_b !== null && _b !== void 0 ? _b : true));
+    return {
+        clockwise,
+        startAngle: (_e = (_d = (_c = options) === null || _c === void 0 ? void 0 : _c.angleRange) === null || _d === void 0 ? void 0 : _d.start, (_e !== null && _e !== void 0 ? _e : (clockwise ? DEGREE_0 : DEGREE_360))),
+        endAngle: (_h = (_g = (_f = options) === null || _f === void 0 ? void 0 : _f.angleRange) === null || _g === void 0 ? void 0 : _g.end, (_h !== null && _h !== void 0 ? _h : (clockwise ? DEGREE_360 : DEGREE_0))),
+    };
+}
+export function getDefaultRadius({ width, height }, isSemiCircular = false, maxLabelWidth = 0, maxLabelHeight = 0) {
+    let result;
+    if (isSemiCircular) {
+        result = Math.min(width / 2, height) - maxLabelHeight;
+    }
+    else if (width > height) {
+        result = height / 2 - maxLabelHeight;
+    }
+    else {
+        result = width / 2 - maxLabelWidth;
+    }
+    return Math.max(result, MINIMUM_RADIUS);
+}
+function getRadian(startAngle, endAngle, drawingStartAngle, needCalculateByHalf) {
+    const degree = needCalculateByHalf ? (endAngle + startAngle) / 2 : startAngle;
+    return calculateDegreeToRadian(degree, drawingStartAngle);
+}
+export function getRadialLabelAlign(model, anchor, needCalculateByHalf = true) {
+    const { totalAngle = DEGREE_360, degree: { start, end }, drawingStartAngle = DEGREE_NEGATIVE_90, } = model;
+    let textAlign = 'center';
+    if (anchor !== 'outer') {
+        return textAlign;
+    }
+    const radian0 = calculateDegreeToRadian(0, drawingStartAngle);
+    const halfRadian = calculateDegreeToRadian(totalAngle / 2, drawingStartAngle);
+    const radian = getRadian(start, end, drawingStartAngle, needCalculateByHalf);
+    if (drawingStartAngle >= DEGREE_NEGATIVE_90 && drawingStartAngle < DEGREE_90) {
+        if (radian0 < radian && halfRadian > radian) {
+            textAlign = 'left';
+        }
+        else if (halfRadian < radian) {
+            textAlign = 'right';
+        }
+    }
+    else if (radian0 < radian && halfRadian > radian) {
+        textAlign = 'right';
+    }
+    else if (halfRadian < radian) {
+        textAlign = 'left';
+    }
+    return textAlign;
+}
+export function getRadiusRanges(radiusRanges, padding) {
+    return radiusRanges.reduce((acc, cur, index) => {
+        if (index) {
+            acc.push({
+                inner: cur + padding,
+                outer: radiusRanges[index - 1] - padding,
+            });
+        }
+        if (index === radiusRanges.length - 1) {
+            acc.push({
+                inner: padding,
+                outer: cur - padding,
+            });
+        }
+        return acc;
+    }, []);
+}
+// Recalculate to an angle between 0 and 360 degrees.
+export function calculateValidAngle(angle) {
+    if (angle < DEGREE_0) {
+        return DEGREE_360 + (angle % DEGREE_360);
+    }
+    if (angle > DEGREE_360) {
+        return angle % DEGREE_360;
+    }
+    return angle;
+}

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

@@ -0,0 +1,8 @@
+import { TreemapSeriesData } from "../../types/store/store";
+import { Rect } from "../../types/options";
+declare type IdType = string | number;
+export declare type BoundMap = {
+    [key in IdType]: Rect;
+};
+export declare function squarify(layout: Rect, seriesItems: TreemapSeriesData[]): {};
+export {};

package/dist/esm/helpers/squarifier.js

@@ -0,0 +1,110 @@
+import { sum } from "./calculator";
+import { pluck } from "./arrayUtil";
+function calculateScale(values, width, height) {
+    return (width * height) / sum(values);
+}
+function isVerticalStack({ height, width }) {
+    return height < width;
+}
+function selectBaseSize(baseBound) {
+    return isVerticalStack(baseBound) ? baseBound.height : baseBound.width;
+}
+function makeBaseData(seriesItems, baseBound) {
+    const { width, height } = baseBound;
+    const scale = calculateScale(pluck(seriesItems, 'data'), width, height);
+    return seriesItems
+        .map((seriesItem) => ({
+        id: seriesItem.id,
+        weight: seriesItem.data * scale,
+    }))
+        .sort((a, b) => b.weight - a.weight);
+}
+/**
+ * Calculate worst aspect ratio.
+ * Referred function worst() in https://www.win.tue.nl/~vanwijk/stm.pdf
+ */
+function worst(total, min, max, baseSize) {
+    const sumSquare = total * total;
+    const sizeSquare = baseSize * baseSize;
+    return Math.max((sizeSquare * max) / sumSquare, sumSquare / (sizeSquare * min));
+}
+function changedStackDirection(total, weights, baseSize, newWeight) {
+    const minWeight = Math.min(...weights);
+    const maxWeight = Math.max(...weights);
+    const beforeWorst = worst(total, minWeight, maxWeight, baseSize);
+    const newWorst = worst(total + newWeight, Math.min(minWeight, newWeight), Math.max(maxWeight, newWeight), baseSize);
+    return newWorst >= beforeWorst;
+}
+function calculateFixedSize(baseSize, total, rows) {
+    if (!total) {
+        const weights = pluck(rows, 'weight');
+        total = sum(weights);
+    }
+    return total / baseSize;
+}
+function addBounds(startPosition, rows, fixedSize, callback) {
+    rows.reduce((storedPosition, rowDatum) => {
+        const dynamicSize = rowDatum.weight / fixedSize;
+        callback(dynamicSize, storedPosition, rowDatum.id);
+        return storedPosition + dynamicSize;
+    }, startPosition);
+}
+function addBound(boundMap, id, rect) {
+    boundMap[id] = rect;
+}
+function addBoundsForVerticalStack(boundMap, rows, baseBound, baseSize, total) {
+    const fixedWidth = calculateFixedSize(baseSize, total, rows);
+    addBounds(baseBound.y, rows, fixedWidth, (dynamicHeight, storedTop, id) => {
+        addBound(boundMap, id, {
+            x: baseBound.x,
+            y: storedTop,
+            width: fixedWidth,
+            height: dynamicHeight,
+        });
+    });
+    baseBound.x += fixedWidth;
+    baseBound.width -= fixedWidth;
+}
+function addBoundsForHorizontalStack(boundMap, rows, baseBound, baseSize, total) {
+    const fixedHeight = calculateFixedSize(baseSize, total, rows);
+    addBounds(baseBound.x, rows, fixedHeight, (dynamicWidth, storedLeft, id) => {
+        addBound(boundMap, id, {
+            x: storedLeft,
+            y: baseBound.y,
+            width: dynamicWidth,
+            height: fixedHeight,
+        });
+    });
+    baseBound.y += fixedHeight;
+    baseBound.height -= fixedHeight;
+}
+function getAddingBoundsFunction(baseBound) {
+    if (isVerticalStack(baseBound)) {
+        return addBoundsForVerticalStack;
+    }
+    return addBoundsForHorizontalStack;
+}
+export function squarify(layout, seriesItems) {
+    const baseBound = layout;
+    const baseData = makeBaseData(seriesItems, baseBound);
+    let row = [];
+    let baseSize, addBoundsFunc;
+    const boundMap = {};
+    baseData.forEach((datum) => {
+        const weights = pluck(row, 'weight');
+        const totalWeight = sum(weights);
+        if (row.length && changedStackDirection(totalWeight, weights, baseSize, datum.weight)) {
+            addBoundsFunc(boundMap, row, baseBound, baseSize, totalWeight);
+            row = [];
+        }
+        if (!row.length) {
+            baseSize = selectBaseSize(baseBound);
+            addBoundsFunc = getAddingBoundsFunction(baseBound);
+        }
+        row.push(datum);
+    });
+    if (row.length) {
+        addBoundsFunc(boundMap, row, baseBound, baseSize);
+    }
+    return boundMap;
+}