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

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

@@ -0,0 +1,107 @@
+const daysInWeek = 7;
+const defaultMonthLabelHeight = 18;
+const defaultWeekdayLabelWidth = 28;
+const millisecondsInOneDay = 24 * 60 * 60 * 1000;
+const clampInteger = (value, min, max) => {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.min(Math.max(Math.floor(value), min), max);
+};
+const shiftDate = (date, numDays) => {
+    const shiftedDate = new Date(date);
+    shiftedDate.setDate(shiftedDate.getDate() + numDays);
+    return shiftedDate;
+};
+const getDayOffset = (date, weekStartsOn) => (date.getDay() - weekStartsOn + daysInWeek) % daysInWeek;
+const getDayIndex = (date, startDate) => Math.round((date.valueOf() - startDate.valueOf()) / millisecondsInOneDay);
+export const buildContributionHeatmap = ({ data, cellSize, gutterSize = 3, weekStartsOn = 0, showOutOfRangeDays = false, monthLabelHeight = defaultMonthLabelHeight, weekdayLabelWidth = defaultWeekdayLabelWidth }) => {
+    const safeCellSize = Number.isFinite(cellSize) && cellSize > 0 ? cellSize : 0;
+    const safeGutterSize = Number.isFinite(gutterSize) && gutterSize >= 0 ? gutterSize : 0;
+    const safeWeekStartsOn = clampInteger(weekStartsOn, 0, daysInWeek - 1);
+    const safeMonthLabelHeight = Number.isFinite(monthLabelHeight) && monthLabelHeight > 0
+        ? monthLabelHeight
+        : 0;
+    const safeWeekdayLabelWidth = Number.isFinite(weekdayLabelWidth) && weekdayLabelWidth > 0
+        ? weekdayLabelWidth
+        : 0;
+    const startOffset = getDayOffset(data.startDate, safeWeekStartsOn);
+    const totalSlots = startOffset + data.days.length;
+    const endOffset = totalSlots % daysInWeek === 0 ? 0 : daysInWeek - (totalSlots % daysInWeek);
+    const weekCount = Math.ceil((totalSlots + endOffset) / daysInWeek);
+    const step = safeCellSize + safeGutterSize;
+    const firstSlotDate = shiftDate(data.startDate, -startOffset);
+    const daysByIndex = new Map(data.days.map((day) => [day.index, day]));
+    const cells = Array.from({ length: weekCount * daysInWeek }, (_, slotIndex) => {
+        const weekIndex = Math.floor(slotIndex / daysInWeek);
+        const weekdayIndex = slotIndex % daysInWeek;
+        const date = shiftDate(firstSlotDate, slotIndex);
+        const inRangeIndex = getDayIndex(date, data.startDate);
+        const day = inRangeIndex >= 0 && inRangeIndex < data.days.length
+            ? daysByIndex.get(inRangeIndex)
+            : undefined;
+        const outOfRange = day === undefined;
+        const cell = {
+            index: day?.index ?? -1,
+            date,
+            value: day?.value ?? null,
+            defined: day?.defined ?? false,
+            outOfRange,
+            weekIndex,
+            weekdayIndex,
+            x: safeWeekdayLabelWidth + weekIndex * step,
+            y: safeMonthLabelHeight + weekdayIndex * step,
+            size: safeCellSize
+        };
+        if (day?.raw !== undefined) {
+            cell.raw = day.raw;
+        }
+        return cell;
+    }).filter((cell) => showOutOfRangeDays || !cell.outOfRange);
+    const visibleValues = cells
+        .map((cell) => cell.value)
+        .filter((value) => value !== null && Number.isFinite(value));
+    const valueMin = visibleValues.length > 0 ? Math.min(...visibleValues) : 0;
+    const valueMax = visibleValues.length > 0 ? Math.max(...visibleValues) : 0;
+    const monthLabels = [];
+    const seenMonths = new Set();
+    data.days.forEach((day) => {
+        if (day.date.getDate() !== 1 && day.index !== 0) {
+            return;
+        }
+        const slotIndex = startOffset + day.index;
+        const weekIndex = Math.floor(slotIndex / daysInWeek);
+        const key = `${day.date.getFullYear()}-${day.date.getMonth()}`;
+        if (seenMonths.has(key)) {
+            return;
+        }
+        seenMonths.add(key);
+        monthLabels.push({
+            key,
+            date: day.date,
+            monthIndex: day.date.getMonth(),
+            x: safeWeekdayLabelWidth + weekIndex * step,
+            y: Math.max(10, safeMonthLabelHeight - 6)
+        });
+    });
+    const weekdayLabels = [1, 3, 5].map((weekdayIndex) => {
+        const dayIndex = (safeWeekStartsOn + weekdayIndex) % daysInWeek;
+        return {
+            key: `weekday-${weekdayIndex}`,
+            weekdayIndex,
+            dayIndex,
+            x: 0,
+            y: safeMonthLabelHeight + weekdayIndex * step + safeCellSize * 0.75
+        };
+    });
+    return {
+        cells,
+        monthLabels,
+        weekdayLabels,
+        width: safeWeekdayLabelWidth + Math.max(0, weekCount * step - safeGutterSize),
+        height: safeMonthLabelHeight + Math.max(0, daysInWeek * step - safeGutterSize),
+        weekCount,
+        valueMin,
+        valueMax
+    };
+};

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

