@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-PRDVPOZX.mjs

@@ -0,0 +1,223 @@
+import { withCanvasState, createSvgCircle, createSvgPath, createSvgRect } from './chunk-SSLTFJ3U.mjs';
+
+// src/renderers/marker.utils.ts
+var MARKER_SHAPE_NAMES = /* @__PURE__ */ new Set(["circle", "square", "triangle", "cross", "star"]);
+function buildEquilateralTrianglePath(cx, cy, size) {
+  const h = size * Math.sqrt(3);
+  const top = cy - h * 2 / 3;
+  const bottom = cy + h / 3;
+  return `M ${cx} ${top} L ${cx + size} ${bottom} L ${cx - size} ${bottom} Z`;
+}
+function buildDiamondPath(cx, cy, size) {
+  return `M ${cx} ${cy - size} L ${cx + size} ${cy} L ${cx} ${cy + size} L ${cx - size} ${cy} Z`;
+}
+function buildCrossPath(cx, cy, size) {
+  const t = size * 0.35;
+  return `M ${cx - t} ${cy - size} L ${cx + t} ${cy - size} L ${cx + t} ${cy - t} L ${cx + size} ${cy - t} L ${cx + size} ${cy + t} L ${cx + t} ${cy + t} L ${cx + t} ${cy + size} L ${cx - t} ${cy + size} L ${cx - t} ${cy + t} L ${cx - size} ${cy + t} L ${cx - size} ${cy - t} L ${cx - t} ${cy - t} Z`;
+}
+function buildStarPath(cx, cy, size) {
+  const outerR = size;
+  const innerR = size * 0.4;
+  const points = [];
+  for (let i = 0; i < 10; i++) {
+    const angle = -Math.PI / 2 + i * Math.PI / 5;
+    const r = i % 2 === 0 ? outerR : innerR;
+    const x = cx + r * Math.cos(angle);
+    const y = cy + r * Math.sin(angle);
+    points.push(`${i === 0 ? "M" : "L"} ${x} ${y}`);
+  }
+  return points.join(" ") + " Z";
+}
+function resolveBoostActive(boost, visibleCount, autoThreshold) {
+  if (boost === true) return true;
+  if (boost === false) return false;
+  return visibleCount >= autoThreshold;
+}
+function buildMarkerShapePath(shape, cx, cy, size) {
+  switch (shape) {
+    case "rect":
+    case "square":
+      return `M${cx - size} ${cy - size}h${size * 2}v${size * 2}h${-size * 2}Z`;
+    case "triangle":
+      return buildEquilateralTrianglePath(cx, cy, size);
+    case "diamond":
+      return buildDiamondPath(cx, cy, size);
+    case "cross":
+      return buildCrossPath(cx, cy, size);
+    case "star":
+      return buildStarPath(cx, cy, size);
+    default:
+      return `M${cx - size} ${cy}a${size} ${size} 0 1 0 ${size * 2} 0a${size} ${size} 0 1 0 ${-size * 2} 0`;
+  }
+}
+function drawMarkerCanvas(ctx, opts) {
+  const { x, y, size, shape, fillStyle, strokeStyle, lineStrokeWidth, opacity, fillOpacity, rotation, lineDash, lineDashOffset, lineJoin } = opts;
+  withCanvasState(ctx, () => {
+    ctx.translate(x, y);
+    if (rotation) ctx.rotate(rotation * Math.PI / 180);
+    const resolvedShape = typeof shape === "function" ? shape({ size }) : shape;
+    traceMarkerShapeCanvas(ctx, resolvedShape, size);
+    ctx.fillStyle = fillStyle;
+    ctx.globalAlpha = opacity * (fillOpacity ?? 1);
+    ctx.fill();
+    if (lineStrokeWidth > 0) {
+      ctx.globalAlpha = opacity;
+      ctx.strokeStyle = strokeStyle;
+      ctx.lineWidth = lineStrokeWidth;
+      if (lineDash?.length) ctx.setLineDash(lineDash);
+      if (lineDashOffset) ctx.lineDashOffset = lineDashOffset;
+      if (lineJoin) ctx.lineJoin = lineJoin;
+      ctx.stroke();
+    }
+  });
+}
+function renderMarkerShapeSvg(shape, cx, cy, size, attrs) {
+  switch (shape) {
+    case "rect":
+    case "square":
+      return createSvgRect(cx - size, cy - size, size * 2, size * 2, attrs);
+    case "triangle":
+      return createSvgPath(buildEquilateralTrianglePath(cx, cy, size), attrs);
+    case "diamond":
+      return createSvgPath(buildDiamondPath(cx, cy, size), attrs);
+    case "cross":
+      return createSvgPath(buildCrossPath(cx, cy, size), attrs);
+    case "star":
+      return createSvgPath(buildStarPath(cx, cy, size), attrs);
+    default:
+      return createSvgCircle(cx, cy, size, attrs);
+  }
+}
+function traceMarkerShapeCanvasAt(ctx, shape, cx, cy, size, rotation = 0) {
+  let cos = 1;
+  let sin = 0;
+  if (rotation !== 0 && shape !== "circle") {
+    const rad = rotation * Math.PI / 180;
+    cos = Math.cos(rad);
+    sin = Math.sin(rad);
+  }
+  const ax = (x, y) => cx + x * cos - y * sin;
+  const ay = (x, y) => cy + x * sin + y * cos;
+  switch (shape) {
+    case "rect":
+    case "square":
+      if (rotation === 0) {
+        ctx.rect(cx - size, cy - size, size * 2, size * 2);
+      } else {
+        ctx.moveTo(ax(-size, -size), ay(-size, -size));
+        ctx.lineTo(ax(size, -size), ay(size, -size));
+        ctx.lineTo(ax(size, size), ay(size, size));
+        ctx.lineTo(ax(-size, size), ay(-size, size));
+        ctx.closePath();
+      }
+      break;
+    case "triangle": {
+      const h = size * Math.sqrt(3);
+      const top = -(h * 2) / 3;
+      const bot = h / 3;
+      ctx.moveTo(ax(0, top), ay(0, top));
+      ctx.lineTo(ax(size, bot), ay(size, bot));
+      ctx.lineTo(ax(-size, bot), ay(-size, bot));
+      ctx.closePath();
+      break;
+    }
+    case "diamond":
+      ctx.moveTo(ax(0, -size), ay(0, -size));
+      ctx.lineTo(ax(size, 0), ay(size, 0));
+      ctx.lineTo(ax(0, size), ay(0, size));
+      ctx.lineTo(ax(-size, 0), ay(-size, 0));
+      ctx.closePath();
+      break;
+    case "cross": {
+      const t = size * 0.35;
+      ctx.moveTo(ax(-t, -size), ay(-t, -size));
+      ctx.lineTo(ax(t, -size), ay(t, -size));
+      ctx.lineTo(ax(t, -t), ay(t, -t));
+      ctx.lineTo(ax(size, -t), ay(size, -t));
+      ctx.lineTo(ax(size, t), ay(size, t));
+      ctx.lineTo(ax(t, t), ay(t, t));
+      ctx.lineTo(ax(t, size), ay(t, size));
+      ctx.lineTo(ax(-t, size), ay(-t, size));
+      ctx.lineTo(ax(-t, t), ay(-t, t));
+      ctx.lineTo(ax(-size, t), ay(-size, t));
+      ctx.lineTo(ax(-size, -t), ay(-size, -t));
+      ctx.lineTo(ax(-t, -t), ay(-t, -t));
+      ctx.closePath();
+      break;
+    }
+    case "star": {
+      const innerR = size * 0.4;
+      for (let i = 0; i < 10; i++) {
+        const angle = -Math.PI / 2 + i * Math.PI / 5;
+        const r = i % 2 === 0 ? size : innerR;
+        const sx = r * Math.cos(angle);
+        const sy = r * Math.sin(angle);
+        if (i === 0) ctx.moveTo(ax(sx, sy), ay(sx, sy));
+        else ctx.lineTo(ax(sx, sy), ay(sx, sy));
+      }
+      ctx.closePath();
+      break;
+    }
+    default:
+      ctx.moveTo(cx + size, cy);
+      ctx.arc(cx, cy, size, 0, Math.PI * 2);
+  }
+}
+function traceMarkerShapeCanvas(ctx, shape, size) {
+  ctx.beginPath();
+  switch (shape) {
+    case "rect":
+    case "square":
+      ctx.rect(-size, -size, size * 2, size * 2);
+      break;
+    case "triangle": {
+      const h = size * Math.sqrt(3);
+      ctx.moveTo(0, -(h * 2) / 3);
+      ctx.lineTo(size, h / 3);
+      ctx.lineTo(-size, h / 3);
+      ctx.closePath();
+      break;
+    }
+    case "diamond":
+      ctx.moveTo(0, -size);
+      ctx.lineTo(size, 0);
+      ctx.lineTo(0, size);
+      ctx.lineTo(-size, 0);
+      ctx.closePath();
+      break;
+    case "cross": {
+      const t = size * 0.35;
+      ctx.moveTo(-t, -size);
+      ctx.lineTo(t, -size);
+      ctx.lineTo(t, -t);
+      ctx.lineTo(size, -t);
+      ctx.lineTo(size, t);
+      ctx.lineTo(t, t);
+      ctx.lineTo(t, size);
+      ctx.lineTo(-t, size);
+      ctx.lineTo(-t, t);
+      ctx.lineTo(-size, t);
+      ctx.lineTo(-size, -t);
+      ctx.lineTo(-t, -t);
+      ctx.closePath();
+      break;
+    }
+    case "star": {
+      const innerR = size * 0.4;
+      for (let i = 0; i < 10; i++) {
+        const angle = -Math.PI / 2 + i * Math.PI / 5;
+        const r = i % 2 === 0 ? size : innerR;
+        const sx = r * Math.cos(angle);
+        const sy = r * Math.sin(angle);
+        if (i === 0) ctx.moveTo(sx, sy);
+        else ctx.lineTo(sx, sy);
+      }
+      ctx.closePath();
+      break;
+    }
+    default:
+      ctx.arc(0, 0, size, 0, Math.PI * 2);
+  }
+}
+
+export { MARKER_SHAPE_NAMES, buildCrossPath, buildDiamondPath, buildEquilateralTrianglePath, buildMarkerShapePath, buildStarPath, drawMarkerCanvas, renderMarkerShapeSvg, resolveBoostActive, traceMarkerShapeCanvas, traceMarkerShapeCanvasAt };

package/dist/chunk-Q6PPVIHU.mjs

@@ -0,0 +1,21 @@
+// src/cartesian/compositor.utils.ts
+function registerDatasetLayers(compositor, prefix, datasetIds, getOrder, createPaint) {
+  for (const dsId of datasetIds) {
+    compositor.registerLayer({
+      id: `${prefix}:${dsId}`,
+      order: getOrder(dsId),
+      paint: createPaint(dsId)
+    });
+  }
+}
+function triggerCompositorRepaint(renderer, canvas, compositor) {
+  if (renderer !== "canvas" || !compositor || !compositor.hasLayers()) return false;
+  const ctx = canvas?.getContext("2d");
+  if (ctx) {
+    compositor.repaint(ctx);
+    return true;
+  }
+  return false;
+}
+
+export { registerDatasetLayers, triggerCompositorRepaint };