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

package/dist/v2/core/interaction/viewport.js

@@ -0,0 +1,216 @@
+const minVisiblePoints = 2;
+const millisecondsInOneDay = 24 * 60 * 60 * 1000;
+const presetDayCounts = {
+    "1D": 1,
+    "1W": 7,
+    "1M": 30,
+    "3M": 90,
+    "6M": 180,
+    "1Y": 365
+};
+const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+const normalizePositiveInteger = (value, fallback, min = 1) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(min, Math.floor(value));
+};
+export const resolveChartViewport = ({ itemCount, scrollable = false, viewportWidth, visiblePoints }) => {
+    const safeViewportWidth = Number.isFinite(viewportWidth) && viewportWidth > 0 ? viewportWidth : 0;
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    const fallbackVisiblePoints = Math.max(safeItemCount, minVisiblePoints);
+    const normalizedVisiblePoints = clamp(normalizePositiveInteger(visiblePoints, fallbackVisiblePoints), minVisiblePoints, Math.max(safeItemCount, minVisiblePoints));
+    const shouldScroll = scrollable &&
+        safeViewportWidth > 0 &&
+        safeItemCount > normalizedVisiblePoints;
+    const pointSpacing = normalizedVisiblePoints > 1
+        ? safeViewportWidth / (normalizedVisiblePoints - 1)
+        : safeViewportWidth;
+    const contentWidth = shouldScroll
+        ? safeViewportWidth +
+            (safeItemCount - normalizedVisiblePoints) * pointSpacing
+        : safeViewportWidth;
+    return {
+        contentWidth,
+        itemCount: safeItemCount,
+        maxOffset: Math.max(0, contentWidth - safeViewportWidth),
+        pointSpacing,
+        scrollable: shouldScroll,
+        viewportWidth: safeViewportWidth,
+        visiblePoints: normalizedVisiblePoints
+    };
+};
+export const resolveChartViewportInitialOffset = ({ initialIndex = "start", viewport }) => {
+    if (!viewport.scrollable || initialIndex === "start") {
+        return 0;
+    }
+    if (initialIndex === "end") {
+        return viewport.maxOffset;
+    }
+    if (!Number.isFinite(initialIndex)) {
+        return 0;
+    }
+    const index = clamp(Math.floor(initialIndex), 0, viewport.itemCount - 1);
+    return clamp(index * viewport.pointSpacing, 0, viewport.maxOffset);
+};
+export const resolveChartViewportWindow = ({ endIndex, initialIndex = "start", itemCount, startIndex, visiblePoints }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return {
+            endIndex: 0,
+            isWindowed: false,
+            itemCount: 0,
+            startIndex: 0,
+            visibleCount: 0
+        };
+    }
+    if (startIndex !== undefined || endIndex !== undefined) {
+        const normalizedStartIndex = clamp(normalizePositiveInteger(startIndex, 0, 0), 0, safeItemCount - 1);
+        const normalizedEndIndex = clamp(normalizePositiveInteger(endIndex, safeItemCount, 0), normalizedStartIndex + 1, safeItemCount);
+        return {
+            endIndex: normalizedEndIndex,
+            isWindowed: normalizedStartIndex > 0 || normalizedEndIndex < safeItemCount,
+            itemCount: safeItemCount,
+            startIndex: normalizedStartIndex,
+            visibleCount: normalizedEndIndex - normalizedStartIndex
+        };
+    }
+    const normalizedVisiblePoints = clamp(normalizePositiveInteger(visiblePoints, safeItemCount), minVisiblePoints, safeItemCount);
+    if (normalizedVisiblePoints >= safeItemCount) {
+        return {
+            endIndex: safeItemCount,
+            isWindowed: false,
+            itemCount: safeItemCount,
+            startIndex: 0,
+            visibleCount: safeItemCount
+        };
+    }
+    const startFromInitialIndex = initialIndex === "end"
+        ? safeItemCount - normalizedVisiblePoints
+        : typeof initialIndex === "number" && Number.isFinite(initialIndex)
+            ? Math.floor(initialIndex)
+            : 0;
+    const normalizedStartIndex = clamp(startFromInitialIndex, 0, safeItemCount - normalizedVisiblePoints);
+    return {
+        endIndex: normalizedStartIndex + normalizedVisiblePoints,
+        isWindowed: true,
+        itemCount: safeItemCount,
+        startIndex: normalizedStartIndex,
+        visibleCount: normalizedVisiblePoints
+    };
+};
+export const sliceChartViewportData = (data, window) => data.slice(window.startIndex, window.endIndex);
+export const resolveChartViewportIndexFromPosition = ({ itemCount, locationX, plotWidth, plotX }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return 0;
+    }
+    const safePlotWidth = Number.isFinite(plotWidth) && plotWidth > 0 ? plotWidth : 1;
+    const normalizedPosition = clamp((locationX - plotX) / safePlotWidth, 0, 1);
+    return clamp(Math.round(normalizedPosition * (safeItemCount - 1)), 0, safeItemCount - 1);
+};
+export const resolveChartViewportWindowFromPosition = ({ itemCount, locationX, plotWidth, plotX, visibleCount }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const safeVisibleCount = clamp(normalizePositiveInteger(visibleCount, safeItemCount), minVisiblePoints, safeItemCount);
+    if (safeVisibleCount >= safeItemCount) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const centerIndex = resolveChartViewportIndexFromPosition({
+        itemCount: safeItemCount,
+        locationX,
+        plotWidth,
+        plotX
+    });
+    const startIndex = clamp(centerIndex - Math.floor(safeVisibleCount / 2), 0, safeItemCount - safeVisibleCount);
+    return resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex,
+        endIndex: startIndex + safeVisibleCount
+    });
+};
+export const resolveChartViewportWindowFromHandlePosition = ({ currentWindow, handle, itemCount, locationX, minVisibleCount, plotWidth, plotX }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const normalizedCurrentWindow = resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex: currentWindow.startIndex,
+        endIndex: currentWindow.endIndex
+    });
+    const safeMinVisibleCount = clamp(normalizePositiveInteger(minVisibleCount, minVisiblePoints), minVisiblePoints, safeItemCount);
+    const targetIndex = resolveChartViewportIndexFromPosition({
+        itemCount: safeItemCount,
+        locationX,
+        plotWidth,
+        plotX
+    });
+    if (handle === "start") {
+        const startIndex = clamp(targetIndex, 0, normalizedCurrentWindow.endIndex - safeMinVisibleCount);
+        return resolveChartViewportWindow({
+            itemCount: safeItemCount,
+            startIndex,
+            endIndex: normalizedCurrentWindow.endIndex
+        });
+    }
+    const endIndex = clamp(targetIndex + 1, normalizedCurrentWindow.startIndex + safeMinVisibleCount, safeItemCount);
+    return resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex: normalizedCurrentWindow.startIndex,
+        endIndex
+    });
+};
+const isFiniteDate = (value) => value instanceof Date && Number.isFinite(value.valueOf());
+const getPresetPointFallback = (preset, itemCount) => {
+    if (preset === "ALL") {
+        return itemCount;
+    }
+    if (preset === "YTD") {
+        return Math.min(itemCount, 252);
+    }
+    return Math.min(itemCount, presetDayCounts[preset] ?? itemCount);
+};
+const getStartDateForPreset = (preset, lastDate) => {
+    if (preset === "ALL") {
+        return undefined;
+    }
+    if (preset === "YTD") {
+        return new Date(lastDate.getFullYear(), 0, 1);
+    }
+    const days = presetDayCounts[preset];
+    if (days === undefined) {
+        return undefined;
+    }
+    return new Date(lastDate.valueOf() - days * millisecondsInOneDay);
+};
+export const resolveChartViewportPresetWindow = ({ preset, xValues }) => {
+    const itemCount = xValues.length;
+    if (preset === "ALL") {
+        return resolveChartViewportWindow({ itemCount });
+    }
+    const lastValue = xValues[itemCount - 1];
+    if (lastValue && isFiniteDate(lastValue)) {
+        const startDate = getStartDateForPreset(preset, lastValue);
+        if (startDate) {
+            const startIndex = xValues.findIndex((value) => isFiniteDate(value) && value.valueOf() >= startDate.valueOf());
+            return resolveChartViewportWindow({
+                itemCount,
+                startIndex: startIndex >= 0 ? startIndex : itemCount - 1,
+                endIndex: itemCount
+            });
+        }
+    }
+    return resolveChartViewportWindow({
+        itemCount,
+        visiblePoints: getPresetPointFallback(preset, itemCount),
+        initialIndex: "end"
+    });
+};

