@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-J4RI2C2G.mjs

@@ -0,0 +1,172 @@
+import { drawMarkerCanvas } from './chunk-PRDVPOZX.mjs';
+import { DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER, DEFAULT_LINE_MARKER_SIZE } from './chunk-NKUYIWAP.mjs';
+import { getDefaultColor, createCanvasGradientFromColor, makeItemContext, resolveDash, resolveAccessor, sampleGradientAt, getPrimaryColor } from './chunk-O2X6FF45.mjs';
+import { createCanvasPathBuilder, traceClosedSpline } from './chunk-IEGLX7VL.mjs';
+import { adjustBrightness, withCanvasState } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/radar/canvas/index.ts
+function renderRadarSeriesCanvas(ctx, layout, seriesIndex, hoverState, effectConfig, seriesProps, theme) {
+  const sd = layout.series[seriesIndex];
+  if (!sd || !sd.visible || sd.points.length === 0) return;
+  const sharedAxisIdx = hoverState.axisIndex ?? null;
+  const isSharedHover = sharedAxisIdx !== null;
+  const isSeriesHovered = isSharedHover ? true : hoverState.datasetId === sd.id;
+  const anyHover = hoverState.datasetId !== null || isSharedHover;
+  let seriesOpacity = 1;
+  if (anyHover && !isSharedHover && !isSeriesHovered && effectConfig?.dimOpacity !== void 0) {
+    seriesOpacity = effectConfig.dimOpacity;
+  }
+  const baseColor = sd.color ?? getDefaultColor(sd.seriesIdx, theme);
+  let fillColor = baseColor;
+  let strokeColor = baseColor;
+  if (!isSharedHover && isSeriesHovered && effectConfig?.hoverBrightness) {
+    fillColor = adjustBrightness(fillColor, effectConfig.hoverBrightness);
+    strokeColor = adjustBrightness(strokeColor, effectConfig.hoverBrightness);
+  }
+  const isStacked = sd.basePoints && sd.basePoints.length > 0;
+  const isSmooth = sd.curve === "smooth";
+  const canvasBuilder = createCanvasPathBuilder(ctx);
+  const borderColor = seriesProps?.borderColor && typeof seriesProps.borderColor === "string" ? seriesProps.borderColor : void 0;
+  const borderWidth = typeof seriesProps?.borderStrokeWidth === "number" ? seriesProps.borderStrokeWidth : 0;
+  withCanvasState(ctx, () => {
+    ctx.beginPath();
+    if (isSmooth) {
+      traceClosedSpline(canvasBuilder, sd.points);
+    } else {
+      for (let i = 0; i < sd.points.length; i++) {
+        const pt = sd.points[i];
+        if (i === 0) ctx.moveTo(pt.x, pt.y);
+        else ctx.lineTo(pt.x, pt.y);
+      }
+      ctx.closePath();
+    }
+    if (isStacked) {
+      const basePts = sd.basePoints;
+      if (isSmooth) {
+        traceClosedSpline(canvasBuilder, [...basePts].reverse());
+      } else {
+        for (let i = basePts.length - 1; i >= 0; i--) {
+          const pt = basePts[i];
+          if (i === basePts.length - 1) ctx.moveTo(pt.x, pt.y);
+          else ctx.lineTo(pt.x, pt.y);
+        }
+        ctx.closePath();
+      }
+    }
+    const resolvedFill = sd.gradientColor ? createCanvasGradientFromColor(ctx, sd.gradientColor, layout.center, layout.radius) : fillColor;
+    const resolvedStroke = sd.gradientColor ? sd.gradientColor.stops[0]?.color ?? strokeColor : strokeColor;
+    ctx.fillStyle = resolvedFill;
+    ctx.globalAlpha = sd.fillOpacity * seriesOpacity;
+    ctx.fill(isStacked ? "evenodd" : "nonzero");
+    const traceOuterPath = () => {
+      ctx.beginPath();
+      if (isSmooth) {
+        traceClosedSpline(canvasBuilder, sd.points);
+      } else {
+        for (let i = 0; i < sd.points.length; i++) {
+          const pt = sd.points[i];
+          if (i === 0) ctx.moveTo(pt.x, pt.y);
+          else ctx.lineTo(pt.x, pt.y);
+        }
+        ctx.closePath();
+      }
+    };
+    ctx.globalAlpha = seriesOpacity;
+    const borderAlign = seriesProps?.borderAlign ?? "center";
+    const radarDataArrCanvas = seriesProps?.data;
+    const radarSeriesDashCtx = makeItemContext(radarDataArrCanvas?.[0], 0);
+    const resolvedSeriesDash = resolveDash(seriesProps?.borderDash, radarSeriesDashCtx);
+    const resolvedSeriesDashOffset = resolveAccessor(seriesProps?.borderDashOffset, radarSeriesDashCtx, { arrayMode: "clip", fallback: 0 }) ?? 0;
+    const borderDashPattern = resolvedSeriesDash && resolvedSeriesDash.length > 0 ? resolvedSeriesDash : [];
+    if (borderColor && borderWidth > 0 && borderAlign === "center") {
+      traceOuterPath();
+      ctx.strokeStyle = borderColor;
+      ctx.lineWidth = sd.lineStrokeWidth + borderWidth * 2;
+      ctx.lineJoin = seriesProps?.borderJoinStyle ?? "round";
+      ctx.setLineDash(borderDashPattern);
+      if (resolvedSeriesDashOffset) ctx.lineDashOffset = resolvedSeriesDashOffset;
+      ctx.stroke();
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+    traceOuterPath();
+    ctx.strokeStyle = resolvedStroke;
+    ctx.lineWidth = sd.lineStrokeWidth;
+    ctx.lineJoin = "round";
+    const dashArray = sd.lineDash ?? (sd.lineStyle === "dashed" ? [6, 4] : sd.lineStyle === "dotted" ? [2, 3] : []);
+    ctx.setLineDash(dashArray);
+    ctx.stroke();
+    if (borderColor && borderWidth > 0 && borderAlign === "inner") {
+      ctx.save();
+      traceOuterPath();
+      ctx.clip();
+      traceOuterPath();
+      ctx.strokeStyle = borderColor;
+      ctx.lineWidth = borderWidth * 2;
+      ctx.lineJoin = seriesProps?.borderJoinStyle ?? "round";
+      ctx.setLineDash(borderDashPattern);
+      if (resolvedSeriesDashOffset) ctx.lineDashOffset = resolvedSeriesDashOffset;
+      ctx.stroke();
+      ctx.restore();
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+  });
+  const showMarkers = seriesProps?.showMarkers !== false;
+  const dataArrCanvas = seriesProps?.data;
+  const ptValueCanvas = (idx) => sd.points[idx]?.value;
+  const ptCategoryCanvas = (idx) => layout.categories[sd.points[idx]?.categoryIndex ?? idx];
+  const seriesExtras = { seriesIndex, seriesId: sd.id ?? "" };
+  const resolveMarkerSize = (idx) => resolveAccessor(seriesProps?.markerSize, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), {
+    arrayMode: "clip",
+    fallback: DEFAULT_LINE_MARKER_SIZE
+  }) ?? DEFAULT_LINE_MARKER_SIZE;
+  const resolvePointRotationCanvas = (idx) => resolveAccessor(seriesProps?.pointRotation, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0;
+  const resolveMarkerHoverColorCanvas = (idx) => {
+    const v = resolveAccessor(seriesProps?.hoverColor, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "cycle" });
+    return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+  };
+  const resolveMarkerHoverBorderColorCanvas = (idx) => {
+    const v = resolveAccessor(seriesProps?.hoverBorderColor, makeItemContext(dataArrCanvas?.[idx], idx, { value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "cycle" });
+    return typeof v === "string" ? v : v ? getPrimaryColor(v) : void 0;
+  };
+  const resolveMarkerShapeCanvas = (idx, size) => resolveAccessor(seriesProps?.markerShape, makeItemContext(dataArrCanvas?.[idx], idx, { size, value: ptValueCanvas(idx), category: ptCategoryCanvas(idx), ...seriesExtras }), { arrayMode: "clip" }) ?? "circle";
+  const anyPointHoveredCanvas = isSharedHover ? sharedAxisIdx !== null : isSeriesHovered && hoverState.index !== null;
+  if (showMarkers || anyPointHoveredCanvas) {
+    for (let pi = 0; pi < sd.points.length; pi++) {
+      const pt = sd.points[pi];
+      const isPointHovered = isSharedHover ? pi === sharedAxisIdx : isSeriesHovered && hoverState.index === pi;
+      if (!showMarkers && !isPointHovered) continue;
+      const ptMarkerSize = resolveMarkerSize(pi);
+      const pointR = isPointHovered ? ptMarkerSize * (effectConfig?.hoverRadiusMultiplier ?? DEFAULT_HOVER_POINT_RADIUS_MULTIPLIER) : ptMarkerSize;
+      let ptColor = sd.gradientColor ? sampleGradientAt(sd.gradientColor, pt, layout.center, layout.radius) : strokeColor;
+      if (isPointHovered) {
+        const ptHoverColor = resolveMarkerHoverColorCanvas(pi);
+        if (ptHoverColor) {
+          ptColor = ptHoverColor;
+        } else if (effectConfig?.hoverBrightness && effectConfig.hoverBrightness !== 1) {
+          ptColor = adjustBrightness(ptColor, effectConfig.hoverBrightness);
+        }
+      }
+      const ptHoverBorderColorCanvas = isPointHovered ? resolveMarkerHoverBorderColorCanvas(pi) : void 0;
+      if (!seriesProps?.renderMarker) {
+        drawMarkerCanvas(ctx, {
+          x: pt.x,
+          y: pt.y,
+          size: pointR,
+          shape: resolveMarkerShapeCanvas(pi, pointR),
+          fillStyle: ptColor,
+          strokeStyle: ptHoverBorderColorCanvas ?? seriesProps?.pointBorderColor ?? ptColor,
+          lineStrokeWidth: resolveAccessor(seriesProps?.pointBorderStrokeWidth, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0,
+          opacity: seriesOpacity,
+          lineDash: resolveDash(seriesProps?.pointBorderDash, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras })),
+          lineDashOffset: resolveAccessor(seriesProps?.pointBorderDashOffset, makeItemContext(dataArrCanvas?.[pi], pi, { value: pt.value, category: ptCategoryCanvas(pi), ...seriesExtras }), { arrayMode: "clip", fallback: 0 }) ?? 0,
+          lineJoin: seriesProps?.pointBorderJoinStyle,
+          rotation: resolvePointRotationCanvas(pi)
+        });
+      }
+    }
+  }
+}
+
+export { renderRadarSeriesCanvas };

package/dist/chunk-J65DBT4R.mjs

@@ -0,0 +1,13 @@
+import { renderLineSvg } from './chunk-3FFJEX4A.mjs';
+import { renderLineCanvas } from './chunk-KQIFO5I3.mjs';
+import { hitTestLine, calculateLineLayout } from './chunk-6HSEJLSR.mjs';
+
+// src/series/line/index.ts
+var lineRenderer = {
+  calculateLayout: calculateLineLayout,
+  renderSvg: renderLineSvg,
+  renderCanvas: renderLineCanvas,
+  hitTest: hitTestLine
+};
+
+export { lineRenderer };

package/dist/chunk-JGOVWSKH.mjs

@@ -0,0 +1,179 @@
+import { formatTimeLabel, formatHitValue, formatCursorValue } from './chunk-DP2IZNN3.mjs';
+import { hitTestBar } from './chunk-AUF4CHDP.mjs';
+import { makeItemContext, resolveAccessor, getColor, resolveSwatchColor, asGradient } from './chunk-O2X6FF45.mjs';
+
+// src/cartesian/hittest-wrappers/bar.ts
+function barHitTest(x, y, ctx) {
+  const { layouts, renderPropsCache, datasets, layoutData } = ctx;
+  const orientation = layoutData.orientation ?? "vertical";
+  const barEntries = layoutData.isOverlap ? [...layouts].reverse() : layouts;
+  for (const [datasetId, layout] of barEntries) {
+    const dataset = datasets.get(datasetId);
+    if (!dataset) continue;
+    const barProps = renderPropsCache.get(datasetId) ?? dataset.props;
+    const hitIndex = hitTestBar(x, y, {}, layout);
+    if (hitIndex !== null) {
+      const item = barProps.data?.[hitIndex];
+      const hitCtx = makeItemContext(item, hitIndex);
+      const rawLabel = item ? String(resolveAccessor(barProps.categoryField, hitCtx) ?? `Item ${hitIndex}`) : `Item ${hitIndex}`;
+      const label = formatTimeLabel(rawLabel, layoutData);
+      const value = item ? Number(resolveAccessor(barProps.valueField, hitCtx) ?? 0) : 0;
+      const color = typeof layout.colors[hitIndex] === "string" ? layout.colors[hitIndex] : getColor({ color: layout.colors[hitIndex] }, layout.datasetIndex, void 0, ctx.theme);
+      const swatchColor = resolveSwatchColor({ color: layout.colors[hitIndex] }, layout.datasetIndex, void 0, ctx.theme);
+      let percentage;
+      if (layoutData.isPercentStacked && layoutData.categoryTotals) {
+        const catTotal = layoutData.categoryTotals[hitIndex];
+        percentage = catTotal > 0 ? Math.round(Math.abs(value) / catTotal * 100) : 0;
+      }
+      const bar = layout.visibleBars.find((b) => b.dataIndex === hitIndex);
+      let snapX;
+      let snapY;
+      if (bar) {
+        if (orientation === "vertical") {
+          snapX = bar.x + bar.width / 2;
+          snapY = bar.isNegative ? bar.y + bar.height : bar.y;
+        } else {
+          snapX = bar.isNegative ? bar.x : bar.x + bar.width;
+          snapY = bar.y + bar.height / 2;
+        }
+      } else {
+        snapX = x;
+        snapY = y;
+      }
+      const displayValue = layoutData.isPercentStacked ? Math.round(value * 10) / 10 : value;
+      const formattedValue = formatHitValue(displayValue, barProps, orientation, layoutData);
+      const cursorFormattedValue = formatCursorValue(x, y, barProps, orientation, layoutData);
+      return { datasetId, index: hitIndex, label, value, color, colorGradient: asGradient(layout.colors[hitIndex]), swatchColor, percentage, snapX, snapY, formattedValue, cursorFormattedValue };
+    }
+  }
+  return null;
+}
+function barFindNearest(x, y, ctx) {
+  const { layouts, renderPropsCache, datasets, layoutData } = ctx;
+  const { orientation, cartesianArea } = layoutData;
+  if (x < cartesianArea.x || x > cartesianArea.x + cartesianArea.width || y < cartesianArea.y || y > cartesianArea.y + cartesianArea.height) {
+    return null;
+  }
+  let nearestCatIdx = -1;
+  let minCatDist = Infinity;
+  for (const layout of layouts.values()) {
+    for (const bar of layout.visibleBars) {
+      const center = orientation === "vertical" ? bar.x + bar.width / 2 : bar.y + bar.height / 2;
+      const dist = orientation === "vertical" ? Math.abs(x - center) : Math.abs(y - center);
+      if (dist < minCatDist) {
+        minCatDist = dist;
+        nearestCatIdx = bar.dataIndex;
+      }
+    }
+  }
+  if (nearestCatIdx === -1) return null;
+  let bestHit = null;
+  let bestDist = Infinity;
+  for (const [datasetId, layout] of layouts) {
+    const bar = layout.visibleBars.find((b) => b.dataIndex === nearestCatIdx);
+    if (!bar) continue;
+    const dataset = datasets.get(datasetId);
+    if (!dataset) continue;
+    const barCenterX = bar.x + bar.width / 2;
+    const barCenterY = bar.y + bar.height / 2;
+    const dist = Math.sqrt((x - barCenterX) ** 2 + (y - barCenterY) ** 2);
+    if (dist < bestDist) {
+      bestDist = dist;
+      const barProps = renderPropsCache.get(datasetId) ?? dataset.props;
+      const item = barProps.data?.[nearestCatIdx];
+      const nearCtx = makeItemContext(item, nearestCatIdx);
+      const rawLabel = item ? String(resolveAccessor(barProps.categoryField, nearCtx) ?? `Item ${nearestCatIdx}`) : `Item ${nearestCatIdx}`;
+      const label = formatTimeLabel(rawLabel, layoutData);
+      const value = item ? Number(resolveAccessor(barProps.valueField, nearCtx) ?? 0) : 0;
+      const color = typeof layout.colors[nearestCatIdx] === "string" ? layout.colors[nearestCatIdx] : getColor({ color: layout.colors[nearestCatIdx] }, layout.datasetIndex, void 0, ctx.theme);
+      const swatchColor = resolveSwatchColor({ color: layout.colors[nearestCatIdx] }, layout.datasetIndex, void 0, ctx.theme);
+      let snapX;
+      let snapY;
+      if (orientation === "vertical") {
+        snapX = barCenterX;
+        snapY = bar.isNegative ? bar.y + bar.height : bar.y;
+      } else {
+        snapX = bar.isNegative ? bar.x : bar.x + bar.width;
+        snapY = barCenterY;
+      }
+      let percentage;
+      if (layoutData.isPercentStacked && layoutData.categoryTotals) {
+        const catTotal = layoutData.categoryTotals[nearestCatIdx];
+        percentage = catTotal > 0 ? Math.round(Math.abs(value) / catTotal * 100) : 0;
+      }
+      const displayValue = layoutData.isPercentStacked ? Math.round(value * 10) / 10 : value;
+      const formattedValue = formatHitValue(displayValue, barProps, orientation, layoutData);
+      const cursorFormattedValue = formatCursorValue(x, y, barProps, orientation, layoutData);
+      bestHit = { datasetId, index: nearestCatIdx, label, value, color, colorGradient: asGradient(layout.colors[nearestCatIdx]), swatchColor, percentage, snapX, snapY, formattedValue, cursorFormattedValue };
+    }
+  }
+  return bestHit;
+}
+function barFindAllNearest(x, y, ctx) {
+  const { layouts, renderPropsCache, datasets, layoutData } = ctx;
+  const { orientation, cartesianArea } = layoutData;
+  if (x < cartesianArea.x || x > cartesianArea.x + cartesianArea.width || y < cartesianArea.y || y > cartesianArea.y + cartesianArea.height) {
+    return null;
+  }
+  let nearestCatIdx = -1;
+  let minCatDist = Infinity;
+  for (const layout of layouts.values()) {
+    for (const bar of layout.visibleBars) {
+      const center = orientation === "vertical" ? bar.x + bar.width / 2 : bar.y + bar.height / 2;
+      const dist = orientation === "vertical" ? Math.abs(x - center) : Math.abs(y - center);
+      if (dist < minCatDist) {
+        minCatDist = dist;
+        nearestCatIdx = bar.dataIndex;
+      }
+    }
+  }
+  if (nearestCatIdx === -1) return null;
+  let primaryHit = null;
+  let bestDist = Infinity;
+  const allSeries = [];
+  for (const [datasetId, layout] of layouts) {
+    const bar = layout.visibleBars.find((b) => b.dataIndex === nearestCatIdx);
+    if (!bar) continue;
+    const dataset = datasets.get(datasetId);
+    if (!dataset) continue;
+    const barProps = renderPropsCache.get(datasetId) ?? dataset.props;
+    const item = barProps.data?.[nearestCatIdx];
+    const nearCtx2 = makeItemContext(item, nearestCatIdx);
+    const rawLabel = item ? String(resolveAccessor(barProps.categoryField, nearCtx2) ?? `Item ${nearestCatIdx}`) : `Item ${nearestCatIdx}`;
+    const label = formatTimeLabel(rawLabel, layoutData);
+    const value = item ? Number(resolveAccessor(barProps.valueField, nearCtx2) ?? 0) : 0;
+    const color = typeof layout.colors[nearestCatIdx] === "string" ? layout.colors[nearestCatIdx] : getColor({ color: layout.colors[nearestCatIdx] }, layout.datasetIndex, void 0, ctx.theme);
+    const colorGradient = asGradient(layout.colors[nearestCatIdx]);
+    const swatchColor = resolveSwatchColor({ color: layout.colors[nearestCatIdx] }, layout.datasetIndex, void 0, ctx.theme);
+    let snapX;
+    let snapY;
+    if (orientation === "vertical") {
+      snapX = bar.x + bar.width / 2;
+      snapY = bar.isNegative ? bar.y + bar.height : bar.y;
+    } else {
+      snapX = bar.isNegative ? bar.x : bar.x + bar.width;
+      snapY = bar.y + bar.height / 2;
+    }
+    const displayValue = layoutData.isPercentStacked ? Math.round(value * 10) / 10 : value;
+    const formattedValue = formatHitValue(displayValue, barProps, orientation, layoutData);
+    const cursorFormattedValue = formatCursorValue(x, y, barProps, orientation, layoutData);
+    const snapPixel = orientation === "vertical" ? snapY : snapX;
+    let percentage;
+    if (layoutData.isPercentStacked && layoutData.categoryTotals) {
+      const catTotal = layoutData.categoryTotals[nearestCatIdx];
+      percentage = catTotal > 0 ? Math.round(Math.abs(value) / catTotal * 100) : 0;
+    }
+    allSeries.push({ datasetId, name: barProps.name, label, color, colorGradient, swatchColor, value, percentage, formattedValue, cursorFormattedValue, snapPixel });
+    const barCenterX = bar.x + bar.width / 2;
+    const barCenterY = bar.y + bar.height / 2;
+    const dist = Math.sqrt((x - barCenterX) ** 2 + (y - barCenterY) ** 2);
+    if (dist < bestDist) {
+      bestDist = dist;
+      primaryHit = { datasetId, index: nearestCatIdx, label, value, color, colorGradient, swatchColor, percentage, snapX, snapY, formattedValue, cursorFormattedValue };
+    }
+  }
+  if (!primaryHit) return null;
+  return { primary: primaryHit, allSeries };
+}
+
+export { barFindAllNearest, barFindNearest, barHitTest };

package/dist/chunk-JO7VACY2.mjs

@@ -0,0 +1,25 @@
+// src/animations/candlestick.ts
+function buildCandlestickFingerprint(layouts) {
+  const parts = [];
+  for (const [dsId, layout] of layouts) {
+    const candles = layout.candles;
+    const count = candles.length;
+    if (count === 0) {
+      parts.push(`${dsId}=0`);
+      continue;
+    }
+    const first = candles[0];
+    const last = candles[count - 1];
+    let minLow = first.low;
+    let maxHigh = first.high;
+    for (let i = 1; i < count; i++) {
+      const c = candles[i];
+      if (c.low < minLow) minLow = c.low;
+      if (c.high > maxHigh) maxHigh = c.high;
+    }
+    parts.push(`${dsId}=${count}:${first.x}:${last.x}:${minLow}:${maxHigh}`);
+  }
+  return parts.join(";");
+}
+
+export { buildCandlestickFingerprint };

package/dist/chunk-JWFBOPM6.mjs

@@ -0,0 +1,122 @@
+// src/utils/interaction/keyboard.utils.ts
+var INACTIVE_STATE = {
+  active: false,
+  focusedDatasetId: null,
+  focusedIndex: null,
+  focusedSection: null
+};
+function getNavigableDatasets(datasets, datasetVisibility) {
+  const result = [];
+  const sorted = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+  for (const [id, ds] of sorted) {
+    if (datasetVisibility.get(id) === false) continue;
+    const props = ds.props;
+    const dataLength = props.data?.length ?? 0;
+    if (dataLength > 0) {
+      result.push({ id, dataLength });
+    }
+  }
+  return result;
+}
+function generateAnnouncement(datasets, datasetId, index) {
+  const ds = datasets.get(datasetId);
+  if (!ds) return "";
+  const props = ds.props;
+  const data = props.data;
+  if (!data || !data[index]) return "";
+  const item = data[index];
+  const seriesName = props.name ?? datasetId;
+  const parts = [`${seriesName}`];
+  const labelField = props.categoryField ?? props.columnField ?? props.x;
+  if (labelField && typeof labelField === "string" && item[labelField] != null) {
+    parts.push(`${item[labelField]}`);
+  } else {
+    parts.push(`point ${index + 1}`);
+  }
+  const valueField = props.valueField ?? props.y;
+  if (valueField && typeof valueField === "string" && item[valueField] != null) {
+    parts.push(`value ${item[valueField]}`);
+  }
+  return `${parts.join(", ")}.`;
+}
+var INIT_KEYS = /* @__PURE__ */ new Set(["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "Enter", " "]);
+function handleKeyNavigation(key, focusedDatasetId, focusedIndex, navDatasets, config, lastFocusedIndexMap) {
+  if (navDatasets.length === 0) return { type: "none" };
+  const { wrapAround, seriesMode, rememberPointFocus } = config;
+  if (!focusedDatasetId || focusedIndex === null) {
+    if (INIT_KEYS.has(key)) {
+      return { type: "navigate", datasetId: navDatasets[0].id, index: 0 };
+    }
+    return { type: "none" };
+  }
+  const currentDsIdx = navDatasets.findIndex((ds) => ds.id === focusedDatasetId);
+  if (currentDsIdx === -1) {
+    return { type: "navigate", datasetId: navDatasets[0].id, index: 0 };
+  }
+  const currentDs = navDatasets[currentDsIdx];
+  switch (key) {
+    case "ArrowRight": {
+      if (seriesMode === "serialize") {
+        const nextIndex2 = focusedIndex + 1;
+        if (nextIndex2 >= currentDs.dataLength) {
+          const nextDsIdx = currentDsIdx + 1;
+          if (nextDsIdx < navDatasets.length) {
+            return { type: "navigate", datasetId: navDatasets[nextDsIdx].id, index: 0 };
+          } else if (wrapAround) {
+            return { type: "navigate", datasetId: navDatasets[0].id, index: 0 };
+          }
+          return { type: "none" };
+        }
+        return { type: "navigate", datasetId: focusedDatasetId, index: nextIndex2 };
+      }
+      let nextIndex = focusedIndex + 1;
+      if (nextIndex >= currentDs.dataLength) {
+        nextIndex = wrapAround ? 0 : currentDs.dataLength - 1;
+      }
+      return { type: "navigate", datasetId: focusedDatasetId, index: nextIndex };
+    }
+    case "ArrowLeft": {
+      if (seriesMode === "serialize") {
+        const prevIndex2 = focusedIndex - 1;
+        if (prevIndex2 < 0) {
+          const prevDsIdx = currentDsIdx - 1;
+          if (prevDsIdx >= 0) {
+            return { type: "navigate", datasetId: navDatasets[prevDsIdx].id, index: navDatasets[prevDsIdx].dataLength - 1 };
+          } else if (wrapAround) {
+            const lastDs = navDatasets[navDatasets.length - 1];
+            return { type: "navigate", datasetId: lastDs.id, index: lastDs.dataLength - 1 };
+          }
+          return { type: "none" };
+        }
+        return { type: "navigate", datasetId: focusedDatasetId, index: prevIndex2 };
+      }
+      let prevIndex = focusedIndex - 1;
+      if (prevIndex < 0) {
+        prevIndex = wrapAround ? currentDs.dataLength - 1 : 0;
+      }
+      return { type: "navigate", datasetId: focusedDatasetId, index: prevIndex };
+    }
+    case "ArrowDown": {
+      const nextDsIdx = currentDsIdx + 1 < navDatasets.length ? currentDsIdx + 1 : wrapAround ? 0 : currentDsIdx;
+      const nextDs = navDatasets[nextDsIdx];
+      const targetIndex = rememberPointFocus ? lastFocusedIndexMap.get(nextDs.id) ?? Math.min(focusedIndex, nextDs.dataLength - 1) : Math.min(focusedIndex, nextDs.dataLength - 1);
+      return { type: "navigate", datasetId: nextDs.id, index: targetIndex };
+    }
+    case "ArrowUp": {
+      const prevDsIdx = currentDsIdx - 1 >= 0 ? currentDsIdx - 1 : wrapAround ? navDatasets.length - 1 : currentDsIdx;
+      const prevDs = navDatasets[prevDsIdx];
+      const targetIndex = rememberPointFocus ? lastFocusedIndexMap.get(prevDs.id) ?? Math.min(focusedIndex, prevDs.dataLength - 1) : Math.min(focusedIndex, prevDs.dataLength - 1);
+      return { type: "navigate", datasetId: prevDs.id, index: targetIndex };
+    }
+    case "Home":
+      return { type: "navigate", datasetId: focusedDatasetId, index: 0 };
+    case "End":
+      return { type: "navigate", datasetId: focusedDatasetId, index: currentDs.dataLength - 1 };
+    case "Escape":
+      return { type: "reset" };
+    default:
+      return { type: "none" };
+  }
+}
+
+export { INACTIVE_STATE, generateAnnouncement, getNavigableDatasets, handleKeyNavigation };