@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-5JCI2DEB.mjs

@@ -0,0 +1,97 @@
+// src/utils/interaction/interaction.utils.ts
+function hitTest(regions, x, y) {
+  for (const region of regions) {
+    if (region.contains(x, y)) {
+      return region;
+    }
+  }
+  return null;
+}
+function hitTestAll(regions, x, y) {
+  const hits = [];
+  for (const region of regions) {
+    if (region.contains(x, y)) {
+      hits.push(region);
+    }
+  }
+  return hits;
+}
+function createSliceRegion(data, datasetId, index, cx, cy, outerRadius, startAngle, endAngle, innerRadius = 0) {
+  const arcSpan = endAngle - startAngle;
+  const isFullCircle = arcSpan >= 359.9;
+  return {
+    data,
+    datasetId,
+    index,
+    contains(x, y) {
+      if (outerRadius <= 0) return false;
+      const dx = x - cx;
+      const dy = y - cy;
+      const distanceSq = dx * dx + dy * dy;
+      const outerRadiusSq = outerRadius * outerRadius;
+      const innerRadiusSq = innerRadius * innerRadius;
+      if (distanceSq > outerRadiusSq) return false;
+      if (innerRadius > 0 && distanceSq < innerRadiusSq) return false;
+      if (isFullCircle) return true;
+      let angle = Math.atan2(dy, dx) * (180 / Math.PI);
+      if (angle < 0) angle += 360;
+      const start = (startAngle % 360 + 360) % 360;
+      const end = (endAngle % 360 + 360) % 360;
+      if (start <= end) {
+        return angle >= start && angle <= end;
+      }
+      return angle >= start || angle <= end;
+    }
+  };
+}
+function createRectRegion(data, datasetId, index, x, y, width, height) {
+  return {
+    data,
+    datasetId,
+    index,
+    contains(px, py) {
+      return px >= x && px <= x + width && py >= y && py <= y + height;
+    }
+  };
+}
+function createCircleRegion(data, datasetId, index, cx, cy, radius) {
+  const radiusSq = radius * radius;
+  return {
+    data,
+    datasetId,
+    index,
+    contains(x, y) {
+      const dx = x - cx;
+      const dy = y - cy;
+      return dx * dx + dy * dy <= radiusSq;
+    }
+  };
+}
+function createLineRegion(data, datasetId, index, x1, y1, x2, y2, hitWidth = 6) {
+  const halfWidth = hitWidth / 2;
+  return {
+    data,
+    datasetId,
+    index,
+    contains(px, py) {
+      const dx = x2 - x1;
+      const dy = y2 - y1;
+      const lengthSq = dx * dx + dy * dy;
+      if (lengthSq === 0) {
+        const d = Math.sqrt((px - x1) ** 2 + (py - y1) ** 2);
+        return d <= halfWidth;
+      }
+      const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lengthSq));
+      const projX = x1 + t * dx;
+      const projY = y1 + t * dy;
+      const distance = Math.sqrt((px - projX) ** 2 + (py - projY) ** 2);
+      return distance <= halfWidth;
+    }
+  };
+}
+function isIndexVisible(visibility, index) {
+  if (!visibility) return true;
+  return visibility.get(index) ?? true;
+}
+
+export { createCircleRegion, createLineRegion, createRectRegion, createSliceRegion, hitTest, hitTestAll, isIndexVisible };

package/dist/chunk-66T4MRC5.mjs

