@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-KP2TWD4Z.mjs

@@ -0,0 +1,90 @@
+import { materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
+
+// src/utils/render/reconcile.ts
+var PROTECTED_ATTRS = /* @__PURE__ */ new Set(["style", "tabindex"]);
+function keyOf(el) {
+  const ds = el.getAttribute("data-dataset");
+  if (ds !== null) return "ds:" + ds;
+  const i = el.getAttribute("data-index");
+  if (i !== null) return "i:" + i;
+  const id = el.getAttribute("id");
+  if (id !== null) return "id:" + id;
+  const layer = el.getAttribute("data-layer");
+  if (layer !== null) return "layer:" + layer;
+  return null;
+}
+function keyOfNode(node) {
+  const a = node.attributes;
+  if (a["data-dataset"] != null) return "ds:" + a["data-dataset"];
+  if (a["data-index"] != null) return "i:" + a["data-index"];
+  if (a["id"] != null) return "id:" + a["id"];
+  if (a["data-layer"] != null) return "layer:" + a["data-layer"];
+  return null;
+}
+function reconcileSvgElement(live, next) {
+  const fp = next.attributes["data-fp"];
+  if (fp != null && live.getAttribute("data-fp") === fp) return;
+  for (const k in next.attributes) {
+    if (live.getAttribute(k) !== next.attributes[k]) live.setAttribute(k, next.attributes[k]);
+  }
+  const liveAttrs = live.attributes;
+  for (let i = liveAttrs.length - 1; i >= 0; i--) {
+    const name = liveAttrs[i].name;
+    if (!(name in next.attributes) && !PROTECTED_ATTRS.has(name)) live.removeAttribute(name);
+  }
+  if (next.children.length === 1 && typeof next.children[0] === "string") {
+    if (live.textContent !== next.children[0]) live.textContent = next.children[0];
+    return;
+  }
+  if (next.children.length > 0) {
+    reconcileSvgChildren(live, next.children);
+  }
+}
+function reconcileSvgChildren(parent, nextChildren) {
+  const liveByKey = /* @__PURE__ */ new Map();
+  const liveByTag = /* @__PURE__ */ new Map();
+  for (const child of Array.from(parent.children)) {
+    const k = keyOf(child);
+    if (k !== null) {
+      const arr = liveByKey.get(k);
+      if (arr) arr.push(child);
+      else liveByKey.set(k, [child]);
+    } else {
+      const tag = child.tagName;
+      const arr = liveByTag.get(tag);
+      if (arr) arr.push(child);
+      else liveByTag.set(tag, [child]);
+    }
+  }
+  const desired = [];
+  for (const child of nextChildren) {
+    if (typeof child === "string") continue;
+    const k = keyOfNode(child);
+    let match;
+    if (k !== null) {
+      const arr = liveByKey.get(k);
+      if (arr && arr.length && arr[0].tagName === child.tag) match = arr.shift();
+    } else {
+      const arr = liveByTag.get(child.tag);
+      if (arr && arr.length) match = arr.shift();
+    }
+    if (match) {
+      reconcileSvgElement(match, child);
+      desired.push(match);
+    } else {
+      desired.push(materializeSvgNode(child));
+    }
+  }
+  for (const arr of liveByKey.values()) for (const el of arr) parent.removeChild(el);
+  for (const arr of liveByTag.values()) for (const el of arr) parent.removeChild(el);
+  let cur = parent.firstElementChild;
+  for (const want of desired) {
+    if (cur === want) {
+      cur = want.nextElementSibling;
+    } else {
+      parent.insertBefore(want, cur);
+    }
+  }
+}
+
+export { keyOf, keyOfNode, reconcileSvgChildren, reconcileSvgElement };

package/dist/chunk-KQIFO5I3.mjs

@@ -0,0 +1,225 @@
+import { createCanvasLinePathBuilder, traceCurve, reversedBaseEdge } from './chunk-HDFGCN2F.mjs';
+import { resolveBoostActive, MARKER_SHAPE_NAMES, traceMarkerShapeCanvasAt, drawMarkerCanvas } from './chunk-PRDVPOZX.mjs';
+import { computeItemHoverState, applyHoverEffects } from './chunk-BZN2QHGP.mjs';
+import { DEFAULT_LINE_WIDTH, DEFAULT_LINE_MARKER_SIZE, DEFAULT_AREA_FILL_OPACITY, DEFAULT_HOVER_DIM_OPACITY, LINE_BOOST_AUTO_THRESHOLD, DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER } from './chunk-NKUYIWAP.mjs';
+import { makeItemContext, resolveDash, resolveAccessor, getDefaultColor, isGradientColor, createCanvasGradientFromColor, getPrimaryColor } from './chunk-O2X6FF45.mjs';
+import { withCanvasState } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/line/canvas/index.ts
+var DEFAULT_CURVE = "linear";
+var DEFAULT_TENSION = 0.5;
+var DEFAULT_SHOW_MARKERS = true;
+var DEFAULT_MARKER_SHAPE = "circle";
+function renderLineCanvas(props, layout, ctx, context) {
+  const lineWidth = props.lineStrokeWidth ?? DEFAULT_LINE_WIDTH;
+  const borderColor = typeof props.borderColor === "string" ? props.borderColor : void 0;
+  const borderWidth = typeof props.borderStrokeWidth === "number" ? props.borderStrokeWidth : 0;
+  const lineStyle = props.lineStyle ?? "solid";
+  const showMarkers = props.showMarkers ?? DEFAULT_SHOW_MARKERS;
+  const markerSizeAccessor = props.markerSize;
+  const defaultMarkerSize = props.pointRadius ?? DEFAULT_LINE_MARKER_SIZE;
+  const resolveMarkerSize = (ctx2) => markerSizeAccessor === void 0 ? defaultMarkerSize : resolveAccessor(markerSizeAccessor, ctx2, { arrayMode: "clip", fallback: defaultMarkerSize }) ?? defaultMarkerSize;
+  const resolveMarkerShape = (ctx2, size) => props.markerShape === void 0 ? DEFAULT_MARKER_SHAPE : resolveAccessor(props.markerShape, typeof props.markerShape === "function" ? { ...ctx2, size } : ctx2, { arrayMode: "clip" }) ?? DEFAULT_MARKER_SHAPE;
+  const rotationAccessor = props.pointRotation;
+  const resolveMarkerRotation = (ctx2) => rotationAccessor === void 0 ? 0 : resolveAccessor(rotationAccessor, ctx2, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const seriesDashCtx = makeItemContext(props.data?.[0], 0);
+  const seriesBorderDash = resolveDash(props.borderDash, seriesDashCtx);
+  const seriesBorderDashOffset = resolveAccessor(props.borderDashOffset, seriesDashCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolvePointDash = (ctx2) => props.pointBorderDash === void 0 ? void 0 : resolveDash(props.pointBorderDash, ctx2);
+  const resolvePointDashOffset = (ctx2) => props.pointBorderDashOffset === void 0 ? 0 : resolveAccessor(props.pointBorderDashOffset, ctx2, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const curve = props.curve ?? DEFAULT_CURVE;
+  const tension = props.tension ?? DEFAULT_TENSION;
+  const fillOpacity = props.fillOpacity ?? DEFAULT_AREA_FILL_OPACITY;
+  const hoveredIndex = props.interaction?.hoveredIndex ?? null;
+  const isSeriesDimmed = props.interaction?.isSeriesDimmed ?? false;
+  const effects = props.effects;
+  const seriesDimOpacity = isSeriesDimmed ? effects?.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY : 1;
+  const lineColor = layout.lineColor ?? getDefaultColor(layout.seriesIdx, context.theme);
+  const seriesExtras = { seriesIndex: layout.seriesIdx, seriesId: layout.datasetId };
+  let strokeStyle;
+  if (isGradientColor(lineColor)) {
+    const cx = layout.chartArea.x + layout.chartArea.width / 2;
+    const cy = layout.chartArea.y + layout.chartArea.height / 2;
+    const r = Math.max(layout.chartArea.width, layout.chartArea.height) / 2;
+    strokeStyle = createCanvasGradientFromColor(ctx, lineColor, { x: cx, y: cy }, r, layout.chartArea, "horizontal");
+  } else {
+    strokeStyle = lineColor;
+  }
+  let areaFillStyle = strokeStyle;
+  if (layout.isArea && isGradientColor(lineColor)) {
+    const acx = layout.chartArea.x + layout.chartArea.width / 2;
+    const acy = layout.chartArea.y + layout.chartArea.height / 2;
+    const ar = Math.max(layout.chartArea.width, layout.chartArea.height) / 2;
+    areaFillStyle = createCanvasGradientFromColor(ctx, lineColor, { x: acx, y: acy }, ar, layout.chartArea, "vertical");
+  }
+  let dashPattern = [];
+  if (props.lineDash && props.lineDash.length > 0) {
+    dashPattern = props.lineDash;
+  } else if (lineStyle === "dashed") {
+    dashPattern = [lineWidth * 4, lineWidth * 3];
+  } else if (lineStyle === "dotted") {
+    dashPattern = [lineWidth, lineWidth * 2];
+  }
+  withCanvasState(ctx, () => {
+    if (seriesDimOpacity < 1) ctx.globalAlpha = seriesDimOpacity;
+    if (layout.isArea) {
+      ctx.globalAlpha = fillOpacity * seriesDimOpacity;
+      for (const seg of layout.segments) {
+        if (seg.points.length === 0) continue;
+        ctx.fillStyle = seg.style?.segmentFillColor ?? areaFillStyle;
+        ctx.beginPath();
+        const builder = createCanvasLinePathBuilder(ctx);
+        builder.moveTo(seg.points[0].x, seg.points[0].y);
+        traceCurve(builder, seg.points, curve, tension);
+        const hasBaseY = seg.points[0].baseY !== void 0;
+        if (hasBaseY) {
+          const basePoints = reversedBaseEdge(seg.points);
+          builder.lineTo(basePoints[0].x, basePoints[0].y);
+          traceCurve(builder, basePoints, curve, tension);
+        } else {
+          builder.lineTo(seg.points[seg.points.length - 1].x, layout.baselineY);
+          builder.lineTo(seg.points[0].x, layout.baselineY);
+        }
+        builder.closePath();
+        ctx.fill();
+      }
+      ctx.globalAlpha = seriesDimOpacity;
+    }
+    if (borderColor && borderWidth > 0) {
+      const usingLineDash = dashPattern.length > 0;
+      const borderDashPattern = usingLineDash ? dashPattern : seriesBorderDash && seriesBorderDash.length > 0 ? seriesBorderDash : [];
+      const effectiveBorderDashOffset = usingLineDash ? props.lineDashOffset ?? seriesBorderDashOffset : seriesBorderDashOffset;
+      ctx.strokeStyle = borderColor;
+      ctx.lineWidth = lineWidth + borderWidth * 2;
+      ctx.lineCap = props.borderCapStyle ?? props.lineCapStyle ?? "round";
+      ctx.lineJoin = props.borderJoinStyle ?? props.lineJoinStyle ?? "round";
+      ctx.setLineDash(borderDashPattern);
+      if (effectiveBorderDashOffset) ctx.lineDashOffset = effectiveBorderDashOffset;
+      for (const seg of layout.segments) {
+        if (seg.points.length === 0) continue;
+        ctx.beginPath();
+        const builder = createCanvasLinePathBuilder(ctx);
+        builder.moveTo(seg.points[0].x, seg.points[0].y);
+        traceCurve(builder, seg.points, curve, tension);
+        ctx.stroke();
+      }
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+    ctx.lineCap = props.lineCapStyle ?? "round";
+    ctx.lineJoin = props.lineJoinStyle ?? "round";
+    if (props.lineDashOffset) ctx.lineDashOffset = props.lineDashOffset;
+    if (props.segmentColor || props.segmentStrokeWidth || props.segmentDash || props.segmentFillColor) {
+      for (const seg of layout.segments) {
+        if (seg.points.length === 0) continue;
+        ctx.strokeStyle = seg.style?.segmentColor ?? strokeStyle;
+        ctx.lineWidth = seg.style?.segmentStrokeWidth ?? lineWidth;
+        ctx.setLineDash(seg.style?.segmentDash ?? dashPattern);
+        ctx.beginPath();
+        const builder = createCanvasLinePathBuilder(ctx);
+        builder.moveTo(seg.points[0].x, seg.points[0].y);
+        traceCurve(builder, seg.points, curve, tension);
+        ctx.stroke();
+      }
+    } else {
+      ctx.strokeStyle = strokeStyle;
+      ctx.lineWidth = lineWidth;
+      ctx.setLineDash(dashPattern);
+      for (const seg of layout.segments) {
+        if (seg.points.length === 0) continue;
+        ctx.beginPath();
+        const builder = createCanvasLinePathBuilder(ctx);
+        builder.moveTo(seg.points[0].x, seg.points[0].y);
+        traceCurve(builder, seg.points, curve, tension);
+        ctx.stroke();
+      }
+    }
+    ctx.setLineDash([]);
+    const hasCustomRenderMarkerCanvas = !!props.renderMarker;
+    if ((showMarkers || hoveredIndex !== null) && !hasCustomRenderMarkerCanvas) {
+      const anyHovered = hoveredIndex !== null && !!effects;
+      if (resolveBoostActive(props.boost, layout.visiblePoints.length, LINE_BOOST_AUTO_THRESHOLD) && showMarkers && typeof props.markerShape !== "function" && layout.visiblePoints.length > 0) {
+        const firstB = layout.visiblePoints[0];
+        const firstCtxB = makeItemContext(props.data?.[firstB.dataIndex], firstB.dataIndex, { value: firstB.value, category: firstB.category, ...seriesExtras });
+        const seriesShapeB = resolveMarkerShape(firstCtxB, resolveMarkerSize(firstCtxB));
+        if (MARKER_SHAPE_NAMES.has(seriesShapeB)) {
+          const BOOST_CHUNK_SIZE = 5e3;
+          const batches = /* @__PURE__ */ new Map();
+          for (const pt of layout.visiblePoints) {
+            const ptCtxB = makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras });
+            const markerColor = props.pointColors?.[pt.dataIndex] ?? resolveAccessor(props.pointBackgroundColor, ptCtxB, { arrayMode: "cycle" }) ?? lineColor;
+            const key = getPrimaryColor(markerColor);
+            let bucket = batches.get(key);
+            if (!bucket) batches.set(key, bucket = []);
+            bucket.push(pt);
+          }
+          const boostBorderColor = resolveAccessor(props.pointBorderColor, firstCtxB, { arrayMode: "cycle" });
+          const boostBorderWidth = resolveAccessor(props.pointBorderStrokeWidth, firstCtxB, { arrayMode: "clip", fallback: 0 }) ?? 0;
+          for (const [fillColor, pts] of batches) {
+            ctx.globalAlpha = seriesDimOpacity;
+            ctx.fillStyle = fillColor;
+            for (let i = 0; i < pts.length; i += BOOST_CHUNK_SIZE) {
+              ctx.beginPath();
+              for (let j = i, end = Math.min(i + BOOST_CHUNK_SIZE, pts.length); j < end; j++) {
+                const pt = pts[j];
+                traceMarkerShapeCanvasAt(ctx, seriesShapeB, pt.x, pt.y, resolveMarkerSize(makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras })), 0);
+              }
+              ctx.fill();
+            }
+            if (boostBorderWidth > 0) {
+              ctx.strokeStyle = getPrimaryColor(boostBorderColor ?? fillColor);
+              ctx.lineWidth = boostBorderWidth;
+              for (let i = 0; i < pts.length; i += BOOST_CHUNK_SIZE) {
+                ctx.beginPath();
+                for (let j = i, end = Math.min(i + BOOST_CHUNK_SIZE, pts.length); j < end; j++) {
+                  const pt = pts[j];
+                  traceMarkerShapeCanvasAt(ctx, seriesShapeB, pt.x, pt.y, resolveMarkerSize(makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras })), 0);
+                }
+                ctx.stroke();
+              }
+            }
+          }
+          return;
+        }
+      }
+      for (const pt of layout.visiblePoints) {
+        const hoverState = computeItemHoverState(pt.dataIndex, hoveredIndex, anyHovered);
+        if (!showMarkers && !hoverState.isHovered) continue;
+        const pointColor = props.pointColors?.[pt.dataIndex];
+        const ptCtxC = makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras });
+        const baseColor = pointColor ?? resolveAccessor(props.pointBackgroundColor, ptCtxC, { arrayMode: "cycle" }) ?? (typeof lineColor === "string" ? lineColor : "#000");
+        const baseBorderColor = resolveAccessor(props.pointBorderColor, ptCtxC, { arrayMode: "cycle" }) ?? baseColor;
+        const baseBorderWidth = resolveAccessor(props.pointBorderStrokeWidth, ptCtxC, { arrayMode: "clip", fallback: 0 }) ?? 0;
+        const ptHoverBgC = resolveAccessor(props.pointHoverBackgroundColor, ptCtxC, { arrayMode: "cycle" });
+        const ptHoverBorderC = resolveAccessor(props.pointHoverBorderColor, ptCtxC, { arrayMode: "cycle" });
+        const ptHoverBorderWidthC = resolveAccessor(props.pointHoverBorderStrokeWidth, ptCtxC, { arrayMode: "clip" });
+        const effectConfig = effects ? {
+          hoverBrightness: effects.hoverBrightness,
+          dimOpacity: effects.dimOpacity,
+          hoverBackgroundColor: ptHoverBgC ?? effects.hoverBackgroundColor,
+          hoverBorderColor: ptHoverBorderC ?? effects.hoverBorderColor,
+          hoverBorderStrokeWidth: ptHoverBorderWidthC ?? effects.hoverBorderStrokeWidth
+        } : void 0;
+        const effectResult = applyHoverEffects(baseColor, baseBorderColor, baseBorderWidth, props.lineDash, props.lineDashOffset ?? 0, hoverState, effectConfig, context.theme);
+        const ptMarkerSize = resolveMarkerSize(ptCtxC);
+        const currentSize = hoverState.isHovered ? effects?.hoverPointRadius ?? ptMarkerSize * (effects?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : ptMarkerSize;
+        drawMarkerCanvas(ctx, {
+          x: pt.x,
+          y: pt.y,
+          size: currentSize,
+          shape: resolveMarkerShape(ptCtxC, currentSize),
+          fillStyle: effectResult.color,
+          strokeStyle: effectResult.borderColor,
+          lineStrokeWidth: effectResult.borderStrokeWidth,
+          opacity: effectResult.opacity,
+          rotation: resolveMarkerRotation(ptCtxC),
+          lineDash: resolvePointDash(ptCtxC),
+          lineDashOffset: resolvePointDashOffset(ptCtxC),
+          lineJoin: props.pointBorderJoinStyle
+        });
+      }
+    }
+  });
+}
+
+export { renderLineCanvas };

