@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-BKP26M4K.mjs

@@ -0,0 +1,413 @@
+import { normalizePadding } from './chunk-NPDZLYIF.mjs';
+import { DEFAULT_NAV_GRIP_LINE_GAP, DEFAULT_NAV_HANDLE_WIDTH, DEFAULT_NAV_MIN_SELECTION_WIDTH, DEFAULT_NAV_STYLE, DEFAULT_NAV_PADDING_X, DEFAULT_NAV_PADDING_Y } from './chunk-NKUYIWAP.mjs';
+import { defaultLightTheme, batchResolveAccessor, FIELD_DEFAULTS } from './chunk-O2X6FF45.mjs';
+import { toTimestamp, createLinearScale, generateNiceTicks, generateTimeTicks, formatTimeTick } from './chunk-RQ3CKQOX.mjs';
+
+// src/renderers/navigator/geometry.ts
+var NAV_PADDING_Y = DEFAULT_NAV_PADDING_Y;
+var NAV_PADDING_X = DEFAULT_NAV_PADDING_X;
+var MIN_SELECTION_WIDTH = DEFAULT_NAV_MIN_SELECTION_WIDTH;
+var HANDLE_WIDTH = DEFAULT_NAV_HANDLE_WIDTH;
+var GRIP_LINE_GAP = DEFAULT_NAV_GRIP_LINE_GAP;
+var NAV_DEFAULTS = DEFAULT_NAV_STYLE;
+function resolveNavigatorConfig(config, theme = defaultLightTheme) {
+  const padding = normalizePadding(config.padding ?? { top: DEFAULT_NAV_PADDING_Y, right: DEFAULT_NAV_PADDING_X, bottom: DEFAULT_NAV_PADDING_Y, left: DEFAULT_NAV_PADDING_X });
+  let animation;
+  if (config.animation === false) {
+    animation = false;
+  } else if (config.animation === true || config.animation === void 0) {
+    animation = { duration: 200, easing: "easeOutCubic" };
+  } else {
+    animation = {
+      duration: config.animation.duration ?? 200,
+      easing: config.animation.easing ?? "easeOutCubic"
+    };
+  }
+  return {
+    height: config.height ?? NAV_DEFAULTS.height,
+    gap: config.gap ?? NAV_DEFAULTS.gap,
+    color: config.color ?? theme.navigatorSeries,
+    opacity: config.opacity ?? NAV_DEFAULTS.opacity,
+    selectionColor: config.selectionColor ?? theme.navigatorSelectionColor,
+    selectionFill: config.selectionFill ?? theme.navigatorSelectionFill,
+    maskColor: config.maskColor ?? theme.navigatorMask,
+    backgroundColor: config.backgroundColor ?? theme.bandFill,
+    gridColor: config.gridColor ?? theme.grid,
+    labelColor: config.labelColor ?? theme.tickLabel,
+    handleWidth: config.handleWidth ?? DEFAULT_NAV_HANDLE_WIDTH,
+    gripLineGap: config.gripLineGap ?? DEFAULT_NAV_GRIP_LINE_GAP,
+    padding,
+    series: config.series,
+    animation
+  };
+}
+function extractNavigatorData(datasets, targetSeriesId, isTimeAxis) {
+  let targetDs;
+  if (targetSeriesId) {
+    targetDs = datasets.get(targetSeriesId);
+  } else {
+    for (const ds of datasets.values()) {
+      if (ds.type === "candlestick" || ds.type === "line" || ds.type === "bar" || ds.type === "scatter") {
+        targetDs = ds;
+        break;
+      }
+    }
+  }
+  if (!targetDs) return null;
+  const props = targetDs.props;
+  const data = props.data;
+  if (!data?.length) return null;
+  let xValues;
+  let yValues;
+  let isCategoryAxis = false;
+  let isNumericAxis = false;
+  let catLabels;
+  if (targetDs.type === "candlestick") {
+    const cp = props;
+    const rawTimeValues = batchResolveAccessor(cp.timeField, data);
+    if (isTimeAxis) {
+      xValues = rawTimeValues.map((v) => toTimestamp(v));
+    } else {
+      isCategoryAxis = true;
+      catLabels = rawTimeValues.map((v) => String(v ?? ""));
+      xValues = rawTimeValues.map((_, i) => i);
+    }
+    yValues = batchResolveAccessor(cp.closeField, data);
+  } else if (targetDs.type === "scatter") {
+    const xField = props.xField ?? props.x ?? FIELD_DEFAULTS.xField;
+    const yField = props.yField ?? props.y ?? FIELD_DEFAULTS.yField;
+    xValues = batchResolveAccessor(xField, data);
+    yValues = batchResolveAccessor(yField, data);
+    isCategoryAxis = false;
+    isNumericAxis = true;
+  } else {
+    const catField = props.time ?? props.timeField ?? props.categoryField ?? props.category ?? FIELD_DEFAULTS.categoryField;
+    const valField = props.valueField ?? props.value ?? FIELD_DEFAULTS.valueField;
+    const rawXValues = batchResolveAccessor(catField, data);
+    if (isTimeAxis) {
+      xValues = rawXValues.map((v) => toTimestamp(v));
+    } else {
+      isCategoryAxis = true;
+      catLabels = rawXValues.map((v) => String(v ?? ""));
+      xValues = rawXValues.map((_, i) => i);
+    }
+    yValues = batchResolveAccessor(valField, data);
+  }
+  const points = [];
+  for (let i = 0; i < xValues.length; i++) {
+    const x = xValues[i];
+    const y = yValues[i];
+    if (!isNaN(x) && y != null && !isNaN(y)) {
+      points.push({ x, y });
+    }
+  }
+  points.sort((a, b) => a.x - b.x);
+  if (points.length === 0) return null;
+  const xDomain = [points[0].x, points[points.length - 1].x];
+  let yMin = Infinity;
+  let yMax = -Infinity;
+  for (const p of points) {
+    if (p.y < yMin) yMin = p.y;
+    if (p.y > yMax) yMax = p.y;
+  }
+  if (yMin === yMax) {
+    yMin -= 1;
+    yMax += 1;
+  }
+  return { points, xDomain, yDomain: [yMin, yMax], isCategory: isCategoryAxis, categoryLabels: catLabels, isNumericAxis, sourceType: targetDs.type };
+}
+function createNavigatorScales(data, width, height, padding) {
+  const px = padding?.left ?? NAV_PADDING_X;
+  const pxRight = padding?.right ?? NAV_PADDING_X;
+  const py = padding?.top ?? NAV_PADDING_Y;
+  return {
+    x: createLinearScale(data.xDomain, [px, width - pxRight]),
+    y: createLinearScale(data.yDomain, [height, py])
+  };
+}
+function buildNavigatorPaths(points, scales, height, sourceType) {
+  if (points.length === 0) return { linePath: "", areaPath: "" };
+  if (sourceType === "scatter") {
+    const dots = points.map((p) => ({
+      px: scales.x(p.x),
+      py: scales.y(p.y)
+    }));
+    return { linePath: "", areaPath: "", dots };
+  }
+  if (sourceType === "bar") {
+    const barCount = points.length;
+    const totalWidth = scales.x(points[points.length - 1].x) - scales.x(points[0].x);
+    const barWidth = Math.max(1, totalWidth / barCount * 0.8);
+    const bars = points.map((p) => {
+      const px = scales.x(p.x) - barWidth / 2;
+      const py = scales.y(p.y);
+      return { px, width: barWidth, py, height: height - py };
+    });
+    return { linePath: "", areaPath: "", bars };
+  }
+  const baseline = height;
+  let linePath = "";
+  let areaPath = "";
+  for (let i = 0; i < points.length; i++) {
+    const px = scales.x(points[i].x);
+    const py = scales.y(points[i].y);
+    const cmd = i === 0 ? "M" : "L";
+    linePath += `${cmd}${px},${py}`;
+    areaPath += `${cmd}${px},${py}`;
+  }
+  const lastX = scales.x(points[points.length - 1].x);
+  const firstX = scales.x(points[0].x);
+  areaPath += `L${lastX},${baseline}L${firstX},${baseline}Z`;
+  return { linePath, areaPath };
+}
+function computeNavigatorTicks(xDomain, xScale, width, locale, categoryLabels, isNumericAxis, tickFormat) {
+  if (width <= 0 || xDomain[1] <= xDomain[0]) return [];
+  if (categoryLabels && categoryLabels.length > 0) {
+    const totalCats = categoryLabels.length;
+    const formatter = typeof tickFormat === "function" ? tickFormat : void 0;
+    const maxTicks = Math.floor(width / 120);
+    const step = Math.max(1, Math.ceil(totalCats / maxTicks));
+    const ticks2 = [];
+    for (let i = 0; i < totalCats; i += step) {
+      const raw = categoryLabels[i];
+      ticks2.push({ px: xScale(i), label: formatter ? formatter(raw, i) : raw });
+    }
+    return ticks2;
+  }
+  if (isNumericAxis) {
+    const tickCount = Math.max(2, Math.floor(width / 120));
+    const tickValues = generateNiceTicks(xDomain[0], xDomain[1], tickCount);
+    return tickValues.map((v) => ({
+      px: xScale(v),
+      label: String(v)
+    }));
+  }
+  const { ticks, interval } = generateTimeTicks(xDomain[0], xDomain[1], width, {
+    minTickSpacing: 120
+  });
+  return ticks.map((ts) => ({
+    px: xScale(ts),
+    label: formatTimeTick(ts, interval.unit, void 0, void 0, locale)
+  }));
+}
+function computeNavigatorSelection(zoomState, xScale, width, yScale, height) {
+  if (!xScale || !zoomState.x) {
+    return { x: 0, width, isZoomed: false };
+  }
+  const minW = Math.min(MIN_SELECTION_WIDTH, width);
+  const rawLeft = Math.max(0, xScale(zoomState.x.min));
+  const rawRight = Math.min(width, xScale(zoomState.x.max));
+  const selW = Math.max(rawRight - rawLeft, minW);
+  const selX = Math.min(rawLeft, Math.max(0, width - selW));
+  if (yScale && height != null && zoomState.y) {
+    const minH = Math.min(MIN_SELECTION_WIDTH, height);
+    const rawTop = Math.max(0, yScale(zoomState.y.max));
+    const rawBottom = Math.min(height, yScale(zoomState.y.min));
+    const selH = Math.max(rawBottom - rawTop, minH);
+    const selY = Math.min(rawTop, Math.max(0, height - selH));
+    return { x: selX, width: selW, isZoomed: true, y: selY, height: selH, is2D: true };
+  }
+  return { x: selX, width: selW, isZoomed: true };
+}
+function calculateNavigatorLayout(chartArea, config, datasets, zoomState, isTimeAxis, tickFormat, locale, theme = defaultLightTheme, overrideXDomain) {
+  const resolved = resolveNavigatorConfig(config, theme);
+  const area = {
+    x: chartArea.x,
+    y: chartArea.y + chartArea.height + resolved.gap,
+    width: chartArea.width,
+    height: resolved.height
+  };
+  const rawSeries = resolved.series;
+  let seriesConfigs;
+  if (Array.isArray(rawSeries)) {
+    seriesConfigs = rawSeries.map((s) => typeof s === "string" ? { id: s } : { id: s.id, color: s.color });
+  } else if (rawSeries) {
+    seriesConfigs = [{ id: rawSeries }];
+  } else {
+    seriesConfigs = [];
+  }
+  if (seriesConfigs.length === 0) {
+    for (const [id, ds] of datasets.entries()) {
+      if (ds.type === "candlestick" || ds.type === "line" || ds.type === "bar" || ds.type === "scatter") {
+        seriesConfigs.push({ id });
+      }
+    }
+  }
+  const resolveSeriesColor = (entry, ds) => {
+    if (entry.color === "series") {
+      return ds?.props?.color ?? resolved.color;
+    }
+    return entry.color ?? resolved.color;
+  };
+  const primaryConfig = seriesConfigs[0] ?? {};
+  const primarySeriesId = primaryConfig.id;
+  const additionalConfigs = seriesConfigs.slice(1);
+  const data = extractNavigatorData(datasets, primarySeriesId, isTimeAxis);
+  if (!data) {
+    return {
+      area,
+      data: null,
+      scales: null,
+      paths: null,
+      allSeries: [],
+      ticks: [],
+      selection: { x: 0, width: area.width, isZoomed: false },
+      config: resolved
+    };
+  }
+  const additionalEntries = [];
+  let mergedYMin = data.yDomain[0];
+  let mergedYMax = data.yDomain[1];
+  for (const cfg of additionalConfigs) {
+    const addData = extractNavigatorData(datasets, cfg.id, isTimeAxis);
+    if (!addData) continue;
+    const ds = cfg.id ? datasets.get(cfg.id) : void 0;
+    const color = resolveSeriesColor(cfg, ds);
+    if (addData.yDomain[0] < mergedYMin) mergedYMin = addData.yDomain[0];
+    if (addData.yDomain[1] > mergedYMax) mergedYMax = addData.yDomain[1];
+    additionalEntries.push({ data: addData, color });
+  }
+  const mergedData = { ...data, yDomain: [mergedYMin, mergedYMax] };
+  const effectiveXDomain = overrideXDomain ?? mergedData.xDomain;
+  const animatedData = overrideXDomain ? { ...mergedData, xDomain: overrideXDomain } : mergedData;
+  const scales = createNavigatorScales(animatedData, area.width, area.height, resolved.padding);
+  const paths = buildNavigatorPaths(data.points, scales, area.height, data.sourceType);
+  const ticks = computeNavigatorTicks(effectiveXDomain, scales.x, area.width, locale, data.categoryLabels, data.isNumericAxis, tickFormat);
+  const selection = computeNavigatorSelection(zoomState, scales.x, area.width, data.isNumericAxis ? scales.y : null, data.isNumericAxis ? area.height : void 0);
+  const primaryColor = resolveSeriesColor(primaryConfig, primarySeriesId ? datasets.get(primarySeriesId) : void 0);
+  const allSeries = [
+    { points: data.points, paths, color: primaryColor, sourceType: data.sourceType },
+    ...additionalEntries.map((e) => ({
+      points: e.data.points,
+      paths: buildNavigatorPaths(e.data.points, scales, area.height, e.data.sourceType),
+      color: e.color,
+      sourceType: e.data.sourceType
+    }))
+  ];
+  return { area, data: animatedData, scales, paths, ticks, selection, config: resolved, allSeries };
+}
+function computeNavigatorPan(startMin, startMax, deltaPixels, xScale, domainBounds) {
+  const deltaData = xScale.invert(deltaPixels) - xScale.invert(0);
+  const rangeWidth = startMax - startMin;
+  const [domainMin, domainMax] = domainBounds;
+  let newMin = startMin + deltaData;
+  let newMax = startMax + deltaData;
+  if (newMin < domainMin) {
+    newMin = domainMin;
+    newMax = domainMin + rangeWidth;
+  }
+  if (newMax > domainMax) {
+    newMax = domainMax;
+    newMin = domainMax - rangeWidth;
+  }
+  return { min: newMin, max: newMax };
+}
+function computeNavigatorResizeLeft(startMin, max, deltaPixels, xScale, domainBounds) {
+  const deltaData = xScale.invert(deltaPixels) - xScale.invert(0);
+  const minDataWidth = xScale.invert(MIN_SELECTION_WIDTH) - xScale.invert(0);
+  let newMin = Math.max(domainBounds[0], startMin + deltaData);
+  if (max - newMin < minDataWidth) {
+    newMin = max - minDataWidth;
+  }
+  return { min: newMin, max };
+}
+function computeNavigatorResizeRight(min, startMax, deltaPixels, xScale, domainBounds) {
+  const deltaData = xScale.invert(deltaPixels) - xScale.invert(0);
+  const minDataWidth = xScale.invert(MIN_SELECTION_WIDTH) - xScale.invert(0);
+  let newMax = Math.min(domainBounds[1], startMax + deltaData);
+  if (newMax - min < minDataWidth) {
+    newMax = min + minDataWidth;
+  }
+  return { min, max: newMax };
+}
+function computeNavigatorJump(clickPixelX, currentWidth, xScale, domainBounds) {
+  const clickDataX = xScale.invert(clickPixelX);
+  const [domainMin, domainMax] = domainBounds;
+  const windowWidth = currentWidth ?? (domainMax - domainMin) * 0.2;
+  const halfWidth = windowWidth / 2;
+  let newMin = clickDataX - halfWidth;
+  let newMax = clickDataX + halfWidth;
+  if (newMin < domainMin) {
+    newMin = domainMin;
+    newMax = domainMin + windowWidth;
+  }
+  if (newMax > domainMax) {
+    newMax = domainMax;
+    newMin = domainMax - windowWidth;
+  }
+  return { min: newMin, max: newMax };
+}
+function computeNavigatorPanY(startMin, startMax, deltaPixels, yScale, domainBounds) {
+  const deltaData = yScale.invert(deltaPixels) - yScale.invert(0);
+  const rangeHeight = startMax - startMin;
+  const [domainMin, domainMax] = domainBounds;
+  let newMin = startMin + deltaData;
+  let newMax = startMax + deltaData;
+  if (newMin < domainMin) {
+    newMin = domainMin;
+    newMax = domainMin + rangeHeight;
+  }
+  if (newMax > domainMax) {
+    newMax = domainMax;
+    newMin = domainMax - rangeHeight;
+  }
+  return { min: newMin, max: newMax };
+}
+function computeNavigatorResizeTop(min, startMax, deltaPixels, yScale, domainBounds) {
+  const deltaData = yScale.invert(deltaPixels) - yScale.invert(0);
+  const minDataHeight = yScale.invert(0) - yScale.invert(MIN_SELECTION_WIDTH);
+  let newMax = Math.min(domainBounds[1], startMax + deltaData);
+  if (newMax - min < minDataHeight) {
+    newMax = min + minDataHeight;
+  }
+  return { min, max: newMax };
+}
+function computeNavigatorResizeBottom(startMin, max, deltaPixels, yScale, domainBounds) {
+  const deltaData = yScale.invert(deltaPixels) - yScale.invert(0);
+  const minDataHeight = yScale.invert(0) - yScale.invert(MIN_SELECTION_WIDTH);
+  let newMin = Math.max(domainBounds[0], startMin + deltaData);
+  if (max - newMin < minDataHeight) {
+    newMin = max - minDataHeight;
+  }
+  return { min: newMin, max };
+}
+function computeNavigatorJumpY(clickPixelY, currentHeight, yScale, domainBounds) {
+  const clickDataY = yScale.invert(clickPixelY);
+  const [domainMin, domainMax] = domainBounds;
+  const windowHeight = currentHeight ?? (domainMax - domainMin) * 0.2;
+  const halfHeight = windowHeight / 2;
+  let newMin = clickDataY - halfHeight;
+  let newMax = clickDataY + halfHeight;
+  if (newMin < domainMin) {
+    newMin = domainMin;
+    newMax = domainMin + windowHeight;
+  }
+  if (newMax > domainMax) {
+    newMax = domainMax;
+    newMin = domainMax - windowHeight;
+  }
+  return { min: newMin, max: newMax };
+}
+function hitTestNavigator(localX, selection, localY, handleWidth = HANDLE_WIDTH) {
+  if (!selection.isZoomed) return null;
+  const { x: selX, width: selW } = selection;
+  const halfHandle = handleWidth / 2;
+  if (selection.is2D && localY != null && selection.y != null && selection.height != null) {
+    const selY = selection.y;
+    const selH = selection.height;
+    const inXRange = localX >= selX - halfHandle && localX <= selX + selW + halfHandle;
+    const inYRange = localY >= selY - halfHandle && localY <= selY + selH + halfHandle;
+    if (inYRange && localX >= selX - halfHandle && localX <= selX + halfHandle) return "resize-left";
+    if (inYRange && localX >= selX + selW - halfHandle && localX <= selX + selW + halfHandle) return "resize-right";
+    if (inXRange && localY >= selY - halfHandle && localY <= selY + halfHandle) return "resize-top";
+    if (inXRange && localY >= selY + selH - halfHandle && localY <= selY + selH + halfHandle) return "resize-bottom";
+    if (localX >= selX && localX <= selX + selW && localY >= selY && localY <= selY + selH) return "pan";
+    return "background";
+  }
+  if (localX >= selX - halfHandle && localX <= selX + halfHandle) return "resize-left";
+  if (localX >= selX + selW - halfHandle && localX <= selX + selW + halfHandle) return "resize-right";
+  if (localX >= selX && localX <= selX + selW) return "pan";
+  return "background";
+}
+
+export { GRIP_LINE_GAP, HANDLE_WIDTH, MIN_SELECTION_WIDTH, NAV_DEFAULTS, NAV_PADDING_X, NAV_PADDING_Y, buildNavigatorPaths, calculateNavigatorLayout, computeNavigatorJump, computeNavigatorJumpY, computeNavigatorPan, computeNavigatorPanY, computeNavigatorResizeBottom, computeNavigatorResizeLeft, computeNavigatorResizeRight, computeNavigatorResizeTop, computeNavigatorSelection, computeNavigatorTicks, createNavigatorScales, extractNavigatorData, hitTestNavigator, resolveNavigatorConfig };

