react-native-chart-kit 7.0.0-next.1 → 7.0.0-next.3

package/dist/v2/react-native/charts/line/xLabels.d.ts

@@ -0,0 +1,39 @@
+import { type ChartXValue, type Size } from "../../../core/index";
+import type { LineChartEdgeLabelPolicy, LineChartLabelStrategy, LineChartResolvedLabelStrategy } from "./types";
+export declare const defaultLabelRotation = -35;
+export declare const xLabelRowGap = 6;
+export declare const xLabelBaselineOffset = 20;
+export type XLabelCandidate = {
+    index: number;
+    value: ChartXValue;
+    text: string;
+    x: number;
+    size: Size;
+};
+export type XLabelLayoutItem = XLabelCandidate & {
+    gridX: number;
+    y: number;
+    row: number;
+    rotation: number;
+    textAnchor: "start" | "middle" | "end";
+};
+export type XLabelLayout = {
+    strategy: LineChartResolvedLabelStrategy;
+    items: XLabelLayoutItem[];
+    height: number;
+    rotation: number;
+    rows: number;
+};
+export declare const dedupeXLabelCandidates: (candidates: XLabelCandidate[]) => XLabelCandidate[];
+export declare const getMaxSize: (sizes: Size[]) => Size;
+export declare const resolveXLabelLayout: ({ candidates, plotWidth, chartWidth, strategy, rotation, edgeLabelPolicy, minGap, baseY }: {
+    candidates: XLabelCandidate[];
+    plotWidth: number;
+    chartWidth: number;
+    strategy: LineChartLabelStrategy;
+    rotation: number;
+    edgeLabelPolicy: LineChartEdgeLabelPolicy;
+    minGap: number;
+    baseY: number;
+}) => XLabelLayout;
+//# sourceMappingURL=xLabels.d.ts.map

package/dist/v2/react-native/charts/line/xLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xLabels.d.ts","sourceRoot":"","sources":["../../../src/charts/line/xLabels.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,IAAI,EACV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACtB,8BAA8B,EAC/B,MAAM,SAAS,CAAC;AAGjB,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAGvC,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,IAAI,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,8BAA8B,CAAC;IACzC,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,YAAY,eAAe,EAAE,sBAWnE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,IAAI,EAAE,SAQvC,CAAC;AAiSF,eAAO,MAAM,mBAAmB,GAAI,2FASjC;IACD,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,wBAAwB,CAAC;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,YAoHH,CAAC"}

package/dist/v2/react-native/charts/line/xLabels.js

