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

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

@@ -0,0 +1,201 @@
+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 buildRect = ({ baselineY, dataIndex, heightValue, raw, scaledValue, series, seriesIndex, value, width, x, xValue, yScale }) => {
+    const valueY = yScale(heightValue);
+    if (!isFinitePosition(valueY)) {
+        return undefined;
+    }
+    return {
+        key: `${series.key}-${dataIndex}`,
+        seriesKey: series.key,
+        seriesLabel: series.label,
+        seriesIndex,
+        dataIndex,
+        xValue,
+        value,
+        scaledValue,
+        x,
+        y: Math.min(valueY, baselineY),
+        width,
+        height: Math.abs(baselineY - valueY),
+        baselineY,
+        defined: true,
+        raw
+    };
+};
+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 buildGroupedBars = ({ baselineY, barGapRatio, barWidthRatio, dataIndexOffset, series, xBand, yScale }) => {
+    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 = xBand(referencePoint.x, rowIndex + dataIndexOffset, referencePoint.raw);
+        if (!band || !Number.isFinite(band.x) || !Number.isFinite(band.width)) {
+            continue;
+        }
+        const groupWidth = band.width * barWidthRatio;
+        const groupX = band.x + (band.width - groupWidth) / 2;
+        const totalGapWidth = groupWidth * barGapRatio * Math.max(0, seriesCount - 1);
+        const barWidth = Math.max(0, (groupWidth - totalGapWidth) / seriesCount);
+        const gapWidth = seriesCount > 1 ? groupWidth * 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({
+                baselineY,
+                dataIndex: rowIndex + dataIndexOffset,
+                heightValue: point.value,
+                raw: point.raw,
+                scaledValue: point.value,
+                series: item,
+                seriesIndex,
+                value: point.value,
+                width: barWidth,
+                x: groupX + seriesIndex * (barWidth + gapWidth),
+                xValue: point.x,
+                yScale
+            });
+            if (rect) {
+                bars.push(rect);
+            }
+        });
+    }
+    return bars;
+};
+const buildStackedBars = ({ baselineY, barWidthRatio, dataIndexOffset, mode, series, xBand, yScale }) => {
+    const rowCount = getSeriesRowCount(series);
+    const bars = [];
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const referencePoint = series[0]?.points[rowIndex];
+        if (!referencePoint) {
+            continue;
+        }
+        const band = xBand(referencePoint.x, rowIndex + dataIndexOffset, referencePoint.raw);
+        if (!band || !Number.isFinite(band.x) || !Number.isFinite(band.width)) {
+            continue;
+        }
+        let positiveStart = 0;
+        let negativeStart = 0;
+        const barWidth = band.width * barWidthRatio;
+        const x = band.x + (band.width - barWidth) / 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 stackStartY = yScale(stackStart);
+            const stackEndY = yScale(stackEnd);
+            if (!isFinitePosition(stackStartY) || !isFinitePosition(stackEndY)) {
+                return;
+            }
+            const rect = {
+                key: `${item.key}-${rowIndex + dataIndexOffset}`,
+                seriesKey: item.key,
+                seriesLabel: item.label,
+                seriesIndex,
+                dataIndex: rowIndex + dataIndexOffset,
+                xValue: point.x,
+                value: point.value,
+                scaledValue,
+                x,
+                y: Math.min(stackStartY, stackEndY),
+                width: barWidth,
+                height: Math.abs(stackStartY - stackEndY),
+                baselineY,
+                defined: true,
+                raw: point.raw,
+                stackStart,
+                stackEnd
+            };
+            bars.push(rect);
+            if (scaledValue >= 0) {
+                positiveStart = stackEnd;
+            }
+            else {
+                negativeStart = stackEnd;
+            }
+        });
+    }
+    return bars;
+};
+export const buildBarGeometry = ({ series, xBand, yScale, mode = "grouped", baselineValue = 0, barWidthRatio: rawBarWidthRatio, barGapRatio: rawBarGapRatio, dataIndexOffset = 0 }) => {
+    const baselineY = yScale(baselineValue);
+    if (!isFinitePosition(baselineY) || series.length === 0) {
+        return { mode, bars: [] };
+    }
+    const barWidthRatio = clampRatio(rawBarWidthRatio, defaultBarWidthRatio);
+    const barGapRatio = clampRatio(rawBarGapRatio, defaultBarGapRatio);
+    const bars = mode === "grouped"
+        ? buildGroupedBars({
+            baselineY,
+            barGapRatio,
+            barWidthRatio,
+            dataIndexOffset,
+            series,
+            xBand,
+            yScale
+        })
+        : buildStackedBars({
+            baselineY,
+            barWidthRatio,
+            dataIndexOffset,
+            mode,
+            series,
+            xBand,
+            yScale
+        });
+    return {
+        mode,
+        bars
+    };
+};

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

@@ -0,0 +1,49 @@
+import type { NormalizedContributionData } from "../data";
+export type ContributionHeatmapCell<TData = unknown> = {
+    index: number;
+    date: Date;
+    value: number | null;
+    defined: boolean;
+    outOfRange: boolean;
+    weekIndex: number;
+    weekdayIndex: number;
+    x: number;
+    y: number;
+    size: number;
+    raw?: TData;
+};
+export type ContributionHeatmapMonthLabel = {
+    key: string;
+    date: Date;
+    monthIndex: number;
+    x: number;
+    y: number;
+};
+export type ContributionHeatmapWeekdayLabel = {
+    key: string;
+    weekdayIndex: number;
+    dayIndex: number;
+    x: number;
+    y: number;
+};
+export type ContributionHeatmapModel<TData = unknown> = {
+    cells: Array<ContributionHeatmapCell<TData>>;
+    monthLabels: ContributionHeatmapMonthLabel[];
+    weekdayLabels: ContributionHeatmapWeekdayLabel[];
+    width: number;
+    height: number;
+    weekCount: number;
+    valueMin: number;
+    valueMax: number;
+};
+export type BuildContributionHeatmapOptions<TData = unknown> = {
+    data: NormalizedContributionData<TData>;
+    cellSize: number;
+    gutterSize?: number | undefined;
+    weekStartsOn?: number | undefined;
+    showOutOfRangeDays?: boolean | undefined;
+    monthLabelHeight?: number | undefined;
+    weekdayLabelWidth?: number | undefined;
+};
+export declare const buildContributionHeatmap: <TData = unknown>({ data, cellSize, gutterSize, weekStartsOn, showOutOfRangeDays, monthLabelHeight, weekdayLabelWidth }: BuildContributionHeatmapOptions<TData>) => ContributionHeatmapModel<TData>;
+//# sourceMappingURL=contributionHeatmap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contributionHeatmap.d.ts","sourceRoot":"","sources":["../../src/geometry/contributionHeatmap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAE1D,MAAM,MAAM,uBAAuB,CAAC,KAAK,GAAG,OAAO,IAAI;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,KAAK,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,OAAO,IAAI;IACtD,KAAK,EAAE,KAAK,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,WAAW,EAAE,6BAA6B,EAAE,CAAC;IAC7C,aAAa,EAAE,+BAA+B,EAAE,CAAC;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,+BAA+B,CAAC,KAAK,GAAG,OAAO,IAAI;IAC7D,IAAI,EAAE,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,CAAC;AA2BF,eAAO,MAAM,wBAAwB,GAAI,KAAK,GAAG,OAAO,EAAE,uGAQvD,+BAA+B,CAAC,KAAK,CAAC,KAAG,wBAAwB,CAAC,KAAK,CAgHzE,CAAC"}

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