@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-A6ZQZFL2.mjs

@@ -0,0 +1,272 @@
+import { calculateRadiusAndCenter } from './chunk-NPDZLYIF.mjs';
+import { measureText } from './chunk-XTVE4P3L.mjs';
+import { DEFAULT_RADIAL_LABEL_FONT_SIZE, DEFAULT_GRID_LEVELS, resolveFontSize, resolveFontFamily, DEFAULT_RADAR_FILL_OPACITY, DEFAULT_LINE_WIDTH, DEFAULT_RADAR_HIT_RADIUS } from './chunk-NKUYIWAP.mjs';
+import { isGradientColor, resolveSwatchColor, getPrimaryColor, getDefaultColor, batchResolveAccessor, FIELD_DEFAULTS } from './chunk-O2X6FF45.mjs';
+import { calculateNiceDomain, generateNiceTicks, toRad } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/radar/geometry.ts
+function calculateRadarLayout(datasets, chartArea, globalFont, sharedCategories, sharedDomain, perAxisDomains, referenceBoundaryValues, perSpokeDomains, tickCount) {
+  const categories = sharedCategories ?? extractCategories(datasets);
+  const categoryCount = categories.length;
+  const angleStep = categoryCount > 0 ? 360 / categoryCount : 0;
+  const allValues = [];
+  const stackCumulatives = /* @__PURE__ */ new Map();
+  for (const ds of datasets) {
+    if (!ds.visible) continue;
+    if (ds.props.yAxisId) continue;
+    const values = resolveValues(ds.props);
+    const stackId = ds.props.stackId;
+    if (stackId) {
+      if (!stackCumulatives.has(stackId)) {
+        stackCumulatives.set(stackId, new Array(categoryCount).fill(0));
+      }
+      const cumulative = stackCumulatives.get(stackId);
+      for (let ci = 0; ci < categoryCount; ci++) {
+        cumulative[ci] = (cumulative[ci] ?? 0) + (values[ci] ?? 0);
+        allValues.push(cumulative[ci]);
+      }
+    } else {
+      allValues.push(...values);
+    }
+  }
+  if (allValues.length === 0) {
+    for (const ds of datasets) {
+      if (ds.visible) allValues.push(...resolveValues(ds.props));
+    }
+  }
+  const rawDataMax = allValues.length ? Math.max(...allValues) : 0;
+  let [rawDomainMin, rawDomainMax] = sharedDomain ?? calculateNiceDomain(allValues.length ? allValues : [0, 1], { includeZero: true, nice: true });
+  if (referenceBoundaryValues?.length) {
+    for (const v of referenceBoundaryValues) {
+      if (v < rawDomainMin) rawDomainMin = v;
+      if (v > rawDomainMax) rawDomainMax = v;
+    }
+  }
+  const rawDomain = [rawDomainMin, rawDomainMax];
+  const levelValues = generateNiceTicks(rawDomain[0], rawDomain[1], tickCount ?? DEFAULT_GRID_LEVELS);
+  const firstTick = levelValues[0] ?? rawDomain[0];
+  const lastTick = levelValues[levelValues.length - 1] ?? rawDomain[1];
+  const domain = [Math.min(rawDomain[0], firstTick), Math.max(rawDomain[1], lastTick)];
+  const resolvedLabelFontSize = resolveFontSize(DEFAULT_RADIAL_LABEL_FONT_SIZE, globalFont);
+  const resolvedFontFamily = resolveFontFamily(void 0, globalFont);
+  const labelPadding = measureText("Xg", resolvedLabelFontSize).height;
+  const labelMargins = calculateLabelMargins(categories, angleStep, labelPadding, resolvedLabelFontSize);
+  const adjustedArea = {
+    x: chartArea.x + labelMargins.left,
+    y: chartArea.y + labelMargins.top,
+    width: Math.max(0, chartArea.width - labelMargins.left - labelMargins.right),
+    height: Math.max(0, chartArea.height - labelMargins.top - labelMargins.bottom)
+  };
+  const { center, radius } = calculateRadiusAndCenter(adjustedArea);
+  const levelRadii = levelValues.map((v) => {
+    if (domain[1] === domain[0]) return 0;
+    return (v - domain[0]) / (domain[1] - domain[0]) * radius;
+  });
+  const grid = {
+    shape: "polygon",
+    levels: levelValues.length,
+    levelValues,
+    levelRadii
+  };
+  const spokeEndpoints = [];
+  for (let i = 0; i < categoryCount; i++) {
+    const angleDeg = -90 + i * angleStep;
+    const angleRad = toRad(angleDeg);
+    spokeEndpoints.push({
+      x: center.x + Math.cos(angleRad) * radius,
+      y: center.y + Math.sin(angleRad) * radius
+    });
+  }
+  const series = [];
+  const stackRunning = /* @__PURE__ */ new Map();
+  for (let si = 0; si < datasets.length; si++) {
+    const ds = datasets[si];
+    const gradientColor = ds.props.color && isGradientColor(ds.props.color) ? ds.props.color : void 0;
+    const color = typeof ds.props.color === "string" ? ds.props.color : void 0;
+    const fillOpacity = ds.props.fillOpacity ?? DEFAULT_RADAR_FILL_OPACITY;
+    const lineWidth = ds.props.lineStrokeWidth ?? DEFAULT_LINE_WIDTH;
+    const lineStyle = ds.props.lineStyle;
+    const lineDash = ds.props.lineDash;
+    const curve = ds.props.curve;
+    const stackId = ds.props.stackId;
+    const values = resolveValues(ds.props);
+    const points = [];
+    const basePoints = [];
+    const isStacked = !!stackId;
+    if (isStacked && !stackRunning.has(stackId)) {
+      stackRunning.set(stackId, new Array(categoryCount).fill(0));
+    }
+    const cumulative = isStacked ? stackRunning.get(stackId) : null;
+    const yAxisId = ds.props.yAxisId;
+    const axisOverride = yAxisId ? perAxisDomains?.get(yAxisId) : void 0;
+    const seriesDomain = axisOverride ?? domain;
+    for (let ci = 0; ci < categoryCount; ci++) {
+      const rawValue = values[ci] ?? 0;
+      const baseValue = isStacked ? cumulative[ci] ?? 0 : 0;
+      const topValue = baseValue + rawValue;
+      const [sMin, sMax] = perSpokeDomains?.get(ci) ?? seriesDomain;
+      const domainSpan = sMax - sMin;
+      const angleDeg = -90 + ci * angleStep;
+      const angleRad = toRad(angleDeg);
+      const topR = domainSpan === 0 ? 0 : Math.max(0, (topValue - sMin) / domainSpan) * radius;
+      const baseR = domainSpan === 0 ? 0 : Math.max(0, (baseValue - sMin) / domainSpan) * radius;
+      points.push({
+        x: center.x + Math.cos(angleRad) * topR,
+        y: center.y + Math.sin(angleRad) * topR,
+        value: rawValue,
+        angle: angleDeg,
+        categoryIndex: ci
+      });
+      if (isStacked) {
+        basePoints.push({
+          x: center.x + Math.cos(angleRad) * baseR,
+          y: center.y + Math.sin(angleRad) * baseR,
+          value: baseValue,
+          angle: angleDeg,
+          categoryIndex: ci
+        });
+      }
+    }
+    if (isStacked && ds.visible) {
+      for (let ci = 0; ci < categoryCount; ci++) {
+        cumulative[ci] = (cumulative[ci] ?? 0) + (values[ci] ?? 0);
+      }
+    }
+    series.push({
+      id: ds.id,
+      name: ds.props.name,
+      points,
+      basePoints: isStacked ? basePoints : void 0,
+      color,
+      seriesIdx: si,
+      gradientColor,
+      fillOpacity,
+      lineStrokeWidth: lineWidth,
+      lineStyle,
+      lineDash,
+      curve,
+      visible: ds.visible
+    });
+  }
+  return {
+    center,
+    radius,
+    categories,
+    angleStep,
+    domain,
+    grid,
+    series,
+    spokeEndpoints,
+    chartArea,
+    labelPadding,
+    labelFontSize: resolvedLabelFontSize,
+    fontFamily: resolvedFontFamily,
+    rawDataMax,
+    perSpokeDomains: perSpokeDomains ?? null
+  };
+}
+function hitTestRadar(x, y, layout, theme) {
+  let closest = null;
+  let minDist = DEFAULT_RADAR_HIT_RADIUS;
+  for (const sd of layout.series) {
+    if (!sd.visible) continue;
+    for (let pi = 0; pi < sd.points.length; pi++) {
+      const pt = sd.points[pi];
+      const dx = x - pt.x;
+      const dy = y - pt.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < minDist) {
+        minDist = dist;
+        closest = {
+          datasetId: sd.id,
+          index: pi,
+          label: layout.categories[pi] ?? "",
+          value: pt.value,
+          color: sd.color ?? (sd.gradientColor ? getPrimaryColor(sd.gradientColor) : getDefaultColor(sd.seriesIdx, theme)),
+          colorGradient: sd.gradientColor,
+          swatchColor: resolveSwatchColor({ color: sd.color ?? sd.gradientColor }, sd.seriesIdx, void 0, theme)
+        };
+      }
+    }
+  }
+  return closest;
+}
+function extractCategories(datasets) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ds of datasets) {
+    const props = ds.props;
+    if (!props.data) continue;
+    const cats = batchResolveAccessor(props.categoryField ?? FIELD_DEFAULTS.categoryField, props.data);
+    for (const cat of cats) {
+      const str = String(cat);
+      if (!seen.has(str)) {
+        seen.add(str);
+        result.push(str);
+      }
+    }
+  }
+  return result;
+}
+function resolveValues(props) {
+  if (!props.data) return [];
+  return batchResolveAccessor(props.valueField ?? FIELD_DEFAULTS.valueField, props.data).map((v) => Number(v) || 0);
+}
+function computeRadialComboContext(radarDatasets, polarDatasets) {
+  const allEntries = [...radarDatasets, ...polarDatasets];
+  const categories = extractCategories(allEntries);
+  const allValues = [];
+  for (const ds of allEntries) {
+    allValues.push(...resolveValues(ds.props));
+  }
+  const domain = calculateNiceDomain(allValues, { includeZero: true, nice: true });
+  return { categories, domain };
+}
+function getCategoryLabelAnchor(angleDeg) {
+  const cosA = Math.cos(toRad(angleDeg));
+  if (cosA > 0.15) return "start";
+  if (cosA < -0.15) return "end";
+  return "middle";
+}
+function calculateLabelMargins(categories, angleStep, labelPadding, fontSize = DEFAULT_RADIAL_LABEL_FONT_SIZE) {
+  let top = 0;
+  let right = 0;
+  let bottom = 0;
+  let left = 0;
+  for (let i = 0; i < categories.length; i++) {
+    const angleDeg = -90 + i * angleStep;
+    const angleRad = toRad(angleDeg);
+    const cosA = Math.cos(angleRad);
+    const sinA = Math.sin(angleRad);
+    const { width: textWidth, height: textHeight } = measureText(categories[i], fontSize);
+    const halfH = textHeight / 2;
+    const dx = cosA * labelPadding;
+    const dy = sinA * labelPadding;
+    const anchor = getCategoryLabelAnchor(angleDeg);
+    let textExtentRight;
+    let textExtentLeft;
+    if (anchor === "start") {
+      textExtentRight = textWidth;
+      textExtentLeft = 0;
+    } else if (anchor === "end") {
+      textExtentRight = 0;
+      textExtentLeft = textWidth;
+    } else {
+      textExtentRight = textWidth / 2;
+      textExtentLeft = textWidth / 2;
+    }
+    right = Math.max(right, dx + textExtentRight);
+    left = Math.max(left, -dx + textExtentLeft);
+    bottom = Math.max(bottom, dy + halfH);
+    top = Math.max(top, -dy + halfH);
+  }
+  const buffer = 4;
+  return {
+    top: Math.max(top, 0) + buffer,
+    right: Math.max(right, 0) + buffer,
+    bottom: Math.max(bottom, 0) + buffer,
+    left: Math.max(left, 0) + buffer
+  };
+}
+
+export { calculateLabelMargins, calculateRadarLayout, computeRadialComboContext, extractCategories, getCategoryLabelAnchor, hitTestRadar, resolveValues };

