@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-O2X6FF45.mjs

@@ -0,0 +1,499 @@
+import { hexToRgba, createSvgRadialGradient, createSvgLinearGradient, createCanvasRadialGradient, createCanvasLinearGradient, parseColorToRGB } from './chunk-SSLTFJ3U.mjs';
+
+// src/utils/color/gradient.ts
+function isGradientColor(color) {
+  return color != null && typeof color === "object" && "stops" in color;
+}
+function getPrimaryColor(color) {
+  if (isGradientColor(color)) {
+    return color.stops[0]?.color ?? "#808080";
+  }
+  return color;
+}
+function asGradient(color) {
+  return color != null && isGradientColor(color) ? color : void 0;
+}
+function gradientToCssBackground(gradient) {
+  const stops = resolveSwatchGradientStops(gradient);
+  if (stops.length === 0) return "transparent";
+  const stopList = stops.map((s) => `${s.color} ${Math.round(s.offset * 100)}%`).join(", ");
+  return gradient.radialGradient ? `radial-gradient(circle, ${stopList})` : `linear-gradient(to bottom, ${stopList})`;
+}
+function resolveSwatchGradientStops(gradient) {
+  return (gradient.stops ?? []).map((s) => ({
+    offset: s.offset,
+    color: s.opacity != null && s.color.startsWith("#") ? hexToRgba(s.color, s.opacity) : s.color
+  }));
+}
+function remapStopsForDonut(stops, innerRatio) {
+  const range = 1 - innerRatio;
+  if (range <= 0) return stops;
+  return stops.map((s) => ({
+    ...s,
+    offset: innerRatio + s.offset * range
+  }));
+}
+function normalizeGradient(color, center, radius, chartArea, defaultDirection) {
+  const stops = color.stops.map((s) => ({
+    offset: s.offset,
+    color: s.color,
+    opacity: s.opacity
+  }));
+  if (color.radialGradient) {
+    const r = (color.radialGradient.r ?? 1) * radius;
+    return {
+      type: "radial",
+      stops,
+      coords: {
+        x1: center.x,
+        y1: center.y,
+        x2: center.x,
+        y2: center.y,
+        r1: 0,
+        r2: r
+      }
+    };
+  }
+  const lg = color.linearGradient;
+  if (lg && lg.x1 !== void 0 && lg.y1 !== void 0 && lg.x2 !== void 0 && lg.y2 !== void 0) {
+    const area = chartArea ?? { x: center.x - radius, y: center.y - radius, width: radius * 2, height: radius * 2 };
+    return {
+      type: "linear",
+      stops,
+      coords: {
+        x1: area.x + lg.x1 * area.width,
+        y1: area.y + lg.y1 * area.height,
+        x2: area.x + lg.x2 * area.width,
+        y2: area.y + lg.y2 * area.height
+      }
+    };
+  }
+  const direction = lg?.direction ?? defaultDirection ?? "vertical";
+  if (direction === "horizontal") {
+    const area = chartArea ?? { x: center.x - radius, y: center.y, width: radius * 2};
+    return {
+      type: "linear",
+      stops,
+      coords: {
+        x1: area.x,
+        y1: center.y,
+        x2: area.x + area.width,
+        y2: center.y
+      }
+    };
+  }
+  const vArea = chartArea ?? { x: center.x, y: center.y - radius, height: radius * 2 };
+  return {
+    type: "linear",
+    stops,
+    coords: {
+      x1: center.x,
+      y1: vArea.y,
+      x2: center.x,
+      y2: vArea.y + vArea.height
+    }
+  };
+}
+function createSvgGradientFromColor(color, id, center, radius, chartArea, defaultDirection) {
+  const normalized = normalizeGradient(color, center, radius, chartArea, defaultDirection);
+  if (normalized.type === "radial") {
+    return createSvgRadialGradient(id, normalized.coords.x1, normalized.coords.y1, normalized.coords.r2, normalized.stops, { useAbsoluteCoords: true });
+  }
+  return createSvgLinearGradient(id, normalized.coords.x1, normalized.coords.y1, normalized.coords.x2, normalized.coords.y2, normalized.stops, { useAbsoluteCoords: true });
+}
+function createCanvasGradientFromColor(ctx, color, center, radius, chartArea, defaultDirection) {
+  const normalized = normalizeGradient(color, center, radius, chartArea, defaultDirection);
+  if (normalized.type === "radial") {
+    return createCanvasRadialGradient(ctx, normalized.coords.x1, normalized.coords.y1, normalized.coords.r1, normalized.coords.r2, normalized.stops);
+  }
+  return createCanvasLinearGradient(ctx, normalized.coords.x1, normalized.coords.y1, normalized.coords.x2, normalized.coords.y2, normalized.stops);
+}
+function sampleGradientAt(color, point, center, radius, chartArea, defaultDirection) {
+  const normalized = normalizeGradient(color, center, radius, chartArea, defaultDirection);
+  const stops = normalized.stops;
+  if (stops.length === 0) return "#000";
+  if (stops.length === 1) return stops[0].color;
+  let t;
+  if (normalized.type === "radial") {
+    const { x1, y1, r2 } = normalized.coords;
+    const dist = Math.hypot(point.x - x1, point.y - y1);
+    t = !r2 ? 0 : dist / r2;
+  } else {
+    const { x1, y1, x2, y2 } = normalized.coords;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const len2 = dx * dx + dy * dy;
+    t = len2 === 0 ? 0 : ((point.x - x1) * dx + (point.y - y1) * dy) / len2;
+  }
+  t = Math.max(0, Math.min(1, t));
+  const sorted = stops.slice().sort((a, b) => a.offset - b.offset);
+  if (t <= sorted[0].offset) return sorted[0].color;
+  if (t >= sorted[sorted.length - 1].offset) return sorted[sorted.length - 1].color;
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i];
+    const b = sorted[i + 1];
+    if (t >= a.offset && t <= b.offset) {
+      const span = b.offset - a.offset;
+      const localT = span === 0 ? 0 : (t - a.offset) / span;
+      const rgbA = parseColorToRGB(a.color);
+      const rgbB = parseColorToRGB(b.color);
+      if (!rgbA || !rgbB) return a.color;
+      const r = Math.round(rgbA.r + (rgbB.r - rgbA.r) * localT);
+      const g = Math.round(rgbA.g + (rgbB.g - rgbA.g) * localT);
+      const bl = Math.round(rgbA.b + (rgbB.b - rgbA.b) * localT);
+      return `rgb(${r},${g},${bl})`;
+    }
+  }
+  return sorted[sorted.length - 1].color;
+}
+
+// src/themes/default.ts
+var defaultLightTheme = {
+  // Series — 10-hue Studio palette, hand-tuned for white backgrounds.
+  series: [
+    "#3563e9",
+    // cobalt
+    "#e8722d",
+    // persimmon
+    "#1fbe8b",
+    // jade
+    "#dc2f4f",
+    // crimson
+    "#6852d9",
+    // lavender
+    "#1dafd9",
+    // cerulean
+    "#d63384",
+    // magenta
+    "#88b83f",
+    // olive
+    "#a855cc",
+    // plum
+    "#d9a422"
+    // saffron
+  ],
+  // Chrome — drives axes, grid, labels, title, caption.
+  // All 4 axis slots default to the same neutral; override individual entries for multi-axis charts.
+  axes: ["#666666", "#666666", "#666666", "#666666"],
+  grid: "#e2e8f0",
+  gridMinor: "#cbd5e1",
+  tickLabel: "#666666",
+  dataLabel: "#334155",
+  dataLabelBackground: "#00000000",
+  // transparent by default
+  dataLabelBorder: "#00000000",
+  annotation: "#334155",
+  annotationBackground: "#00000000",
+  // transparent by default
+  annotationBorder: "#00000000",
+  titleColor: "#0f172a",
+  captionColor: "#64748b",
+  bandFill: "#f1f5f9",
+  // Direction signals — independent of series ramp so candlestick charts
+  // don't collide with series-colored overlays.
+  positive: "#1eb854",
+  negative: "#dc2828",
+  candleNeutral: "#6b7280",
+  // Effect coefficients — mirror state class CSS defaults.
+  hoverBrightness: 1.1,
+  dimOpacity: 0.6,
+  barStrokeWidth: 0,
+  // Tick halo — opposite-luma from text fill so labels pop against
+  // series-colored backgrounds. `#ffffffd9` = rgba(255,255,255,0.85).
+  tickHalo: "#ffffffd9",
+  // Heatmap defaults — mirror `--p-chart-heat-min/max/empty/null`.
+  heatColorMin: "#fde68a",
+  heatColorMax: "#ee1c1c",
+  heatEmpty: "#e5e7eb",
+  heatNull: "#f3f4f6",
+  // Tooltip — semi-transparent surface with subtle border. `f2` ≈ 0.95 alpha,
+  // `1a` ≈ 0.10 alpha. Hex w/ alpha keeps parity-test regex simple.
+  tooltipBackground: "#ffffffd9",
+  tooltipBorder: "#0000001a",
+  tooltipColor: "#374151",
+  tooltipRadius: "8px",
+  tooltipBlur: "12px",
+  tooltipShadow: "0 8px 24px #0000001f",
+  tooltipPadding: "10px 14px",
+  legendColor: "#374151",
+  legendBackground: "#00000000",
+  // transparent by default
+  legendBorder: "#00000000",
+  // Reference lines/bands — neutral-40 stroke, 10% opacity fill.
+  referenceLineColor: "#94a3b8",
+  referenceBandFill: "#0000001a",
+  // rgba(0,0,0,0.10)
+  // Navigator chrome — series line/area, dim mask outside the selection window,
+  // and the selection border + interior. Hex-with-alpha keeps the parity-test regex
+  // happy: `#3b82f6b3` ≈ rgba(59,130,246,0.70), `#3b82f614` ≈ rgba(59,130,246,0.08),
+  // `#0000001f` ≈ rgba(0,0,0,0.12).
+  navigatorSeries: "#94a3b8",
+  navigatorMask: "#0000001f",
+  navigatorSelectionColor: "#3b82f6b3",
+  navigatorSelectionFill: "#3b82f614",
+  // Treemap defaults — mirror existing `--p-chart-treemap-*` vars.
+  treemapCell: "#3563e9",
+  treemapCellBorder: "#00000026",
+  // rgba(0,0,0,0.15)
+  treemapHeaderBg: "#ffffffe6",
+  // near-white header band in light mode
+  treemapHeaderText: "#1f2937",
+  // dark slate text on the light band
+  // Generic fallback border (final fallback in pie/bar canvas paths).
+  borderColor: "#000000",
+  // Crosshair line color — falls back to axes[0] by default.
+  crosshairColor: "#666666",
+  // Base typography — chart-level `fontFamily`/`fontSize` props still win.
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif',
+  fontSize: 12
+};
+var defaultDarkTheme = {
+  series: ["#5790ff", "#ff8838", "#14e5a4", "#ff4d6d", "#8270ff", "#33cdff", "#ff4da0", "#b8e92f", "#c766ff", "#ffc633"],
+  axes: ["#a1a1aa", "#a1a1aa", "#a1a1aa", "#a1a1aa"],
+  grid: "#3f3f46",
+  gridMinor: "#52525b",
+  tickLabel: "#a1a1aa",
+  dataLabel: "#e4e4e7",
+  dataLabelBackground: "#00000000",
+  dataLabelBorder: "#00000000",
+  annotation: "#e4e4e7",
+  annotationBackground: "#00000000",
+  annotationBorder: "#00000000",
+  titleColor: "#fafafa",
+  captionColor: "#a1a1aa",
+  bandFill: "#27272a",
+  positive: "#22d96a",
+  negative: "#ff4d4d",
+  candleNeutral: "#a1a1a1",
+  hoverBrightness: 1.1,
+  dimOpacity: 0.6,
+  barStrokeWidth: 0,
+  // `#000000d9` = rgba(0,0,0,0.85) — dark halo for light text in dark mode.
+  tickHalo: "#000000d9",
+  heatColorMin: "#fde68a",
+  heatColorMax: "#ee1c1c",
+  heatEmpty: "#3f3f46",
+  heatNull: "#27272a",
+  // Tooltip — dark surface, subtle light border for separation against dark page bg.
+  tooltipBackground: "#0a0a0acc",
+  // near-black + 0.80 (frosted glass)
+  tooltipBorder: "#ffffff1a",
+  // 0.10 alpha
+  tooltipColor: "#e4e4e7",
+  tooltipRadius: "8px",
+  tooltipBlur: "12px",
+  tooltipShadow: "0 8px 24px #00000066",
+  tooltipPadding: "10px 14px",
+  legendColor: "#e4e4e7",
+  legendBackground: "#00000000",
+  legendBorder: "#00000000",
+  referenceLineColor: "#71717a",
+  referenceBandFill: "#ffffff14",
+  // rgba(255,255,255,0.08)
+  // Navigator chrome — Highcharts-style: light overlay dims dark bg so selection stands out;
+  // brighter blue (blue-400) for selection so it pops on dark surfaces.
+  // `#ffffff14` ≈ rgba(255,255,255,0.08), `#60a5fab3` ≈ rgba(96,165,250,0.70),
+  // `#60a5fa1f` ≈ rgba(96,165,250,0.12).
+  navigatorSeries: "#a1a1aa",
+  navigatorMask: "#ffffff14",
+  navigatorSelectionColor: "#60a5fab3",
+  navigatorSelectionFill: "#60a5fa1f",
+  // Treemap defaults — same Studio cobalt for cell, mirrored borders/headers.
+  treemapCell: "#5790ff",
+  // theme.series[0] dark
+  treemapCellBorder: "#ffffff26",
+  // rgba(255,255,255,0.15)
+  treemapHeaderBg: "#00000099",
+  // rgba(0,0,0,0.6) — dark header band in dark mode
+  treemapHeaderText: "#ffffff",
+  borderColor: "#ffffff",
+  crosshairColor: "#a1a1aa",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif',
+  fontSize: 12
+};
+
+// src/utils/accessor.utils.ts
+function isAccessorFunction(accessor) {
+  return typeof accessor === "function";
+}
+function isAccessorArray(accessor) {
+  return Array.isArray(accessor);
+}
+function isAccessorString(accessor) {
+  return typeof accessor === "string";
+}
+function makeItemContext(datum, index, extras) {
+  return {
+    datum,
+    index,
+    value: extras?.value ?? null,
+    seriesIndex: extras?.seriesIndex ?? 0,
+    seriesId: extras?.seriesId ?? "",
+    category: extras?.category,
+    size: extras?.size
+  };
+}
+function resolveNestedPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function isNestedPath(str) {
+  return str.includes(".") && !str.startsWith("#") && !str.startsWith("rgb") && !str.startsWith("hsl");
+}
+function resolveAccessor(accessor, ctx, opts) {
+  const fallback = opts?.fallback;
+  const arrayMode = opts?.arrayMode ?? "cycle";
+  if (accessor === void 0) return fallback;
+  if (typeof accessor === "function") {
+    const result = accessor(ctx);
+    return result ?? fallback;
+  }
+  if (Array.isArray(accessor)) {
+    const arr = accessor;
+    if (arr.length === 0) return fallback;
+    if (arrayMode === "cycle") {
+      return arr[(ctx.index % arr.length + arr.length) % arr.length] ?? fallback;
+    }
+    if (ctx.index >= 0 && ctx.index < arr.length) {
+      const v = arr[ctx.index];
+      return v === void 0 ? fallback : v;
+    }
+    return fallback;
+  }
+  if (typeof accessor === "string") {
+    const item = ctx.datum;
+    if (item !== null && typeof item === "object") {
+      if (accessor in item) {
+        return item[accessor];
+      }
+      if (isNestedPath(accessor)) {
+        const value = resolveNestedPath(item, accessor);
+        return value === void 0 ? fallback : value;
+      }
+    }
+    return accessor;
+  }
+  return accessor;
+}
+function batchResolveAccessor(accessor, data) {
+  return data.map((item, index) => resolveAccessor(accessor, makeItemContext(item, index)));
+}
+function resolveRequired(value, fieldName, rowIndex) {
+  if (value === void 0) {
+    const where = rowIndex !== void 0 ? ` at row ${rowIndex}` : "";
+    throw new Error(`Chart: required accessor "${fieldName}" returned undefined${where}. Provide a value for every row. Use null as an explicit gap sentinel where supported (line/area).`);
+  }
+  return value;
+}
+function batchResolveRequired(accessor, data, fieldName) {
+  if (accessor === void 0) {
+    throw new Error(`Chart: required accessor "${fieldName}" was not provided.`);
+  }
+  return data.map((item, index) => resolveRequired(resolveAccessor(accessor, makeItemContext(item, index)), fieldName, index));
+}
+var DASH_PATTERNS = {
+  solid: [],
+  dashed: [5, 5],
+  dotted: [1, 3],
+  dashdot: [5, 3, 1, 3],
+  longdash: [10, 5]
+};
+function resolveDash(accessor, ctx) {
+  if (accessor === void 0) return void 0;
+  let resolved;
+  if (typeof accessor === "function") {
+    resolved = accessor(ctx);
+  } else if (typeof accessor === "string") {
+    if (accessor in DASH_PATTERNS) {
+      resolved = accessor;
+    } else if (ctx.datum != null && accessor in ctx.datum) {
+      resolved = ctx.datum[accessor];
+    } else {
+      return void 0;
+    }
+  } else if (Array.isArray(accessor)) {
+    resolved = accessor;
+  }
+  if (resolved === void 0) return void 0;
+  if (Array.isArray(resolved)) return resolved;
+  return DASH_PATTERNS[resolved];
+}
+var FIELD_DEFAULTS = {
+  categoryField: "category",
+  valueField: "value",
+  xField: "x",
+  yField: "y",
+  columnField: "column",
+  rowField: "row",
+  openField: "open",
+  highField: "high",
+  lowField: "low",
+  closeField: "close"
+};
+function getDefaultColor(index, theme = defaultLightTheme) {
+  return theme.series[index % theme.series.length];
+}
+function resolveColor(accessor, ctx, theme = defaultLightTheme) {
+  if (accessor === void 0) {
+    return getDefaultColor(ctx.index, theme);
+  }
+  const resolved = resolveAccessor(accessor, ctx);
+  return typeof resolved === "string" && resolved ? resolved : getDefaultColor(ctx.index, theme);
+}
+
+// src/utils/color/resolution.ts
+function getColorValue(props, index, item, theme = defaultLightTheme, extras) {
+  if (props.color != null) {
+    const resolved = resolveAccessor(props.color, makeItemContext(item, index, extras), { arrayMode: "cycle" });
+    if (resolved != null) return resolved;
+  }
+  return getDefaultColor(index, theme);
+}
+function getMostOpaqueStopColor(stops) {
+  if (!stops || stops.length === 0) return void 0;
+  if (stops.length === 1) return stops[0].color;
+  let bestStop = stops[0];
+  let bestAlpha = 0;
+  for (const stop of stops) {
+    const match = stop.color.match(/rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*([\d.]+)\s*)?\)/);
+    const alpha = match ? match[1] !== void 0 ? parseFloat(match[1]) : 1 : 1;
+    if (alpha > bestAlpha) {
+      bestAlpha = alpha;
+      bestStop = stop;
+    }
+  }
+  return bestStop.color;
+}
+function extractGradientColor(gradient) {
+  return getMostOpaqueStopColor(gradient.stops);
+}
+function getColor(props, index, item, theme = defaultLightTheme, extras) {
+  if (props.color != null) {
+    const resolved = resolveAccessor(props.color, makeItemContext(item, index, extras), { arrayMode: "cycle" });
+    if (resolved != null) {
+      if (typeof resolved === "string") return resolved;
+      const extracted = extractGradientColor(resolved);
+      if (extracted) return extracted;
+    }
+  }
+  return getDefaultColor(index, theme);
+}
+function resolveSwatchColor(props, index, item, theme, extras) {
+  if (props.color != null) {
+    return getColor(props, index, item, theme, extras);
+  }
+  return `var(--p-chart-color-${index % 10}, ${getDefaultColor(index, theme)})`;
+}
+
+export { FIELD_DEFAULTS, asGradient, batchResolveAccessor, batchResolveRequired, createCanvasGradientFromColor, createSvgGradientFromColor, defaultDarkTheme, defaultLightTheme, getColor, getColorValue, getDefaultColor, getPrimaryColor, gradientToCssBackground, isAccessorArray, isAccessorFunction, isAccessorString, isGradientColor, isNestedPath, makeItemContext, normalizeGradient, remapStopsForDonut, resolveAccessor, resolveColor, resolveDash, resolveNestedPath, resolveRequired, resolveSwatchColor, resolveSwatchGradientStops, sampleGradientAt };