@@ -0,0 +1,113 @@
+import { computeBarLabelPosition } from './chunk-AUF4CHDP.mjs';
+import { formatDataLabelText } from './chunk-OXTFAWSK.mjs';
+import { DEFAULT_LABEL_SPACING } from './chunk-NKUYIWAP.mjs';
+import { makeItemContext, resolveAccessor } from './chunk-O2X6FF45.mjs';
+
+// src/cartesian/label.ts
+var BASELINE_TO_CANVAS = { central: "middle", hanging: "top", auto: "alphabetic" };
+function resolveBarLabels(bars, colors, datasetTotal, orientation, config, isPercentStacked, seriesName, data) {
+  const labels = [];
+  const fontSizeAccessor = config.fontSizeAccessor;
+  const colorAccessor = config.colorAccessor;
+  const needsCtx = fontSizeAccessor !== void 0 || colorAccessor !== void 0;
+  for (const bar of bars) {
+    if (orientation === "vertical" ? bar.height < 2 : bar.width < 2) continue;
+    const percentage = isPercentStacked ? bar.value : datasetTotal > 0 ? Math.abs(bar.value) / datasetTotal * 100 : 0;
+    if (config.minPercentage > 0 && percentage < config.minPercentage) continue;
+    const text = formatDataLabelText(bar.value, percentage, config.display, config.formatter);
+    if (!text) continue;
+    const pos = computeBarLabelPosition(bar, orientation, DEFAULT_LABEL_SPACING);
+    const labelCtx = needsCtx ? makeItemContext(data?.[bar.dataIndex], bar.dataIndex) : null;
+    const perLabelFontSize = fontSizeAccessor && labelCtx ? resolveAccessor(fontSizeAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColorRaw = colorAccessor && labelCtx ? resolveAccessor(colorAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColor = typeof perLabelColorRaw === "string" ? perLabelColorRaw : void 0;
+    labels.push({
+      dataIndex: bar.dataIndex,
+      value: bar.value,
+      percentage,
+      text,
+      category: bar.category ?? "",
+      seriesName,
+      color: String(colors[bar.dataIndex % colors.length] ?? config.color ?? ""),
+      x: Math.round(pos.x),
+      y: Math.round(pos.y),
+      textAnchor: pos.textAnchor,
+      baseline: pos.baseline,
+      canvasTextAlign: pos.textAnchor === "middle" ? "center" : pos.textAnchor,
+      canvasTextBaseline: BASELINE_TO_CANVAS[pos.baseline] ?? "alphabetic",
+      fontSize: perLabelFontSize,
+      textColor: perLabelColor
+    });
+  }
+  return labels;
+}
+function resolveScatterLabels(points, seriesColor, config, seriesName, data) {
+  const labels = [];
+  const fontSizeAccessor = config.fontSizeAccessor;
+  const colorAccessor = config.colorAccessor;
+  const needsCtx = fontSizeAccessor !== void 0 || colorAccessor !== void 0;
+  for (const pt of points) {
+    if (!Number.isFinite(pt.yValue) || !Number.isFinite(pt.py)) continue;
+    const text = formatDataLabelText(pt.yValue, 0, config.display, config.formatter);
+    if (!text) continue;
+    const labelCtx = needsCtx ? makeItemContext(data?.[pt.dataIndex], pt.dataIndex) : null;
+    const perLabelFontSize = fontSizeAccessor && labelCtx ? resolveAccessor(fontSizeAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColorRaw = colorAccessor && labelCtx ? resolveAccessor(colorAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColor = typeof perLabelColorRaw === "string" ? perLabelColorRaw : void 0;
+    labels.push({
+      dataIndex: pt.dataIndex,
+      value: pt.yValue,
+      percentage: 0,
+      text,
+      category: "",
+      seriesName,
+      color: seriesColor,
+      x: Math.round(pt.px),
+      y: Math.round(pt.py - pt.radius - DEFAULT_LABEL_SPACING),
+      textAnchor: "middle",
+      baseline: "auto",
+      canvasTextAlign: "center",
+      canvasTextBaseline: "alphabetic",
+      fontSize: perLabelFontSize,
+      textColor: perLabelColor
+    });
+  }
+  return labels;
+}
+function resolvePointLabels(points, seriesColor, datasetTotal, config, seriesName, data) {
+  const labels = [];
+  const fontSizeAccessor = config.fontSizeAccessor;
+  const colorAccessor = config.colorAccessor;
+  const needsCtx = fontSizeAccessor !== void 0 || colorAccessor !== void 0;
+  for (const pt of points) {
+    if (pt.value == null || Number.isNaN(pt.y)) continue;
+    const percentage = datasetTotal > 0 ? Math.abs(pt.value) / datasetTotal * 100 : 0;
+    if (config.minPercentage > 0 && percentage < config.minPercentage) continue;
+    const text = formatDataLabelText(pt.value, percentage, config.display, config.formatter);
+    if (!text) continue;
+    const labelCtx = needsCtx ? makeItemContext(data?.[pt.dataIndex], pt.dataIndex) : null;
+    const perLabelFontSize = fontSizeAccessor && labelCtx ? resolveAccessor(fontSizeAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColorRaw = colorAccessor && labelCtx ? resolveAccessor(colorAccessor, labelCtx, { arrayMode: "cycle" }) : void 0;
+    const perLabelColor = typeof perLabelColorRaw === "string" ? perLabelColorRaw : void 0;
+    labels.push({
+      dataIndex: pt.dataIndex,
+      value: pt.value,
+      percentage,
+      text,
+      category: pt.category ?? "",
+      seriesName,
+      color: seriesColor,
+      x: Math.round(pt.x),
+      y: Math.round(pt.y - DEFAULT_LABEL_SPACING),
+      textAnchor: "middle",
+      baseline: "auto",
+      canvasTextAlign: "center",
+      canvasTextBaseline: "alphabetic",
+      fontSize: perLabelFontSize,
+      textColor: perLabelColor
+    });
+  }
+  return labels;
+}
+
+export { BASELINE_TO_CANVAS, resolveBarLabels, resolvePointLabels, resolveScatterLabels };

package/dist/chunk-6HSEJLSR.mjs

@@ -0,0 +1,376 @@
+import { createSvgLinePathBuilder, traceCurve, reversedBaseEdge, invertCurveForReverse } from './chunk-HDFGCN2F.mjs';
+import { batchResolveRequired, resolveAccessor, makeItemContext } from './chunk-O2X6FF45.mjs';
+import { createBandScale, calculateNiceDomain, createLinearScale } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/line/geometry.ts
+var DEFAULT_CURVE = "linear";
+var DEFAULT_TENSION = 0.5;
+var DEFAULT_CONNECT_NULLS = "gap";
+function buildLinePath(points, curve, tension) {
+  if (points.length === 0) return "";
+  const builder = createSvgLinePathBuilder();
+  builder.moveTo(points[0].x, points[0].y);
+  traceCurve(builder, points, curve, tension);
+  return builder.build();
+}
+function buildFillPath(points, curve, baselineY, tension) {
+  if (points.length === 0) return "";
+  const builder = createSvgLinePathBuilder();
+  builder.moveTo(points[0].x, points[0].y);
+  traceCurve(builder, points, curve, tension);
+  builder.lineTo(points[points.length - 1].x, baselineY);
+  builder.lineTo(points[0].x, baselineY);
+  builder.closePath();
+  return builder.build();
+}
+function buildStackedFillPath(points, curve, tension) {
+  if (points.length === 0) return "";
+  const builder = createSvgLinePathBuilder();
+  builder.moveTo(points[0].x, points[0].y);
+  traceCurve(builder, points, curve, tension);
+  const basePoints = reversedBaseEdge(points);
+  builder.lineTo(basePoints[0].x, basePoints[0].y);
+  traceCurve(builder, basePoints, invertCurveForReverse(curve), tension);
+  builder.closePath();
+  return builder.build();
+}
+function applyTipExtension(layout, progress) {
+  const curve = layout.curve;
+  const tension = layout.tension;
+  const pts = layout.visiblePoints;
+  if (pts.length < 2) return null;
+  const last = pts[pts.length - 1];
+  const prev = pts[pts.length - 2];
+  const origX = last.x;
+  const origY = last.y;
+  last.x = prev.x + (origX - prev.x) * progress;
+  last.y = prev.y + (origY - prev.y) * progress;
+  let segIndex = -1;
+  for (let i = layout.segments.length - 1; i >= 0; i--) {
+    if (layout.segments[i].points.length > 0) {
+      segIndex = i;
+      break;
+    }
+  }
+  if (segIndex < 0) {
+    last.x = origX;
+    last.y = origY;
+    return null;
+  }
+  const seg = layout.segments[segIndex];
+  const origLinePath = seg.linePath;
+  const origFillPath = seg.fillPath;
+  seg.linePath = buildLinePath(seg.points, curve, tension);
+  if (origFillPath && seg.points.length > 0) {
+    const baselineY = seg.points[0].baseY ?? layout.chartArea.y + layout.chartArea.height;
+    seg.fillPath = buildFillPath(seg.points, curve, baselineY, tension);
+  }
+  return { lastPoint: last, origX, origY, segIndex, origLinePath, origFillPath };
+}
+function restoreTipExtension(layout, state) {
+  state.lastPoint.x = state.origX;
+  state.lastPoint.y = state.origY;
+  const seg = layout.segments[state.segIndex];
+  seg.linePath = state.origLinePath;
+  seg.fillPath = state.origFillPath;
+}
+function buildRangeFillPath(pointsA, pointsB, curve, tension = DEFAULT_TENSION) {
+  if (pointsA.length < 2 || pointsB.length < 2) return null;
+  const builder = createSvgLinePathBuilder();
+  builder.moveTo(pointsA[0].x, pointsA[0].y);
+  traceCurve(builder, pointsA, curve, tension);
+  const reversedB = [];
+  for (let i = pointsB.length - 1; i >= 0; i--) {
+    reversedB.push(pointsB[i]);
+  }
+  builder.lineTo(reversedB[0].x, reversedB[0].y);
+  traceCurve(builder, reversedB, invertCurveForReverse(curve), tension);
+  builder.closePath();
+  return builder.build();
+}
+function buildDualRangeFillPaths(pointsA, pointsB, curve = "linear", tension = DEFAULT_TENSION) {
+  const len = Math.min(pointsA.length, pointsB.length);
+  if (len < 2) return null;
+  const abovePaths = [];
+  const belowPaths = [];
+  let segVertices = [{ xA: pointsA[0].x, yA: pointsA[0].y, xB: pointsB[0].x, yB: pointsB[0].y }];
+  let segAbove = pointsA[0].y <= pointsB[0].y;
+  for (let i = 0; i < len - 1; i++) {
+    const ax0 = pointsA[i].x, ay0 = pointsA[i].y;
+    const ax1 = pointsA[i + 1].x, ay1 = pointsA[i + 1].y;
+    const by0 = pointsB[i].y;
+    const bx1 = pointsB[i + 1].x, by1 = pointsB[i + 1].y;
+    if (isNaN(ay0) || isNaN(ay1) || isNaN(by0) || isNaN(by1)) {
+      if (segVertices.length >= 2) {
+        flushSegment(segVertices, segAbove, abovePaths, belowPaths, curve, tension);
+      }
+      if (i + 1 < len) {
+        segVertices = [{ xA: ax1, yA: ay1, xB: bx1, yB: by1 }];
+        segAbove = ay1 <= by1;
+      }
+      continue;
+    }
+    const dA = ay0 - by0;
+    const dB = ay1 - by1;
+    if (dA * dB < 0) {
+      const t = dA / (dA - dB);
+      const ix = ax0 + (ax1 - ax0) * t;
+      const iy = ay0 + (ay1 - ay0) * t;
+      segVertices.push({ xA: ix, yA: iy, xB: ix, yB: iy });
+      flushSegment(segVertices, segAbove, abovePaths, belowPaths, curve, tension);
+      segAbove = !segAbove;
+      segVertices = [{ xA: ix, yA: iy, xB: ix, yB: iy }];
+    } else if (dA === 0 && dB !== 0) {
+      const newAbove = dB < 0;
+      if (newAbove !== segAbove) {
+        flushSegment(segVertices, segAbove, abovePaths, belowPaths, curve, tension);
+        segAbove = newAbove;
+        segVertices = [{ xA: ax0, yA: ay0, xB: ax0, yB: by0 }];
+      }
+    }
+    segVertices.push({ xA: ax1, yA: ay1, xB: bx1, yB: by1 });
+  }
+  if (segVertices.length >= 2) {
+    flushSegment(segVertices, segAbove, abovePaths, belowPaths, curve, tension);
+  }
+  if (abovePaths.length === 0 && belowPaths.length === 0) return null;
+  return { abovePaths, belowPaths };
+}
+function flushSegment(vertices, isAbove, abovePaths, belowPaths, curve, tension) {
+  if (vertices.length < 2) return;
+  const builder = createSvgLinePathBuilder();
+  const ptsA = vertices.map((v) => ({ x: v.xA, y: v.yA, dataIndex: 0, value: 0, visible: true, category: "" }));
+  builder.moveTo(ptsA[0].x, ptsA[0].y);
+  traceCurve(builder, ptsA, curve, tension);
+  const ptsB = [];
+  for (let i = vertices.length - 1; i >= 0; i--) {
+    ptsB.push({ x: vertices[i].xB, y: vertices[i].yB, dataIndex: 0, value: 0, visible: true, category: "" });
+  }
+  builder.lineTo(ptsB[0].x, ptsB[0].y);
+  traceCurve(builder, ptsB, invertCurveForReverse(curve), tension);
+  builder.closePath();
+  const path = builder.build();
+  if (isAbove) {
+    abovePaths.push(path);
+  } else {
+    belowPaths.push(path);
+  }
+}
+function splitSegments(points, connectNulls) {
+  const bridge = connectNulls === true || connectNulls === "connect" || connectNulls === "zero";
+  if (bridge) {
+    const valid = points.filter((p) => p.visible && !isNaN(p.y));
+    return valid.length > 0 ? [valid] : [];
+  }
+  const segments = [];
+  let current = [];
+  for (const pt of points) {
+    if (pt.visible && pt.value !== null && !isNaN(pt.y) && !isNaN(pt.x)) {
+      current.push(pt);
+    } else if (current.length > 0) {
+      segments.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+function resolveStyleValue(value, ctx) {
+  if (value === void 0) return void 0;
+  if (typeof value === "function") return value(ctx);
+  return value;
+}
+function resolveSegmentStyle(overrides, ctx) {
+  return {
+    segmentColor: resolveStyleValue(overrides.segmentColor, ctx),
+    segmentStrokeWidth: resolveStyleValue(overrides.segmentStrokeWidth, ctx),
+    segmentDash: resolveStyleValue(overrides.segmentDash, ctx),
+    segmentFillColor: resolveStyleValue(overrides.segmentFillColor, ctx)
+  };
+}
+function segmentStyleKey(s) {
+  return `${s.segmentColor ?? ""}|${s.segmentStrokeWidth ?? ""}|${(s.segmentDash ?? []).join(",")}|${s.segmentFillColor ?? ""}`;
+}
+function splitSegmentByStyle(segPts, overrides, curve, tension, isArea, isStacked, baselineY, data, seriesId, seriesIndex) {
+  if (segPts.length < 2) {
+    return [
+      {
+        points: segPts,
+        linePath: buildLinePath(segPts, curve, tension),
+        fillPath: isArea ? isStacked ? buildStackedFillPath(segPts, curve, tension) : buildFillPath(segPts, curve, baselineY, tension) : void 0
+      }
+    ];
+  }
+  const hasCallback = typeof overrides.segmentColor === "function" || typeof overrides.segmentStrokeWidth === "function" || typeof overrides.segmentDash === "function" || typeof overrides.segmentFillColor === "function";
+  if (!hasCallback) {
+    const style = resolveSegmentStyle(overrides, {
+      p0: segPts[0],
+      p1: segPts[1],
+      p0DataIndex: segPts[0].dataIndex,
+      p1DataIndex: segPts[1].dataIndex,
+      datum0: data[segPts[0].dataIndex],
+      datum1: data[segPts[1].dataIndex],
+      seriesId,
+      seriesIndex
+    });
+    return [
+      {
+        points: segPts,
+        linePath: buildLinePath(segPts, curve, tension),
+        fillPath: isArea ? isStacked ? buildStackedFillPath(segPts, curve, tension) : buildFillPath(segPts, curve, baselineY, tension) : void 0,
+        style
+      }
+    ];
+  }
+  const pairStyles = [];
+  for (let i = 0; i < segPts.length - 1; i++) {
+    const p0 = segPts[i];
+    const p1 = segPts[i + 1];
+    const ctx = {
+      p0,
+      p1,
+      p0DataIndex: p0.dataIndex,
+      p1DataIndex: p1.dataIndex,
+      datum0: data[p0.dataIndex],
+      datum1: data[p1.dataIndex],
+      seriesId,
+      seriesIndex
+    };
+    pairStyles.push(resolveSegmentStyle(overrides, ctx));
+  }
+  const runs = [];
+  let runStart = 0;
+  let runKey = segmentStyleKey(pairStyles[0]);
+  for (let i = 1; i < pairStyles.length; i++) {
+    const key = segmentStyleKey(pairStyles[i]);
+    if (key !== runKey) {
+      runs.push({ startIdx: runStart, endIdx: i, style: pairStyles[runStart] });
+      runStart = i;
+      runKey = key;
+    }
+  }
+  runs.push({ startIdx: runStart, endIdx: pairStyles.length, style: pairStyles[runStart] });
+  return runs.map((run) => {
+    const pts = segPts.slice(run.startIdx, run.endIdx + 1);
+    return {
+      points: pts,
+      linePath: buildLinePath(pts, curve, tension),
+      fillPath: isArea ? isStacked ? buildStackedFillPath(pts, curve, tension) : buildFillPath(pts, curve, baselineY, tension) : void 0,
+      style: run.style
+    };
+  });
+}
+function calculateLineLayout(props, chartArea, config) {
+  const { data = [] } = props;
+  const curve = props.curve ?? DEFAULT_CURVE;
+  const tension = props.tension ?? DEFAULT_TENSION;
+  const connectNulls = props.connectNulls ?? DEFAULT_CONNECT_NULLS;
+  const fillOpacity = props.fillOpacity;
+  const isArea = typeof fillOpacity === "number" && fillOpacity > 0;
+  const categoryAccessor = props.categoryField;
+  const valueAccessor = props.valueField;
+  const categories = categoryAccessor ? batchResolveRequired(categoryAccessor, data, "categoryField") : data.map((_, i) => String(i));
+  const rawValues = valueAccessor ? batchResolveRequired(valueAccessor, data, "valueField") : data.map((d) => {
+    const v = d["value"];
+    return v != null && !isNaN(Number(v)) ? Number(v) : null;
+  });
+  const categoryScale = config?.categoryScale ?? createBandScale(categories, [chartArea.x, chartArea.x + chartArea.width]);
+  const numericValues = rawValues.filter((v) => v !== null && v !== void 0 && !isNaN(Number(v)));
+  const valueDomain = config?.valueScale?.domain() ?? calculateNiceDomain(numericValues.length > 0 ? numericValues : [0, 1], {
+    includeZero: true
+  });
+  const valueScale = config?.valueScale ?? createLinearScale(valueDomain, [chartArea.y + chartArea.height, chartArea.y]);
+  const baselineY = Math.min(Math.max(valueScale(0), chartArea.y), chartArea.y + chartArea.height);
+  const lineColor = props.color != null && data.length > 0 ? resolveAccessor(props.color, makeItemContext(data[0], 0)) : props.color;
+  const seriesIdx = props.order ?? 0;
+  const stackBases = config?.stackBases;
+  const transformedValues = config?.transformedValues;
+  const treatNullAsZero = connectNulls === "zero";
+  const points = data.map((_, i) => {
+    const category = categories[i] ?? String(i);
+    const rawVal = rawValues[i];
+    const value = rawVal !== null && rawVal !== void 0 && !isNaN(Number(rawVal)) ? Number(rawVal) : null;
+    const visible = props.visibility ? props.visibility.get(i) !== false : true;
+    const bandLeft = categoryScale(category);
+    const centerX = bandLeft + categoryScale.bandwidth() / 2;
+    const stackBase = stackBases?.[i] ?? 0;
+    const effectiveValue = transformedValues ? transformedValues[i] : value;
+    const isNullPoint = effectiveValue === null || effectiveValue === void 0 || typeof effectiveValue === "number" && isNaN(effectiveValue);
+    const y = !isNullPoint ? valueScale(stackBase + effectiveValue) : treatNullAsZero ? valueScale(stackBase) : NaN;
+    return {
+      dataIndex: i,
+      x: centerX,
+      y,
+      value,
+      category,
+      visible,
+      ...stackBases && { baseY: valueScale(stackBase) }
+    };
+  });
+  const step = categoryScale.step();
+  if (step > 0) {
+    for (let i = 0; i < points.length; i++) {
+      const pt = points[i];
+      if (isNaN(pt.x) && pt.visible && pt.value !== null && !isNaN(pt.y)) {
+        const next = points[i + 1];
+        const prev = points[i - 1];
+        if (next && !isNaN(next.x) && next.visible && next.value !== null && !isNaN(next.y)) {
+          pt.x = next.x - step;
+        }
+        if (prev && !isNaN(prev.x) && prev.visible && prev.value !== null && !isNaN(prev.y)) {
+          pt.x = prev.x + step;
+        }
+      }
+    }
+  }
+  const visiblePoints = points.filter((p) => p.visible && p.value !== null && !isNaN(p.y) && !isNaN(p.x));
+  const pointGroups = splitSegments(points, connectNulls);
+  const isStacked = stackBases !== void 0;
+  const segmentOverrides = props.segmentColor || props.segmentStrokeWidth || props.segmentDash || props.segmentFillColor ? { segmentColor: props.segmentColor, segmentStrokeWidth: props.segmentStrokeWidth, segmentDash: props.segmentDash, segmentFillColor: props.segmentFillColor } : void 0;
+  let segments;
+  if (segmentOverrides) {
+    segments = [];
+    for (const segPts of pointGroups) {
+      segments.push(...splitSegmentByStyle(segPts, segmentOverrides, curve, tension, isArea, isStacked, baselineY, data, config?.seriesId, seriesIdx));
+    }
+  } else {
+    segments = pointGroups.map((segPts) => ({
+      points: segPts,
+      linePath: buildLinePath(segPts, curve, tension),
+      fillPath: isArea ? isStacked ? buildStackedFillPath(segPts, curve, tension) : buildFillPath(segPts, curve, baselineY, tension) : void 0
+    }));
+  }
+  return {
+    datasetId: "",
+    points,
+    visiblePoints,
+    segments,
+    categoryScale,
+    valueScale,
+    lineColor,
+    seriesIdx,
+    chartArea,
+    valueDomain,
+    isArea,
+    baselineY,
+    curve,
+    tension
+  };
+}
+function hitTestLine(x, y, props, layout) {
+  let nearestIndex = null;
+  const hitRadius = props.pointHitRadius ?? 10;
+  let minDistSq = hitRadius * hitRadius;
+  for (const pt of layout.visiblePoints) {
+    const dx = pt.x - x;
+    const dy = pt.y - y;
+    const distSq = dx * dx + dy * dy;
+    if (distSq < minDistSq) {
+      minDistSq = distSq;
+      nearestIndex = pt.dataIndex;
+    }
+  }
+  return nearestIndex;
+}
+
+export { applyTipExtension, buildDualRangeFillPaths, buildFillPath, buildLinePath, buildRangeFillPath, buildStackedFillPath, calculateLineLayout, hitTestLine, restoreTipExtension };