@@ -0,0 +1,27 @@
+import type { ChartXValue, NormalizedSeries } from "../data";
+import type { BarGeometryMode, ProjectBarValueScale, ProjectedBarRect } from "./barRects";
+export type ProjectedHorizontalBarBand<TData = unknown> = {
+    y: number;
+    height: number;
+    raw?: TData;
+};
+export type ProjectHorizontalBarBand<TData = unknown> = (value: ChartXValue, dataIndex: number, raw: TData | undefined) => ProjectedHorizontalBarBand<TData> | undefined;
+export type ProjectedHorizontalBarRect<TData = unknown> = ProjectedBarRect<TData> & {
+    baselineX: number;
+};
+export type HorizontalBarGeometry<TData = unknown> = {
+    mode: BarGeometryMode;
+    bars: Array<ProjectedHorizontalBarRect<TData>>;
+};
+export type BuildHorizontalBarGeometryOptions<TData = unknown> = {
+    series: Array<NormalizedSeries<TData>>;
+    yBand: ProjectHorizontalBarBand<TData>;
+    xScale: ProjectBarValueScale;
+    mode?: BarGeometryMode;
+    baselineValue?: number;
+    barWidthRatio?: number;
+    barGapRatio?: number;
+    dataIndexOffset?: number;
+};
+export declare const buildHorizontalBarGeometry: <TData = unknown>({ series, yBand, xScale, mode, baselineValue, barWidthRatio: rawBarWidthRatio, barGapRatio: rawBarGapRatio, dataIndexOffset }: BuildHorizontalBarGeometryOptions<TData>) => HorizontalBarGeometry<TData>;
+//# sourceMappingURL=horizontalBarRects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"horizontalBarRects.d.ts","sourceRoot":"","sources":["../../src/geometry/horizontalBarRects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,0BAA0B,CAAC,KAAK,GAAG,OAAO,IAAI;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,OAAO,IAAI,CACtD,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,KAAK,GAAG,SAAS,KACnB,0BAA0B,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AAEnD,MAAM,MAAM,0BAA0B,CAAC,KAAK,GAAG,OAAO,IACpD,gBAAgB,CAAC,KAAK,CAAC,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEJ,MAAM,MAAM,qBAAqB,CAAC,KAAK,GAAG,OAAO,IAAI;IACnD,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,KAAK,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,iCAAiC,CAAC,KAAK,GAAG,OAAO,IAAI;IAC/D,MAAM,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACvC,KAAK,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAC;IACvC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AA8SF,eAAO,MAAM,0BAA0B,GAAI,KAAK,GAAG,OAAO,EAAE,+HASzD,iCAAiC,CAAC,KAAK,CAAC,KAAG,qBAAqB,CAAC,KAAK,CAkCxE,CAAC"}

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

