@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-2QRS4YQ5.mjs

@@ -0,0 +1,18 @@
+import { renderScatterSvg } from './chunk-6STOLMCA.mjs';
+import { renderScatterCanvas } from './chunk-AHYIS6EB.mjs';
+import { hitTestScatter, calculateScatterLayout } from './chunk-DTWTCFRG.mjs';
+import { batchResolveRequired } from './chunk-O2X6FF45.mjs';
+
+// src/series/scatter/index.ts
+var scatterRenderer = {
+  calculateLayout: calculateScatterLayout,
+  renderSvg: renderScatterSvg,
+  renderCanvas: renderScatterCanvas,
+  hitTest: hitTestScatter,
+  getAxisHints(props, data) {
+    const domainValues = props.yField ? batchResolveRequired(props.yField, data, "yField") : [];
+    return { domainValues };
+  }
+};
+
+export { scatterRenderer };

package/dist/chunk-3FFJEX4A.mjs

@@ -0,0 +1,261 @@
+import { resolveBoostActive, MARKER_SHAPE_NAMES, buildMarkerShapePath, renderMarkerShapeSvg } from './chunk-PRDVPOZX.mjs';
+import { computeItemHoverState, applyHoverEffects, resolveSvgHoverFill } from './chunk-BZN2QHGP.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { SVG_ELEMENT_CEILING_WARNING, 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, isGradientColor, createSvgGradientFromColor, getPrimaryColor } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, createSvgDefs, appendChild, svgClass, createSvgPath, setAttr, prependChild } from './chunk-SSLTFJ3U.mjs';
+import { warnChartDevOnce } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/line/svg/index.ts
+var DEFAULT_SHOW_MARKERS = true;
+var DEFAULT_MARKER_SHAPE = "circle";
+function renderLineSvg(props, layout, context) {
+  if (layout.visiblePoints.length >= SVG_ELEMENT_CEILING_WARNING) {
+    warnChartDevOnce("line-svg-ceiling", `SVG line is rendering ${layout.visiblePoints.length.toLocaleString()} points. Above ~8k elements, prefer <ChartCanvas> or <ChartDecimation> for materially better performance.`);
+  }
+  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 = (ctx) => markerSizeAccessor === void 0 ? defaultMarkerSize : resolveAccessor(markerSizeAccessor, ctx, { arrayMode: "clip", fallback: defaultMarkerSize }) ?? defaultMarkerSize;
+  const resolveMarkerShape = (ctx, size) => props.markerShape === void 0 ? DEFAULT_MARKER_SHAPE : resolveAccessor(props.markerShape, typeof props.markerShape === "function" ? { ...ctx, size } : ctx, { arrayMode: "clip" }) ?? DEFAULT_MARKER_SHAPE;
+  const rotationAccessor = props.pointRotation;
+  const resolveMarkerRotation = (ctx) => rotationAccessor === void 0 ? 0 : resolveAccessor(rotationAccessor, ctx, { 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 = (ctx) => props.pointBorderDash === void 0 ? void 0 : resolveDash(props.pointBorderDash, ctx);
+  const resolvePointDashOffset = (ctx) => props.pointBorderDashOffset === void 0 ? 0 : resolveAccessor(props.pointBorderDashOffset, ctx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  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 a11y = context.accessibility;
+  const a11yEnabled = !!(a11y?.enabled && layout.visiblePoints.length <= (a11y.pointDescriptionThreshold ?? 200));
+  const group = createSvgGroup(void 0, seriesDimOpacity < 1 ? { opacity: String(seriesDimOpacity) } : void 0);
+  const defs = createSvgDefs();
+  let defsUsed = false;
+  let strokeDasharray;
+  if (props.lineDash && props.lineDash.length > 0) {
+    strokeDasharray = props.lineDash.join(" ");
+  } else if (lineStyle === "dashed") {
+    strokeDasharray = `${lineWidth * 4} ${lineWidth * 3}`;
+  } else if (lineStyle === "dotted") {
+    strokeDasharray = `${lineWidth} ${lineWidth * 2}`;
+  }
+  let strokeColor;
+  const lineColor = layout.lineColor;
+  const seriesIdx = layout.seriesIdx;
+  const colorClassN = `p-chart-color-${seriesIdx % 10}`;
+  const seriesExtras = { seriesIndex: layout.seriesIdx, seriesId: layout.datasetId };
+  if (lineColor && isGradientColor(lineColor)) {
+    const gradId = `line-stroke-${context.chartId}-${layout.datasetIndex}`;
+    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;
+    appendChild(defs, createSvgGradientFromColor(lineColor, gradId, { x: cx, y: cy }, r, layout.chartArea, "horizontal"));
+    defsUsed = true;
+    strokeColor = `url(#${gradId})`;
+  } else if (typeof lineColor === "string") {
+    strokeColor = lineColor;
+  }
+  if (layout.isArea) {
+    const areaGroup = createSvgGroup(void 0, { class: "line-area", "data-layer": "area" });
+    const areaGradCache = /* @__PURE__ */ new Map();
+    for (const seg of layout.segments) {
+      if (!seg.fillPath) continue;
+      const segFill = seg.style?.segmentFillColor;
+      let fill = segFill ?? strokeColor;
+      if (!segFill && lineColor && isGradientColor(lineColor)) {
+        const cacheKey = lineColor.stops.map((s) => `${s.offset}:${s.color}:${s.opacity ?? ""}`).join("|");
+        let areaGradId = areaGradCache.get(cacheKey);
+        if (!areaGradId) {
+          areaGradId = `line-area-${context.chartId}-${layout.datasetIndex}-grad`;
+          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;
+          appendChild(defs, createSvgGradientFromColor(lineColor, areaGradId, { x: acx, y: acy }, ar, layout.chartArea, "vertical"));
+          defsUsed = true;
+          areaGradCache.set(cacheKey, areaGradId);
+        }
+        fill = `url(#${areaGradId})`;
+      }
+      const attrs = {
+        d: seg.fillPath,
+        "fill-opacity": fillOpacity,
+        stroke: "none",
+        fill: fill ?? context.theme.series[seriesIdx % context.theme.series.length],
+        class: svgClass("p-chart-area", `p-chart-series-${seriesIdx}`, !fill && colorClassN)
+      };
+      appendChild(areaGroup, createSvgPath(seg.fillPath, attrs));
+    }
+    appendChild(group, areaGroup);
+  }
+  if (borderColor && borderWidth > 0) {
+    const borderGroup = createSvgGroup(void 0, { class: "line-border", "data-layer": "border" });
+    const usingLineDash = !!strokeDasharray;
+    const effectiveBorderDash = strokeDasharray ?? (seriesBorderDash && seriesBorderDash.length > 0 ? seriesBorderDash.join(" ") : void 0);
+    const borderDashArray = effectiveBorderDash;
+    const effectiveBorderDashOffset = usingLineDash ? props.lineDashOffset ?? seriesBorderDashOffset : seriesBorderDashOffset;
+    for (const seg of layout.segments) {
+      if (!seg.linePath || seg.points.length === 0) continue;
+      const pathAttrs = {
+        d: seg.linePath,
+        fill: "none",
+        stroke: borderColor,
+        "stroke-width": lineWidth + borderWidth * 2,
+        "stroke-linecap": props.borderCapStyle ?? props.lineCapStyle ?? "round",
+        "stroke-linejoin": props.borderJoinStyle ?? props.lineJoinStyle ?? "round"
+      };
+      if (borderDashArray) pathAttrs["stroke-dasharray"] = borderDashArray;
+      if (effectiveBorderDashOffset) pathAttrs["stroke-dashoffset"] = effectiveBorderDashOffset;
+      appendChild(borderGroup, createSvgPath(seg.linePath, pathAttrs));
+    }
+    appendChild(group, borderGroup);
+  }
+  const lineGroup = createSvgGroup(void 0, { class: "line-strokes", "data-layer": "strokes" });
+  for (const seg of layout.segments) {
+    if (!seg.linePath || seg.points.length === 0) continue;
+    const segStroke = seg.style?.segmentColor ?? strokeColor;
+    const segWidth = seg.style?.segmentStrokeWidth ?? lineWidth;
+    const segDash = seg.style?.segmentDash ? seg.style.segmentDash.join(" ") : strokeDasharray;
+    const pathAttrs = {
+      d: seg.linePath,
+      fill: "none",
+      "stroke-width": segWidth,
+      "stroke-linecap": props.lineCapStyle ?? "round",
+      "stroke-linejoin": props.lineJoinStyle ?? "round",
+      stroke: segStroke ?? context.theme.series[seriesIdx % context.theme.series.length],
+      class: svgClass("p-chart-line", `p-chart-series-${seriesIdx}`, !segStroke && colorClassN)
+    };
+    if (segDash) pathAttrs["stroke-dasharray"] = segDash;
+    if (props.lineDashOffset) pathAttrs["stroke-dashoffset"] = props.lineDashOffset;
+    appendChild(lineGroup, createSvgPath(seg.linePath, pathAttrs));
+  }
+  appendChild(group, lineGroup);
+  const hasCustomRenderMarker = !!props.renderMarker;
+  if ((showMarkers || hoveredIndex !== null) && !hasCustomRenderMarker) {
+    const markerGroup = createSvgGroup(void 0, { class: "line-markers", "data-layer": "markers" });
+    const anyHovered = hoveredIndex !== null && !!effects;
+    let boostBatched = false;
+    if (resolveBoostActive(props.boost, layout.visiblePoints.length, LINE_BOOST_AUTO_THRESHOLD) && showMarkers && typeof props.markerShape !== "function" && layout.visiblePoints.length > 0) {
+      const first = layout.visiblePoints[0];
+      const firstCtx = makeItemContext(props.data?.[first.dataIndex], first.dataIndex, { value: first.value, category: first.category, ...seriesExtras });
+      const seriesShape = resolveMarkerShape(firstCtx, resolveMarkerSize(firstCtx));
+      if (MARKER_SHAPE_NAMES.has(seriesShape)) {
+        const themedSeriesColor = context.theme.series[seriesIdx % context.theme.series.length];
+        const CLASS_KEY = "__class__";
+        const batches = /* @__PURE__ */ new Map();
+        for (const pt of layout.visiblePoints) {
+          const ptCtx = makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras });
+          const markerColor = props.pointColors?.[pt.dataIndex] ?? resolveAccessor(props.pointBackgroundColor, ptCtx, { arrayMode: "cycle" }) ?? lineColor;
+          const key = markerColor != null ? getPrimaryColor(markerColor) : CLASS_KEY;
+          let bucket = batches.get(key);
+          if (!bucket) batches.set(key, bucket = []);
+          bucket.push(pt);
+        }
+        const boostBorderWidth = resolveAccessor(props.pointBorderStrokeWidth, firstCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+        for (const [key, pts] of batches) {
+          let d = "";
+          for (const pt of pts) {
+            const ptCtx = makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras });
+            d += buildMarkerShapePath(seriesShape, pt.x, pt.y, resolveMarkerSize(ptCtx));
+          }
+          const classDriven = key === CLASS_KEY;
+          const pathAttrs = {
+            "stroke-width": boostBorderWidth,
+            fill: classDriven ? themedSeriesColor : key,
+            stroke: boostBorderWidth <= 0 ? "none" : classDriven ? themedSeriesColor : key,
+            class: svgClass("p-chart-marker", `p-chart-series-${seriesIdx}`, classDriven && colorClassN)
+          };
+          appendChild(markerGroup, createSvgPath(d, pathAttrs));
+        }
+        boostBatched = true;
+      }
+    }
+    if (!boostBatched)
+      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 ptCtx = makeItemContext(props.data?.[pt.dataIndex], pt.dataIndex, { value: pt.value, category: pt.category, ...seriesExtras });
+        const userMarkerColor = pointColor ?? resolveAccessor(props.pointBackgroundColor, ptCtx, { arrayMode: "cycle" }) ?? (typeof lineColor === "string" ? lineColor : strokeColor);
+        const userBorderColor = resolveAccessor(props.pointBorderColor, ptCtx, { arrayMode: "cycle" }) ?? userMarkerColor;
+        const baseBorderWidth = resolveAccessor(props.pointBorderStrokeWidth, ptCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+        const ptHoverBg = resolveAccessor(props.pointHoverBackgroundColor, ptCtx, { arrayMode: "cycle" });
+        const ptHoverBorder = resolveAccessor(props.pointHoverBorderColor, ptCtx, { arrayMode: "cycle" });
+        const ptHoverBorderWidth = resolveAccessor(props.pointHoverBorderStrokeWidth, ptCtx, { arrayMode: "clip" });
+        const effectConfig = effects ? {
+          hoverBrightness: effects.hoverBrightness,
+          dimOpacity: effects.dimOpacity,
+          hoverBackgroundColor: ptHoverBg ?? effects.hoverBackgroundColor,
+          hoverBorderColor: ptHoverBorder ?? effects.hoverBorderColor,
+          hoverBorderStrokeWidth: ptHoverBorderWidth ?? effects.hoverBorderStrokeWidth
+        } : void 0;
+        const isInactive = hoverState.hasAnyHover && !hoverState.isHovered;
+        let renderFill;
+        let renderStroke;
+        let renderBorderWidth = baseBorderWidth;
+        let renderOpacity;
+        if (userMarkerColor !== void 0) {
+          const effectResult = applyHoverEffects(userMarkerColor, userBorderColor, baseBorderWidth, props.lineDash, props.lineDashOffset ?? 0, hoverState, effectConfig, context.theme);
+          renderFill = effectResult.color;
+          renderStroke = effectResult.borderColor;
+          renderBorderWidth = effectResult.borderStrokeWidth;
+          renderOpacity = effectResult.opacity;
+        } else if (hoverState.isHovered && effectConfig?.hoverBorderStrokeWidth !== void 0) {
+          renderBorderWidth = effectConfig.hoverBorderStrokeWidth;
+        }
+        const ptMarkerSize = resolveMarkerSize(ptCtx);
+        const currentSize = hoverState.isHovered ? effects?.hoverPointRadius ?? ptMarkerSize * (effects?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : ptMarkerSize;
+        const { fill: overrideFill, overridden: fillOverridden } = resolveSvgHoverFill(renderFill, hoverState.isHovered, effectConfig?.hoverBackgroundColor);
+        renderFill = overrideFill;
+        const themedSeriesColor = context.theme.series[seriesIdx % context.theme.series.length];
+        const cssClassApplied = renderFill === void 0;
+        const inlineStroke = cssClassApplied && userBorderColor !== void 0 ? userBorderColor : void 0;
+        const markerAttrs = {
+          "data-index": pt.dataIndex,
+          "stroke-width": renderBorderWidth,
+          "stroke-linejoin": props.pointBorderJoinStyle ?? "miter",
+          fill: renderFill ?? themedSeriesColor,
+          stroke: renderStroke ?? themedSeriesColor,
+          ...inlineStroke !== void 0 && { style: `stroke: ${inlineStroke}` },
+          ...renderOpacity !== void 0 && renderOpacity < 1 && { opacity: renderOpacity },
+          class: svgClass("p-chart-marker", `p-chart-series-${seriesIdx}`, renderFill === void 0 && colorClassN, hoverState.isHovered && !fillOverridden && "p-chart-point-hover", isInactive && "p-chart-point-inactive")
+        };
+        const ptDash = resolvePointDash(ptCtx);
+        if (ptDash && ptDash.length > 0) markerAttrs["stroke-dasharray"] = ptDash.join(" ");
+        const ptDashOffset = resolvePointDashOffset(ptCtx);
+        if (ptDashOffset) markerAttrs["stroke-dashoffset"] = ptDashOffset;
+        let markerEl;
+        const ptShape = resolveMarkerShape(ptCtx, currentSize);
+        const ptRotation = resolveMarkerRotation(ptCtx);
+        if (MARKER_SHAPE_NAMES.has(ptShape)) {
+          if (ptRotation !== 0) {
+            markerAttrs.transform = `rotate(${ptRotation}, ${pt.x}, ${pt.y})`;
+          }
+          markerEl = renderMarkerShapeSvg(ptShape, pt.x, pt.y, currentSize, markerAttrs);
+        } else {
+          const transformParts = [`translate(${pt.x}, ${pt.y})`];
+          if (ptRotation !== 0) transformParts.push(`rotate(${ptRotation})`);
+          markerAttrs.transform = transformParts.join(" ");
+          markerEl = createSvgPath(ptShape, markerAttrs);
+        }
+        if (a11yEnabled) {
+          const desc = formatPointDescription({ category: pt.category ?? `Point ${pt.dataIndex + 1}`, value: pt.value ?? 0, seriesName: props.name ?? "Series", index: pt.dataIndex }, a11y.pointDescriptionFormatter);
+          setAttr(markerEl, "role", "img");
+          setAttr(markerEl, "aria-label", desc);
+        }
+        appendChild(markerGroup, markerEl);
+      }
+    appendChild(group, markerGroup);
+  }
+  if (defsUsed) prependChild(group, defs);
+  return group;
+}
+
+export { renderLineSvg };