react-native-chart-kit 7.0.0-next.0 → 7.0.0-next.2

package/dist/v2/core/geometry/lineDecimation.js

@@ -0,0 +1,110 @@
+const isFiniteGeometryPoint = (point) => {
+    return point.defined && Number.isFinite(point.x) && Number.isFinite(point.y);
+};
+const appendUniquePoint = (points, point) => {
+    if (points[points.length - 1] !== point) {
+        points.push(point);
+    }
+};
+export const splitLinePathSegments = (points, connectNulls = false) => {
+    if (connectNulls) {
+        return [points.filter(isFiniteGeometryPoint)];
+    }
+    const segments = [];
+    let current = [];
+    points.forEach((point) => {
+        if (isFiniteGeometryPoint(point)) {
+            current.push(point);
+            return;
+        }
+        if (current.length > 0) {
+            segments.push(current);
+            current = [];
+        }
+    });
+    if (current.length > 0) {
+        segments.push(current);
+    }
+    return segments;
+};
+const getSegmentMinimumBudget = (segment) => {
+    return segment.length > 1 ? 2 : segment.length;
+};
+const decimateMinMaxSegment = (segment, maxPoints) => {
+    if (segment.length <= maxPoints) {
+        return segment;
+    }
+    if (maxPoints <= 1) {
+        return segment.slice(0, 1);
+    }
+    const first = segment[0];
+    const last = segment[segment.length - 1];
+    const interior = segment.slice(1, -1);
+    const selected = [first];
+    const interiorBudget = Math.max(0, maxPoints - 2);
+    const bucketCount = Math.max(1, Math.ceil(interiorBudget / 2));
+    const bucketSize = interior.length / bucketCount;
+    for (let bucketIndex = 0; bucketIndex < bucketCount; bucketIndex++) {
+        const bucketStart = Math.floor(bucketIndex * bucketSize);
+        const bucketEnd = bucketIndex === bucketCount - 1
+            ? interior.length
+            : Math.floor((bucketIndex + 1) * bucketSize);
+        const bucket = interior.slice(bucketStart, bucketEnd);
+        if (bucket.length === 0) {
+            continue;
+        }
+        let minIndex = 0;
+        let maxIndex = 0;
+        bucket.forEach((point, index) => {
+            if (point.y < bucket[minIndex].y) {
+                minIndex = index;
+            }
+            if (point.y > bucket[maxIndex].y) {
+                maxIndex = index;
+            }
+        });
+        const extrema = minIndex <= maxIndex
+            ? [bucket[minIndex], bucket[maxIndex]]
+            : [bucket[maxIndex], bucket[minIndex]];
+        for (const point of extrema) {
+            if (selected.length >= maxPoints - 1) {
+                break;
+            }
+            appendUniquePoint(selected, point);
+        }
+    }
+    appendUniquePoint(selected, last);
+    return selected;
+};
+const allocateSegmentBudgets = (segments, maxPoints) => {
+    const minimumRequired = segments.reduce((sum, segment) => sum + getSegmentMinimumBudget(segment), 0);
+    const effectiveMaxPoints = Math.max(maxPoints, minimumRequired);
+    let remainingBudget = effectiveMaxPoints;
+    let remainingPoints = segments.reduce((sum, segment) => sum + segment.length, 0);
+    return segments.map((segment, index) => {
+        if (index === segments.length - 1) {
+            return Math.min(segment.length, remainingBudget);
+        }
+        const minimumBudget = getSegmentMinimumBudget(segment);
+        const proportionalBudget = Math.round((segment.length / remainingPoints) * remainingBudget);
+        const budget = Math.min(segment.length, Math.max(minimumBudget, proportionalBudget));
+        remainingBudget -= budget;
+        remainingPoints -= segment.length;
+        return budget;
+    });
+};
+export const getDecimatedLinePathSegments = ({ connectNulls = false, decimation, points }) => {
+    const segments = splitLinePathSegments(points, connectNulls).filter((segment) => segment.length > 0);
+    if (!decimation ||
+        !Number.isFinite(decimation.maxPoints) ||
+        decimation.maxPoints <= 0) {
+        return segments;
+    }
+    const totalPointCount = segments.reduce((sum, segment) => sum + segment.length, 0);
+    const maxPoints = Math.floor(decimation.maxPoints);
+    if (totalPointCount <= maxPoints) {
+        return segments;
+    }
+    const budgets = allocateSegmentBudgets(segments, maxPoints);
+    return segments.map((segment, index) => decimateMinMaxSegment(segment, budgets[index] ?? segment.length));
+};

