@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-DP2IZNN3.mjs

@@ -0,0 +1,92 @@
+import { toTimestamp } from './chunk-RQ3CKQOX.mjs';
+
+// src/cartesian/hittest.ts
+function resolveValueAxisId(barProps, layoutData) {
+  if (barProps.yAxisId) return barProps.yAxisId;
+  const firstId = layoutData.valueScales.keys().next().value;
+  return firstId ?? "default";
+}
+function resolveValueAxisFormat(barProps, orientation, layoutData) {
+  if (!layoutData) return null;
+  const axisId = resolveValueAxisId(barProps, layoutData);
+  const valAxisKey = orientation === "vertical" ? `y:${axisId}` : `x:${axisId}`;
+  const valAxisInfo = layoutData.axisLayouts.get(valAxisKey);
+  return typeof valAxisInfo?.props?.tickFormat === "function" ? valAxisInfo.props.tickFormat : null;
+}
+function formatHitValue(value, barProps, orientation, layoutData) {
+  const tickFmt = resolveValueAxisFormat(barProps, orientation, layoutData);
+  return tickFmt ? tickFmt(value) : String(value);
+}
+function formatCursorValue(cursorX, cursorY, barProps, orientation, layoutData) {
+  if (!layoutData) return "";
+  const axisId = resolveValueAxisId(barProps, layoutData);
+  const valueScale = layoutData.valueScales.get(axisId);
+  if (!valueScale) return "";
+  const cursorPixel = orientation === "vertical" ? cursorY : cursorX;
+  const cursorValue = valueScale.invert(cursorPixel);
+  const tickFmt = resolveValueAxisFormat(barProps, orientation, layoutData);
+  const rounded = Math.round(cursorValue);
+  return tickFmt ? tickFmt(rounded) : String(rounded);
+}
+var TOOLTIP_DATE_FORMAT = {
+  weekday: "long",
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: true
+};
+var TOOLTIP_DATE_ONLY_FORMAT = {
+  weekday: "long",
+  year: "numeric",
+  month: "short",
+  day: "numeric"
+};
+var TOOLTIP_SECONDS_SPAN_MS = 10 * 60 * 1e3;
+var TOOLTIP_TIME_SECONDS_FORMAT = {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: true
+};
+var _tooltipDateFmt = null;
+var _tooltipDateOnlyFmt = null;
+var _tooltipSecondsFmt = null;
+var _tooltipFmtTimezone;
+var _tooltipFmtLocale;
+function formatTimeLabel(rawLabel, layoutData, locale) {
+  if (!layoutData?.sharedTimeScale) return rawLabel;
+  const ts = toTimestamp(rawLabel);
+  if (isNaN(ts)) return rawLabel;
+  const tz = layoutData.timeAxisTimezone;
+  const d = new Date(ts);
+  const isMidnight = d.getUTCHours() === 0 && d.getUTCMinutes() === 0 && d.getUTCSeconds() === 0 && d.getUTCMilliseconds() === 0;
+  if (tz !== _tooltipFmtTimezone || locale !== _tooltipFmtLocale) {
+    _tooltipDateFmt = null;
+    _tooltipDateOnlyFmt = null;
+    _tooltipSecondsFmt = null;
+    _tooltipFmtTimezone = tz;
+    _tooltipFmtLocale = locale;
+  }
+  const [minTs, maxTs] = layoutData.sharedTimeScale.domain();
+  const spanMs = maxTs - minTs;
+  if (spanMs > 0 && spanMs <= TOOLTIP_SECONDS_SPAN_MS) {
+    if (!_tooltipSecondsFmt) {
+      _tooltipSecondsFmt = new Intl.DateTimeFormat(locale, { timeZone: tz ?? "UTC", ...TOOLTIP_TIME_SECONDS_FORMAT });
+    }
+    return _tooltipSecondsFmt.format(d);
+  }
+  if (isMidnight) {
+    if (!_tooltipDateOnlyFmt) {
+      _tooltipDateOnlyFmt = new Intl.DateTimeFormat(locale, { timeZone: tz ?? "UTC", ...TOOLTIP_DATE_ONLY_FORMAT });
+    }
+    return _tooltipDateOnlyFmt.format(d);
+  }
+  if (!_tooltipDateFmt) {
+    _tooltipDateFmt = new Intl.DateTimeFormat(locale, { timeZone: tz ?? "UTC", ...TOOLTIP_DATE_FORMAT });
+  }
+  return _tooltipDateFmt.format(d);
+}
+
+export { formatCursorValue, formatHitValue, formatTimeLabel, resolveValueAxisFormat, resolveValueAxisId };

