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

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

@@ -0,0 +1,32 @@
+export type LineCurve = "linear" | "monotone" | "step";
+export type GeometryPoint<TData = unknown> = {
+    index: number;
+    x: number;
+    y: number;
+    defined: boolean;
+    value?: number | null;
+    raw?: TData;
+};
+export type GeometrySegment<TPoint extends GeometryPoint = GeometryPoint> = {
+    points: TPoint[];
+    path: string;
+};
+export type LinePathModel<TPoint extends GeometryPoint = GeometryPoint> = {
+    path: string;
+    segments: Array<GeometrySegment<TPoint>>;
+};
+export type LinePathDecimationStrategy = "min-max";
+export type LinePathDecimationConfig = {
+    maxPoints: number;
+    strategy?: LinePathDecimationStrategy;
+};
+export type BuildLinePathOptions<TPoint extends GeometryPoint = GeometryPoint> = {
+    points: TPoint[];
+    curve?: LineCurve;
+    connectNulls?: boolean;
+    decimation?: false | LinePathDecimationConfig | undefined;
+};
+export type BuildAreaPathOptions<TPoint extends GeometryPoint = GeometryPoint> = BuildLinePathOptions<TPoint> & {
+    baselineY: number | ((point: TPoint) => number);
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/geometry/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;AAEvD,MAAM,MAAM,aAAa,CAAC,KAAK,GAAG,OAAO,IAAI;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAAI;IAC1E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAAI;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,SAAS,CAAC;AAEnD,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,0BAA0B,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAC3E;IACE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,KAAK,GAAG,wBAAwB,GAAG,SAAS,CAAC;CAC3D,CAAC;AAEJ,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAC3E,oBAAoB,CAAC,MAAM,CAAC,GAAG;IAC7B,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;CACjD,CAAC"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+export * from "./data";
+export * from "./geometry";
+export * from "./interaction";
+export * from "./layout";
+export * from "./scales";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/v2/core/index.js

@@ -0,0 +1,6 @@
+// CKV2 core owns renderer-agnostic chart logic and must not import React Native.
+export * from "./data";
+export * from "./geometry";
+export * from "./interaction";
+export * from "./layout";
+export * from "./scales";

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

@@ -0,0 +1,5 @@
+export { resolveChartViewport, resolveChartViewportIndexFromPosition, resolveChartViewportInitialOffset, resolveChartViewportPresetWindow, resolveChartViewportWindow, resolveChartViewportWindowFromHandlePosition, resolveChartViewportWindowFromPosition, sliceChartViewportData } from "./viewport";
+export { resolveChartViewportWindowFromPanDelta, resolveChartViewportWindowFromZoom } from "./viewportTransform";
+export type { ChartViewportInitialIndex, ChartViewportPresetName, ChartViewportWindowHandle, ResolveChartViewportIndexFromPositionOptions, ResolveChartViewportPresetWindowOptions, ResolveChartViewportWindowFromHandlePositionOptions, ResolveChartViewportWindowFromPositionOptions, ResolvedChartViewportWindow, ResolvedChartViewport, ResolveChartViewportOptions, ResolveChartViewportWindowOptions } from "./viewport";
+export type { ResolveChartViewportWindowFromPanDeltaOptions, ResolveChartViewportWindowFromZoomOptions } from "./viewportTransform";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interaction/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qCAAqC,EACrC,iCAAiC,EACjC,gCAAgC,EAChC,0BAA0B,EAC1B,4CAA4C,EAC5C,sCAAsC,EACtC,sBAAsB,EACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sCAAsC,EACtC,kCAAkC,EACnC,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,4CAA4C,EAC5C,uCAAuC,EACvC,mDAAmD,EACnD,6CAA6C,EAC7C,2BAA2B,EAC3B,qBAAqB,EACrB,2BAA2B,EAC3B,iCAAiC,EAClC,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,6CAA6C,EAC7C,yCAAyC,EAC1C,MAAM,qBAAqB,CAAC"}

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

@@ -0,0 +1,2 @@
+export { resolveChartViewport, resolveChartViewportIndexFromPosition, resolveChartViewportInitialOffset, resolveChartViewportPresetWindow, resolveChartViewportWindow, resolveChartViewportWindowFromHandlePosition, resolveChartViewportWindowFromPosition, sliceChartViewportData } from "./viewport";
+export { resolveChartViewportWindowFromPanDelta, resolveChartViewportWindowFromZoom } from "./viewportTransform";

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

@@ -0,0 +1,71 @@
+import type { ChartXValue } from "../data";
+export type ChartViewportInitialIndex = "start" | "end" | number;
+export type ChartViewportWindowHandle = "start" | "end";
+export type ChartViewportPresetName = "1D" | "1W" | "1M" | "3M" | "6M" | "YTD" | "1Y" | "ALL";
+export type ResolveChartViewportOptions = {
+    itemCount: number;
+    scrollable?: boolean | undefined;
+    viewportWidth: number;
+    visiblePoints?: number | undefined;
+};
+export type ResolvedChartViewport = {
+    contentWidth: number;
+    itemCount: number;
+    maxOffset: number;
+    pointSpacing: number;
+    scrollable: boolean;
+    viewportWidth: number;
+    visiblePoints: number;
+};
+export type ResolveChartViewportWindowOptions = {
+    endIndex?: number | undefined;
+    initialIndex?: ChartViewportInitialIndex | undefined;
+    itemCount: number;
+    startIndex?: number | undefined;
+    visiblePoints?: number | undefined;
+};
+export type ResolvedChartViewportWindow = {
+    endIndex: number;
+    isWindowed: boolean;
+    itemCount: number;
+    startIndex: number;
+    visibleCount: number;
+};
+export type ResolveChartViewportPresetWindowOptions = {
+    preset: ChartViewportPresetName;
+    xValues: readonly ChartXValue[];
+};
+export type ResolveChartViewportWindowFromPositionOptions = {
+    itemCount: number;
+    locationX: number;
+    plotWidth: number;
+    plotX: number;
+    visibleCount: number;
+};
+export type ResolveChartViewportIndexFromPositionOptions = {
+    itemCount: number;
+    locationX: number;
+    plotWidth: number;
+    plotX: number;
+};
+export type ResolveChartViewportWindowFromHandlePositionOptions = {
+    currentWindow: ResolvedChartViewportWindow;
+    handle: ChartViewportWindowHandle;
+    itemCount: number;
+    locationX: number;
+    minVisibleCount?: number | undefined;
+    plotWidth: number;
+    plotX: number;
+};
+export declare const resolveChartViewport: ({ itemCount, scrollable, viewportWidth, visiblePoints }: ResolveChartViewportOptions) => ResolvedChartViewport;
+export declare const resolveChartViewportInitialOffset: ({ initialIndex, viewport }: {
+    initialIndex?: ChartViewportInitialIndex | undefined;
+    viewport: ResolvedChartViewport;
+}) => number;
+export declare const resolveChartViewportWindow: ({ endIndex, initialIndex, itemCount, startIndex, visiblePoints }: ResolveChartViewportWindowOptions) => ResolvedChartViewportWindow;
+export declare const sliceChartViewportData: <TData>(data: readonly TData[], window: ResolvedChartViewportWindow) => TData[];
+export declare const resolveChartViewportIndexFromPosition: ({ itemCount, locationX, plotWidth, plotX }: ResolveChartViewportIndexFromPositionOptions) => number;
+export declare const resolveChartViewportWindowFromPosition: ({ itemCount, locationX, plotWidth, plotX, visibleCount }: ResolveChartViewportWindowFromPositionOptions) => ResolvedChartViewportWindow;
+export declare const resolveChartViewportWindowFromHandlePosition: ({ currentWindow, handle, itemCount, locationX, minVisibleCount, plotWidth, plotX }: ResolveChartViewportWindowFromHandlePositionOptions) => ResolvedChartViewportWindow;
+export declare const resolveChartViewportPresetWindow: ({ preset, xValues }: ResolveChartViewportPresetWindowOptions) => ResolvedChartViewportWindow;
+//# sourceMappingURL=viewport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewport.d.ts","sourceRoot":"","sources":["../../src/interaction/viewport.ts"],"names":[],"mappings":"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"}

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"}