package/dist/v2/core/geometry/linePath.d.ts

@@ -0,0 +1,5 @@
+import type { BuildLinePathOptions, GeometryPoint, LinePathModel } from "./types";
+export declare const splitDefinedSegments: <TPoint extends GeometryPoint = GeometryPoint>(points: TPoint[], connectNulls?: boolean) => TPoint[][];
+export declare const buildLineSegmentPath: <TPoint extends GeometryPoint>(points: TPoint[], curve?: BuildLinePathOptions<TPoint>["curve"]) => string;
+export declare const buildLinePath: <TPoint extends GeometryPoint = GeometryPoint>({ points, curve, connectNulls, decimation }: BuildLinePathOptions<TPoint>) => LinePathModel<TPoint>;
+//# sourceMappingURL=linePath.d.ts.map

package/dist/v2/core/geometry/linePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linePath.d.ts","sourceRoot":"","sources":["../../src/geometry/linePath.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EAEb,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,oBAAoB,GAC/B,MAAM,SAAS,aAAa,GAAG,aAAa,EAE5C,QAAQ,MAAM,EAAE,EAChB,sBAAoB,KACnB,MAAM,EAAE,EAAiD,CAAC;AAgH7D,eAAO,MAAM,oBAAoB,GAAI,MAAM,SAAS,aAAa,EAC/D,QAAQ,MAAM,EAAE,EAChB,QAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAY,WAexD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,SAAS,aAAa,GAAG,aAAa,EAAE,6CAKzE,oBAAoB,CAAC,MAAM,CAAC,KAAG,aAAa,CAAC,MAAM,CAcrD,CAAC"}

package/dist/v2/core/geometry/linePath.js

@@ -0,0 +1,98 @@
+import { cubicCommand, horizontalCommand, pointCommand, verticalCommand } from "./path";
+import { getDecimatedLinePathSegments, splitLinePathSegments } from "./lineDecimation";
+export const splitDefinedSegments = (points, connectNulls = false) => splitLinePathSegments(points, connectNulls);
+const buildLinearSegmentPath = (points) => {
+    return points
+        .map((point, index) => pointCommand(index === 0 ? "M" : "L", point.x, point.y))
+        .join(" ");
+};
+const buildStepSegmentPath = (points) => {
+    if (points.length === 0) {
+        return "";
+    }
+    const first = points[0];
+    if (!first) {
+        return "";
+    }
+    const rest = points.slice(1);
+    let path = pointCommand("M", first.x, first.y);
+    let previous = first;
+    rest.forEach((point) => {
+        const midpoint = previous.x + (point.x - previous.x) / 2;
+        path = [
+            path,
+            horizontalCommand(midpoint),
+            verticalCommand(point.y),
+            horizontalCommand(point.x)
+        ].join(" ");
+        previous = point;
+    });
+    return path;
+};
+const isStrictlyIncreasingX = (points) => {
+    return points.every((point, index) => {
+        return index === 0 || point.x > points[index - 1].x;
+    });
+};
+const buildMonotoneSegmentPath = (points) => {
+    if (points.length < 3 || !isStrictlyIncreasingX(points)) {
+        return buildLinearSegmentPath(points);
+    }
+    const slopes = points.slice(0, -1).map((point, index) => {
+        const next = points[index + 1];
+        return (next.y - point.y) / (next.x - point.x);
+    });
+    const tangents = points.map((_, index) => {
+        if (index === 0) {
+            return slopes[0];
+        }
+        if (index === points.length - 1) {
+            return slopes[slopes.length - 1];
+        }
+        const previousSlope = slopes[index - 1];
+        const nextSlope = slopes[index];
+        if (previousSlope * nextSlope <= 0) {
+            return 0;
+        }
+        const sign = Math.sign(previousSlope);
+        return (sign *
+            Math.min(Math.abs(previousSlope), Math.abs(nextSlope), Math.abs((previousSlope + nextSlope) / 2)));
+    });
+    let path = pointCommand("M", points[0].x, points[0].y);
+    for (let index = 0; index < points.length - 1; index++) {
+        const point = points[index];
+        const next = points[index + 1];
+        const deltaX = next.x - point.x;
+        path = [
+            path,
+            cubicCommand(point.x + deltaX / 3, point.y + (tangents[index] * deltaX) / 3, next.x - deltaX / 3, next.y - (tangents[index + 1] * deltaX) / 3, next.x, next.y)
+        ].join(" ");
+    }
+    return path;
+};
+export const buildLineSegmentPath = (points, curve = "linear") => {
+    if (points.length === 0) {
+        return "";
+    }
+    if (curve === "step") {
+        return buildStepSegmentPath(points);
+    }
+    if (curve === "monotone") {
+        return buildMonotoneSegmentPath(points);
+    }
+    return buildLinearSegmentPath(points);
+};
+export const buildLinePath = ({ points, curve = "linear", connectNulls = false, decimation }) => {
+    const segments = getDecimatedLinePathSegments({
+        points,
+        connectNulls,
+        decimation
+    }).map((segment) => ({
+        points: segment,
+        path: buildLineSegmentPath(segment, curve)
+    }));
+    return {
+        segments,
+        path: segments.map((segment) => segment.path).join(" ")
+    };
+};