package/dist/chunk-KVDEROP6.mjs

@@ -0,0 +1,59 @@
+import { raf, cancelRaf } from './chunk-EDAKJLNA.mjs';
+
+// src/utils/layout/resize.utils.ts
+var ResizeDebouncer = class {
+  constructor(options) {
+    this.pending = null;
+    this.rafId = null;
+    this.timerId = null;
+    this.delayMs = options?.delayMs ?? 0;
+  }
+  /**
+   * Schedule a dimension update. The callback fires after debounce settles.
+   * Subsequent calls before settlement replace the pending dimensions.
+   */
+  schedule(dims, apply) {
+    if (this.delayMs > 0) {
+      this.pending = dims;
+      if (this.timerId !== null) {
+        clearTimeout(this.timerId);
+      }
+      this.timerId = setTimeout(() => {
+        if (this.pending) {
+          apply(this.pending);
+          this.pending = null;
+        }
+        this.timerId = null;
+      }, this.delayMs);
+    } else {
+      this.pending = dims;
+      if (this.rafId === null) {
+        this.rafId = raf(() => {
+          if (this.pending) {
+            apply(this.pending);
+            this.pending = null;
+          }
+          this.rafId = null;
+        });
+      }
+    }
+  }
+  /** Cancel any pending debounce. Call on unmount. */
+  cancel() {
+    if (this.rafId !== null) {
+      cancelRaf(this.rafId);
+      this.rafId = null;
+    }
+    if (this.timerId !== null) {
+      clearTimeout(this.timerId);
+      this.timerId = null;
+    }
+    this.pending = null;
+  }
+  /** Update debounce options (e.g. when props change). */
+  updateOptions(options) {
+    this.delayMs = options.delayMs ?? 0;
+  }
+};
+
+export { ResizeDebouncer };