package/dist/chunk-DTWTCFRG.mjs

@@ -0,0 +1,119 @@
+import { resolveBoostActive } from './chunk-PRDVPOZX.mjs';
+import { SCATTER_BOOST_AUTO_THRESHOLD, DEFAULT_MIN_BUBBLE_SIZE, DEFAULT_MAX_BUBBLE_SIZE, DEFAULT_SCATTER_MARKER_SIZE, DEFAULT_SCATTER_HIT_RADIUS, SCATTER_SPATIAL_INDEX_THRESHOLD } from './chunk-NKUYIWAP.mjs';
+import { buildQuadtree } from './chunk-C36VWQ7A.mjs';
+import { batchResolveAccessor, resolveAccessor, makeItemContext } from './chunk-O2X6FF45.mjs';
+
+// src/series/scatter/geometry.ts
+function isBoostActive(props, visibleCount) {
+  return resolveBoostActive(props.boost, visibleCount, SCATTER_BOOST_AUTO_THRESHOLD);
+}
+function calculateScatterLayout(props, chartArea, config) {
+  const { data = [] } = props;
+  const { xScale, yScale, stackBases } = config ?? { xScale: void 0, yScale: void 0, stackBases: void 0 };
+  const markerSizeAccessor = props.markerSize;
+  const minSize = props.minSize ?? DEFAULT_MIN_BUBBLE_SIZE;
+  const maxSize = props.maxSize ?? DEFAULT_MAX_BUBBLE_SIZE;
+  const seriesIdx = props.order ?? 0;
+  const seriesExtras = { seriesIndex: seriesIdx, seriesId: props.id ?? "" };
+  const xValues = batchResolveAccessor(props.xField, data);
+  const yValues = batchResolveAccessor(props.yField, data);
+  const seriesColor = props.color != null && data.length > 0 ? resolveAccessor(props.color, makeItemContext(data[0], 0, { value: yValues[0], category: String(xValues[0]), ...seriesExtras })) : void 0;
+  let sizeValues;
+  let sizeMin = Infinity;
+  let sizeMax = -Infinity;
+  if (props.sizeField) {
+    sizeValues = batchResolveAccessor(props.sizeField, data);
+    for (const s of sizeValues) {
+      if (s != null && !isNaN(s)) {
+        if (s < sizeMin) sizeMin = s;
+        if (s > sizeMax) sizeMax = s;
+      }
+    }
+    if (sizeMin === sizeMax) {
+      sizeMin = 0;
+      sizeMax = sizeMax || 1;
+    }
+  }
+  const treatNullAsZero = props.connectNulls === "zero";
+  const colorAccessor = props.color;
+  const rotationAccessor = props.pointRotation;
+  const points = data.map((item, i) => {
+    const rawX = xValues[i];
+    const rawY = yValues[i];
+    const xVal = (rawX == null || isNaN(rawX)) && treatNullAsZero ? 0 : rawX;
+    const yVal = (rawY == null || isNaN(rawY)) && treatNullAsZero ? 0 : rawY;
+    const visible = props.visibility ? props.visibility.get(i) !== false : true;
+    const stackBase = stackBases?.[i] ?? 0;
+    const px = xScale(xVal);
+    const py = yScale(yVal == null || typeof yVal === "number" && isNaN(yVal) ? yVal : stackBase + yVal);
+    const ctx = makeItemContext(item, i, { value: yVal, category: String(xVal), ...seriesExtras });
+    let radius = resolveAccessor(markerSizeAccessor, ctx, { arrayMode: "clip", fallback: DEFAULT_SCATTER_MARKER_SIZE }) ?? DEFAULT_SCATTER_MARKER_SIZE;
+    if (sizeValues) {
+      const sizeVal = sizeValues[i];
+      if (sizeVal != null && !isNaN(sizeVal)) {
+        const normalized = (sizeVal - sizeMin) / (sizeMax - sizeMin);
+        radius = Math.sqrt(normalized) * (maxSize - minSize) + minSize;
+      }
+    }
+    const rotation = resolveAccessor(rotationAccessor, ctx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+    let color;
+    if (colorAccessor != null) {
+      const resolved = resolveAccessor(colorAccessor, ctx);
+      if (resolved != null) color = resolved;
+    }
+    return {
+      dataIndex: i,
+      px,
+      py,
+      xValue: xVal,
+      yValue: yVal,
+      radius,
+      rotation,
+      ...sizeValues ? { sizeValue: sizeValues[i] } : {},
+      color,
+      visible
+    };
+  });
+  const visiblePoints = points.filter((p) => p.visible && !isNaN(p.px) && !isNaN(p.py) && isFinite(p.px) && isFinite(p.py));
+  return {
+    datasetId: "",
+    points,
+    visiblePoints,
+    chartArea,
+    seriesColor,
+    seriesIdx
+  };
+}
+function hitTestScatter(x, y, _props, layout) {
+  const baseRadius = _props.pointHitRadius ?? DEFAULT_SCATTER_HIT_RADIUS;
+  if (layout.visiblePoints.length > SCATTER_SPATIAL_INDEX_THRESHOLD) {
+    if (!layout.spatialIndex) {
+      const area = layout.chartArea;
+      const quadPoints = new Array(layout.visiblePoints.length);
+      const map = /* @__PURE__ */ new Map();
+      for (let i = 0; i < layout.visiblePoints.length; i++) {
+        const pt = layout.visiblePoints[i];
+        quadPoints[i] = { x: pt.px, y: pt.py, idx: pt.dataIndex, r: pt.radius };
+        map.set(pt.dataIndex, pt);
+      }
+      layout.spatialIndex = buildQuadtree(quadPoints, { x0: area.x, y0: area.y, x1: area.x + area.width, y1: area.y + area.height });
+      layout.pointByDataIndex = map;
+    }
+    return layout.spatialIndex.queryNearest(x, y, baseRadius)?.idx ?? null;
+  }
+  let nearestIndex = null;
+  let minDistSq = Infinity;
+  for (const pt of layout.visiblePoints) {
+    const hitRadius = Math.max(baseRadius, pt.radius);
+    const dx = pt.px - x;
+    const dy = pt.py - y;
+    const distSq = dx * dx + dy * dy;
+    if (distSq <= hitRadius * hitRadius && distSq < minDistSq) {
+      minDistSq = distSq;
+      nearestIndex = pt.dataIndex;
+    }
+  }
+  return nearestIndex;
+}
+
+export { calculateScatterLayout, hitTestScatter, isBoostActive };

package/dist/chunk-EAMUNLRU.mjs

@@ -0,0 +1,172 @@
+// src/renderers/navigator/canvas.ts
+function traceRoundedRect(ctx, x, y, w, h, r) {
+  const mr = Math.min(r, w / 2, h / 2);
+  ctx.beginPath();
+  ctx.moveTo(x + mr, y);
+  ctx.lineTo(x + w - mr, y);
+  ctx.arcTo(x + w, y, x + w, y + mr, mr);
+  ctx.lineTo(x + w, y + h - mr);
+  ctx.arcTo(x + w, y + h, x + w - mr, y + h, mr);
+  ctx.lineTo(x + mr, y + h);
+  ctx.arcTo(x, y + h, x, y + h - mr, mr);
+  ctx.lineTo(x, y + mr);
+  ctx.arcTo(x, y, x + mr, y, mr);
+  ctx.closePath();
+}
+function renderNavigatorCanvas(ctx, layout) {
+  const { area, data, scales, allSeries, ticks, selection, config } = layout;
+  const w = area.width;
+  const h = area.height;
+  ctx.save();
+  traceRoundedRect(ctx, 0, 0, w, h, 3);
+  ctx.fillStyle = config.backgroundColor;
+  ctx.fill();
+  traceRoundedRect(ctx, 0, 0, w, h, 3);
+  ctx.clip();
+  if (data && scales) {
+    ctx.strokeStyle = config.gridColor;
+    ctx.lineWidth = 1;
+    for (const tick of ticks) {
+      ctx.beginPath();
+      ctx.moveTo(tick.px, 0);
+      ctx.lineTo(tick.px, h);
+      ctx.stroke();
+    }
+    for (let si = 0; si < allSeries.length; si++) {
+      const entry = allSeries[si];
+      const isPrimary = si === 0;
+      const { points } = entry;
+      if (entry.paths.dots) {
+        ctx.fillStyle = entry.color;
+        ctx.globalAlpha = 0.7;
+        for (const dot of entry.paths.dots) {
+          ctx.beginPath();
+          ctx.arc(dot.px, dot.py, 2, 0, Math.PI * 2);
+          ctx.fill();
+        }
+        ctx.globalAlpha = 1;
+      } else if (entry.paths.bars) {
+        ctx.fillStyle = entry.color;
+        ctx.globalAlpha = config.opacity;
+        for (const bar of entry.paths.bars) {
+          ctx.fillRect(bar.px, bar.py, bar.width, bar.height);
+        }
+        ctx.globalAlpha = 1;
+      } else if (points.length > 0) {
+        if (isPrimary) {
+          ctx.beginPath();
+          ctx.moveTo(scales.x(points[0].x), scales.y(points[0].y));
+          for (let i = 1; i < points.length; i++) {
+            ctx.lineTo(scales.x(points[i].x), scales.y(points[i].y));
+          }
+          ctx.lineTo(scales.x(points[points.length - 1].x), h);
+          ctx.lineTo(scales.x(points[0].x), h);
+          ctx.closePath();
+          ctx.globalAlpha = config.opacity;
+          ctx.fillStyle = entry.color;
+          ctx.fill();
+          ctx.globalAlpha = 1;
+        }
+        ctx.beginPath();
+        ctx.moveTo(scales.x(points[0].x), scales.y(points[0].y));
+        for (let i = 1; i < points.length; i++) {
+          ctx.lineTo(scales.x(points[i].x), scales.y(points[i].y));
+        }
+        ctx.strokeStyle = entry.color;
+        ctx.lineWidth = 1.5;
+        ctx.stroke();
+      }
+    }
+    ctx.fillStyle = config.labelColor;
+    ctx.font = "10px sans-serif";
+    ctx.textBaseline = "alphabetic";
+    ctx.textAlign = "start";
+    for (const tick of ticks) {
+      ctx.fillText(tick.label, tick.px + 3, h - 3);
+    }
+  }
+  const { x: selX, width: selW, isZoomed, is2D, y: selY, height: selH } = selection;
+  if (isZoomed) {
+    if (is2D && selY != null && selH != null) {
+      ctx.fillStyle = config.maskColor;
+      if (selY > 0) ctx.fillRect(0, 0, w, selY);
+      if (selY + selH < h) ctx.fillRect(0, selY + selH, w, h - selY - selH);
+      if (selX > 0) ctx.fillRect(0, selY, selX, selH);
+      if (selX + selW < w) ctx.fillRect(selX + selW, selY, w - selX - selW, selH);
+      ctx.fillStyle = config.selectionFill;
+      ctx.fillRect(selX, selY, selW, selH);
+      ctx.strokeStyle = config.selectionColor;
+      ctx.lineWidth = 1;
+      ctx.strokeRect(selX, selY, selW, selH);
+      ctx.strokeStyle = config.selectionColor;
+      ctx.lineCap = "round";
+      const midX = selX + selW / 2;
+      const midY = selY + selH / 2;
+      const gripLen = Math.min(selW * 0.3, 12);
+      const gripLenV = Math.min(selH * 0.3, 12);
+      ctx.lineWidth = 2;
+      ctx.beginPath();
+      ctx.moveTo(selX, midY - gripLenV);
+      ctx.lineTo(selX, midY + gripLenV);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(selX + selW, midY - gripLenV);
+      ctx.lineTo(selX + selW, midY + gripLenV);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(midX - gripLen, selY);
+      ctx.lineTo(midX + gripLen, selY);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(midX - gripLen, selY + selH);
+      ctx.lineTo(midX + gripLen, selY + selH);
+      ctx.stroke();
+    } else {
+      if (selX > 0) {
+        traceRoundedRect(ctx, 0, 0, selX, h, 3);
+        ctx.fillStyle = config.maskColor;
+        ctx.fill();
+      }
+      if (selX + selW < w) {
+        ctx.fillStyle = config.maskColor;
+        ctx.fillRect(selX + selW, 0, w - selX - selW, h);
+      }
+      ctx.fillStyle = config.selectionFill;
+      ctx.fillRect(selX, 0, selW, h);
+      ctx.strokeStyle = config.selectionColor;
+      ctx.lineWidth = 1;
+      ctx.strokeRect(selX, 0, selW, h);
+      const gripY1 = h * 0.3;
+      const gripY2 = h * 0.7;
+      ctx.strokeStyle = config.selectionColor;
+      ctx.lineWidth = 2;
+      ctx.lineCap = "round";
+      ctx.beginPath();
+      ctx.moveTo(selX, gripY1);
+      ctx.lineTo(selX, gripY2);
+      ctx.stroke();
+      ctx.globalAlpha = 0.5;
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.moveTo(selX + config.gripLineGap, gripY1 + 2);
+      ctx.lineTo(selX + config.gripLineGap, gripY2 - 2);
+      ctx.stroke();
+      ctx.globalAlpha = 1;
+      ctx.lineWidth = 2;
+      ctx.beginPath();
+      ctx.moveTo(selX + selW, gripY1);
+      ctx.lineTo(selX + selW, gripY2);
+      ctx.stroke();
+      ctx.globalAlpha = 0.5;
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      ctx.moveTo(selX + selW - config.gripLineGap, gripY1 + 2);
+      ctx.lineTo(selX + selW - config.gripLineGap, gripY2 - 2);
+      ctx.stroke();
+      ctx.globalAlpha = 1;
+    }
+  }
+  ctx.restore();
+}
+
+export { renderNavigatorCanvas };

package/dist/chunk-EDAKJLNA.mjs

@@ -0,0 +1,17 @@
+// src/animations/frameScheduler.ts
+var browserScheduler = {
+  raf: (cb) => globalThis.requestAnimationFrame(cb),
+  cancelRaf: (id) => globalThis.cancelAnimationFrame(id)
+};
+var activeScheduler = browserScheduler;
+function setFrameScheduler(api) {
+  activeScheduler = api ?? browserScheduler;
+}
+function raf(callback) {
+  return activeScheduler.raf(callback);
+}
+function cancelRaf(id) {
+  activeScheduler.cancelRaf(id);
+}
+
+export { cancelRaf, raf, setFrameScheduler };

package/dist/chunk-ERVQB2VZ.mjs

@@ -0,0 +1,59 @@
+import { drawCanvasArc } from './chunk-LVMDQ4OJ.mjs';
+import { getDefaultColor, createCanvasGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { adjustBrightness, withCanvasState } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/polar/canvas/index.ts
+function renderPolarBarsCanvas(ctx, layout, hoverState, effectConfig, theme) {
+  const { center } = layout;
+  const sharedAxisIdx = hoverState.axisIndex ?? null;
+  const anyHover = hoverState.datasetId !== null || sharedAxisIdx !== null;
+  for (const bar of layout.bars) {
+    if (bar.outerRadius <= bar.innerRadius) continue;
+    const isSeriesHover = sharedAxisIdx === null && hoverState.datasetId !== null && hoverState.index == null;
+    const isHovered = sharedAxisIdx !== null ? bar.categoryIndex === sharedAxisIdx : isSeriesHover ? hoverState.datasetId === bar.datasetId : hoverState.datasetId === bar.datasetId && hoverState.index === bar.categoryIndex;
+    const gradColor = layout.gradientColors.get(bar.datasetId);
+    const baseColor = bar.color ?? getDefaultColor(bar.seriesIdx, theme);
+    let fillColor = baseColor;
+    let opacity = bar.opacity ?? 1;
+    if (anyHover) {
+      if (isHovered && bar.hoverColor !== void 0) {
+        fillColor = bar.hoverColor;
+      } else if (isHovered && effectConfig.hoverBrightness && !gradColor) {
+        fillColor = adjustBrightness(baseColor, effectConfig.hoverBrightness);
+      } else if (!isHovered && effectConfig.dimOpacity !== void 0) {
+        opacity = opacity * effectConfig.dimOpacity;
+      }
+    }
+    withCanvasState(ctx, () => {
+      if (opacity < 1) {
+        ctx.globalAlpha = opacity;
+      }
+      drawCanvasArc(
+        ctx,
+        center.x,
+        center.y,
+        {
+          rotation: bar.startAngle,
+          endAngle: bar.endAngle,
+          outerRadius: bar.outerRadius,
+          innerRadius: bar.innerRadius,
+          borderRadius: bar.borderRadius
+        },
+        false
+      );
+      ctx.fillStyle = gradColor ? createCanvasGradientFromColor(ctx, gradColor, center, layout.maxRadius) : fillColor;
+      ctx.fill();
+      if (bar.borderStrokeWidth && bar.borderColor) {
+        ctx.strokeStyle = (isHovered ? bar.hoverBorderColor : void 0) ?? bar.borderColor;
+        ctx.lineWidth = bar.borderStrokeWidth;
+        if (bar.borderDash && bar.borderDash.length > 0) ctx.setLineDash(bar.borderDash);
+        if (bar.borderDashOffset) ctx.lineDashOffset = bar.borderDashOffset;
+        ctx.stroke();
+        if (bar.borderDash && bar.borderDash.length > 0) ctx.setLineDash([]);
+        if (bar.borderDashOffset) ctx.lineDashOffset = 0;
+      }
+    });
+  }
+}
+
+export { renderPolarBarsCanvas };

package/dist/chunk-FFMT6OCO.mjs

@@ -0,0 +1,92 @@
+// src/utils/data/collect.utils.ts
+function collectItems(sortedDatasets, datasetVisibility) {
+  const result = {
+    bar: [],
+    line: [],
+    scatter: [],
+    candlestick: [],
+    heatmap: [],
+    radar: [],
+    polar: [],
+    pie: []
+  };
+  for (const [id, dataset] of sortedDatasets) {
+    const visible = datasetVisibility.get(id) ?? true;
+    switch (dataset.type) {
+      case "bar":
+        result.bar.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible,
+          stackId: dataset.props.stackId
+        });
+        break;
+      case "line":
+        result.line.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible,
+          type: "line",
+          stackId: dataset.props.stackId,
+          rangeId: dataset.props.rangeId
+        });
+        break;
+      case "scatter":
+        result.scatter.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible,
+          stackId: dataset.props.stackId
+        });
+        break;
+      case "candlestick":
+        result.candlestick.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible
+        });
+        break;
+      case "heatmap":
+        result.heatmap.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible
+        });
+        break;
+      case "radar":
+        result.radar.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible
+        });
+        break;
+      case "polar":
+        result.polar.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible
+        });
+        break;
+      case "pie":
+      case "donut":
+        result.pie.push({
+          id,
+          props: dataset.props,
+          order: dataset.order,
+          visible,
+          type: dataset.type
+        });
+        break;
+    }
+  }
+  return result;
+}
+
+export { collectItems };