package/dist/chunk-OGJ6IIBW.mjs

@@ -0,0 +1,176 @@
+import { batchResolveAccessor, FIELD_DEFAULTS } from './chunk-O2X6FF45.mjs';
+
+// src/utils/interaction/accessibility.utils.ts
+var CHART_TYPE_LABELS = {
+  bar: "Bar",
+  line: "Line",
+  area: "Area",
+  scatter: "Scatter",
+  pie: "Pie",
+  radar: "Radar",
+  polar: "Polar",
+  candlestick: "Candlestick",
+  heatmap: "Heatmap",
+  treemap: "Treemap"
+};
+function generateChartTypeDescription(datasets) {
+  if (datasets.size === 0) return "Empty chart.";
+  const typeCounts = /* @__PURE__ */ new Map();
+  for (const [, ds] of datasets) {
+    typeCounts.set(ds.type, (typeCounts.get(ds.type) ?? 0) + 1);
+  }
+  const types = Array.from(typeCounts.keys());
+  if (types.length === 1) {
+    const type = types[0];
+    const count = typeCounts.get(type);
+    const label = CHART_TYPE_LABELS[type] ?? type;
+    if (type === "pie") {
+      const totalSlices = getTotalDataPoints(datasets);
+      return `${label} chart with ${totalSlices} ${totalSlices === 1 ? "slice" : "slices"}.`;
+    }
+    if (count === 1) {
+      const totalPoints = getTotalDataPoints(datasets);
+      return `${label} chart with ${totalPoints} data ${totalPoints === 1 ? "point" : "points"}.`;
+    }
+    return `${label} chart with ${count} data series.`;
+  }
+  return `Combination chart with ${datasets.size} data series.`;
+}
+function generateSeriesDescription(name, type, pointCount) {
+  const label = CHART_TYPE_LABELS[type] ?? type;
+  return `${name}, ${label.toLowerCase()} series with ${pointCount} data ${pointCount === 1 ? "point" : "points"}.`;
+}
+function buildAccessibilityRenderContext(features) {
+  const a11yConfig = features?.get("accessibility")?.props;
+  if (a11yConfig?.enabled === false) return void 0;
+  return {
+    enabled: true,
+    pointDescriptionThreshold: a11yConfig?.pointDescriptionThreshold ?? 200,
+    pointDescriptionFormatter: a11yConfig?.pointDescriptionFormatter,
+    landmarkVerbosity: a11yConfig?.landmarkVerbosity ?? "all"
+  };
+}
+function generatePointDescription(category, value, seriesName) {
+  return `${seriesName}: ${category}, ${value}.`;
+}
+function generatePiePointDescription(label, value, percentage) {
+  if (percentage !== void 0) {
+    return `${label}: ${value}, ${percentage.toFixed(1)}%.`;
+  }
+  return `${label}: ${value}.`;
+}
+function formatPointDescription(context, formatter) {
+  if (formatter) return formatter(context);
+  if (context.percentage !== void 0) {
+    return generatePiePointDescription(context.category, context.value, context.percentage);
+  }
+  return generatePointDescription(context.category, context.value, context.seriesName);
+}
+function generateChartSummary(title, caption, typeDescription, axisDescriptions) {
+  const parts = [];
+  if (title) parts.push(title + ".");
+  if (caption) parts.push(caption + ".");
+  parts.push(typeDescription);
+  for (const axisDesc of axisDescriptions) {
+    parts.push(axisDesc);
+  }
+  return parts.join(" ");
+}
+function getTotalDataPoints(datasets) {
+  let total = 0;
+  for (const [, ds] of datasets) {
+    const props = ds.props;
+    if (Array.isArray(props.data)) {
+      total += props.data.length;
+    }
+  }
+  return total;
+}
+var DEFAULT_DATA_TABLE_MAX_ROWS = 200;
+function pickField(props, prop, fallback) {
+  const v = props[prop];
+  return typeof v === "string" ? v : fallback;
+}
+function buildChartDataTable(datasets, maxRows = DEFAULT_DATA_TABLE_MAX_ROWS, cellFormatter) {
+  if (datasets.size === 0) return null;
+  const entries = [...datasets.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const type = entries[0].type;
+  const multi = entries.length > 1;
+  const rows = [];
+  let columns;
+  let caption;
+  const seriesName = (props, i) => typeof props.name === "string" ? props.name : `Series ${i + 1}`;
+  if (type === "scatter") {
+    columns = multi ? ["Series", "X", "Y"] : ["X", "Y"];
+    caption = "Scatter chart data";
+    entries.forEach((ds, i) => {
+      const props = ds.props;
+      const data = props.data ?? [];
+      const xs = batchResolveAccessor(pickField(props, "xField", FIELD_DEFAULTS.xField), data);
+      const ys = batchResolveAccessor(pickField(props, "yField", FIELD_DEFAULTS.yField), data);
+      data.forEach((_, r) => {
+        const row = [xs[r] ?? "", ys[r] ?? ""];
+        rows.push(multi ? [seriesName(props, i), ...row] : row);
+      });
+    });
+  } else if (type === "candlestick") {
+    columns = ["Time", "Open", "High", "Low", "Close"];
+    caption = "Candlestick chart data";
+    const props = entries[0].props;
+    const data = props.data ?? [];
+    const times = batchResolveAccessor(pickField(props, "timeField", "time"), data);
+    const opens = batchResolveAccessor(pickField(props, "openField", FIELD_DEFAULTS.openField), data);
+    const highs = batchResolveAccessor(pickField(props, "highField", FIELD_DEFAULTS.highField), data);
+    const lows = batchResolveAccessor(pickField(props, "lowField", FIELD_DEFAULTS.lowField), data);
+    const closes = batchResolveAccessor(pickField(props, "closeField", FIELD_DEFAULTS.closeField), data);
+    data.forEach((_, r) => rows.push([String(times[r] ?? r), opens[r] ?? "", highs[r] ?? "", lows[r] ?? "", closes[r] ?? ""]));
+  } else if (type === "heatmap") {
+    columns = ["Row", "Column", "Value"];
+    caption = "Heatmap chart data";
+    const props = entries[0].props;
+    const data = props.data ?? [];
+    const ys = batchResolveAccessor(pickField(props, "yField", FIELD_DEFAULTS.yField), data);
+    const xs = batchResolveAccessor(pickField(props, "xField", FIELD_DEFAULTS.xField), data);
+    const vals = batchResolveAccessor(pickField(props, "valueField", FIELD_DEFAULTS.valueField), data);
+    data.forEach((_, r) => rows.push([String(ys[r] ?? r), String(xs[r] ?? r), vals[r] ?? ""]));
+  } else if (type === "pie") {
+    columns = ["Slice", "Value"];
+    caption = "Pie chart data";
+    const props = entries[0].props;
+    const data = props.data ?? [];
+    const cats = batchResolveAccessor(pickField(props, "categoryField", FIELD_DEFAULTS.categoryField), data);
+    const vals = batchResolveAccessor(pickField(props, "valueField", FIELD_DEFAULTS.valueField), data);
+    data.forEach((_, r) => rows.push([String(cats[r] ?? r), vals[r] ?? ""]));
+  } else {
+    columns = multi ? ["Series", "Category", "Value"] : ["Category", "Value"];
+    caption = `${CHART_TYPE_LABELS[type] ?? "Chart"} chart data`;
+    entries.forEach((ds, i) => {
+      const props = ds.props;
+      const data = props.data ?? [];
+      const cats = batchResolveAccessor(pickField(props, "categoryField", FIELD_DEFAULTS.categoryField), data);
+      const vals = batchResolveAccessor(pickField(props, "valueField", FIELD_DEFAULTS.valueField), data);
+      data.forEach((_, r) => {
+        const row = [String(cats[r] ?? r), vals[r] ?? ""];
+        rows.push(multi ? [seriesName(props, i), ...row] : row);
+      });
+    });
+  }
+  if (rows.length === 0) return null;
+  const limit = maxRows > 0 ? maxRows : DEFAULT_DATA_TABLE_MAX_ROWS;
+  const truncatedRowCount = rows.length > limit ? rows.length - limit : 0;
+  let visibleRows = truncatedRowCount > 0 ? rows.slice(0, limit) : rows;
+  if (cellFormatter) {
+    visibleRows = visibleRows.map((row, rowIndex) => row.map((value, columnIndex) => cellFormatter({ value, column: columns[columnIndex] ?? "", columnIndex, rowIndex, isNumeric: typeof value === "number" })));
+  }
+  return { caption, columns, rows: visibleRows, truncatedRowCount };
+}
+function dataTableToCsv(table) {
+  const escape = (cell) => {
+    const s = String(cell);
+    return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  const lines = [table.columns.map(escape).join(","), ...table.rows.map((row) => row.map(escape).join(","))];
+  return lines.join("\r\n");
+}
+
+export { buildAccessibilityRenderContext, buildChartDataTable, dataTableToCsv, formatPointDescription, generateChartSummary, generateChartTypeDescription, generatePiePointDescription, generatePointDescription, generateSeriesDescription };