@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-AUF4CHDP.mjs

@@ -0,0 +1,422 @@
+import { resolveBorderRadius, clampRectBorderRadius, isUniformBorderRadius, hasBorderRadius } from './chunk-VGLSBZDN.mjs';
+import { isIndexVisible } from './chunk-5JCI2DEB.mjs';
+import { computeItemHoverState, applyHoverEffects } from './chunk-BZN2QHGP.mjs';
+import { batchResolveRequired, batchResolveAccessor, resolveAccessor, makeItemContext, getDefaultColor, resolveDash } from './chunk-O2X6FF45.mjs';
+import { calculateNiceDomain, createBandScale, createLinearScale } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/bar/shared.ts
+var EDGES = ["top", "right", "bottom", "left"];
+var EMPTY_EDGE_SET = /* @__PURE__ */ new Set();
+var TOP_SET = /* @__PURE__ */ new Set(["top"]);
+var BOTTOM_SET = /* @__PURE__ */ new Set(["bottom"]);
+var LEFT_SET = /* @__PURE__ */ new Set(["left"]);
+var RIGHT_SET = /* @__PURE__ */ new Set(["right"]);
+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();
+}
+function tracePartialBorder(pb, x, y, w, h, skipped, radius) {
+  const { topLeft: tl, topRight: tr, bottomRight: br, bottomLeft: bl } = radius;
+  const starts = {
+    top: [x + tl, y],
+    right: [x + w, y + tr],
+    bottom: [x + w - br, y + h],
+    left: [x, y + h - bl]
+  };
+  const ends = {
+    top: [x + w - tr, y],
+    right: [x + w, y + h - br],
+    bottom: [x + bl, y + h],
+    left: [x, y + tl]
+  };
+  const corners = {
+    "top\u2192right": { cx: x + w, cy: y, r: tr },
+    "right\u2192bottom": { cx: x + w, cy: y + h, r: br },
+    "bottom\u2192left": { cx: x, cy: y + h, r: bl },
+    "left\u2192top": { cx: x, cy: y, r: tl }
+  };
+  let firstSkippedIdx = -1;
+  for (let i = 0; i < 4; i++) {
+    if (skipped.has(EDGES[i])) {
+      firstSkippedIdx = i;
+      break;
+    }
+  }
+  if (firstSkippedIdx === -1) return;
+  let inRun = false;
+  let prevEdge = null;
+  for (let i = 1; i <= 4; i++) {
+    const idx = (firstSkippedIdx + i) % 4;
+    const edge = EDGES[idx];
+    if (skipped.has(edge)) {
+      inRun = false;
+      prevEdge = null;
+      continue;
+    }
+    if (!inRun) {
+      pb.moveTo(starts[edge][0], starts[edge][1]);
+      inRun = true;
+    } else if (prevEdge) {
+      const c = corners[`${prevEdge}\u2192${edge}`];
+      pb.arcTo(c.cx, c.cy, starts[edge][0], starts[edge][1], c.r);
+    }
+    pb.lineTo(ends[edge][0], ends[edge][1]);
+    prevEdge = edge;
+  }
+}
+
+// src/series/bar/geom/layout.ts
+var DEFAULT_ORIENTATION = "vertical";
+var DEFAULT_BASE = 0;
+function resolveSkippedEdges(borderSkipped, orientation, isNegative) {
+  if (borderSkipped === false || borderSkipped === void 0) return EMPTY_EDGE_SET;
+  if (borderSkipped === "start") {
+    if (orientation === "vertical") return isNegative ? TOP_SET : BOTTOM_SET;
+    return isNegative ? RIGHT_SET : LEFT_SET;
+  }
+  if (borderSkipped === "end") {
+    if (orientation === "vertical") return isNegative ? BOTTOM_SET : TOP_SET;
+    return isNegative ? LEFT_SET : RIGHT_SET;
+  }
+  switch (borderSkipped) {
+    case "top":
+      return TOP_SET;
+    case "bottom":
+      return BOTTOM_SET;
+    case "left":
+      return LEFT_SET;
+    case "right":
+      return RIGHT_SET;
+  }
+}
+function calculateBarLayout(props, chartArea, config) {
+  const { data, categoryField, valueField, color: colorProp, orientation = DEFAULT_ORIENTATION, visibility } = props;
+  const categoryAccessor = categoryField;
+  const valueAccessor = valueField;
+  const openAccessor = props.openField;
+  const base = props.base ?? DEFAULT_BASE;
+  const categories = categoryAccessor ? batchResolveRequired(categoryAccessor, data, "categoryField") : data.map((_, i) => String(i));
+  const values = valueAccessor ? batchResolveRequired(valueAccessor, data, "valueField") : data.map(() => 0);
+  const openValues = openAccessor ? batchResolveAccessor(openAccessor, data) : void 0;
+  let valueDomain;
+  let categoryScale;
+  let valueScale;
+  if (config?.categoryScale && config?.valueScale) {
+    categoryScale = config.categoryScale;
+    valueScale = config.valueScale;
+    valueDomain = config.valueScale.domain();
+  } else {
+    valueDomain = calculateNiceDomain(values, { includeZero: true });
+    if (orientation === "vertical") {
+      categoryScale = createBandScale(categories, [chartArea.x, chartArea.x + chartArea.width]);
+      valueScale = createLinearScale(valueDomain, [chartArea.y + chartArea.height, chartArea.y]);
+    } else {
+      categoryScale = createBandScale(categories, [chartArea.y, chartArea.y + chartArea.height]);
+      valueScale = createLinearScale(valueDomain, [chartArea.x, chartArea.x + chartArea.width]);
+    }
+  }
+  const borderColorProp = props.borderColor;
+  const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+  const bars = [];
+  const colors = [];
+  const borderColors = [];
+  const effectiveBase = base >= valueDomain[0] && base <= valueDomain[1] ? base : valueDomain[0];
+  const defaultBasePosition = valueScale(effectiveBase);
+  const bandwidth = categoryScale.bandwidth();
+  const slotWidth = config?.groupBarWidth ?? bandwidth;
+  const groupOffset = config?.groupOffset ?? 0;
+  let hasHiddenBars = false;
+  const barThickness = props.barThickness;
+  const maxBarThickness = props.maxBarThickness;
+  let effectiveBarWidth = slotWidth;
+  if (barThickness !== void 0) {
+    effectiveBarWidth = barThickness;
+  } else if (maxBarThickness !== void 0) {
+    effectiveBarWidth = Math.min(slotWidth, maxBarThickness);
+  }
+  const barCenterOffset = effectiveBarWidth < slotWidth ? (slotWidth - effectiveBarWidth) / 2 : 0;
+  const minBarLength = props.minBarLength;
+  const connectNulls = props.connectNulls ?? "gap";
+  const skipNullEnabled = connectNulls === "gap" || connectNulls === false;
+  for (let i = 0; i < data.length; i++) {
+    const category = categories[i];
+    const rawValue = values[i];
+    const visible = isIndexVisible(visibility, i);
+    const isNullValue = rawValue === null || rawValue === void 0 || Number.isNaN(rawValue);
+    if (skipNullEnabled && isNullValue) {
+      bars.push({
+        dataIndex: i,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        value: 0,
+        category,
+        visible: false,
+        isNegative: false
+      });
+      colors.push("transparent");
+      borderColors.push("transparent");
+      hasHiddenBars = true;
+      continue;
+    }
+    const value = isNullValue ? 0 : rawValue;
+    const barBase = openValues ? openValues[i] ?? base : base;
+    const basePosition = openValues ? valueScale(barBase) : defaultBasePosition;
+    const isNegative = value < barBase;
+    if (!visible) hasHiddenBars = true;
+    let x, y, width, height;
+    const catPos = config?.categoryPositions?.[i];
+    if (orientation === "vertical") {
+      if (catPos) {
+        const catSlot = catPos.size;
+        const catBarWidth = barThickness !== void 0 ? barThickness : maxBarThickness !== void 0 ? Math.min(catSlot, maxBarThickness) : catSlot;
+        const catCenterOff = catBarWidth < catSlot ? (catSlot - catBarWidth) / 2 : 0;
+        x = catPos.pos + catCenterOff;
+        width = catBarWidth;
+      } else {
+        x = categoryScale(category) + groupOffset + barCenterOffset;
+        width = effectiveBarWidth;
+      }
+      if (config?.stackBases) {
+        const stackBase = config.stackBases[i] ?? 0;
+        const endPixel = valueScale(stackBase + value);
+        const basePixel = valueScale(stackBase);
+        y = Math.min(endPixel, basePixel);
+        height = Math.abs(endPixel - basePixel);
+      } else if (isNegative) {
+        y = basePosition;
+        height = valueScale(value) - basePosition;
+      } else {
+        y = valueScale(value);
+        height = basePosition - valueScale(value);
+      }
+      if (minBarLength !== void 0) {
+        const absHeight = Math.abs(height);
+        if (absHeight < minBarLength && absHeight >= 0) {
+          if (isNegative) {
+            height = minBarLength;
+          } else {
+            y = y + absHeight - minBarLength;
+            height = minBarLength;
+          }
+        }
+      }
+    } else {
+      if (catPos) {
+        const catSlot = catPos.size;
+        const catBarHeight = barThickness !== void 0 ? barThickness : maxBarThickness !== void 0 ? Math.min(catSlot, maxBarThickness) : catSlot;
+        const catCenterOff = catBarHeight < catSlot ? (catSlot - catBarHeight) / 2 : 0;
+        y = catPos.pos + catCenterOff;
+        height = catBarHeight;
+      } else {
+        y = categoryScale(category) + groupOffset + barCenterOffset;
+        height = effectiveBarWidth;
+      }
+      if (config?.stackBases) {
+        const stackBase = config.stackBases[i] ?? 0;
+        const basePixel = valueScale(stackBase);
+        const endPixel = valueScale(stackBase + value);
+        x = Math.min(basePixel, endPixel);
+        width = Math.abs(endPixel - basePixel);
+      } else if (isNegative) {
+        x = valueScale(value);
+        width = basePosition - valueScale(value);
+      } else {
+        x = basePosition;
+        width = valueScale(value) - basePosition;
+      }
+      if (minBarLength !== void 0) {
+        const absWidth = Math.abs(width);
+        if (absWidth < minBarLength && absWidth >= 0) {
+          if (isNegative) {
+            x = x + absWidth - minBarLength;
+            width = minBarLength;
+          } else {
+            width = minBarLength;
+          }
+        }
+      }
+    }
+    if (Number.isNaN(x) || Number.isNaN(y) || Number.isNaN(width) || Number.isNaN(height)) {
+      bars.push({ dataIndex: i, x: 0, y: 0, width: 0, height: 0, value, category, visible: false, isNegative });
+      colors.push("transparent");
+      borderColors.push("transparent");
+      hasHiddenBars = true;
+      continue;
+    }
+    bars.push({
+      dataIndex: i,
+      x: width < 0 ? x + width : x,
+      y: height < 0 ? y + height : y,
+      width: Math.abs(width),
+      height: Math.abs(height),
+      value,
+      category,
+      visible,
+      isNegative
+    });
+    let color;
+    let borderColor;
+    if (colorProp != null) {
+      const resolved = resolveAccessor(colorProp, makeItemContext(data[i], i, { value, category, ...seriesExtras }));
+      if (resolved) color = resolved;
+    }
+    colors.push(color);
+    if (borderColorProp) {
+      const resolvedBorderColor = resolveAccessor(borderColorProp, makeItemContext(data[i], i, { value, category, ...seriesExtras }));
+      if (resolvedBorderColor) {
+        borderColor = resolvedBorderColor;
+      }
+    }
+    borderColors.push(borderColor ?? "transparent");
+  }
+  const visibleBars = hasHiddenBars ? bars.filter((b) => b.visible) : bars;
+  return {
+    bars,
+    visibleBars,
+    categoryScale,
+    valueScale,
+    orientation,
+    colors,
+    borderColors,
+    chartArea,
+    valueDomain,
+    base,
+    openValues
+  };
+}
+
+// src/series/bar/geom/render-state.ts
+function computeBarRenderStates(props, layout, theme) {
+  const { interaction, effects } = props;
+  const { visibleBars, colors, borderColors, orientation } = layout;
+  const dataArr = props.data;
+  const resolveBarBorderRadius = (ctx) => props.borderRadius === void 0 ? 0 : resolveAccessor(props.borderRadius, ctx, { arrayMode: "clip" }) ?? 0;
+  const resolveBarBorderWidth = (ctx) => props.borderStrokeWidth === void 0 ? 0 : resolveAccessor(props.borderStrokeWidth, ctx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolveBarBorderDash = (ctx) => props.borderDash === void 0 ? void 0 : resolveDash(props.borderDash, ctx);
+  const resolveBarBorderDashOffset = (ctx) => props.borderDashOffset === void 0 ? 0 : resolveAccessor(props.borderDashOffset, ctx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolveBarOpacity = (ctx) => props.opacity === void 0 ? void 0 : resolveAccessor(props.opacity, ctx, { arrayMode: "clip" });
+  const resolveBarHoverColor = (ctx) => props.hoverColor === void 0 ? void 0 : resolveAccessor(props.hoverColor, ctx, { arrayMode: "cycle" });
+  const resolveBarHoverBorderColor = (ctx) => props.hoverBorderColor === void 0 ? void 0 : resolveAccessor(props.hoverBorderColor, ctx, { arrayMode: "cycle" });
+  const borderJoinStyle = props.borderJoinStyle ?? "miter";
+  const borderAlign = props.borderAlign ?? "center";
+  const resolveBarBorderSkipped = (ctx) => props.borderSkipped === void 0 ? void 0 : resolveAccessor(props.borderSkipped, ctx, { arrayMode: "clip" });
+  const hoverEnabled = effects !== void 0;
+  const isSeriesDimmed = interaction?.isSeriesDimmed ?? false;
+  const isSeriesHovered = interaction?.isSeriesHovered ?? false;
+  const seriesIdx = props.order ?? 0;
+  const seriesExtras = { seriesIndex: seriesIdx, seriesId: props.id ?? "" };
+  const bars = visibleBars.map((bar) => {
+    const { dataIndex, width, height, isNegative } = bar;
+    const ctx = makeItemContext(dataArr[dataIndex], dataIndex, { value: bar.value, category: bar.category, ...seriesExtras });
+    const userFill = colors[dataIndex];
+    const borderColor = borderColors[dataIndex];
+    const borderWidth = resolveBarBorderWidth(ctx);
+    const resolvedRadius = resolveBorderRadius(resolveBarBorderRadius(ctx));
+    const canvasFill = userFill ?? getDefaultColor(seriesIdx, theme);
+    let hoverState;
+    if (hoverEnabled && isSeriesDimmed) {
+      hoverState = { isHovered: false, hasAnyHover: true };
+    } else if (hoverEnabled && isSeriesHovered) {
+      hoverState = { isHovered: true, hasAnyHover: true };
+    } else {
+      hoverState = computeItemHoverState(dataIndex, interaction?.hoveredIndex, hoverEnabled);
+    }
+    const isInactive = hoverState.hasAnyHover && !hoverState.isHovered;
+    const itemHoverColor = resolveBarHoverColor(ctx);
+    const itemHoverBorderColor = resolveBarHoverBorderColor(ctx);
+    const itemEffects = hoverEnabled && effects && (itemHoverColor !== void 0 || itemHoverBorderColor !== void 0) ? {
+      ...effects,
+      hoverBackgroundColor: itemHoverColor ?? effects.hoverBackgroundColor,
+      hoverBorderColor: itemHoverBorderColor ?? effects.hoverBorderColor
+    } : hoverEnabled ? effects : void 0;
+    const {
+      color: effectColor,
+      opacity: hoverOpacity,
+      borderColor: effectBorderColor,
+      borderStrokeWidth: effectBorderWidth,
+      borderDash: effectBorderDash,
+      borderDashOffset: effectBorderDashOffset
+    } = applyHoverEffects(canvasFill, borderColor, borderWidth, resolveBarBorderDash(ctx), resolveBarBorderDashOffset(ctx), hoverState, itemEffects, theme);
+    const userOpacity = resolveBarOpacity(ctx);
+    const opacity = userOpacity !== void 0 ? hoverOpacity * userOpacity : hoverOpacity;
+    const isItemHovered = hoverEnabled && (isSeriesHovered ? interaction?.hoveredIndex === dataIndex : hoverState.isHovered);
+    let offsetX = 0;
+    let offsetY = 0;
+    if (isItemHovered && effects?.hoverOffset && effects.hoverOffset > 0) {
+      if (orientation === "vertical") {
+        offsetY = isNegative ? effects.hoverOffset : -effects.hoverOffset;
+      } else {
+        offsetX = isNegative ? -effects.hoverOffset : effects.hoverOffset;
+      }
+    }
+    const hoverScale = isItemHovered && effects?.hoverScale ? effects.hoverScale : 1;
+    const drawWidth = width * hoverScale;
+    const drawHeight = height * hoverScale;
+    const clampedRadius = clampRectBorderRadius(resolvedRadius, drawWidth, drawHeight);
+    const skippedEdges = resolveSkippedEdges(resolveBarBorderSkipped(ctx), orientation, isNegative);
+    return {
+      bar,
+      effectColor,
+      effectBorderColor,
+      effectBorderWidth,
+      effectBorderDash,
+      effectBorderDashOffset,
+      opacity,
+      // SVG state — class composition + inline overrides
+      userFill,
+      hoverColorOverride: itemEffects?.hoverBackgroundColor,
+      userBorder: borderColor === "transparent" ? void 0 : borderColor,
+      seriesIdx,
+      isHovered: hoverState.isHovered,
+      isInactive,
+      drawX: bar.x + offsetX - (drawWidth - width) / 2,
+      drawY: bar.y + offsetY - (drawHeight - height) / 2,
+      drawWidth,
+      drawHeight,
+      clampedRadius,
+      hasRadius: hasBorderRadius(clampedRadius),
+      uniformRadius: isUniformBorderRadius(clampedRadius),
+      skippedEdges
+    };
+  });
+  return { bars, borderJoinStyle, borderAlign };
+}
+function computeBarLabelPosition(bar, orientation, padding = 6) {
+  if (orientation === "vertical") {
+    return {
+      x: bar.x + bar.width / 2,
+      y: bar.isNegative ? bar.y + bar.height + padding : bar.y - padding,
+      textAnchor: "middle",
+      baseline: bar.isNegative ? "hanging" : "auto"
+    };
+  }
+  return {
+    x: bar.isNegative ? bar.x - padding : bar.x + bar.width + padding,
+    y: bar.y + bar.height / 2,
+    textAnchor: bar.isNegative ? "end" : "start",
+    baseline: "central"
+  };
+}
+function hitTestBar(x, y, _props, layout) {
+  const { visibleBars } = layout;
+  for (let i = visibleBars.length - 1; i >= 0; i--) {
+    const bar = visibleBars[i];
+    if (x >= bar.x && x <= bar.x + bar.width && y >= bar.y && y <= bar.y + bar.height) {
+      return bar.dataIndex;
+    }
+  }
+  return null;
+}
+
+export { calculateBarLayout, computeBarLabelPosition, computeBarRenderStates, hitTestBar, resolveSkippedEdges, tracePartialBorder, traceRoundedRect };