@@ -0,0 +1,202 @@
+const defaultBarWidthRatio = 0.72;
+const defaultBarGapRatio = 0.12;
+const clampRatio = (value, fallback) => typeof value === "number" && Number.isFinite(value)
+    ? Math.max(0, Math.min(1, value))
+    : fallback;
+const isFinitePosition = (value) => typeof value === "number" && Number.isFinite(value);
+const getSeriesPoint = (series, rowIndex) => series.points[rowIndex];
+const getSeriesRowCount = (series) => Math.max(0, ...series.map((item) => item.points.length));
+const getStackTotals = (series, rowIndex) => {
+    let positive = 0;
+    let negative = 0;
+    series.forEach((item) => {
+        const value = getSeriesPoint(item, rowIndex)?.value;
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            return;
+        }
+        if (value >= 0) {
+            positive += value;
+        }
+        else {
+            negative += Math.abs(value);
+        }
+    });
+    return { negative, positive };
+};
+const getStackedScaledValue = ({ mode, rowIndex, series, value }) => {
+    if (mode !== "stacked100") {
+        return value;
+    }
+    const totals = getStackTotals(series, rowIndex);
+    if (value >= 0) {
+        return totals.positive > 0 ? (value / totals.positive) * 100 : 0;
+    }
+    return totals.negative > 0 ? (value / totals.negative) * 100 : 0;
+};
+const buildRect = ({ baselineX, dataIndex, height, raw, scaledValue, series, seriesIndex, value, widthValue, xScale, xValue, y }) => {
+    const valueX = xScale(widthValue);
+    if (!isFinitePosition(valueX)) {
+        return undefined;
+    }
+    return {
+        key: `${series.key}-${dataIndex}`,
+        seriesKey: series.key,
+        seriesLabel: series.label,
+        seriesIndex,
+        dataIndex,
+        xValue,
+        value,
+        scaledValue,
+        x: Math.min(valueX, baselineX),
+        y,
+        width: Math.abs(valueX - baselineX),
+        height,
+        baselineX,
+        baselineY: y + height / 2,
+        defined: true,
+        raw
+    };
+};
+const buildGroupedHorizontalBars = ({ baselineX, barGapRatio, barWidthRatio, dataIndexOffset, series, xScale, yBand }) => {
+    const rowCount = getSeriesRowCount(series);
+    const bars = [];
+    const seriesCount = Math.max(1, series.length);
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const referencePoint = series[0]?.points[rowIndex];
+        if (!referencePoint) {
+            continue;
+        }
+        const band = yBand(referencePoint.x, rowIndex + dataIndexOffset, referencePoint.raw);
+        if (!band || !Number.isFinite(band.y) || !Number.isFinite(band.height)) {
+            continue;
+        }
+        const groupHeight = band.height * barWidthRatio;
+        const groupY = band.y + (band.height - groupHeight) / 2;
+        const totalGapHeight = groupHeight * barGapRatio * Math.max(0, seriesCount - 1);
+        const barHeight = Math.max(0, (groupHeight - totalGapHeight) / seriesCount);
+        const gapHeight = seriesCount > 1 ? groupHeight * barGapRatio : 0;
+        series.forEach((item, seriesIndex) => {
+            const point = getSeriesPoint(item, rowIndex);
+            if (!point ||
+                typeof point.value !== "number" ||
+                !Number.isFinite(point.value)) {
+                return;
+            }
+            const rect = buildRect({
+                baselineX,
+                dataIndex: rowIndex + dataIndexOffset,
+                height: barHeight,
+                raw: point.raw,
+                scaledValue: point.value,
+                series: item,
+                seriesIndex,
+                value: point.value,
+                widthValue: point.value,
+                xScale,
+                xValue: point.x,
+                y: groupY + seriesIndex * (barHeight + gapHeight)
+            });
+            if (rect) {
+                bars.push(rect);
+            }
+        });
+    }
+    return bars;
+};
+const buildStackedHorizontalBars = ({ baselineX, barWidthRatio, dataIndexOffset, mode, series, xScale, yBand }) => {
+    const rowCount = getSeriesRowCount(series);
+    const bars = [];
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const referencePoint = series[0]?.points[rowIndex];
+        if (!referencePoint) {
+            continue;
+        }
+        const band = yBand(referencePoint.x, rowIndex + dataIndexOffset, referencePoint.raw);
+        if (!band || !Number.isFinite(band.y) || !Number.isFinite(band.height)) {
+            continue;
+        }
+        let positiveStart = 0;
+        let negativeStart = 0;
+        const barHeight = band.height * barWidthRatio;
+        const y = band.y + (band.height - barHeight) / 2;
+        series.forEach((item, seriesIndex) => {
+            const point = getSeriesPoint(item, rowIndex);
+            if (!point ||
+                typeof point.value !== "number" ||
+                !Number.isFinite(point.value)) {
+                return;
+            }
+            const scaledValue = getStackedScaledValue({
+                mode,
+                rowIndex,
+                series,
+                value: point.value
+            });
+            const stackStart = scaledValue >= 0 ? positiveStart : negativeStart;
+            const stackEnd = stackStart + scaledValue;
+            const stackStartX = xScale(stackStart);
+            const stackEndX = xScale(stackEnd);
+            if (!isFinitePosition(stackStartX) || !isFinitePosition(stackEndX)) {
+                return;
+            }
+            bars.push({
+                key: `${item.key}-${rowIndex + dataIndexOffset}`,
+                seriesKey: item.key,
+                seriesLabel: item.label,
+                seriesIndex,
+                dataIndex: rowIndex + dataIndexOffset,
+                xValue: point.x,
+                value: point.value,
+                scaledValue,
+                x: Math.min(stackStartX, stackEndX),
+                y,
+                width: Math.abs(stackEndX - stackStartX),
+                height: barHeight,
+                baselineX,
+                baselineY: y + barHeight / 2,
+                defined: true,
+                raw: point.raw,
+                stackStart,
+                stackEnd
+            });
+            if (scaledValue >= 0) {
+                positiveStart = stackEnd;
+            }
+            else {
+                negativeStart = stackEnd;
+            }
+        });
+    }
+    return bars;
+};
+export const buildHorizontalBarGeometry = ({ series, yBand, xScale, mode = "grouped", baselineValue = 0, barWidthRatio: rawBarWidthRatio, barGapRatio: rawBarGapRatio, dataIndexOffset = 0 }) => {
+    const baselineX = xScale(baselineValue);
+    if (!isFinitePosition(baselineX) || series.length === 0) {
+        return { mode, bars: [] };
+    }
+    const barWidthRatio = clampRatio(rawBarWidthRatio, defaultBarWidthRatio);
+    const barGapRatio = clampRatio(rawBarGapRatio, defaultBarGapRatio);
+    const bars = mode === "grouped"
+        ? buildGroupedHorizontalBars({
+            baselineX,
+            barGapRatio,
+            barWidthRatio,
+            dataIndexOffset,
+            series,
+            xScale,
+            yBand
+        })
+        : buildStackedHorizontalBars({
+            baselineX,
+            barWidthRatio,
+            dataIndexOffset,
+            mode,
+            series,
+            xScale,
+            yBand
+        });
+    return {
+        mode,
+        bars
+    };
+};

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