package/dist/v2/core/interaction/viewportTransform.d.ts

@@ -0,0 +1,17 @@
+import { type ResolvedChartViewportWindow } from "./viewport";
+export type ResolveChartViewportWindowFromZoomOptions = {
+    anchorIndex?: number | undefined;
+    currentWindow: ResolvedChartViewportWindow;
+    itemCount: number;
+    maxVisibleCount?: number | undefined;
+    minVisibleCount?: number | undefined;
+    zoomFactor: number;
+};
+export type ResolveChartViewportWindowFromPanDeltaOptions = {
+    currentWindow: ResolvedChartViewportWindow;
+    deltaPoints: number;
+    itemCount: number;
+};
+export declare const resolveChartViewportWindowFromZoom: ({ anchorIndex, currentWindow, itemCount, maxVisibleCount, minVisibleCount, zoomFactor }: ResolveChartViewportWindowFromZoomOptions) => ResolvedChartViewportWindow;
+export declare const resolveChartViewportWindowFromPanDelta: ({ currentWindow, deltaPoints, itemCount }: ResolveChartViewportWindowFromPanDeltaOptions) => ResolvedChartViewportWindow;
+//# sourceMappingURL=viewportTransform.d.ts.map

package/dist/v2/core/interaction/viewportTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportTransform.d.ts","sourceRoot":"","sources":["../../src/interaction/viewportTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,yCAAyC,GAAG;IACtD,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,aAAa,EAAE,2BAA2B,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,6CAA6C,GAAG;IAC1D,aAAa,EAAE,2BAA2B,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwBF,eAAO,MAAM,kCAAkC,GAAI,yFAOhD,yCAAyC,KAAG,2BA+D9C,CAAC;AAEF,eAAO,MAAM,sCAAsC,GAAI,2CAIpD,6CAA6C,KAAG,2BAgClD,CAAC"}

