@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-6STOLMCA.mjs

@@ -0,0 +1,187 @@
+import { DEFAULT_MARKER_SHAPE } from './chunk-AP3UYWYT.mjs';
+import { isBoostActive } from './chunk-DTWTCFRG.mjs';
+import { MARKER_SHAPE_NAMES, buildMarkerShapePath, renderMarkerShapeSvg } from './chunk-PRDVPOZX.mjs';
+import { computeItemHoverState, applyHoverEffects, resolveSvgHoverFill } from './chunk-BZN2QHGP.mjs';
+import { formatPointDescription } from './chunk-OGJ6IIBW.mjs';
+import { DEFAULT_HOVER_DIM_OPACITY, SCATTER_SVG_CEILING_WARNING, DEFAULT_SCATTER_FILL_OPACITY, DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER, DEFAULT_SCATTER_BORDER_WIDTH } from './chunk-NKUYIWAP.mjs';
+import { getPrimaryColor, makeItemContext, isGradientColor, createSvgGradientFromColor, resolveAccessor, resolveDash } from './chunk-O2X6FF45.mjs';
+import { createSvgGroup, createSvgDefs, svgClass, appendChild, createSvgPath, setAttr } from './chunk-SSLTFJ3U.mjs';
+import { warnChartDevOnce } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/scatter/svg/index.ts
+function renderScatterSvg(props, layout, context) {
+  const isSeriesDimmed = props.interaction?.isSeriesDimmed ?? false;
+  const effects = props.effects;
+  const seriesDimOpacity = isSeriesDimmed ? effects?.dimOpacity ?? context.theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY : 1;
+  const animationOpacity = props.animationOpacity ?? 1;
+  const groupOpacity = seriesDimOpacity * animationOpacity;
+  const boostActive = isBoostActive(props, layout.visiblePoints.length);
+  const seriesExtras = { seriesIndex: layout.seriesIdx, seriesId: props.id ?? "" };
+  if (layout.visiblePoints.length >= SCATTER_SVG_CEILING_WARNING) {
+    warnChartDevOnce(
+      "scatter-svg-ceiling",
+      `SVG scatter is rendering ${layout.visiblePoints.length.toLocaleString()} points. Above ~10k points, prefer <ChartCanvas> or wrap the dataset in <ChartDecimation> for materially better performance.`
+    );
+  }
+  const group = createSvgGroup(void 0, { class: "scatter-series", ...groupOpacity < 1 && { opacity: String(groupOpacity) } });
+  const scatterDataArr = props.data;
+  const resolveMarkerShape = (i, size, value, category) => resolveAccessor(props.markerShape, makeItemContext(scatterDataArr[i], i, { size, value, category, ...seriesExtras }), { arrayMode: "clip" }) ?? DEFAULT_MARKER_SHAPE;
+  const resolvePointOpacity = (ctx) => resolveAccessor(props.opacity, ctx, { arrayMode: "clip" });
+  const seriesIdx = layout.seriesIdx;
+  const colorClassN = `p-chart-color-${seriesIdx % 10}`;
+  const hoveredIndex = boostActive ? null : props.interaction?.hoveredIndex ?? null;
+  const anyHovered = hoveredIndex !== null;
+  const a11y = context.accessibility;
+  const a11yEnabled = !!(a11y?.enabled && layout.visiblePoints.length <= (a11y.pointDescriptionThreshold ?? 200));
+  if (props.renderMarker) return group;
+  const defs = createSvgDefs();
+  const markerGroup = createSvgGroup(void 0, { class: "scatter-markers" });
+  let hasDefs = false;
+  const baseBorderColorShared = props.pointBorderColor != null ? props.pointBorderColor : void 0;
+  const borderWidthAccessor = props.pointBorderStrokeWidth;
+  const dataArr = props.data;
+  const resolveBorderWidth = (ctx) => resolveAccessor(borderWidthAccessor, ctx, { arrayMode: "clip", fallback: DEFAULT_SCATTER_BORDER_WIDTH }) ?? DEFAULT_SCATTER_BORDER_WIDTH;
+  const resolvePointDash = (ctx) => resolveDash(props.pointBorderDash, ctx);
+  const resolvePointDashOffset = (ctx) => resolveAccessor(props.pointBorderDashOffset, ctx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolvePtHoverBg = (ctx) => resolveAccessor(props.pointHoverBackgroundColor, ctx, { arrayMode: "cycle" });
+  const resolvePtHoverBorder = (ctx) => resolveAccessor(props.pointHoverBorderColor, ctx, { arrayMode: "cycle" });
+  const resolvePtHoverBorderWidth = (ctx) => resolveAccessor(props.pointHoverBorderStrokeWidth, ctx, { arrayMode: "clip" });
+  const fillOpacity = props.pointFillOpacity ?? DEFAULT_SCATTER_FILL_OPACITY;
+  const baseEffectConfig = boostActive || !effects ? void 0 : {
+    hoverBrightness: effects.hoverBrightness,
+    dimOpacity: effects.dimOpacity,
+    hoverBackgroundColor: effects.hoverBackgroundColor,
+    hoverBorderColor: effects.hoverBorderColor,
+    hoverBorderStrokeWidth: effects.hoverBorderStrokeWidth
+  };
+  const needsHoverCalc = anyHovered || baseEffectConfig;
+  if (boostActive && typeof props.markerShape !== "function" && layout.visiblePoints.length > 0) {
+    const first = layout.visiblePoints[0];
+    const seriesShape = resolveMarkerShape(first.dataIndex, first.radius, first.yValue, String(first.xValue));
+    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 key = pt.color !== void 0 ? getPrimaryColor(pt.color) : CLASS_KEY;
+        let bucket = batches.get(key);
+        if (!bucket) batches.set(key, bucket = []);
+        bucket.push(pt);
+      }
+      const boostBorderWidth = resolveBorderWidth(makeItemContext(dataArr[first.dataIndex], first.dataIndex, { value: first.yValue, category: String(first.xValue), ...seriesExtras }));
+      const boostBorderColor = baseBorderColorShared ? getPrimaryColor(baseBorderColorShared) : void 0;
+      for (const [key, pts] of batches) {
+        let d = "";
+        for (const pt of pts) d += buildMarkerShapePath(seriesShape, pt.px, pt.py, pt.radius);
+        const classDriven = key === CLASS_KEY;
+        const pathAttrs = {
+          "fill-opacity": fillOpacity,
+          "stroke-width": boostBorderWidth,
+          fill: classDriven ? themedSeriesColor : key,
+          stroke: boostBorderWidth <= 0 ? "none" : classDriven ? themedSeriesColor : boostBorderColor ?? key,
+          class: svgClass("p-chart-marker", `p-chart-series-${seriesIdx}`, classDriven && colorClassN)
+        };
+        appendChild(markerGroup, createSvgPath(d, pathAttrs));
+      }
+      appendChild(group, markerGroup);
+      return group;
+    }
+  }
+  for (const pt of layout.visiblePoints) {
+    const itemCtx = makeItemContext(dataArr[pt.dataIndex], pt.dataIndex, { value: pt.yValue, category: String(pt.xValue), ...seriesExtras });
+    const userFill = pt.color;
+    const userBorder = baseBorderColorShared ?? (userFill !== void 0 ? getPrimaryColor(userFill) : void 0);
+    const ptBorderWidth = resolveBorderWidth(itemCtx);
+    let fillColor = userFill;
+    let strokeColor = userBorder;
+    let strokeWidth = ptBorderWidth;
+    let opacity = 1;
+    let isHovered = false;
+    let isInactive = false;
+    let hoverBgOverride;
+    if (needsHoverCalc) {
+      const hoverState = computeItemHoverState(pt.dataIndex, hoveredIndex, anyHovered);
+      isHovered = hoverState.isHovered;
+      isInactive = hoverState.hasAnyHover && !isHovered;
+      const ptHoverBg = resolvePtHoverBg(itemCtx);
+      const ptHoverBorder = resolvePtHoverBorder(itemCtx);
+      const ptHoverBorderWidth = resolvePtHoverBorderWidth(itemCtx);
+      const effectConfig = baseEffectConfig ? {
+        ...baseEffectConfig,
+        hoverBackgroundColor: ptHoverBg ?? baseEffectConfig.hoverBackgroundColor,
+        hoverBorderColor: ptHoverBorder ?? baseEffectConfig.hoverBorderColor,
+        hoverBorderStrokeWidth: ptHoverBorderWidth ?? baseEffectConfig.hoverBorderStrokeWidth
+      } : void 0;
+      hoverBgOverride = effectConfig?.hoverBackgroundColor;
+      if (userFill !== void 0) {
+        const effectResult = applyHoverEffects(userFill, userBorder ?? userFill, ptBorderWidth, void 0, 0, hoverState, effectConfig, context.theme);
+        fillColor = effectResult.color;
+        strokeColor = effectResult.borderColor;
+        strokeWidth = effectResult.borderStrokeWidth;
+        opacity = effectResult.opacity;
+      } else if (isHovered && effectConfig?.hoverBorderStrokeWidth !== void 0) {
+        strokeWidth = effectConfig.hoverBorderStrokeWidth;
+      }
+    }
+    const currentSize = isHovered ? effects?.hoverPointRadius ?? pt.radius * (effects?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : pt.radius;
+    const userOpacity = resolvePointOpacity(itemCtx);
+    if (userOpacity !== void 0) opacity *= userOpacity;
+    const pointFillOpacity = isHovered ? 1 : fillOpacity;
+    let fillAttr;
+    if (fillColor !== void 0) {
+      if (isGradientColor(fillColor)) {
+        const gradientId = `${context.chartId}-scatter-${layout.datasetIndex}-grad-${pt.dataIndex}`;
+        appendChild(defs, createSvgGradientFromColor(fillColor, gradientId, { x: pt.px, y: pt.py }, currentSize, layout.chartArea));
+        fillAttr = `url(#${gradientId})`;
+        hasDefs = true;
+      } else {
+        fillAttr = fillColor;
+      }
+    }
+    const { fill: ovFillAttr, overridden: fillOverridden } = resolveSvgHoverFill(fillAttr, isHovered, hoverBgOverride);
+    fillAttr = ovFillAttr;
+    const markerCls = svgClass("p-chart-marker", `p-chart-series-${seriesIdx}`, fillAttr === void 0 && colorClassN, isHovered && !fillOverridden && "p-chart-point-hover", isInactive && "p-chart-point-inactive");
+    const themedSeriesColor = context.theme.series[seriesIdx % context.theme.series.length];
+    const strokeStr = strokeColor === void 0 ? void 0 : strokeColor;
+    const useInlineStroke = fillAttr === void 0 && baseBorderColorShared !== void 0 && strokeStr !== void 0;
+    const markerAttrs = {
+      "fill-opacity": pointFillOpacity,
+      "stroke-width": strokeWidth,
+      "stroke-linejoin": props.pointBorderJoinStyle ?? "miter",
+      fill: fillAttr ?? themedSeriesColor,
+      stroke: strokeStr ?? themedSeriesColor,
+      ...useInlineStroke && { style: `stroke: ${strokeStr}` },
+      ...opacity < 1 && { opacity },
+      class: markerCls
+    };
+    const ptDash = resolvePointDash(itemCtx);
+    const ptDashOffset = resolvePointDashOffset(itemCtx);
+    if (ptDash && ptDash.length > 0) markerAttrs["stroke-dasharray"] = ptDash.join(" ");
+    if (ptDashOffset) markerAttrs["stroke-dashoffset"] = ptDashOffset;
+    let markerEl;
+    const ptShape = resolveMarkerShape(pt.dataIndex, currentSize, pt.yValue, String(pt.xValue));
+    if (MARKER_SHAPE_NAMES.has(ptShape)) {
+      if (pt.rotation !== 0) {
+        markerAttrs.transform = `rotate(${pt.rotation}, ${pt.px}, ${pt.py})`;
+      }
+      markerEl = renderMarkerShapeSvg(ptShape, pt.px, pt.py, currentSize, markerAttrs);
+    } else {
+      const transformParts = [`translate(${pt.px}, ${pt.py})`];
+      if (pt.rotation !== 0) transformParts.push(`rotate(${pt.rotation})`);
+      markerAttrs.transform = transformParts.join(" ");
+      markerEl = createSvgPath(ptShape, markerAttrs);
+    }
+    if (a11yEnabled) {
+      const desc = formatPointDescription({ category: `(${pt.xValue}, ${pt.yValue})`, value: pt.yValue, seriesName: props.name ?? "Series", index: pt.dataIndex }, a11y.pointDescriptionFormatter);
+      setAttr(markerEl, "role", "img");
+      setAttr(markerEl, "aria-label", desc);
+    }
+    setAttr(markerEl, "data-index", String(pt.dataIndex));
+    appendChild(markerGroup, markerEl);
+  }
+  if (hasDefs) appendChild(group, defs);
+  appendChild(group, markerGroup);
+  return group;
+}
+
+export { renderScatterSvg };