package/dist/v2/core/geometry/lineSeries.d.ts

@@ -0,0 +1,29 @@
+import type { ChartXValue, NormalizedDataPoint, NormalizedSeries } from "../data";
+import type { BuildAreaPathOptions, GeometryPoint, LineCurve, LinePathModel } from "./types";
+export type ProjectedLinePoint<TData = unknown> = GeometryPoint<TData> & {
+    dataIndex: number;
+    seriesKey: string;
+    xValue: ChartXValue;
+};
+export type ProjectScale<TData = unknown> = (value: ChartXValue, point: NormalizedDataPoint<TData>) => number | undefined;
+export type ProjectValueScale<TData = unknown> = (value: number, point: NormalizedDataPoint<TData>) => number | undefined;
+export type BuildLineSeriesGeometryOptions<TData = unknown> = {
+    series: NormalizedSeries<TData>;
+    xScale: ProjectScale<TData>;
+    yScale: ProjectValueScale<TData>;
+    curve?: LineCurve;
+    connectNulls?: boolean;
+    dataIndexOffset?: number;
+    pathDecimation?: BuildAreaPathOptions<ProjectedLinePoint<TData>>["decimation"];
+    areaBaselineY?: BuildAreaPathOptions<ProjectedLinePoint<TData>>["baselineY"];
+};
+export type LineSeriesGeometry<TData = unknown> = {
+    key: string;
+    label: string;
+    color?: string;
+    points: Array<ProjectedLinePoint<TData>>;
+    line: LinePathModel<ProjectedLinePoint<TData>>;
+    area?: LinePathModel<ProjectedLinePoint<TData>>;
+};
+export declare const buildLineSeriesGeometry: <TData = unknown>({ series, xScale, yScale, curve, connectNulls, dataIndexOffset, pathDecimation, areaBaselineY }: BuildLineSeriesGeometryOptions<TData>) => LineSeriesGeometry<TData>;
+//# sourceMappingURL=lineSeries.d.ts.map

package/dist/v2/core/geometry/lineSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineSeries.d.ts","sourceRoot":"","sources":["../../src/geometry/lineSeries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,kBAAkB,CAAC,KAAK,GAAG,OAAO,IAAI,aAAa,CAAC,KAAK,CAAC,GAAG;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,KAAK,GAAG,OAAO,IAAI,CAC1C,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAC9B,MAAM,GAAG,SAAS,CAAC;AAExB,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,OAAO,IAAI,CAC/C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAC9B,MAAM,GAAG,SAAS,CAAC;AAExB,MAAM,MAAM,8BAA8B,CAAC,KAAK,GAAG,OAAO,IAAI;IAC5D,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAChC,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IAC5B,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,oBAAoB,CACnC,kBAAkB,CAAC,KAAK,CAAC,CAC1B,CAAC,YAAY,CAAC,CAAC;IAChB,aAAa,CAAC,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;CAC9E,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAAC,KAAK,GAAG,OAAO,IAAI;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,IAAI,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/C,IAAI,CAAC,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;CACjD,CAAC;AAkCF,eAAO,MAAM,uBAAuB,GAAI,KAAK,GAAG,OAAO,EAAE,iGAStD,8BAA8B,CAAC,KAAK,CAAC,KAAG,kBAAkB,CAAC,KAAK,CAgClE,CAAC"}