package/dist/v2/core/interaction/viewportTransform.js

@@ -0,0 +1,70 @@
+import { resolveChartViewportWindow } from "./viewport";
+const minVisiblePoints = 2;
+const clamp = (value, min, max) => {
+    if (max < min) {
+        return min;
+    }
+    return Math.min(Math.max(value, min), max);
+};
+const normalizePositiveInteger = (value, fallback, min = 1) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(min, Math.floor(value));
+};
+export const resolveChartViewportWindowFromZoom = ({ anchorIndex, currentWindow, itemCount, maxVisibleCount, minVisibleCount, zoomFactor }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const normalizedCurrentWindow = resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex: currentWindow.startIndex,
+        endIndex: currentWindow.endIndex
+    });
+    const normalizedMinVisibleCount = clamp(normalizePositiveInteger(minVisibleCount, minVisiblePoints), minVisiblePoints, safeItemCount);
+    const normalizedMaxVisibleCount = clamp(normalizePositiveInteger(maxVisibleCount, safeItemCount), normalizedMinVisibleCount, safeItemCount);
+    const safeZoomFactor = typeof zoomFactor === "number" && Number.isFinite(zoomFactor)
+        ? Math.max(0.01, zoomFactor)
+        : 1;
+    const nextVisibleCount = clamp(Math.round(normalizedCurrentWindow.visibleCount / safeZoomFactor), normalizedMinVisibleCount, normalizedMaxVisibleCount);
+    if (nextVisibleCount >= safeItemCount) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const currentSpan = Math.max(1, normalizedCurrentWindow.visibleCount - 1);
+    const fallbackAnchor = normalizedCurrentWindow.startIndex +
+        (normalizedCurrentWindow.visibleCount - 1) / 2;
+    const resolvedAnchor = clamp(typeof anchorIndex === "number" && Number.isFinite(anchorIndex)
+        ? anchorIndex
+        : fallbackAnchor, normalizedCurrentWindow.startIndex, normalizedCurrentWindow.endIndex - 1);
+    const anchorRatio = clamp((resolvedAnchor - normalizedCurrentWindow.startIndex) / currentSpan, 0, 1);
+    const startIndex = clamp(Math.round(resolvedAnchor - (nextVisibleCount - 1) * anchorRatio), 0, safeItemCount - nextVisibleCount);
+    return resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex,
+        endIndex: startIndex + nextVisibleCount
+    });
+};
+export const resolveChartViewportWindowFromPanDelta = ({ currentWindow, deltaPoints, itemCount }) => {
+    const safeItemCount = normalizePositiveInteger(itemCount, 0, 0);
+    if (safeItemCount === 0) {
+        return resolveChartViewportWindow({ itemCount: safeItemCount });
+    }
+    const normalizedCurrentWindow = resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex: currentWindow.startIndex,
+        endIndex: currentWindow.endIndex
+    });
+    if (normalizedCurrentWindow.visibleCount >= safeItemCount) {
+        return normalizedCurrentWindow;
+    }
+    const delta = typeof deltaPoints === "number" && Number.isFinite(deltaPoints)
+        ? Math.round(deltaPoints)
+        : 0;
+    const startIndex = clamp(normalizedCurrentWindow.startIndex + delta, 0, safeItemCount - normalizedCurrentWindow.visibleCount);
+    return resolveChartViewportWindow({
+        itemCount: safeItemCount,
+        startIndex,
+        endIndex: startIndex + normalizedCurrentWindow.visibleCount
+    });
+};