@@ -0,0 +1,289 @@
+import { solveLabelCollision } from "../../../core/index";
+import { clamp } from "./utils";
+export const defaultLabelRotation = -35;
+export const xLabelRowGap = 6;
+export const xLabelBaselineOffset = 20;
+const rotatedLabelClearance = 10;
+export const dedupeXLabelCandidates = (candidates) => {
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate.text)) {
+            return false;
+        }
+        seen.add(candidate.text);
+        return true;
+    });
+};
+export const getMaxSize = (sizes) => {
+    return sizes.reduce((max, size) => ({
+        width: Math.max(max.width, size.width),
+        height: Math.max(max.height, size.height)
+    }), { width: 0, height: 0 });
+};
+const getRotatedLabelHeight = (sizes, rotation) => {
+    const maxSize = getMaxSize(sizes);
+    const radians = (Math.abs(rotation) * Math.PI) / 180;
+    return (maxSize.width * Math.sin(radians) +
+        maxSize.height * Math.cos(radians) +
+        rotatedLabelClearance);
+};
+const getXLabelHeight = ({ strategy, sizes, rotation, rows }) => {
+    if (strategy === "hide" || sizes.length === 0) {
+        return 0;
+    }
+    if (strategy === "rotate") {
+        return getRotatedLabelHeight(sizes, rotation);
+    }
+    const maxHeight = getMaxSize(sizes).height;
+    if (strategy === "stagger") {
+        return maxHeight * rows + xLabelRowGap * Math.max(0, rows - 1);
+    }
+    return maxHeight;
+};
+const getExplicitXLabelCollision = ({ labels, strategy, availableWidth, minGap, rotation }) => {
+    const allIndexes = labels.map((_, index) => index);
+    if (strategy === "hide") {
+        return {
+            strategy,
+            visibleIndexes: [],
+            rotation: 0,
+            rows: 0
+        };
+    }
+    if (strategy === "skip") {
+        const result = solveLabelCollision({
+            labels,
+            availableWidth,
+            allowRotate: false,
+            allowStagger: false,
+            minGap
+        });
+        return {
+            strategy: result.strategy === "hide" ? "hide" : result.strategy,
+            visibleIndexes: result.visibleIndexes,
+            rotation: 0,
+            rows: 1
+        };
+    }
+    return {
+        strategy,
+        visibleIndexes: allIndexes,
+        rotation: strategy === "rotate" ? rotation : 0,
+        rows: strategy === "stagger" ? 2 : 1
+    };
+};
+const getShiftedXLabel = ({ candidate, chartWidth, edgeLabelPolicy, rotation, textAnchor }) => {
+    if (edgeLabelPolicy === "show") {
+        return candidate.x;
+    }
+    const margin = 4;
+    const width = rotation === 0
+        ? candidate.size.width
+        : candidate.size.width * Math.cos((Math.abs(rotation) * Math.PI) / 180);
+    const leftExtent = textAnchor === "start" ? 0 : textAnchor === "end" ? width : width / 2;
+    const rightExtent = textAnchor === "start" ? width : textAnchor === "end" ? 0 : width / 2;
+    const min = margin + leftExtent;
+    const max = chartWidth - margin - rightExtent;
+    return clamp(candidate.x, min, max);
+};
+const getXLabelTextAnchor = ({ candidate, candidates, rotation }) => {
+    if (rotation === 0) {
+        return "middle";
+    }
+    if (rotation < 0) {
+        return candidate.index === candidates[0]?.index ? "start" : "end";
+    }
+    return candidate.index === candidates[candidates.length - 1]?.index
+        ? "end"
+        : "start";
+};
+const getRotatedBaselineOffset = ({ rotation, size, textAnchor }) => {
+    if (rotation === 0) {
+        return 0;
+    }
+    const radians = (Math.abs(rotation) * Math.PI) / 180;
+    const widthProjection = size.width * Math.sin(radians);
+    if (rotation < 0 && textAnchor === "start") {
+        return widthProjection;
+    }
+    if (rotation > 0 && textAnchor === "end") {
+        return widthProjection;
+    }
+    return 0;
+};
+const getXLabelHorizontalBounds = (label) => {
+    if (label.rotation === 0) {
+        const leftExtent = label.textAnchor === "start"
+            ? 0
+            : label.textAnchor === "end"
+                ? label.size.width
+                : label.size.width / 2;
+        const rightExtent = label.textAnchor === "start"
+            ? label.size.width
+            : label.textAnchor === "end"
+                ? 0
+                : label.size.width / 2;
+        return {
+            left: label.x - leftExtent,
+            right: label.x + rightExtent
+        };
+    }
+    const radians = (Math.abs(label.rotation) * Math.PI) / 180;
+    const projectedWidth = label.size.width * Math.cos(radians) +
+        label.size.height * Math.sin(radians);
+    const leftExtent = label.textAnchor === "start"
+        ? 0
+        : label.textAnchor === "end"
+            ? projectedWidth
+            : projectedWidth / 2;
+    const rightExtent = label.textAnchor === "start"
+        ? projectedWidth
+        : label.textAnchor === "end"
+            ? 0
+            : projectedWidth / 2;
+    return {
+        left: label.x - leftExtent,
+        right: label.x + rightExtent
+    };
+};
+const filterOverlappingRotatedLabels = (items, minGap) => {
+    if (items.length <= 1) {
+        return items;
+    }
+    const accepted = [];
+    const lastIndex = items.length - 1;
+    items.forEach((item, index) => {
+        const bounds = getXLabelHorizontalBounds(item);
+        const overlapsPrevious = () => {
+            const previous = accepted[accepted.length - 1];
+            return previous ? previous.bounds.right + minGap > bounds.left : false;
+        };
+        if (index === lastIndex) {
+            while (overlapsPrevious()) {
+                accepted.pop();
+            }
+            accepted.push({ bounds, item });
+            return;
+        }
+        if (!overlapsPrevious()) {
+            accepted.push({ bounds, item });
+        }
+    });
+    return accepted.map(({ item }) => item);
+};
+const isXLabelInsideChart = ({ candidate, chartWidth, x, textAnchor }) => {
+    const margin = 4;
+    const leftExtent = textAnchor === "start"
+        ? 0
+        : textAnchor === "end"
+            ? candidate.size.width
+            : candidate.size.width / 2;
+    const rightExtent = textAnchor === "start"
+        ? candidate.size.width
+        : textAnchor === "end"
+            ? 0
+            : candidate.size.width / 2;
+    return x - leftExtent >= margin && x + rightExtent <= chartWidth - margin;
+};
+export const resolveXLabelLayout = ({ candidates, plotWidth, chartWidth, strategy, rotation, edgeLabelPolicy, minGap, baseY }) => {
+    const labels = candidates.map((candidate) => ({
+        id: String(candidate.index),
+        text: candidate.text,
+        x: candidate.x - candidate.size.width / 2,
+        y: 0,
+        width: candidate.size.width,
+        height: candidate.size.height
+    }));
+    const getAutoCollision = () => {
+        return solveLabelCollision({
+            labels,
+            availableWidth: plotWidth,
+            allowRotate: false,
+            allowStagger: false,
+            minGap
+        });
+    };
+    const collision = strategy === "auto"
+        ? getAutoCollision()
+        : getExplicitXLabelCollision({
+            labels,
+            strategy,
+            availableWidth: plotWidth,
+            minGap,
+            rotation
+        });
+    const resolvedStrategy = collision.strategy;
+    const resolvedRotation = resolvedStrategy === "rotate"
+        ? rotation < 0
+            ? rotation
+            : -Math.abs(rotation)
+        : 0;
+    const rows = resolvedStrategy === "stagger" ? 2 : collision.rows;
+    const sizes = collision.visibleIndexes.flatMap((candidateIndex) => {
+        const candidate = candidates[candidateIndex];
+        return candidate ? [candidate.size] : [];
+    });
+    const height = getXLabelHeight({
+        strategy: resolvedStrategy,
+        sizes,
+        rotation: resolvedRotation,
+        rows
+    });
+    const items = collision.visibleIndexes.flatMap((candidateIndex) => {
+        const candidate = candidates[candidateIndex];
+        if (!candidate) {
+            return [];
+        }
+        const row = resolvedStrategy === "stagger" ? candidate.index % rows : 0;
+        const textAnchor = getXLabelTextAnchor({
+            candidate,
+            candidates,
+            rotation: resolvedRotation
+        });
+        const baselineOffset = resolvedStrategy === "rotate"
+            ? getRotatedBaselineOffset({
+                rotation: resolvedRotation,
+                size: candidate.size,
+                textAnchor
+            })
+            : 0;
+        const y = baseY + row * (candidate.size.height + xLabelRowGap) + baselineOffset;
+        const x = getShiftedXLabel({
+            candidate,
+            chartWidth,
+            edgeLabelPolicy,
+            rotation: resolvedRotation,
+            textAnchor
+        });
+        if (edgeLabelPolicy === "hide" &&
+            !isXLabelInsideChart({
+                candidate,
+                chartWidth,
+                x,
+                textAnchor
+            })) {
+            return [];
+        }
+        return [
+            {
+                ...candidate,
+                gridX: candidate.x,
+                x,
+                y,
+                row,
+                rotation: resolvedRotation,
+                textAnchor
+            }
+        ];
+    });
+    const visibleItems = resolvedStrategy === "rotate"
+        ? filterOverlappingRotatedLabels(items, minGap)
+        : items;
+    return {
+        strategy: resolvedStrategy,
+        items: visibleItems,
+        height,
+        rotation: resolvedRotation,
+        rows
+    };
+};