package/dist/chunk-7CMVDIOU.mjs

@@ -0,0 +1,54 @@
+// src/utils/image.cache.ts
+var MAX_CACHE = 100;
+var imageCache = /* @__PURE__ */ new Map();
+var corsFailedUrls = /* @__PURE__ */ new Set();
+function evictIfFull() {
+  if (imageCache.size >= MAX_CACHE) {
+    const first = imageCache.keys().next().value;
+    if (first !== void 0) imageCache.delete(first);
+  }
+}
+function rememberCorsFailure(url) {
+  if (corsFailedUrls.size >= MAX_CACHE) {
+    const first = corsFailedUrls.values().next().value;
+    if (first !== void 0) corsFailedUrls.delete(first);
+  }
+  corsFailedUrls.add(url);
+}
+function createDrawImage(ctx, onImageLoad) {
+  return (url, x, y, w, h) => {
+    let img = imageCache.get(url);
+    if (img && img.complete && img.naturalWidth > 0) {
+      const nw = img.naturalWidth;
+      const nh = img.naturalHeight;
+      const scale = Math.min(w / nw, h / nh);
+      const dw = nw * scale;
+      const dh = nh * scale;
+      ctx.drawImage(img, x + (w - dw) / 2, y + (h - dh) / 2, dw, dh);
+      return;
+    }
+    if (!img) {
+      img = new Image();
+      img.onload = onImageLoad;
+      if (corsFailedUrls.has(url)) {
+        img.src = url;
+      } else {
+        img.crossOrigin = "anonymous";
+        img.onerror = () => {
+          rememberCorsFailure(url);
+          imageCache.delete(url);
+          const retryImg = new Image();
+          retryImg.onload = onImageLoad;
+          retryImg.src = url;
+          evictIfFull();
+          imageCache.set(url, retryImg);
+        };
+        img.src = url;
+      }
+      evictIfFull();
+      imageCache.set(url, img);
+    }
+  };
+}
+
+export { createDrawImage };