package/dist/chunk-BZN2QHGP.mjs

@@ -0,0 +1,200 @@
+import { DEFAULT_HOVER_BRIGHTNESS, DEFAULT_HOVER_DIM_OPACITY } from './chunk-NKUYIWAP.mjs';
+import { defaultLightTheme, isGradientColor } from './chunk-O2X6FF45.mjs';
+import { adjustBrightness, brightenGradientStops } from './chunk-SSLTFJ3U.mjs';
+
+// src/utils/interaction/hover.utils.ts
+function computeItemHoverState(dataIndex, hoveredIndex, hoverEnabled) {
+  const hasAnyHover = hoverEnabled && hoveredIndex !== null && hoveredIndex !== void 0;
+  const isHovered = hasAnyHover && hoveredIndex === dataIndex;
+  return { isHovered, hasAnyHover };
+}
+function applyHoverColorEffect(baseColor, state, effects, theme) {
+  let color = baseColor;
+  let opacity = 1;
+  if (!effects) {
+    return { color, opacity };
+  }
+  const { isHovered, hasAnyHover } = state;
+  const isDimmed = hasAnyHover && !isHovered;
+  if (isDimmed) {
+    const dim = effects.dimOpacity ?? theme.dimOpacity;
+    if (dim !== void 0) {
+      opacity = dim;
+    }
+  }
+  if (isHovered) {
+    if (effects.hoverBackgroundColor) {
+      color = effects.hoverBackgroundColor;
+    } else {
+      const brightness = effects.hoverBrightness ?? theme.hoverBrightness;
+      if (brightness !== void 0) {
+        if (typeof color === "string") {
+          color = adjustBrightness(color, brightness);
+        } else if (isGradientColor(color)) {
+          color = brightenGradientStops(color, brightness);
+        }
+      }
+    }
+  }
+  return { color, opacity };
+}
+function applyHoverBorderEffect(baseBorderColor, baseBorderWidth, baseBorderDash, baseBorderDashOffset, isHovered, effects, fillColor) {
+  let borderColor = baseBorderColor;
+  let borderWidth = baseBorderWidth;
+  let borderDash = baseBorderDash;
+  let borderDashOffset = baseBorderDashOffset;
+  if (isHovered && effects) {
+    if (effects.hoverBorderColor !== void 0) {
+      borderColor = effects.hoverBorderColor;
+    } else if (effects.hoverBorderStrokeWidth !== void 0 && borderColor === "transparent" && fillColor !== void 0) {
+      borderColor = fillColor;
+    }
+    if (effects.hoverBorderStrokeWidth !== void 0) {
+      borderWidth = effects.hoverBorderStrokeWidth;
+    }
+    if (effects.hoverBorderDash !== void 0) {
+      borderDash = effects.hoverBorderDash;
+    }
+    if (effects.hoverBorderDashOffset !== void 0) {
+      borderDashOffset = effects.hoverBorderDashOffset;
+    }
+  }
+  return { borderColor, borderStrokeWidth: borderWidth, borderDash, borderDashOffset };
+}
+function applyHoverEffects(baseColor, baseBorderColor, baseBorderWidth, baseBorderDash, baseBorderDashOffset, state, effects, theme = defaultLightTheme) {
+  const colorResult = applyHoverColorEffect(baseColor, state, effects, theme);
+  const borderResult = applyHoverBorderEffect(baseBorderColor, baseBorderWidth, baseBorderDash, baseBorderDashOffset, state.isHovered, effects, baseColor);
+  return {
+    ...colorResult,
+    ...borderResult
+  };
+}
+function hoverConfigToFullEffect(config) {
+  return {
+    hoverBrightness: config.brightness,
+    dimOpacity: config.dimOpacity,
+    hoverOffset: config.offset,
+    hoverScale: config.scale,
+    hoverBackgroundColor: config.backgroundColor,
+    hoverBorderColor: config.borderColor,
+    hoverBorderStrokeWidth: config.borderStrokeWidth,
+    hoverBorderDash: config.borderDash,
+    hoverBorderDashOffset: config.borderDashOffset,
+    hoverRadiusMultiplier: config.radiusMultiplier
+  };
+}
+function hoverConfigToBaseEffect(config, theme) {
+  return {
+    hoverBrightness: config.brightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS,
+    hoverBackgroundColor: config.backgroundColor,
+    dimOpacity: config.dimOpacity,
+    hoverBorderColor: config.borderColor,
+    hoverBorderStrokeWidth: config.borderStrokeWidth,
+    hoverBorderDash: config.borderDash,
+    hoverBorderDashOffset: config.borderDashOffset,
+    hoverRadiusMultiplier: config.radiusMultiplier
+  };
+}
+function computeSliceHoverEffects(baseColor, baseBorderColor, baseBorderWidth, isHovered, hasAnyHover, hoverProps, theme) {
+  const effects = hoverProps ? hoverConfigToBaseEffect(hoverProps, theme) : void 0;
+  const result = applyHoverEffects(baseColor, baseBorderColor, baseBorderWidth, void 0, 0, { isHovered, hasAnyHover }, effects, theme);
+  return {
+    fillColor: result.color,
+    borderColor: result.borderColor,
+    borderStrokeWidth: result.borderStrokeWidth,
+    borderDash: result.borderDash,
+    opacity: result.opacity
+  };
+}
+function computeLeaderLineHoverEffects(baseColor, isHovered, hasAnyHover, hoverProps, theme) {
+  let strokeColor = baseColor;
+  let strokeWidth = 1;
+  if (!hoverProps) {
+    return { strokeColor, strokeWidth };
+  }
+  if (isHovered) {
+    const brightness = hoverProps.brightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS;
+    strokeColor = adjustBrightness(baseColor, brightness);
+    strokeWidth = 2;
+  } else if (hasAnyHover) {
+    const dimOpacity = hoverProps.dimOpacity ?? theme.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY;
+    strokeColor = adjustBrightness(baseColor, dimOpacity);
+  }
+  return { strokeColor, strokeWidth };
+}
+function applySvgHoverFill(pathEl, isHovered, hasAnyHover, hoverConfig, applyGradientBrightness, restoreGradientBrightness, theme) {
+  if (!hoverConfig) return;
+  if (!pathEl.hasAttribute("data-original-fill")) {
+    pathEl.setAttribute("data-original-fill", pathEl.getAttribute("fill") || "");
+  }
+  const originalFill = pathEl.getAttribute("data-original-fill") || "";
+  const isGradient = originalFill.startsWith("url(");
+  const brightness = hoverConfig.brightness ?? theme.hoverBrightness ?? DEFAULT_HOVER_BRIGHTNESS;
+  if (isHovered) {
+    if (hoverConfig.backgroundColor) {
+      pathEl.setAttribute("fill", hoverConfig.backgroundColor);
+    } else if (isGradient && applyGradientBrightness) {
+      applyGradientBrightness(pathEl, brightness);
+    } else if (originalFill) {
+      pathEl.setAttribute("fill", adjustBrightness(originalFill, brightness));
+    }
+    pathEl.removeAttribute("opacity");
+  } else if (hasAnyHover && hoverConfig.dimOpacity !== void 0 && hoverConfig.dimOpacity < 1) {
+    pathEl.setAttribute("opacity", String(hoverConfig.dimOpacity));
+    if (isGradient && restoreGradientBrightness) {
+      restoreGradientBrightness(pathEl);
+    } else if (originalFill) {
+      pathEl.setAttribute("fill", originalFill);
+    }
+  } else {
+    if (isGradient && restoreGradientBrightness) {
+      restoreGradientBrightness(pathEl);
+    } else if (originalFill) {
+      pathEl.setAttribute("fill", originalFill);
+    }
+    pathEl.removeAttribute("opacity");
+  }
+}
+function applySvgHoverStroke(pathEl, isHovered, hoverConfig) {
+  if (!hoverConfig) return;
+  if (!pathEl.hasAttribute("data-original-stroke")) {
+    pathEl.setAttribute("data-original-stroke", pathEl.getAttribute("stroke") || "");
+    pathEl.setAttribute("data-original-stroke-width", pathEl.getAttribute("stroke-width") || "");
+    const dashArray = pathEl.getAttribute("stroke-dasharray");
+    if (dashArray) {
+      pathEl.setAttribute("data-original-stroke-dasharray", dashArray);
+    }
+  }
+  if (isHovered && (hoverConfig.borderColor || hoverConfig.borderStrokeWidth !== void 0)) {
+    if (hoverConfig.borderColor) {
+      pathEl.setAttribute("stroke", hoverConfig.borderColor);
+    }
+    if (hoverConfig.borderStrokeWidth !== void 0) {
+      pathEl.setAttribute("stroke-width", String(hoverConfig.borderStrokeWidth * 2));
+    }
+    if (hoverConfig.borderDash) {
+      pathEl.setAttribute("stroke-dasharray", hoverConfig.borderDash.join(" "));
+    }
+    if (!pathEl.hasAttribute("paint-order")) {
+      pathEl.setAttribute("paint-order", "stroke fill");
+    }
+  } else {
+    const originalStroke = pathEl.getAttribute("data-original-stroke");
+    const originalWidth = pathEl.getAttribute("data-original-stroke-width");
+    const originalDash = pathEl.getAttribute("data-original-stroke-dasharray");
+    if (originalStroke) pathEl.setAttribute("stroke", originalStroke);
+    else pathEl.removeAttribute("stroke");
+    if (originalWidth) pathEl.setAttribute("stroke-width", originalWidth);
+    else pathEl.removeAttribute("stroke-width");
+    if (originalDash) pathEl.setAttribute("stroke-dasharray", originalDash);
+    else pathEl.removeAttribute("stroke-dasharray");
+  }
+}
+function resolveSvgHoverFill(baseFill, isHovered, overrideColor) {
+  if (isHovered && typeof overrideColor === "string") {
+    return { fill: overrideColor, overridden: true };
+  }
+  return { fill: baseFill, overridden: false };
+}
+
+export { applyHoverEffects, applySvgHoverFill, applySvgHoverStroke, computeItemHoverState, computeLeaderLineHoverEffects, computeSliceHoverEffects, hoverConfigToBaseEffect, hoverConfigToFullEffect, resolveSvgHoverFill };