package/dist/v2/core/layout/autoPadding.d.ts

@@ -0,0 +1,3 @@
+import type { AutoPaddingOptions, Padding } from "./types";
+export declare const calculateAutoPadding: ({ base, leftLabels, rightLabels, topLabels, bottomLabels, legend, gap }: AutoPaddingOptions) => Padding;
+//# sourceMappingURL=autoPadding.d.ts.map

package/dist/v2/core/layout/autoPadding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoPadding.d.ts","sourceRoot":"","sources":["../../src/layout/autoPadding.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAQ,MAAM,SAAS,CAAC;AAUjE,eAAO,MAAM,oBAAoB,GAAI,yEAQlC,kBAAkB,KAAG,OAyBvB,CAAC"}

package/dist/v2/core/layout/autoPadding.js

@@ -0,0 +1,33 @@
+import { normalizePadding } from "./chartBox";
+const maxWidth = (sizes = []) => {
+    return sizes.reduce((max, size) => Math.max(max, size.width), 0);
+};
+const maxHeight = (sizes = []) => {
+    return sizes.reduce((max, size) => Math.max(max, size.height), 0);
+};
+export const calculateAutoPadding = ({ base = {}, leftLabels = [], rightLabels = [], topLabels = [], bottomLabels = [], legend, gap = 8 }) => {
+    const padding = normalizePadding(base);
+    const leftLabelWidth = maxWidth(leftLabels);
+    const rightLabelWidth = maxWidth(rightLabels);
+    const topLabelHeight = maxHeight(topLabels);
+    const bottomLabelHeight = maxHeight(bottomLabels);
+    padding.left += leftLabelWidth > 0 ? leftLabelWidth + gap : 0;
+    padding.right += rightLabelWidth > 0 ? rightLabelWidth + gap : 0;
+    padding.top += topLabelHeight > 0 ? topLabelHeight + gap : 0;
+    padding.bottom += bottomLabelHeight > 0 ? bottomLabelHeight + gap : 0;
+    if (legend) {
+        if (legend.position === "top") {
+            padding.top += legend.height + gap;
+        }
+        else if (legend.position === "bottom") {
+            padding.bottom += legend.height + gap;
+        }
+        else if (legend.position === "left") {
+            padding.left += legend.width + gap;
+        }
+        else {
+            padding.right += legend.width + gap;
+        }
+    }
+    return padding;
+};