package/dist/chunk-ADKLH73T.mjs

@@ -0,0 +1 @@
+

package/dist/chunk-AGU3NG6D.mjs

@@ -0,0 +1,22 @@
+// src/animations/drilldown.ts
+function computeZoomTransform(origin, target, progress) {
+  const x = origin.x + (target.x - origin.x) * progress;
+  const y = origin.y + (target.y - origin.y) * progress;
+  const w = origin.width + (target.width - origin.width) * progress;
+  const h = origin.height + (target.height - origin.height) * progress;
+  const sx = w / target.width;
+  const sy = h / target.height;
+  const tx = x - target.x * sx;
+  const ty = y - target.y * sy;
+  return { tx, ty, sx, sy };
+}
+function computeDrillOutOrigin(area, ratio = 0.15) {
+  return {
+    x: area.x + area.width * ratio,
+    y: area.y + area.height * ratio,
+    width: area.width * (1 - 2 * ratio),
+    height: area.height * (1 - 2 * ratio)
+  };
+}
+
+export { computeDrillOutOrigin, computeZoomTransform };

package/dist/chunk-AHYIS6EB.mjs

@@ -0,0 +1,230 @@
+import { DEFAULT_MARKER_SHAPE } from './chunk-AP3UYWYT.mjs';
+import { isBoostActive } from './chunk-DTWTCFRG.mjs';
+import { traceMarkerShapeCanvasAt, MARKER_SHAPE_NAMES, drawMarkerCanvas } from './chunk-PRDVPOZX.mjs';
+import { computeItemHoverState, applyHoverEffects } from './chunk-BZN2QHGP.mjs';
+import { DEFAULT_HOVER_DIM_OPACITY, DEFAULT_SCATTER_FILL_OPACITY, DEFAULT_SCATTER_BORDER_WIDTH, DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER } from './chunk-NKUYIWAP.mjs';
+import { resolveAccessor, makeItemContext, getDefaultColor, getPrimaryColor, isGradientColor, createCanvasGradientFromColor, resolveDash } from './chunk-O2X6FF45.mjs';
+
+// src/series/scatter/canvas/index.ts
+function renderScatterCanvas(props, layout, ctx, context) {
+  const isSeriesDimmed = props.interaction?.isSeriesDimmed ?? false;
+  const effects = props.effects;
+  const seriesDimOpacity = (isSeriesDimmed ? effects?.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY : 1) * (props.animationOpacity ?? 1);
+  const enterGlobalAlpha = ctx.globalAlpha;
+  const boostActive = isBoostActive(props, layout.visiblePoints.length);
+  const seriesExtras = { seriesIndex: layout.seriesIdx, seriesId: props.id ?? "" };
+  const scatterDataArrCanvas = props.data;
+  const resolveMarkerShape = (i, size, value, category) => resolveAccessor(props.markerShape, makeItemContext(scatterDataArrCanvas[i], i, { size, value, category, ...seriesExtras }), { arrayMode: "clip" }) ?? DEFAULT_MARKER_SHAPE;
+  const seriesLevelMarkerShape = resolveAccessor(props.markerShape, makeItemContext(scatterDataArrCanvas[0], 0, { size: 0, value: layout.points[0]?.yValue, category: layout.points[0] ? String(layout.points[0].xValue) : void 0, ...seriesExtras }), {
+    arrayMode: "clip"
+  }) ?? DEFAULT_MARKER_SHAPE;
+  const hoveredIndex = boostActive ? null : props.interaction?.hoveredIndex ?? null;
+  const anyHovered = hoveredIndex !== null;
+  const effectiveSeriesColor = layout.seriesColor ?? getDefaultColor(layout.seriesIdx, context.theme);
+  const baseBorderColorShared = props.pointBorderColor != null ? props.pointBorderColor : void 0;
+  const borderWidthAccessor = props.pointBorderStrokeWidth;
+  const dataArr = props.data;
+  const resolveBorderWidth = (i, value, category) => resolveAccessor(borderWidthAccessor, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "clip", fallback: DEFAULT_SCATTER_BORDER_WIDTH }) ?? DEFAULT_SCATTER_BORDER_WIDTH;
+  const resolvePointDash = (i, value, category) => resolveDash(props.pointBorderDash, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }));
+  const resolvePointDashOffset = (i, value, category) => resolveAccessor(props.pointBorderDashOffset, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolvePointOpacity = (i, value, category) => resolveAccessor(props.opacity, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "clip" });
+  const resolvePtHoverBgC = (i, value, category) => resolveAccessor(props.pointHoverBackgroundColor, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "cycle" });
+  const resolvePtHoverBorderC = (i, value, category) => resolveAccessor(props.pointHoverBorderColor, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "cycle" });
+  const resolvePtHoverBorderWidthC = (i, value, category) => resolveAccessor(props.pointHoverBorderStrokeWidth, makeItemContext(dataArr[i], i, { value, category, ...seriesExtras }), { arrayMode: "clip" });
+  const fillOpacity = props.pointFillOpacity ?? DEFAULT_SCATTER_FILL_OPACITY;
+  const baseEffectConfig = boostActive || !effects ? void 0 : {
+    hoverBrightness: effects.hoverBrightness,
+    dimOpacity: effects.dimOpacity,
+    hoverBackgroundColor: effects.hoverBackgroundColor,
+    hoverBorderColor: effects.hoverBorderColor,
+    hoverBorderStrokeWidth: effects.hoverBorderStrokeWidth
+  };
+  const needsHoverCalc = anyHovered || baseEffectConfig;
+  if (boostActive && !props.renderMarker && typeof seriesLevelMarkerShape !== "function") {
+    const BOOST_CHUNK_SIZE = 5e3;
+    const resolvedShape = seriesLevelMarkerShape;
+    const baseAlphaFill = seriesDimOpacity * fillOpacity;
+    const batches = /* @__PURE__ */ new Map();
+    for (const pt of layout.visiblePoints) {
+      const c = getPrimaryColor(pt.color ?? effectiveSeriesColor);
+      let bucket = batches.get(c);
+      if (!bucket) batches.set(c, bucket = []);
+      bucket.push(pt);
+    }
+    for (const [fillColor, pts] of batches) {
+      ctx.globalAlpha = baseAlphaFill;
+      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, resolvedShape, pt.px, pt.py, pt.radius, pt.rotation);
+        }
+        ctx.fill();
+      }
+      const boostBorderWidth = pts.length > 0 ? resolveBorderWidth(pts[0].dataIndex, pts[0].yValue, String(pts[0].xValue)) : DEFAULT_SCATTER_BORDER_WIDTH;
+      if (boostBorderWidth > 0) {
+        const strokeColor = baseBorderColorShared ? getPrimaryColor(baseBorderColorShared) : fillColor;
+        ctx.globalAlpha = seriesDimOpacity;
+        ctx.strokeStyle = strokeColor;
+        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, resolvedShape, pt.px, pt.py, pt.radius, pt.rotation);
+          }
+          ctx.stroke();
+        }
+      }
+    }
+    ctx.globalAlpha = enterGlobalAlpha;
+    return;
+  }
+  const markerShapeIsScalar = typeof props.markerShape === "string" || props.markerShape === void 0;
+  const opacityIsScalar = typeof props.opacity === "number" || props.opacity === void 0;
+  if (!props.renderMarker && MARKER_SHAPE_NAMES.has(seriesLevelMarkerShape) && !isGradientColor(effectiveSeriesColor) && markerShapeIsScalar && opacityIsScalar) {
+    const CHUNK = 5e3;
+    const resolvedShape = seriesLevelMarkerShape;
+    const baseStrokeStr = baseBorderColorShared ? getPrimaryColor(baseBorderColorShared) : null;
+    const dimMult = anyHovered && baseEffectConfig ? baseEffectConfig.dimOpacity ?? 1 : 1;
+    const userScalarOpacity = typeof props.opacity === "number" ? props.opacity : 1;
+    const normalFillAlpha = dimMult * seriesDimOpacity * fillOpacity * userScalarOpacity;
+    const normalStrokeAlpha = dimMult * seriesDimOpacity * userScalarOpacity;
+    const colorBatches = /* @__PURE__ */ new Map();
+    let hoveredPt = null;
+    for (const pt of layout.visiblePoints) {
+      if (hoveredIndex !== null && pt.dataIndex === hoveredIndex) {
+        hoveredPt = pt;
+      } else {
+        const c = getPrimaryColor(pt.color ?? effectiveSeriesColor);
+        let bucket = colorBatches.get(c);
+        if (!bucket) colorBatches.set(c, bucket = []);
+        bucket.push(pt);
+      }
+    }
+    for (const [color, pts] of colorBatches) {
+      ctx.globalAlpha = normalFillAlpha;
+      ctx.fillStyle = color;
+      for (let i = 0; i < pts.length; i += CHUNK) {
+        ctx.beginPath();
+        for (let j = i, end = Math.min(i + CHUNK, pts.length); j < end; j++) {
+          const pt = pts[j];
+          traceMarkerShapeCanvasAt(ctx, resolvedShape, pt.px, pt.py, pt.radius, pt.rotation);
+        }
+        ctx.fill();
+      }
+    }
+    const batchBorderWidth = layout.points.length > 0 ? resolveBorderWidth(layout.points[0].dataIndex, layout.points[0].yValue, String(layout.points[0].xValue)) : DEFAULT_SCATTER_BORDER_WIDTH;
+    if (batchBorderWidth > 0) {
+      for (const [color, pts] of colorBatches) {
+        ctx.globalAlpha = normalStrokeAlpha;
+        ctx.strokeStyle = baseStrokeStr ?? color;
+        ctx.lineWidth = batchBorderWidth;
+        for (let i = 0; i < pts.length; i += CHUNK) {
+          ctx.beginPath();
+          for (let j = i, end = Math.min(i + CHUNK, pts.length); j < end; j++) {
+            const pt = pts[j];
+            traceMarkerShapeCanvasAt(ctx, resolvedShape, pt.px, pt.py, pt.radius, pt.rotation);
+          }
+          ctx.stroke();
+        }
+      }
+    }
+    if (hoveredPt) {
+      const hpt = hoveredPt;
+      const hoverState = computeItemHoverState(hpt.dataIndex, hoveredIndex, anyHovered);
+      const hptColor = hpt.color ?? effectiveSeriesColor;
+      const ptHoverBgB = resolvePtHoverBgC(hpt.dataIndex, hpt.yValue, String(hpt.xValue));
+      const ptHoverBorderB = resolvePtHoverBorderC(hpt.dataIndex, hpt.yValue, String(hpt.xValue));
+      const ptHoverBorderWidthB = resolvePtHoverBorderWidthC(hpt.dataIndex, hpt.yValue, String(hpt.xValue));
+      const hoverEffectConfig = baseEffectConfig ? {
+        ...baseEffectConfig,
+        hoverBackgroundColor: ptHoverBgB ?? baseEffectConfig.hoverBackgroundColor,
+        hoverBorderColor: ptHoverBorderB ?? baseEffectConfig.hoverBorderColor,
+        hoverBorderStrokeWidth: ptHoverBorderWidthB ?? baseEffectConfig.hoverBorderStrokeWidth
+      } : void 0;
+      const er = applyHoverEffects(hptColor, baseBorderColorShared ?? getPrimaryColor(hptColor), resolveBorderWidth(hpt.dataIndex, hpt.yValue, String(hpt.xValue)), void 0, 0, hoverState, hoverEffectConfig, context.theme);
+      const hSize = effects?.hoverPointRadius ?? hpt.radius * (effects?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER);
+      const hFill = isGradientColor(er.color) ? createCanvasGradientFromColor(ctx, er.color, { x: 0, y: 0 }, hSize, {
+        x: layout.chartArea.x - hpt.px,
+        y: layout.chartArea.y - hpt.py,
+        width: layout.chartArea.width,
+        height: layout.chartArea.height
+      }) : er.color;
+      ctx.globalAlpha = er.opacity * seriesDimOpacity;
+      ctx.fillStyle = hFill;
+      ctx.beginPath();
+      traceMarkerShapeCanvasAt(ctx, resolvedShape, hpt.px, hpt.py, hSize, hpt.rotation);
+      ctx.fill();
+      if (er.borderStrokeWidth > 0) {
+        ctx.globalAlpha = er.opacity * seriesDimOpacity;
+        ctx.strokeStyle = getPrimaryColor(er.borderColor);
+        ctx.lineWidth = er.borderStrokeWidth;
+        ctx.beginPath();
+        traceMarkerShapeCanvasAt(ctx, resolvedShape, hpt.px, hpt.py, hSize, hpt.rotation);
+        ctx.stroke();
+      }
+    }
+    ctx.globalAlpha = enterGlobalAlpha;
+    return;
+  }
+  for (const pt of layout.visiblePoints) {
+    const baseColor = pt.color ?? effectiveSeriesColor;
+    const baseBorderColor = baseBorderColorShared ?? getPrimaryColor(baseColor);
+    const ptBorderWidth = resolveBorderWidth(pt.dataIndex, pt.yValue, String(pt.xValue));
+    let fillColor = baseColor;
+    let strokeColor = baseBorderColor;
+    let strokeWidth = ptBorderWidth;
+    let opacity = 1;
+    let isHovered = false;
+    if (needsHoverCalc) {
+      const hoverState = computeItemHoverState(pt.dataIndex, hoveredIndex, anyHovered);
+      const ptHoverBgN = resolvePtHoverBgC(pt.dataIndex, pt.yValue, String(pt.xValue));
+      const ptHoverBorderN = resolvePtHoverBorderC(pt.dataIndex, pt.yValue, String(pt.xValue));
+      const ptHoverBorderWidthN = resolvePtHoverBorderWidthC(pt.dataIndex, pt.yValue, String(pt.xValue));
+      const effectConfig = baseEffectConfig ? {
+        ...baseEffectConfig,
+        hoverBackgroundColor: ptHoverBgN ?? baseEffectConfig.hoverBackgroundColor,
+        hoverBorderColor: ptHoverBorderN ?? baseEffectConfig.hoverBorderColor,
+        hoverBorderStrokeWidth: ptHoverBorderWidthN ?? baseEffectConfig.hoverBorderStrokeWidth
+      } : void 0;
+      const effectResult = applyHoverEffects(baseColor, baseBorderColor, ptBorderWidth, void 0, 0, hoverState, effectConfig, context.theme);
+      fillColor = effectResult.color;
+      strokeColor = effectResult.borderColor;
+      strokeWidth = effectResult.borderStrokeWidth;
+      opacity = effectResult.opacity;
+      isHovered = hoverState.isHovered;
+    }
+    const currentSize = isHovered ? effects?.hoverPointRadius ?? pt.radius * (effects?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : pt.radius;
+    const pointFillOpacity = isHovered ? 1 : fillOpacity;
+    const userOpacity = resolvePointOpacity(pt.dataIndex, pt.yValue, String(pt.xValue));
+    if (userOpacity !== void 0) opacity *= userOpacity;
+    if (!props.renderMarker) {
+      const gradientFill = isGradientColor(fillColor) ? createCanvasGradientFromColor(ctx, fillColor, { x: 0, y: 0 }, currentSize, {
+        x: layout.chartArea.x - pt.px,
+        y: layout.chartArea.y - pt.py,
+        width: layout.chartArea.width,
+        height: layout.chartArea.height
+      }) : fillColor;
+      drawMarkerCanvas(ctx, {
+        x: pt.px,
+        y: pt.py,
+        size: currentSize,
+        shape: resolveMarkerShape(pt.dataIndex, currentSize, pt.yValue, String(pt.xValue)),
+        fillStyle: gradientFill,
+        strokeStyle: getPrimaryColor(strokeColor),
+        lineStrokeWidth: strokeWidth,
+        opacity: opacity * seriesDimOpacity,
+        fillOpacity: pointFillOpacity,
+        rotation: pt.rotation,
+        lineDash: resolvePointDash(pt.dataIndex, pt.yValue, String(pt.xValue)),
+        lineDashOffset: resolvePointDashOffset(pt.dataIndex, pt.yValue, String(pt.xValue)),
+        lineJoin: props.pointBorderJoinStyle
+      });
+    }
+  }
+  ctx.globalAlpha = enterGlobalAlpha;
+}
+
+export { renderScatterCanvas };

package/dist/chunk-AP3UYWYT.mjs

@@ -0,0 +1,4 @@
+// src/series/scatter/shared.ts
+var DEFAULT_MARKER_SHAPE = "circle";
+
+export { DEFAULT_MARKER_SHAPE };