package/dist/chunk-FHTC2YDB.mjs

@@ -0,0 +1,102 @@
+import { traceRoundedRect } from './chunk-CHW4RKY3.mjs';
+import { resolveBorderRadius, clampRectBorderRadius, hasBorderRadius } from './chunk-VGLSBZDN.mjs';
+import { DEFAULT_HOVER_DIM_OPACITY } from './chunk-NKUYIWAP.mjs';
+import { resolveAccessor, makeItemContext } from './chunk-O2X6FF45.mjs';
+
+// src/series/candlestick/canvas/index.ts
+var DEFAULT_BAR_WIDTH_RATIO = 0.7;
+function createCanvasArcPathBuilder(ctx) {
+  return {
+    moveTo: (x, y) => ctx.moveTo(x, y),
+    lineTo: (x, y) => ctx.lineTo(x, y),
+    arcTo: (cx, cy, toX, toY, r) => {
+      if (r > 0) ctx.arcTo(cx, cy, toX, toY, r);
+    },
+    closePath: () => ctx.closePath()
+  };
+}
+function drawCandleBodyAndWicksCanvas(ctx, candle, wickWidth, borderStyle) {
+  const { borderStrokeWidth: borderWidth, borderJoinStyle, borderAlign } = borderStyle;
+  const borderDash = candle.borderDash ?? borderStyle.borderDash;
+  const borderDashOffset = candle.borderDashOffset ?? borderStyle.borderDashOffset;
+  const inset = borderAlign === "inner" ? borderWidth / 2 : 0;
+  const halfBody = candle.bodyWidth / 2;
+  const bodyLeft = candle.x - halfBody + inset;
+  const bodyTop = candle.bodyTop + inset;
+  const bodyWidth = Math.max(0, candle.bodyWidth - inset * 2);
+  const bodyHeight = Math.max(1, candle.bodyBottom - candle.bodyTop - inset * 2);
+  ctx.strokeStyle = candle.wickColor;
+  ctx.lineWidth = wickWidth;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  if (candle.bodyTop > candle.wickTop) {
+    ctx.moveTo(candle.x, candle.wickTop);
+    ctx.lineTo(candle.x, candle.bodyTop);
+  }
+  if (candle.wickBottom > candle.bodyBottom) {
+    ctx.moveTo(candle.x, candle.bodyBottom);
+    ctx.lineTo(candle.x, candle.wickBottom);
+  }
+  ctx.stroke();
+  ctx.strokeStyle = candle.bodyStroke;
+  ctx.lineWidth = borderWidth;
+  ctx.lineJoin = borderJoinStyle;
+  ctx.setLineDash(borderDash);
+  ctx.lineDashOffset = borderDashOffset;
+  const resolvedRadius = resolveBorderRadius(borderStyle.borderRadius);
+  const clampedRadius = clampRectBorderRadius(resolvedRadius, bodyWidth, bodyHeight);
+  ctx.beginPath();
+  if (hasBorderRadius(clampedRadius)) {
+    traceRoundedRect(createCanvasArcPathBuilder(ctx), bodyLeft, bodyTop, bodyWidth, bodyHeight, clampedRadius);
+  } else {
+    ctx.rect(bodyLeft, bodyTop, bodyWidth, bodyHeight);
+  }
+  if (candle.bodyFill !== null) {
+    ctx.fillStyle = candle.bodyFill;
+    ctx.fill();
+  }
+  ctx.stroke();
+  ctx.setLineDash([]);
+  ctx.lineDashOffset = 0;
+}
+function drawOhlcTicksCanvas(ctx, candle, tickWidth, wickWidth) {
+  ctx.strokeStyle = candle.bodyStroke;
+  ctx.lineWidth = wickWidth;
+  ctx.setLineDash([]);
+  ctx.beginPath();
+  ctx.moveTo(candle.x, candle.wickTop);
+  ctx.lineTo(candle.x, candle.wickBottom);
+  ctx.moveTo(candle.x - tickWidth, candle.openY);
+  ctx.lineTo(candle.x, candle.openY);
+  ctx.moveTo(candle.x, candle.closeY);
+  ctx.lineTo(candle.x + tickWidth, candle.closeY);
+  ctx.stroke();
+}
+function renderCandlestickCanvas(props, layout, ctx, context) {
+  const { borderStyle, variant } = layout;
+  const tickWidth = layout.categoryScale.bandwidth() * (props.barWidthRatio ?? DEFAULT_BAR_WIDTH_RATIO) / 2;
+  const baseAlpha = ctx.globalAlpha;
+  const dataArr = props.data;
+  const hoveredIdx = props.hoveredIndex ?? null;
+  const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+  for (const candle of layout.visibleCandles) {
+    ctx.save();
+    if (props.effects && hoveredIdx !== null && hoveredIdx !== candle.dataIndex) {
+      ctx.globalAlpha = baseAlpha * (props.effects.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY);
+    }
+    const isHovered = hoveredIdx !== null && hoveredIdx === candle.dataIndex;
+    const hoverFill = isHovered ? resolveAccessor(props.hoverColor, makeItemContext(dataArr?.[candle.dataIndex], candle.dataIndex, { value: candle.close, category: candle.label, ...seriesExtras }), { arrayMode: "cycle" }) : void 0;
+    const hoverBorder = isHovered ? resolveAccessor(props.hoverBorderColor, makeItemContext(dataArr?.[candle.dataIndex], candle.dataIndex, { value: candle.close, category: candle.label, ...seriesExtras }), { arrayMode: "cycle" }) : void 0;
+    const hoverFillStr = hoverFill !== void 0 ? typeof hoverFill === "string" ? hoverFill : String(hoverFill) : void 0;
+    const hoverBorderStr = hoverBorder !== void 0 ? typeof hoverBorder === "string" ? hoverBorder : String(hoverBorder) : void 0;
+    const renderCandle = hoverFillStr !== void 0 || hoverBorderStr !== void 0 ? { ...candle, bodyFill: hoverFillStr ?? candle.bodyFill, bodyStroke: hoverBorderStr ?? candle.bodyStroke, wickColor: hoverFillStr ?? candle.wickColor} : candle;
+    if (variant === "ohlc") {
+      drawOhlcTicksCanvas(ctx, renderCandle, tickWidth, renderCandle.wickStrokeWidth);
+    } else {
+      drawCandleBodyAndWicksCanvas(ctx, renderCandle, renderCandle.wickStrokeWidth, borderStyle);
+    }
+    ctx.restore();
+  }
+}
+
+export { renderCandlestickCanvas };

package/dist/chunk-FRST55HY.mjs

@@ -0,0 +1,16 @@
+// src/animations/bar.ts
+function animatableBarToComputedBar(bar) {
+  return {
+    dataIndex: bar.dataIndex,
+    x: bar.x,
+    y: bar.y,
+    width: bar.width,
+    height: bar.height,
+    value: bar.value,
+    category: bar.category,
+    visible: true,
+    isNegative: bar.isNegative
+  };
+}
+
+export { animatableBarToComputedBar };