package/dist/v2/react-native/charts/line/xScale.d.ts

@@ -0,0 +1,6 @@
+import { type ChartBoxes, type ChartXValue, type ProjectScale } from "../../../core/index";
+export declare const buildLineChartXScale: <TData>({ boxes, xValues }: {
+    boxes: ChartBoxes;
+    xValues: ChartXValue[];
+}) => ProjectScale<TData>;
+//# sourceMappingURL=xScale.d.ts.map

package/dist/v2/react-native/charts/line/xScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xScale.d.ts","sourceRoot":"","sources":["../../../src/charts/line/xScale.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,iBAAiB,CAAC;AAIzB,eAAO,MAAM,oBAAoB,GAAI,KAAK,EAAE,oBAGzC;IACD,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB,KAAG,YAAY,CAAC,KAAK,CAiCrB,CAAC"}

package/dist/v2/react-native/charts/line/xScale.js

@@ -0,0 +1,25 @@
+import { createLinearScale, createPointScale, createTimeScale } from "../../../core/index";
+import { getXKey, getXScaleType, unique } from "./utils";
+export const buildLineChartXScale = ({ boxes, xValues }) => {
+    const range = [
+        boxes.plot.x,
+        boxes.plot.x + boxes.plot.width
+    ];
+    const xScaleType = getXScaleType(xValues);
+    if (xScaleType === "time") {
+        const dates = xValues.filter((value) => value instanceof Date);
+        const scale = createTimeScale({ values: dates, range });
+        return (value) => (value instanceof Date ? scale.scale(value) : undefined);
+    }
+    if (xScaleType === "linear") {
+        const numbers = xValues.filter((value) => typeof value === "number");
+        const scale = createLinearScale({ values: numbers, range });
+        return (value) => typeof value === "number" ? scale.scale(value) : undefined;
+    }
+    const domain = unique(xValues.map(getXKey));
+    const scale = createPointScale({
+        domain,
+        range
+    });
+    return (value) => scale.scale(getXKey(value));
+};