package/dist/v2/core/layout/chartBox.d.ts

@@ -0,0 +1,5 @@
+import type { ChartBoxes, Padding, Rect, Size } from "./types";
+export declare const normalizePadding: (padding?: Partial<Padding>) => Padding;
+export declare const createRect: (x: number, y: number, width: number, height: number) => Rect;
+export declare const solveChartBoxes: (size: Size, padding?: Partial<Padding>) => ChartBoxes;
+//# sourceMappingURL=chartBox.d.ts.map

package/dist/v2/core/layout/chartBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartBox.d.ts","sourceRoot":"","sources":["../../src/layout/chartBox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,gBAAgB,GAAI,UAAS,OAAO,CAAC,OAAO,CAAM,KAAG,OAKhE,CAAC;AAEH,eAAO,MAAM,UAAU,GACrB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,OAAO,MAAM,EACb,QAAQ,MAAM,KACb,IAKD,CAAC;AAEH,eAAO,MAAM,eAAe,GAC1B,MAAM,IAAI,EACV,UAAS,OAAO,CAAC,OAAO,CAAM,KAC7B,UAeF,CAAC"}

package/dist/v2/core/layout/chartBox.js

@@ -0,0 +1,22 @@
+export const normalizePadding = (padding = {}) => ({
+    top: padding.top ?? 0,
+    right: padding.right ?? 0,
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0
+});
+export const createRect = (x, y, width, height) => ({
+    x,
+    y,
+    width: Math.max(0, width),
+    height: Math.max(0, height)
+});
+export const solveChartBoxes = (size, padding = {}) => {
+    const normalizedPadding = normalizePadding(padding);
+    const outer = createRect(0, 0, size.width, size.height);
+    const plot = createRect(normalizedPadding.left, normalizedPadding.top, size.width - normalizedPadding.left - normalizedPadding.right, size.height - normalizedPadding.top - normalizedPadding.bottom);
+    return {
+        outer,
+        plot,
+        padding: normalizedPadding
+    };
+};

package/dist/v2/core/layout/debugLayout.d.ts

@@ -0,0 +1,3 @@
+import type { BuildLayoutDebugModelOptions, LayoutDebugModel } from "./types";
+export declare const buildLayoutDebugModel: ({ boxes, labels, legend, tooltip }: BuildLayoutDebugModelOptions) => LayoutDebugModel;
+//# sourceMappingURL=debugLayout.d.ts.map

package/dist/v2/core/layout/debugLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugLayout.d.ts","sourceRoot":"","sources":["../../src/layout/debugLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,gBAAgB,EAEjB,MAAM,SAAS,CAAC;AAUjB,eAAO,MAAM,qBAAqB,GAAI,oCAKnC,4BAA4B,KAAG,gBAmBjC,CAAC"}

package/dist/v2/core/layout/debugLayout.js

@@ -0,0 +1,20 @@
+const withKind = (rect, kind) => ({
+    ...rect,
+    kind
+});
+export const buildLayoutDebugModel = ({ boxes, labels = [], legend, tooltip }) => {
+    const rects = [
+        withKind({ id: "outer", ...boxes.outer }, "outer"),
+        withKind({ id: "plot", ...boxes.plot }, "plot")
+    ];
+    labels.forEach((label) => {
+        rects.push(withKind(label, "label"));
+    });
+    legend?.items.forEach((item) => {
+        rects.push(withKind(item, "legend"));
+    });
+    if (tooltip) {
+        rects.push(withKind({ id: "tooltip", ...tooltip.rect }, "tooltip"));
+    }
+    return { rects };
+};

package/dist/v2/core/layout/index.d.ts