package/dist/v2/core/geometry/lineSeries.js

@@ -0,0 +1,51 @@
+import { buildAreaPath } from "./areaPath";
+import { buildLinePath } from "./linePath";
+const isFinitePosition = (value) => {
+    return typeof value === "number" && Number.isFinite(value);
+};
+const projectPoint = (series, point, xScale, yScale, dataIndexOffset) => {
+    const projectedX = xScale(point.x, point);
+    const projectedY = point.value === null ? undefined : yScale(point.value, point);
+    const defined = point.defined &&
+        isFinitePosition(projectedX) &&
+        isFinitePosition(projectedY);
+    return {
+        index: point.index + dataIndexOffset,
+        dataIndex: point.index + dataIndexOffset,
+        seriesKey: series.key,
+        xValue: point.x,
+        x: projectedX ?? 0,
+        y: projectedY ?? 0,
+        value: point.value,
+        defined,
+        raw: point.raw
+    };
+};
+export const buildLineSeriesGeometry = ({ series, xScale, yScale, curve = "linear", connectNulls = false, dataIndexOffset = 0, pathDecimation, areaBaselineY }) => {
+    const points = series.points.map((point) => projectPoint(series, point, xScale, yScale, dataIndexOffset));
+    const line = buildLinePath({
+        points,
+        curve,
+        connectNulls,
+        decimation: pathDecimation
+    });
+    const geometry = {
+        key: series.key,
+        label: series.label,
+        points,
+        line
+    };
+    if (series.color !== undefined) {
+        geometry.color = series.color;
+    }
+    if (areaBaselineY !== undefined) {
+        geometry.area = buildAreaPath({
+            points,
+            curve,
+            connectNulls,
+            decimation: pathDecimation,
+            baselineY: areaBaselineY
+        });
+    }
+    return geometry;
+};

package/dist/v2/core/geometry/path.d.ts

@@ -0,0 +1,6 @@
+export declare const formatPathNumber: (value: number) => string;
+export declare const pointCommand: (command: "M" | "L", x: number, y: number) => string;
+export declare const cubicCommand: (c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number) => string;
+export declare const horizontalCommand: (x: number) => string;
+export declare const verticalCommand: (y: number) => string;
+//# sourceMappingURL=path.d.ts.map

package/dist/v2/core/geometry/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/geometry/path.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAQhD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,SAAS,GAAG,GAAG,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,WAEpE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,MAAM,EACX,GAAG,MAAM,EACT,GAAG,MAAM,WAWV,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,WAA+B,CAAC;AAE3E,eAAO,MAAM,eAAe,GAAI,GAAG,MAAM,WAA+B,CAAC"}

package/dist/v2/core/geometry/path.js

@@ -0,0 +1,24 @@
+const DECIMAL_PLACES = 6;
+export const formatPathNumber = (value) => {
+    const rounded = Number(value.toFixed(DECIMAL_PLACES));
+    if (Object.is(rounded, -0)) {
+        return "0";
+    }
+    return String(rounded);
+};
+export const pointCommand = (command, x, y) => {
+    return `${command} ${formatPathNumber(x)} ${formatPathNumber(y)}`;
+};
+export const cubicCommand = (c1x, c1y, c2x, c2y, x, y) => {
+    return [
+        "C",
+        formatPathNumber(c1x),
+        formatPathNumber(c1y),
+        formatPathNumber(c2x),
+        formatPathNumber(c2y),
+        formatPathNumber(x),
+        formatPathNumber(y)
+    ].join(" ");
+};
+export const horizontalCommand = (x) => `H ${formatPathNumber(x)}`;
+export const verticalCommand = (y) => `V ${formatPathNumber(y)}`;

package/dist/v2/core/geometry/pieArcs.d.ts