package/dist/v2/react-native/charts/line/yAxisModel.d.ts

@@ -0,0 +1,29 @@
+import { type CartesianSeriesInput, type NormalizedCartesianData, type NumericDomainInput } from "../../../core/index";
+import { type LineChartYAxisLabelWidth } from "./axisLabels";
+type AxisLabelSize = {
+    width: number;
+    height: number;
+};
+type TextMeasurer = (text: string, options?: Record<string, unknown>) => AxisLabelSize;
+type ResolveLineChartYAxisModelOptions<TData extends Record<string, unknown>> = {
+    data: TData[];
+    stableData?: TData[] | undefined;
+    xKey: keyof TData & string;
+    series: Array<CartesianSeriesInput<TData>>;
+    yDomain: NumericDomainInput;
+    yAxisLabelWidth?: LineChartYAxisLabelWidth | undefined;
+    formatYLabel: (value: number) => string;
+    measureText: TextMeasurer;
+    textOptions: Record<string, unknown>;
+};
+export declare const resolveLineChartYAxisModel: <TData extends Record<string, unknown>>({ data, stableData, xKey, series, yDomain, yAxisLabelWidth, formatYLabel, measureText, textOptions }: ResolveLineChartYAxisModelOptions<TData>) => {
+    normalized: NormalizedCartesianData<TData>;
+    yDomainResolved: [number, number];
+    yLabelSizes: {
+        width: number;
+        height: number;
+    }[];
+    yTicks: number[];
+};
+export {};
+//# sourceMappingURL=yAxisModel.d.ts.map