@@ -0,0 +1,12 @@
+export * from "./areaPath";
+export * from "./barRects";
+export * from "./contributionHeatmap";
+export * from "./horizontalBarRects";
+export * from "./lineDecimation";
+export * from "./linePath";
+export * from "./lineSeries";
+export * from "./path";
+export * from "./pieArcs";
+export * from "./progressRings";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,11 @@
+export * from "./areaPath";
+export * from "./barRects";
+export * from "./contributionHeatmap";
+export * from "./horizontalBarRects";
+export * from "./lineDecimation";
+export * from "./linePath";
+export * from "./lineSeries";
+export * from "./path";
+export * from "./pieArcs";
+export * from "./progressRings";
+export * from "./types";

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

@@ -0,0 +1,8 @@
+import type { GeometryPoint, LinePathDecimationConfig } from "./types";
+export declare const splitLinePathSegments: <TPoint extends GeometryPoint = GeometryPoint>(points: TPoint[], connectNulls?: boolean) => TPoint[][];
+export declare const getDecimatedLinePathSegments: <TPoint extends GeometryPoint = GeometryPoint>({ connectNulls, decimation, points }: {
+    connectNulls?: boolean;
+    decimation?: false | LinePathDecimationConfig | undefined;
+    points: TPoint[];
+}) => TPoint[][];
+//# sourceMappingURL=lineDecimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lineDecimation.d.ts","sourceRoot":"","sources":["../../src/geometry/lineDecimation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAiBvE,eAAO,MAAM,qBAAqB,GAChC,MAAM,SAAS,aAAa,GAAG,aAAa,EAE5C,QAAQ,MAAM,EAAE,EAChB,sBAAoB,KACnB,MAAM,EAAE,EAyBV,CAAC;AA4GF,eAAO,MAAM,4BAA4B,GACvC,MAAM,SAAS,aAAa,GAAG,aAAa,EAC5C,sCAIC;IACD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,KAAK,GAAG,wBAAwB,GAAG,SAAS,CAAC;IAC1D,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,KAAG,MAAM,EAAE,EA4BX,CAAC"}

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