@@ -0,0 +1,8 @@
+export { calculateAutoPadding } from "./autoPadding";
+export { createRect, normalizePadding, solveChartBoxes } from "./chartBox";
+export { buildLayoutDebugModel } from "./debugLayout";
+export { solveLabelCollision } from "./labelCollision";
+export { layoutLegend } from "./legendLayout";
+export { placeTooltip } from "./tooltipPlacement";
+export type { AutoPaddingOptions, BuildLayoutDebugModelOptions, ChartBoxes, LabelBox, LabelCollisionOptions, LabelCollisionResult, LabelStrategy, LayoutDebugModel, LayoutDebugRect, LegendItem, LegendLayout, LegendLayoutItem, LegendLayoutOptions, LegendPosition, Padding, Rect, Size, TooltipPlacement, TooltipPlacementOptions, TooltipPlacementResult } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/core/layout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/layout/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EACV,kBAAkB,EAClB,4BAA4B,EAC5B,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,oBAAoB,EACpB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC"}

package/dist/v2/core/layout/index.js

@@ -0,0 +1,6 @@
+export { calculateAutoPadding } from "./autoPadding";
+export { createRect, normalizePadding, solveChartBoxes } from "./chartBox";
+export { buildLayoutDebugModel } from "./debugLayout";
+export { solveLabelCollision } from "./labelCollision";
+export { layoutLegend } from "./legendLayout";
+export { placeTooltip } from "./tooltipPlacement";

package/dist/v2/core/layout/labelCollision.d.ts

@@ -0,0 +1,3 @@
+import type { LabelCollisionOptions, LabelCollisionResult } from "./types";
+export declare const solveLabelCollision: ({ labels, availableWidth, allowRotate, allowStagger, minGap, maxRotation }: LabelCollisionOptions) => LabelCollisionResult;
+//# sourceMappingURL=labelCollision.d.ts.map

package/dist/v2/core/layout/labelCollision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labelCollision.d.ts","sourceRoot":"","sources":["../../src/layout/labelCollision.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAuCjB,eAAO,MAAM,mBAAmB,GAAI,4EAOjC,qBAAqB,KAAG,oBA+E1B,CAAC"}

package/dist/v2/core/layout/labelCollision.js

@@ -0,0 +1,90 @@
+const boxesOverlap = (left, right, gap) => {
+    return left.x + left.width + gap > right.x;
+};
+const hasOverlap = (labels, indexes, gap) => {
+    for (let i = 1; i < indexes.length; i++) {
+        const previousIndex = indexes[i - 1];
+        const currentIndex = indexes[i];
+        if (previousIndex === undefined || currentIndex === undefined) {
+            continue;
+        }
+        const previous = labels[previousIndex];
+        const current = labels[currentIndex];
+        if (previous && current && boxesOverlap(previous, current, gap)) {
+            return true;
+        }
+    }
+    return false;
+};
+const visibleIndexesForInterval = (count, interval) => {
+    return Array.from({ length: count }, (_, index) => index).filter((index) => {
+        return index === 0 || index === count - 1 || index % interval === 0;
+    });
+};
+export const solveLabelCollision = ({ labels, availableWidth, allowRotate = true, allowStagger = true, minGap = 4, maxRotation = 45 }) => {
+    if (labels.length === 0) {
+        return {
+            strategy: "show",
+            visibleIndexes: [],
+            interval: 1,
+            rotation: 0,
+            rows: 1
+        };
+    }
+    const allIndexes = visibleIndexesForInterval(labels.length, 1);
+    if (!hasOverlap(labels, allIndexes, minGap)) {
+        return {
+            strategy: "show",
+            visibleIndexes: allIndexes,
+            interval: 1,
+            rotation: 0,
+            rows: 1
+        };
+    }
+    if (allowStagger) {
+        const rowWidth = labels.reduce((max, label) => Math.max(max, label.width), 0);
+        const approximateSlot = availableWidth / Math.max(1, labels.length);
+        if (rowWidth + minGap <= approximateSlot * 2) {
+            return {
+                strategy: "stagger",
+                visibleIndexes: allIndexes,
+                interval: 1,
+                rotation: 0,
+                rows: 2
+            };
+        }
+    }
+    if (allowRotate) {
+        const widest = labels.reduce((max, label) => Math.max(max, label.width), 0);
+        const rotatedWidth = widest * Math.cos((Math.abs(maxRotation) * Math.PI) / 180);
+        const approximateSlot = availableWidth / Math.max(1, labels.length);
+        if (rotatedWidth + minGap <= approximateSlot) {
+            return {
+                strategy: "rotate",
+                visibleIndexes: allIndexes,
+                interval: 1,
+                rotation: maxRotation,
+                rows: 1
+            };
+        }
+    }
+    for (let interval = 2; interval <= labels.length; interval++) {
+        const visibleIndexes = visibleIndexesForInterval(labels.length, interval);
+        if (!hasOverlap(labels, visibleIndexes, minGap)) {
+            return {
+                strategy: "skip",
+                visibleIndexes,
+                interval,
+                rotation: 0,
+                rows: 1
+            };
+        }
+    }
+    return {
+        strategy: "hide",
+        visibleIndexes: [],
+        interval: labels.length,
+        rotation: 0,
+        rows: 0
+    };
+};

