@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-C36VWQ7A.mjs

@@ -0,0 +1,86 @@
+// src/utils/specialized/spatialIndex.utils.ts
+var LEAF_CAPACITY = 16;
+function buildQuadtree(points, bounds) {
+  let maxR = 0;
+  for (const p of points) if (p.r > maxR) maxR = p.r;
+  const root = { bounds, points: [] };
+  for (const p of points) insertPoint(root, p);
+  return {
+    queryNearest(x, y, baseRadius) {
+      const effectiveSearch = Math.max(baseRadius, maxR);
+      const searchSq = effectiveSearch * effectiveSearch;
+      let bestIdx = null;
+      let bestDistSq = Infinity;
+      const visit = (node) => {
+        if (boxDistSq(node.bounds, x, y) > searchSq) return;
+        if (node.points) {
+          for (const p of node.points) {
+            const dx = p.x - x;
+            const dy = p.y - y;
+            const distSq = dx * dx + dy * dy;
+            const hitR = baseRadius > p.r ? baseRadius : p.r;
+            if (distSq <= hitR * hitR && distSq < bestDistSq) {
+              bestDistSq = distSq;
+              bestIdx = p.idx;
+            }
+          }
+        } else if (node.children) {
+          for (const c of node.children) visit(c);
+        }
+      };
+      visit(root);
+      return bestIdx === null ? null : { idx: bestIdx, distSq: bestDistSq };
+    }
+  };
+}
+function insertPoint(node, p) {
+  if (node.children) {
+    insertPoint(childContaining(node, p.x, p.y), p);
+    return;
+  }
+  const points = node.points;
+  points.push(p);
+  if (points.length > LEAF_CAPACITY && canSubdivide(node.bounds)) {
+    subdivide(node);
+  }
+}
+function canSubdivide(b) {
+  return b.x1 - b.x0 > 1 && b.y1 - b.y0 > 1;
+}
+function subdivide(node) {
+  const { x0, y0, x1, y1 } = node.bounds;
+  const mx = (x0 + x1) / 2;
+  const my = (y0 + y1) / 2;
+  const children = [
+    { bounds: { x0, y0, x1: mx, y1: my }, points: [] },
+    // NW
+    { bounds: { x0: mx, y0, x1, y1: my }, points: [] },
+    // NE
+    { bounds: { x0, y0: my, x1: mx, y1 }, points: [] },
+    // SW
+    { bounds: { x0: mx, y0: my, x1, y1 }, points: [] }
+    // SE
+  ];
+  const oldPoints = node.points;
+  node.points = void 0;
+  node.children = children;
+  for (const p of oldPoints) insertPoint(node, p);
+}
+function childContaining(node, x, y) {
+  const { x0, y0, x1, y1 } = node.bounds;
+  const mx = (x0 + x1) / 2;
+  const my = (y0 + y1) / 2;
+  const east = x >= mx;
+  const south = y >= my;
+  const idx = (south ? 2 : 0) + (east ? 1 : 0);
+  return node.children[idx];
+}
+function boxDistSq(b, x, y) {
+  const cx = x < b.x0 ? b.x0 : x > b.x1 ? b.x1 : x;
+  const cy = y < b.y0 ? b.y0 : y > b.y1 ? b.y1 : y;
+  const dx = cx - x;
+  const dy = cy - y;
+  return dx * dx + dy * dy;
+}
+
+export { buildQuadtree };

package/dist/chunk-CHW4RKY3.mjs

@@ -0,0 +1,16 @@
+// src/series/candlestick/shared.ts
+function traceRoundedRect(pb, x, y, w, h, radius) {
+  const { topLeft, topRight, bottomLeft, bottomRight } = radius;
+  pb.moveTo(x + topLeft, y);
+  pb.lineTo(x + w - topRight, y);
+  pb.arcTo(x + w, y, x + w, y + topRight, topRight);
+  pb.lineTo(x + w, y + h - bottomRight);
+  pb.arcTo(x + w, y + h, x + w - bottomRight, y + h, bottomRight);
+  pb.lineTo(x + bottomLeft, y + h);
+  pb.arcTo(x, y + h, x, y + h - bottomLeft, bottomLeft);
+  pb.lineTo(x, y + topLeft);
+  pb.arcTo(x, y, x + topLeft, y, topLeft);
+  pb.closePath();
+}
+
+export { traceRoundedRect };

package/dist/chunk-CINXJIRR.mjs