package/dist/chunk-LKC7MZKK.mjs

@@ -0,0 +1,87 @@
+import { DEFAULT_SCATTER_HIT_RADIUS, SCATTER_SPATIAL_INDEX_THRESHOLD } from './chunk-NKUYIWAP.mjs';
+import { buildQuadtree } from './chunk-C36VWQ7A.mjs';
+import { getDefaultColor, resolveSwatchColor, asGradient, getPrimaryColor } from './chunk-O2X6FF45.mjs';
+
+// src/cartesian/hittest-wrappers/scatter.ts
+function scatterHitTest(x, y, ctx) {
+  let bestResult = null;
+  let bestDistSq = Infinity;
+  for (const [datasetId, scatterLayout] of ctx.layouts) {
+    if (!ctx.renderPropsCache.has(datasetId)) continue;
+    let hitPoint = null;
+    const layoutDefaultColor = scatterLayout.seriesColor ?? getDefaultColor(scatterLayout.seriesIdx, ctx.theme);
+    const scatterProps = ctx.renderPropsCache.get(datasetId);
+    const configuredHitRadius = scatterProps?.pointHitRadius ?? DEFAULT_SCATTER_HIT_RADIUS;
+    if (scatterLayout.visiblePoints.length > SCATTER_SPATIAL_INDEX_THRESHOLD) {
+      if (!scatterLayout.spatialIndex) {
+        const area = scatterLayout.chartArea;
+        const quadPoints = new Array(scatterLayout.visiblePoints.length);
+        const map = /* @__PURE__ */ new Map();
+        for (let i = 0; i < scatterLayout.visiblePoints.length; i++) {
+          const pt = scatterLayout.visiblePoints[i];
+          quadPoints[i] = { x: pt.px, y: pt.py, idx: pt.dataIndex, r: pt.radius };
+          map.set(pt.dataIndex, pt);
+        }
+        scatterLayout.spatialIndex = buildQuadtree(quadPoints, { x0: area.x, y0: area.y, x1: area.x + area.width, y1: area.y + area.height });
+        scatterLayout.pointByDataIndex = map;
+      }
+      const result = scatterLayout.spatialIndex.queryNearest(x, y, configuredHitRadius);
+      if (result && result.distSq < bestDistSq) {
+        const pt = scatterLayout.pointByDataIndex?.get(result.idx);
+        if (pt) {
+          hitPoint = {
+            dataIndex: pt.dataIndex,
+            px: pt.px,
+            py: pt.py,
+            xValue: pt.xValue,
+            yValue: pt.yValue,
+            sizeValue: pt.sizeValue,
+            color: pt.color ?? layoutDefaultColor,
+            swatchColor: resolveSwatchColor({ color: pt.color ?? scatterLayout.seriesColor }, scatterLayout.seriesIdx, void 0, ctx.theme),
+            distSq: result.distSq
+          };
+        }
+      }
+    } else {
+      for (const pt of scatterLayout.visiblePoints) {
+        const hitRadius = Math.max(configuredHitRadius, pt.radius);
+        const dx = pt.px - x;
+        const dy = pt.py - y;
+        const distSq = dx * dx + dy * dy;
+        if (distSq <= hitRadius * hitRadius && distSq < bestDistSq && (!hitPoint || distSq < hitPoint.distSq)) {
+          hitPoint = {
+            dataIndex: pt.dataIndex,
+            px: pt.px,
+            py: pt.py,
+            xValue: pt.xValue,
+            yValue: pt.yValue,
+            sizeValue: pt.sizeValue,
+            color: pt.color ?? layoutDefaultColor,
+            swatchColor: resolveSwatchColor({ color: pt.color ?? scatterLayout.seriesColor }, scatterLayout.seriesIdx, void 0, ctx.theme),
+            distSq
+          };
+        }
+      }
+    }
+    if (hitPoint && hitPoint.distSq < bestDistSq) {
+      bestDistSq = hitPoint.distSq;
+      const seriesName = ctx.renderPropsCache.get(datasetId)?.name ?? datasetId;
+      bestResult = {
+        datasetId,
+        index: hitPoint.dataIndex,
+        label: seriesName,
+        xValue: hitPoint.xValue,
+        yValue: hitPoint.yValue,
+        ...hitPoint.sizeValue != null ? { bubbleValue: hitPoint.sizeValue } : {},
+        x: hitPoint.px,
+        y: hitPoint.py,
+        color: getPrimaryColor(hitPoint.color),
+        colorGradient: asGradient(hitPoint.color),
+        swatchColor: hitPoint.swatchColor
+      };
+    }
+  }
+  return bestResult;
+}
+
+export { scatterHitTest };