@@ -0,0 +1,29 @@
+import type { NormalizedPieSlice } from "../data";
+export type PieArcPoint = {
+    x: number;
+    y: number;
+};
+export type PieArcModel<TData = unknown> = {
+    index: number;
+    label: string;
+    value: number | null;
+    percentage: number;
+    startAngle: number;
+    endAngle: number;
+    color?: string;
+    centroid: PieArcPoint;
+    defined: boolean;
+    path: string;
+    raw?: TData;
+};
+export type BuildPieArcsOptions<TData = unknown> = {
+    slices: Array<NormalizedPieSlice<TData>>;
+    centerX: number;
+    centerY: number;
+    radius: number;
+    innerRadius?: number | undefined;
+    startAngle?: number | undefined;
+    endAngle?: number | undefined;
+};
+export declare const buildPieArcs: <TData = unknown>({ slices, centerX, centerY, radius, innerRadius, startAngle, endAngle }: BuildPieArcsOptions<TData>) => Array<PieArcModel<TData>>;
+//# sourceMappingURL=pieArcs.d.ts.map

package/dist/v2/core/geometry/pieArcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pieArcs.d.ts","sourceRoot":"","sources":["../../src/geometry/pieArcs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,OAAO,IAAI;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,OAAO,IAAI;IACjD,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,CAAC;AAiJF,eAAO,MAAM,YAAY,GAAI,KAAK,GAAG,OAAO,EAAE,yEAQ3C,mBAAmB,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAoEvD,CAAC"}

package/dist/v2/core/geometry/pieArcs.js