package/dist/chunk-7QQ6ETB4.mjs

@@ -0,0 +1,228 @@
+import { renderBarCanvas } from './chunk-X7T34OLW.mjs';
+import { renderBarSvg } from './chunk-SALTGZFR.mjs';
+import { hitTestBar, calculateBarLayout } from './chunk-AUF4CHDP.mjs';
+import { DEFAULT_HOVER_OFFSET, DEFAULT_HOVER_DIM_OPACITY, DEFAULT_HOVER_BRIGHTNESS } from './chunk-NKUYIWAP.mjs';
+import { batchResolveAccessor, batchResolveRequired } from './chunk-O2X6FF45.mjs';
+
+// src/series/bar/geom/visual-layout.ts
+function computeBarVisualLayout(input) {
+  const { intermediate, sharedCategoryScale, valueScales, valueDomains, cartesianArea, orientation, axisLayouts, hover, hoverConfig, theme } = input;
+  const { barDatasets, visibleBarDatasets, mode, valuesPerDataset, stackBasesMap, groupLayout, fullGroupLayout, isVariwide, barGap, datasetAxisMap, firstValueAxisId } = intermediate;
+  const categories = sharedCategoryScale.domain();
+  const sharedValueScale = valueScales.get(firstValueAxisId) ?? valueScales.values().next().value;
+  const layouts = /* @__PURE__ */ new Map();
+  const renderPropsMap = /* @__PURE__ */ new Map();
+  const allTargets = [];
+  const base = barDatasets[0]?.props?.base ?? 0;
+  const syntheticDataMap = /* @__PURE__ */ new Map();
+  if (mode.isPercentStacked || mode.isWaterfall) {
+    for (let dsIdx = 0; dsIdx < barDatasets.length; dsIdx++) {
+      const ds = barDatasets[dsIdx];
+      syntheticDataMap.set(
+        ds.id,
+        ds.props.data.map((item, i) => ({
+          ...item,
+          [ds.props.valueField]: valuesPerDataset[dsIdx][i]
+        }))
+      );
+    }
+  }
+  const valueAxisPrefix = orientation === "vertical" ? "y" : "x";
+  let visibleSeriesIdx = 0;
+  const visibleGroupIdxMap = /* @__PURE__ */ new Map();
+  const allGroupIdxMap = /* @__PURE__ */ new Map();
+  if (mode.isGrouped && mode.isStacked) {
+    let vIdx = 0;
+    let aIdx = 0;
+    for (const ds of barDatasets) {
+      const sid = ds.stackId;
+      if (!allGroupIdxMap.has(sid)) allGroupIdxMap.set(sid, aIdx++);
+    }
+    for (const ds of visibleBarDatasets) {
+      const sid = ds.stackId;
+      if (!visibleGroupIdxMap.has(sid)) visibleGroupIdxMap.set(sid, vIdx++);
+    }
+  }
+  for (let dsIdx = 0; dsIdx < barDatasets.length; dsIdx++) {
+    const ds = barDatasets[dsIdx];
+    const barProps = ds.props;
+    const renderProps = {
+      ...barProps,
+      ...syntheticDataMap.has(ds.id) ? { data: syntheticDataMap.get(ds.id) } : {},
+      categoryField: barProps.categoryField,
+      valueField: barProps.valueField,
+      interaction: {
+        hoveredIndex: hover.datasetId === ds.id ? hover.index : null
+      },
+      effects: hoverConfig ? {
+        ...hoverConfig,
+        hoverBrightness: hoverConfig.hoverBrightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS,
+        dimOpacity: hoverConfig.dimOpacity ?? theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY,
+        hoverOffset: hoverConfig.hoverOffset ?? DEFAULT_HOVER_OFFSET
+      } : void 0
+    };
+    const targetAxisId = datasetAxisMap.get(ds.id) ?? firstValueAxisId;
+    const targetValueScale = valueScales.get(targetAxisId) ?? sharedValueScale;
+    const axisKey = `${valueAxisPrefix}:${targetAxisId}`;
+    const axisInfo = axisLayouts.get(axisKey);
+    const targetAxisType = axisInfo?.props?.type;
+    const effectiveBase = targetAxisType === "logarithmic" ? valueDomains.get(targetAxisId)?.[0] ?? base : base;
+    if (targetAxisType === "logarithmic") {
+      renderProps.base = effectiveBase;
+    }
+    const multiConfig = {
+      categoryScale: sharedCategoryScale,
+      valueScale: targetValueScale,
+      stackBases: stackBasesMap?.get(ds.id),
+      groupOffset: mode.isGrouped && ds.visible ? groupLayout.getOffset(mode.isStacked ? visibleGroupIdxMap.get(ds.stackId) : visibleSeriesIdx) : void 0,
+      groupBarWidth: mode.isGrouped && ds.visible ? groupLayout.barWidth : void 0
+    };
+    if (mode.isOverlap && ds.visible) {
+      const totalVisible = visibleBarDatasets.length;
+      const bandwidth = sharedCategoryScale.bandwidth();
+      if (totalVisible === 1) {
+        multiConfig.groupBarWidth = bandwidth;
+        multiConfig.groupOffset = 0;
+      } else {
+        const minRatio = Math.max(0.3, 1 - (totalVisible - 1) * 0.3);
+        const widthRatio = 1 - visibleSeriesIdx / (totalVisible - 1) * (1 - minRatio);
+        const barWidth = bandwidth * widthRatio;
+        multiConfig.groupBarWidth = barWidth;
+        multiConfig.groupOffset = (bandwidth - barWidth) / 2;
+      }
+    }
+    if (isVariwide && sharedCategoryScale.bandwidthAt) {
+      const catPositions = [];
+      for (let i = 0; i < categories.length; i++) {
+        const catLeft = sharedCategoryScale(categories[i]);
+        const catBw = sharedCategoryScale.bandwidthAt(i);
+        if (mode.isGrouped && ds.visible) {
+          const groupCount = mode.isStacked ? visibleGroupIdxMap.size : visibleBarDatasets.length;
+          const groupSlot = mode.isStacked ? visibleGroupIdxMap.get(ds.stackId) : visibleSeriesIdx;
+          const barGapRatio = barGap ?? 0.02;
+          const gapPx = catBw * barGapRatio;
+          const totalGapPx = gapPx * (groupCount - 1);
+          const perSeriesWidth = (catBw - totalGapPx) / groupCount;
+          const seriesOffset = groupSlot * (perSeriesWidth + gapPx);
+          catPositions.push({ pos: catLeft + seriesOffset, size: perSeriesWidth });
+        } else if (mode.isOverlap && ds.visible) {
+          const totalVisible = visibleBarDatasets.length;
+          if (totalVisible === 1) {
+            catPositions.push({ pos: catLeft, size: catBw });
+          } else {
+            const minRatio = Math.max(0.3, 1 - (totalVisible - 1) * 0.3);
+            const widthRatio = 1 - visibleSeriesIdx / (totalVisible - 1) * (1 - minRatio);
+            const overlapWidth = catBw * widthRatio;
+            catPositions.push({ pos: catLeft + (catBw - overlapWidth) / 2, size: overlapWidth });
+          }
+        } else {
+          catPositions.push({ pos: catLeft, size: catBw });
+        }
+      }
+      multiConfig.categoryPositions = catPositions;
+    }
+    const baseLayout = calculateBarLayout(renderProps, cartesianArea, multiConfig);
+    const layout = { ...baseLayout, datasetIndex: dsIdx };
+    layouts.set(ds.id, layout);
+    renderPropsMap.set(ds.id, renderProps);
+    if (ds.visible) {
+      const dsStackBases = stackBasesMap?.get(ds.id);
+      for (const bar of layout.visibleBars) {
+        const barBaseValue = dsStackBases ? dsStackBases[bar.dataIndex] ?? effectiveBase : layout.openValues ? layout.openValues[bar.dataIndex] ?? effectiveBase : effectiveBase;
+        const barBasePosition = dsStackBases || layout.openValues ? targetValueScale(barBaseValue) : targetValueScale(effectiveBase);
+        allTargets.push({
+          dataIndex: bar.dataIndex,
+          datasetId: ds.id,
+          x: bar.x,
+          y: bar.y,
+          width: bar.width,
+          height: bar.height,
+          value: bar.value,
+          category: bar.category,
+          isNegative: bar.isNegative,
+          baseX: orientation === "horizontal" ? barBasePosition : bar.x,
+          baseY: orientation === "vertical" ? barBasePosition : bar.y,
+          orientation
+        });
+      }
+      visibleSeriesIdx++;
+    } else {
+      const stackBases = stackBasesMap?.get(ds.id);
+      const collapseGroupSlot = mode.isStacked && allGroupIdxMap.size > 0 ? allGroupIdxMap.get(ds.stackId) : dsIdx;
+      const groupedCollapseOffset = fullGroupLayout ? fullGroupLayout.getOffset(collapseGroupSlot) : 0;
+      const groupedCollapseDefaultWidth = fullGroupLayout ? fullGroupLayout.barWidth : sharedCategoryScale.bandwidth();
+      const groupStillVisible = mode.isGrouped && mode.isStacked && visibleGroupIdxMap.has(ds.stackId);
+      const visibleGroupSlot = groupStillVisible ? visibleGroupIdxMap.get(ds.stackId) : void 0;
+      const stackedCollapseOffset = groupStillVisible && groupLayout ? groupLayout.getOffset(visibleGroupSlot) : 0;
+      const stackedCollapseBarWidth = groupStillVisible && groupLayout ? groupLayout.barWidth : sharedCategoryScale.bandwidth();
+      for (let i = 0; i < categories.length; i++) {
+        const catPos = sharedCategoryScale(categories[i]);
+        const bw = sharedCategoryScale.bandwidthAt?.(i) ?? sharedCategoryScale.bandwidth();
+        if (orientation === "vertical") {
+          const collapseY = stackBases ? targetValueScale(stackBases[i]) : targetValueScale(effectiveBase);
+          const collapseX = !mode.isGrouped ? catPos : groupStillVisible ? catPos + stackedCollapseOffset : catPos + groupedCollapseOffset + groupedCollapseDefaultWidth / 2;
+          const collapseW = !mode.isGrouped ? bw : groupStillVisible ? stackedCollapseBarWidth : 0;
+          allTargets.push({
+            dataIndex: i,
+            datasetId: ds.id,
+            x: collapseX,
+            y: collapseY,
+            width: collapseW,
+            height: 0,
+            value: 0,
+            category: categories[i],
+            isNegative: false,
+            baseX: collapseX,
+            baseY: collapseY,
+            orientation
+          });
+        } else {
+          const collapseX = stackBases ? targetValueScale(stackBases[i]) : targetValueScale(effectiveBase);
+          const collapseYPos = !mode.isGrouped ? catPos : groupStillVisible ? catPos + stackedCollapseOffset : catPos + groupedCollapseOffset + groupedCollapseDefaultWidth / 2;
+          const collapseH = !mode.isGrouped ? bw : groupStillVisible ? stackedCollapseBarWidth : 0;
+          allTargets.push({
+            dataIndex: i,
+            datasetId: ds.id,
+            x: collapseX,
+            y: collapseYPos,
+            width: 0,
+            height: collapseH,
+            value: 0,
+            category: categories[i],
+            isNegative: false,
+            baseX: collapseX,
+            baseY: collapseYPos,
+            orientation
+          });
+        }
+      }
+    }
+  }
+  return { layouts, renderProps: renderPropsMap, allTargets };
+}
+function computeBarDatasetTotals(barDatasets, barRawResolved) {
+  const datasetTotals = /* @__PURE__ */ new Map();
+  for (let i = 0; i < barDatasets.length; i++) {
+    const values = barRawResolved?.[i] ?? batchResolveAccessor(barDatasets[i].props.valueField, barDatasets[i].props.data);
+    let total = 0;
+    for (const v of values) total += Math.abs(v);
+    datasetTotals.set(barDatasets[i].id, total);
+  }
+  return datasetTotals;
+}
+function getBarAxisHints(props, data) {
+  const categoryLabels = props.categoryField ? batchResolveRequired(props.categoryField, data, "categoryField") : void 0;
+  const categoryWeights = props.weightField ? batchResolveRequired(props.weightField, data, "weightField") : void 0;
+  return { categoryLabels, categoryWeights };
+}
+
+// src/series/bar/index.ts
+var barRenderer = {
+  calculateLayout: calculateBarLayout,
+  renderSvg: renderBarSvg,
+  renderCanvas: renderBarCanvas,
+  hitTest: hitTestBar,
+  getAxisHints: getBarAxisHints
+};
+
+export { barRenderer, computeBarDatasetTotals, computeBarVisualLayout, getBarAxisHints };