package/dist/v2/core/layout/legendLayout.d.ts

@@ -0,0 +1,3 @@
+import type { LegendLayout, LegendLayoutOptions } from "./types";
+export declare const layoutLegend: ({ items, position, maxWidth, itemGap, rowGap, padding, labelGap, itemPaddingHorizontal, itemPaddingVertical }: LegendLayoutOptions) => LegendLayout;
+//# sourceMappingURL=legendLayout.d.ts.map

package/dist/v2/core/layout/legendLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legendLayout.d.ts","sourceRoot":"","sources":["../../src/layout/legendLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAEZ,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,YAAY,GAAI,+GAU1B,mBAAmB,KAAG,YA2CxB,CAAC"}

package/dist/v2/core/layout/legendLayout.js

@@ -0,0 +1,39 @@
+export const layoutLegend = ({ items, position = "bottom", maxWidth, itemGap = 12, rowGap = 8, padding = 0, labelGap = 4, itemPaddingHorizontal = 0, itemPaddingVertical = 0 }) => {
+    const layoutItems = [];
+    let cursorX = padding;
+    let cursorY = padding;
+    let rowHeight = 0;
+    let width = padding;
+    items.forEach((item) => {
+        const markerSize = item.markerSize ?? 10;
+        const contentWidth = markerSize + labelGap + item.labelWidth;
+        const contentHeight = Math.max(markerSize, item.labelHeight);
+        const itemWidth = contentWidth + itemPaddingHorizontal * 2;
+        const itemHeight = contentHeight + itemPaddingVertical * 2;
+        if (cursorX > padding && cursorX + itemWidth > maxWidth - padding) {
+            cursorX = padding;
+            cursorY += rowHeight + rowGap;
+            rowHeight = 0;
+        }
+        layoutItems.push({
+            ...item,
+            x: cursorX,
+            y: cursorY,
+            width: itemWidth,
+            height: itemHeight,
+            contentX: cursorX + itemPaddingHorizontal,
+            contentY: cursorY + itemPaddingVertical,
+            contentWidth,
+            contentHeight
+        });
+        cursorX += itemWidth + itemGap;
+        rowHeight = Math.max(rowHeight, itemHeight);
+        width = Math.max(width, cursorX - itemGap + padding);
+    });
+    return {
+        position,
+        width: Math.min(maxWidth, width),
+        height: items.length === 0 ? 0 : cursorY + rowHeight + padding,
+        items: layoutItems
+    };
+};

package/dist/v2/core/layout/tooltipPlacement.d.ts

@@ -0,0 +1,3 @@
+import type { TooltipPlacementOptions, TooltipPlacementResult } from "./types";
+export declare const placeTooltip: ({ preferredPlacement, gap, fingerRadius, ...options }: TooltipPlacementOptions) => TooltipPlacementResult;
+//# sourceMappingURL=tooltipPlacement.d.ts.map

package/dist/v2/core/layout/tooltipPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltipPlacement.d.ts","sourceRoot":"","sources":["../../src/layout/tooltipPlacement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAkEjB,eAAO,MAAM,YAAY,GAAI,uDAK1B,uBAAuB,KAAG,sBAkD5B,CAAC"}