@@ -0,0 +1,142 @@
+const fullCircle = Math.PI * 2;
+const defaultStartAngle = -Math.PI / 2;
+const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+const isFinitePositive = (value) => Number.isFinite(value) && value > 0;
+const polarToCartesian = ({ angle, centerX, centerY, radius }) => ({
+    x: centerX + radius * Math.cos(angle),
+    y: centerY + radius * Math.sin(angle)
+});
+const formatNumber = (value) => Number.isInteger(value) ? String(value) : Number(value.toFixed(4)).toString();
+const moveTo = (point) => `M ${formatNumber(point.x)} ${formatNumber(point.y)}`;
+const lineTo = (point) => `L ${formatNumber(point.x)} ${formatNumber(point.y)}`;
+const arcTo = ({ end, largeArc, radius, sweep }) => `A ${formatNumber(radius)} ${formatNumber(radius)} 0 ${largeArc} ${sweep} ${formatNumber(end.x)} ${formatNumber(end.y)}`;
+const getArcPath = ({ centerX, centerY, endAngle, innerRadius, radius, startAngle }) => {
+    const span = Math.max(0, endAngle - startAngle);
+    const isFullCircle = span >= fullCircle - 0.0001;
+    const outerStart = polarToCartesian({
+        angle: startAngle,
+        centerX,
+        centerY,
+        radius
+    });
+    const outerEnd = polarToCartesian({
+        angle: isFullCircle ? startAngle + Math.PI : endAngle,
+        centerX,
+        centerY,
+        radius
+    });
+    const largeArc = span > Math.PI ? 1 : 0;
+    if (innerRadius <= 0) {
+        const center = { x: centerX, y: centerY };
+        if (isFullCircle) {
+            return [
+                moveTo(center),
+                lineTo(outerStart),
+                arcTo({ end: outerEnd, largeArc: 1, radius, sweep: 1 }),
+                arcTo({ end: outerStart, largeArc: 1, radius, sweep: 1 }),
+                "Z"
+            ].join(" ");
+        }
+        return [
+            moveTo(center),
+            lineTo(outerStart),
+            arcTo({
+                end: outerEnd,
+                largeArc,
+                radius,
+                sweep: 1
+            }),
+            "Z"
+        ].join(" ");
+    }
+    const innerStart = polarToCartesian({
+        angle: startAngle,
+        centerX,
+        centerY,
+        radius: innerRadius
+    });
+    const innerEnd = polarToCartesian({
+        angle: isFullCircle ? startAngle + Math.PI : endAngle,
+        centerX,
+        centerY,
+        radius: innerRadius
+    });
+    if (isFullCircle) {
+        return [
+            moveTo(outerStart),
+            arcTo({ end: outerEnd, largeArc: 1, radius, sweep: 1 }),
+            arcTo({ end: outerStart, largeArc: 1, radius, sweep: 1 }),
+            lineTo(innerStart),
+            arcTo({ end: innerEnd, largeArc: 1, radius: innerRadius, sweep: 0 }),
+            arcTo({ end: innerStart, largeArc: 1, radius: innerRadius, sweep: 0 }),
+            "Z"
+        ].join(" ");
+    }
+    return [
+        moveTo(outerStart),
+        arcTo({ end: outerEnd, largeArc, radius, sweep: 1 }),
+        lineTo(innerEnd),
+        arcTo({ end: innerStart, largeArc, radius: innerRadius, sweep: 0 }),
+        "Z"
+    ].join(" ");
+};
+export const buildPieArcs = ({ slices, centerX, centerY, radius, innerRadius = 0, startAngle = defaultStartAngle, endAngle = startAngle + fullCircle }) => {
+    const safeRadius = isFinitePositive(radius) ? radius : 0;
+    const safeInnerRadius = clamp(Number.isFinite(innerRadius) ? innerRadius : 0, 0, safeRadius);
+    const safeStartAngle = Number.isFinite(startAngle)
+        ? startAngle
+        : defaultStartAngle;
+    const safeEndAngle = Number.isFinite(endAngle) && endAngle > safeStartAngle
+        ? endAngle
+        : safeStartAngle + fullCircle;
+    const total = slices.reduce((sum, slice) => slice.defined && isFinitePositive(slice.value ?? 0)
+        ? sum + (slice.value ?? 0)
+        : sum, 0);
+    let cursor = safeStartAngle;
+    return slices.map((slice) => {
+        const value = slice.defined && isFinitePositive(slice.value ?? 0)
+            ? (slice.value ?? 0)
+            : null;
+        const percentage = total > 0 && value !== null ? value / total : 0;
+        const span = (safeEndAngle - safeStartAngle) * percentage;
+        const arcStartAngle = cursor;
+        const arcEndAngle = cursor + span;
+        const centroidAngle = arcStartAngle + span / 2;
+        const centroidRadius = (safeInnerRadius + safeRadius) / 2;
+        const centroid = polarToCartesian({
+            angle: centroidAngle,
+            centerX,
+            centerY,
+            radius: centroidRadius
+        });
+        const path = safeRadius > 0 && span > 0
+            ? getArcPath({
+                centerX,
+                centerY,
+                endAngle: arcEndAngle,
+                innerRadius: safeInnerRadius,
+                radius: safeRadius,
+                startAngle: arcStartAngle
+            })
+            : "";
+        cursor = arcEndAngle;
+        return {
+            index: slice.index,
+            label: slice.label,
+            value,
+            percentage,
+            startAngle: arcStartAngle,
+            endAngle: arcEndAngle,
+            ...(slice.color !== undefined ? { color: slice.color } : {}),
+            centroid,
+            defined: path.length > 0,
+            path,
+            raw: slice.raw
+        };
+    });
+};

package/dist/v2/core/geometry/progressRings.d.ts

@@ -0,0 +1,30 @@
+import type { NormalizedProgressRing } from "../data";
+export type ProgressRingPoint = {
+    x: number;
+    y: number;
+};
+export type ProgressRingModel = {
+    index: number;
+    label?: string;
+    value: number | null;
+    clampedValue: number;
+    defined: boolean;
+    color?: string;
+    radius: number;
+    strokeWidth: number;
+    startAngle: number;
+    endAngle: number;
+    backgroundPath: string;
+    path: string;
+};
+export type BuildProgressRingsOptions = {
+    rings: NormalizedProgressRing[];
+    centerX: number;
+    centerY: number;
+    maxRadius: number;
+    strokeWidth: number;
+    ringGap?: number | undefined;
+    startAngle?: number | undefined;
+};
+export declare const buildProgressRings: ({ rings, centerX, centerY, maxRadius, strokeWidth, ringGap, startAngle }: BuildProgressRingsOptions) => ProgressRingModel[];
+//# sourceMappingURL=progressRings.d.ts.map