@@ -0,0 +1,120 @@
+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';
+import { createSvgGroup, setAttr, appendChild, createSvgLine, createSvgPath, createSvgRect } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/candlestick/svg/index.ts
+var DEFAULT_BAR_WIDTH_RATIO = 0.7;
+function createSvgArcPathBuilder() {
+  const parts = [];
+  return {
+    moveTo: (x, y) => parts.push(`M ${x} ${y}`),
+    lineTo: (x, y) => parts.push(`L ${x} ${y}`),
+    arcTo: (_cx, _cy, toX, toY, r) => {
+      if (r > 0) parts.push(`A ${r} ${r} 0 0 1 ${toX} ${toY}`);
+    },
+    closePath: () => parts.push("Z"),
+    build: () => parts.join(" ")
+  };
+}
+function buildRoundedRectPath(x, y, w, h, radius) {
+  const pb = createSvgArcPathBuilder();
+  traceRoundedRect(pb, x, y, w, h, radius);
+  return pb.build();
+}
+function renderCandleBodyAndWicksSvg(candle, wickWidth, borderStyle) {
+  const group = createSvgGroup();
+  const { borderStrokeWidth: borderWidth, borderJoinStyle, borderAlign, borderRadius } = 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);
+  const candleCls = candle.useClass ? `p-chart-candle-${candle.useClass}` : null;
+  const isHollow = candle.bodyFill === null;
+  if (candle.bodyTop > candle.wickTop) {
+    const upperWick = createSvgLine(candle.x, candle.wickTop, candle.x, candle.bodyTop);
+    if (candleCls) setAttr(upperWick, "class", candleCls);
+    setAttr(upperWick, "stroke", candle.wickColor);
+    setAttr(upperWick, "stroke-width", String(wickWidth));
+    appendChild(group, upperWick);
+  }
+  if (candle.wickBottom > candle.bodyBottom) {
+    const lowerWick = createSvgLine(candle.x, candle.bodyBottom, candle.x, candle.wickBottom);
+    if (candleCls) setAttr(lowerWick, "class", candleCls);
+    setAttr(lowerWick, "stroke", candle.wickColor);
+    setAttr(lowerWick, "stroke-width", String(wickWidth));
+    appendChild(group, lowerWick);
+  }
+  const resolvedRadius = resolveBorderRadius(borderRadius);
+  const clampedRadius = clampRectBorderRadius(resolvedRadius, bodyWidth, bodyHeight);
+  const useRounded = hasBorderRadius(clampedRadius);
+  const body = useRounded ? createSvgPath(buildRoundedRectPath(bodyLeft, bodyTop, bodyWidth, bodyHeight, clampedRadius)) : createSvgRect(bodyLeft, bodyTop, bodyWidth, bodyHeight);
+  if (candleCls) setAttr(body, "class", candleCls);
+  if (candleCls && isHollow) setAttr(body, "style", "fill:none");
+  setAttr(body, "fill", candle.bodyFill ?? "none");
+  setAttr(body, "stroke", candle.bodyStroke);
+  setAttr(body, "stroke-width", String(borderWidth));
+  setAttr(body, "stroke-linejoin", borderJoinStyle);
+  if (borderDash.length > 0) {
+    setAttr(body, "stroke-dasharray", borderDash.join(" "));
+    setAttr(body, "stroke-dashoffset", String(borderDashOffset));
+  }
+  appendChild(group, body);
+  return group;
+}
+function renderOhlcTicksSvg(candle, tickWidth, wickWidth) {
+  const group = createSvgGroup();
+  const candleCls = candle.useClass ? `p-chart-candle-${candle.useClass}` : null;
+  const applyStrokeAttrs = (node) => {
+    if (candleCls) setAttr(node, "class", candleCls);
+    setAttr(node, "stroke", candle.bodyStroke);
+    setAttr(node, "stroke-width", String(wickWidth));
+  };
+  const vertLine = createSvgLine(candle.x, candle.wickTop, candle.x, candle.wickBottom);
+  applyStrokeAttrs(vertLine);
+  appendChild(group, vertLine);
+  const openTick = createSvgLine(candle.x - tickWidth, candle.openY, candle.x, candle.openY);
+  applyStrokeAttrs(openTick);
+  appendChild(group, openTick);
+  const closeTick = createSvgLine(candle.x, candle.closeY, candle.x + tickWidth, candle.closeY);
+  applyStrokeAttrs(closeTick);
+  appendChild(group, closeTick);
+  return group;
+}
+function renderCandlestickSvg(props, layout, context) {
+  const root = createSvgGroup();
+  const { borderStyle, variant } = layout;
+  const tickWidth = layout.categoryScale.bandwidth() * (props.barWidthRatio ?? DEFAULT_BAR_WIDTH_RATIO) / 2;
+  const dataArr = props.data;
+  const hoveredIdx = props.hoveredIndex ?? null;
+  const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+  for (const candle of layout.visibleCandles) {
+    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, useClass: null } : candle;
+    let candleNode;
+    if (variant === "ohlc") {
+      candleNode = renderOhlcTicksSvg(renderCandle, tickWidth, renderCandle.wickStrokeWidth);
+    } else {
+      candleNode = renderCandleBodyAndWicksSvg(renderCandle, renderCandle.wickStrokeWidth, borderStyle);
+    }
+    if (props.effects && hoveredIdx !== null && hoveredIdx !== candle.dataIndex) {
+      setAttr(candleNode, "opacity", String(props.effects.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY));
+    }
+    setAttr(candleNode, "data-index", String(candle.dataIndex));
+    setAttr(candleNode, "role", "img");
+    setAttr(candleNode, "aria-label", `${candle.label}: Open ${candle.open}, High ${candle.high}, Low ${candle.low}, Close ${candle.close}.`);
+    appendChild(root, candleNode);
+  }
+  return root;
+}
+
+export { renderCandlestickSvg };