package/dist/v2/react-native/charts/line/yAxisModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yAxisModel.d.ts","sourceRoot":"","sources":["../../../src/charts/line/yAxisModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACxB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAC;AAEtB,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,YAAY,GAAG,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,aAAa,CAAC;AAEnB,KAAK,iCAAiC,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC1E;IACE,IAAI,EAAE,KAAK,EAAE,CAAC;IACd,UAAU,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,MAAM,KAAK,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,OAAO,EAAE,kBAAkB,CAAC;IAC5B,eAAe,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACvD,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,WAAW,EAAE,YAAY,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAWJ,eAAO,MAAM,0BAA0B,GACrC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,sGAUC,iCAAiC,CAAC,KAAK,CAAC;;;;;;;;CA0C1C,CAAC"}

package/dist/v2/react-native/charts/line/yAxisModel.js

@@ -0,0 +1,39 @@
+import { generateLinearTicks, normalizeCartesianData, resolveNumericDomain } from "../../../core/index";
+import { resolveLineChartYAxisLabelSizes } from "./axisLabels";
+const getNumericYValues = (normalized) => normalized.series.flatMap((item) => item.points.flatMap((point) => typeof point.value === "number" ? [point.value] : []));
+export const resolveLineChartYAxisModel = ({ data, stableData, xKey, series, yDomain, yAxisLabelWidth, formatYLabel, measureText, textOptions }) => {
+    const normalized = normalizeCartesianData({
+        data,
+        xKey,
+        series
+    });
+    const yValues = getNumericYValues(normalized);
+    const yDomainResolved = resolveNumericDomain(yValues, yDomain);
+    const yTicks = generateLinearTicks({
+        domain: yDomainResolved,
+        count: 4
+    });
+    const stableYLabelSizes = yAxisLabelWidth === "stable"
+        ? generateLinearTicks({
+            domain: resolveNumericDomain(stableData
+                ? getNumericYValues(normalizeCartesianData({
+                    data: stableData,
+                    xKey,
+                    series
+                }))
+                : yValues, yDomain),
+            count: 4
+        }).map((tick) => measureText(formatYLabel(tick), textOptions))
+        : undefined;
+    const yLabelSizes = resolveLineChartYAxisLabelSizes({
+        sizes: yTicks.map((tick) => measureText(formatYLabel(tick), textOptions)),
+        stableSizes: stableYLabelSizes,
+        width: yAxisLabelWidth
+    });
+    return {
+        normalized,
+        yDomainResolved,
+        yLabelSizes,
+        yTicks
+    };
+};

package/dist/v2/react-native/charts/pie/PieChart.d.ts

@@ -0,0 +1,7 @@
+import type { PieChartProps } from "./types";
+export type * from "./types";
+export { getPieChartAccessibilitySummary, getPieChartDataTable } from "./accessibility";
+export type { PieChartDataTable, PieChartDataTableRow } from "./accessibility";
+export declare const PieChart: <TData extends Record<string, unknown>>(props: PieChartProps<TData>) => import("react").JSX.Element;
+export declare const DonutChart: <TData extends Record<string, unknown>>(props: PieChartProps<TData>) => import("react").JSX.Element;
+//# sourceMappingURL=PieChart.d.ts.map

package/dist/v2/react-native/charts/pie/PieChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PieChart.d.ts","sourceRoot":"","sources":["../../../src/charts/pie/PieChart.tsx"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAkC,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7E,mBAAmB,SAAS,CAAC;AAC7B,OAAO,EACL,+BAA+B,EAC/B,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAY/E,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5D,OAAO,aAAa,CAAC,KAAK,CAAC,gCAgY5B,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,OAAO,aAAa,CAAC,KAAK,CAAC,gCAM5B,CAAC"}