package/dist/v2/core/geometry/progressRings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressRings.d.ts","sourceRoot":"","sources":["../../src/geometry/progressRings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,CAAC;AA2GF,eAAO,MAAM,kBAAkB,GAAI,0EAQhC,yBAAyB,KAAG,iBAAiB,EA0D/C,CAAC"}

package/dist/v2/core/geometry/progressRings.js

@@ -0,0 +1,104 @@
+const fullCircle = Math.PI * 2;
+const defaultStartAngle = -Math.PI / 2;
+const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+const formatNumber = (value) => Number.isInteger(value) ? String(value) : Number(value.toFixed(4)).toString();
+const polarToCartesian = ({ angle, centerX, centerY, radius }) => ({
+    x: centerX + radius * Math.cos(angle),
+    y: centerY + radius * Math.sin(angle)
+});
+const moveTo = (point) => `M ${formatNumber(point.x)} ${formatNumber(point.y)}`;
+const arcTo = ({ end, largeArc, radius, sweep }) => `A ${formatNumber(radius)} ${formatNumber(radius)} 0 ${largeArc} ${sweep} ${formatNumber(end.x)} ${formatNumber(end.y)}`;
+const buildArcStrokePath = ({ centerX, centerY, endAngle, radius, startAngle }) => {
+    const span = Math.max(0, endAngle - startAngle);
+    if (radius <= 0 || span <= 0) {
+        return "";
+    }
+    const isFullCircle = span >= fullCircle - 0.0001;
+    const start = polarToCartesian({
+        angle: startAngle,
+        centerX,
+        centerY,
+        radius
+    });
+    const mid = polarToCartesian({
+        angle: startAngle + Math.PI,
+        centerX,
+        centerY,
+        radius
+    });
+    const end = polarToCartesian({
+        angle: isFullCircle ? startAngle + fullCircle : endAngle,
+        centerX,
+        centerY,
+        radius
+    });
+    if (isFullCircle) {
+        return [
+            moveTo(start),
+            arcTo({ end: mid, largeArc: 1, radius, sweep: 1 }),
+            arcTo({ end: start, largeArc: 1, radius, sweep: 1 })
+        ].join(" ");
+    }
+    return [
+        moveTo(start),
+        arcTo({
+            end,
+            largeArc: span > Math.PI ? 1 : 0,
+            radius,
+            sweep: 1
+        })
+    ].join(" ");
+};
+export const buildProgressRings = ({ rings, centerX, centerY, maxRadius, strokeWidth, ringGap = 8, startAngle = defaultStartAngle }) => {
+    const safeMaxRadius = Number.isFinite(maxRadius) && maxRadius > 0 ? maxRadius : 0;
+    const safeStrokeWidth = Number.isFinite(strokeWidth) && strokeWidth > 0 ? strokeWidth : 0;
+    const safeRingGap = Number.isFinite(ringGap) && ringGap > 0 ? ringGap : 0;
+    const safeStartAngle = Number.isFinite(startAngle)
+        ? startAngle
+        : defaultStartAngle;
+    return rings.map((ring, index) => {
+        const radius = Math.max(0, safeMaxRadius - index * (safeStrokeWidth + safeRingGap));
+        const value = ring.defined ? ring.value : null;
+        const clampedValue = value !== null && Number.isFinite(value) ? clamp(value, 0, 1) : 0;
+        const endAngle = safeStartAngle + fullCircle * clampedValue;
+        const backgroundPath = buildArcStrokePath({
+            centerX,
+            centerY,
+            endAngle: safeStartAngle + fullCircle,
+            radius,
+            startAngle: safeStartAngle
+        });
+        const path = buildArcStrokePath({
+            centerX,
+            centerY,
+            endAngle,
+            radius,
+            startAngle: safeStartAngle
+        });
+        const defined = ring.defined && safeStrokeWidth > 0 && radius > 0 && path.length > 0;
+        const model = {
+            index: ring.index,
+            value,
+            clampedValue,
+            defined,
+            radius,
+            strokeWidth: safeStrokeWidth,
+            startAngle: safeStartAngle,
+            endAngle,
+            backgroundPath,
+            path
+        };
+        if (ring.label !== undefined) {
+            model.label = ring.label;
+        }
+        if (ring.color !== undefined) {
+            model.color = ring.color;
+        }
+        return model;
+    });
+};