@opendata-ai/openchart-core 2.0.0

package/dist/index.js

@@ -0,0 +1,1176 @@
+// src/types/encoding.ts
+function required(...types) {
+  return { required: true, allowedTypes: types };
+}
+function optional(...types) {
+  return { required: false, allowedTypes: types };
+}
+var CHART_ENCODING_RULES = {
+  line: {
+    x: required("temporal", "ordinal"),
+    y: required("quantitative"),
+    color: optional("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  area: {
+    x: required("temporal", "ordinal"),
+    y: required("quantitative"),
+    color: optional("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  bar: {
+    x: required("quantitative"),
+    y: required("nominal", "ordinal"),
+    color: optional("nominal", "ordinal", "quantitative"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  column: {
+    x: required("nominal", "ordinal", "temporal"),
+    y: required("quantitative"),
+    color: optional("nominal", "ordinal", "quantitative"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  pie: {
+    x: optional(),
+    y: required("quantitative"),
+    color: required("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  donut: {
+    x: optional(),
+    y: required("quantitative"),
+    color: required("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  dot: {
+    x: required("quantitative"),
+    y: required("nominal", "ordinal"),
+    color: optional("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  },
+  scatter: {
+    x: required("quantitative"),
+    y: required("quantitative"),
+    color: optional("nominal", "ordinal"),
+    size: optional("quantitative"),
+    detail: optional("nominal")
+  }
+};
+var GRAPH_ENCODING_RULES = {
+  nodeColor: { required: false, allowedTypes: ["nominal", "ordinal"] },
+  nodeSize: { required: false, allowedTypes: ["quantitative"] },
+  edgeColor: { required: false, allowedTypes: ["nominal", "ordinal"] },
+  edgeWidth: { required: false, allowedTypes: ["quantitative"] },
+  nodeLabel: { required: false, allowedTypes: [] }
+};
+
+// src/types/spec.ts
+var CHART_TYPES = /* @__PURE__ */ new Set([
+  "line",
+  "area",
+  "bar",
+  "column",
+  "pie",
+  "donut",
+  "dot",
+  "scatter"
+]);
+function isChartSpec(spec) {
+  return CHART_TYPES.has(spec.type);
+}
+function isTableSpec(spec) {
+  return spec.type === "table";
+}
+function isGraphSpec(spec) {
+  return spec.type === "graph";
+}
+function isTextAnnotation(annotation) {
+  return annotation.type === "text";
+}
+function isRangeAnnotation(annotation) {
+  return annotation.type === "range";
+}
+function isRefLineAnnotation(annotation) {
+  return annotation.type === "refline";
+}
+
+// src/colors/colorblind.ts
+import { rgb } from "d3-color";
+var PROTAN_MATRIX = [
+  [0.567, 0.433, 0],
+  [0.558, 0.442, 0],
+  [0, 0.242, 0.758]
+];
+var DEUTAN_MATRIX = [
+  [0.625, 0.375, 0],
+  [0.7, 0.3, 0],
+  [0, 0.3, 0.7]
+];
+var TRITAN_MATRIX = [
+  [0.95, 0.05, 0],
+  [0, 0.433, 0.567],
+  [0, 0.475, 0.525]
+];
+var MATRICES = {
+  protanopia: PROTAN_MATRIX,
+  deuteranopia: DEUTAN_MATRIX,
+  tritanopia: TRITAN_MATRIX
+};
+function linearize(v) {
+  const s = v / 255;
+  return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+}
+function delinearize(v) {
+  const s = v <= 31308e-7 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055;
+  return Math.round(Math.max(0, Math.min(255, s * 255)));
+}
+function simulateColorBlindness(color, type) {
+  const c = rgb(color);
+  if (c == null) return color;
+  const lin = [linearize(c.r), linearize(c.g), linearize(c.b)];
+  const m = MATRICES[type];
+  const r = m[0][0] * lin[0] + m[0][1] * lin[1] + m[0][2] * lin[2];
+  const g = m[1][0] * lin[0] + m[1][1] * lin[1] + m[1][2] * lin[2];
+  const b = m[2][0] * lin[0] + m[2][1] * lin[1] + m[2][2] * lin[2];
+  return rgb(delinearize(r), delinearize(g), delinearize(b)).formatHex();
+}
+function checkPaletteDistinguishability(colors, type, minDistance = 30) {
+  const simulated = colors.map((c) => {
+    const s = rgb(simulateColorBlindness(c, type));
+    return s ? [s.r, s.g, s.b] : [0, 0, 0];
+  });
+  for (let i = 0; i < simulated.length; i++) {
+    for (let j = i + 1; j < simulated.length; j++) {
+      const dr = simulated[i][0] - simulated[j][0];
+      const dg = simulated[i][1] - simulated[j][1];
+      const db = simulated[i][2] - simulated[j][2];
+      const dist = Math.sqrt(dr * dr + dg * dg + db * db);
+      if (dist < minDistance) return false;
+    }
+  }
+  return true;
+}
+
+// src/colors/contrast.ts
+import { rgb as rgb2 } from "d3-color";
+function relativeLuminance(color) {
+  const c = rgb2(color);
+  if (c == null) return 0;
+  const srgb = [c.r / 255, c.g / 255, c.b / 255];
+  const linear = srgb.map((v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4);
+  return 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];
+}
+function contrastRatio(fg, bg) {
+  const l1 = relativeLuminance(fg);
+  const l2 = relativeLuminance(bg);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function meetsAA(fg, bg, largeText = false) {
+  const ratio = contrastRatio(fg, bg);
+  return largeText ? ratio >= 3 : ratio >= 4.5;
+}
+function findAccessibleColor(baseColor, bg, targetRatio = 4.5) {
+  if (contrastRatio(baseColor, bg) >= targetRatio) {
+    return baseColor;
+  }
+  const c = rgb2(baseColor);
+  if (c == null) return baseColor;
+  const bgLum = relativeLuminance(bg);
+  const bgIsLight = bgLum > 0.5;
+  let lo = 0;
+  let hi = 1;
+  let best = baseColor;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const adjusted = bgIsLight ? rgb2(c.r * (1 - mid), c.g * (1 - mid), c.b * (1 - mid)) : rgb2(c.r + (255 - c.r) * mid, c.g + (255 - c.g) * mid, c.b + (255 - c.b) * mid);
+    const hex = adjusted.formatHex();
+    const ratio = contrastRatio(hex, bg);
+    if (ratio >= targetRatio) {
+      best = hex;
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return best;
+}
+
+// src/colors/palettes.ts
+var CATEGORICAL_PALETTE = [
+  "#1b7fa3",
+  // teal-blue (primary)
+  "#c44e52",
+  // warm red (secondary)
+  "#6a9f58",
+  // softer green (tertiary)
+  "#d47215",
+  // orange
+  "#507e79",
+  // muted teal
+  "#9a6a8d",
+  // purple
+  "#c4636b",
+  // rose
+  "#9c755f",
+  // brown
+  "#a88f22",
+  // olive gold
+  "#858078"
+  // warm gray
+];
+var SEQUENTIAL_BLUE = {
+  name: "blue",
+  stops: ["#deebf7", "#c6dbef", "#9ecae1", "#6baed6", "#3182bd", "#08519c"]
+};
+var SEQUENTIAL_GREEN = {
+  name: "green",
+  stops: ["#e5f5e0", "#c7e9c0", "#a1d99b", "#74c476", "#31a354", "#006d2c"]
+};
+var SEQUENTIAL_ORANGE = {
+  name: "orange",
+  stops: ["#fee6ce", "#fdd0a2", "#fdae6b", "#fd8d3c", "#e6550d", "#a63603"]
+};
+var SEQUENTIAL_PURPLE = {
+  name: "purple",
+  stops: ["#efedf5", "#dadaeb", "#bcbddc", "#9e9ac8", "#756bb1", "#54278f"]
+};
+var SEQUENTIAL_PALETTES = {
+  blue: [...SEQUENTIAL_BLUE.stops],
+  green: [...SEQUENTIAL_GREEN.stops],
+  orange: [...SEQUENTIAL_ORANGE.stops],
+  purple: [...SEQUENTIAL_PURPLE.stops]
+};
+var DIVERGING_RED_BLUE = {
+  name: "redBlue",
+  stops: [
+    "#b2182b",
+    // strong red
+    "#d6604d",
+    // medium red
+    "#f4a582",
+    // light red
+    "#f7f7f7",
+    // neutral
+    "#92c5de",
+    // light blue
+    "#4393c3",
+    // medium blue
+    "#2166ac"
+    // strong blue
+  ]
+};
+var DIVERGING_BROWN_TEAL = {
+  name: "brownTeal",
+  stops: [
+    "#8c510a",
+    // strong brown
+    "#bf812d",
+    // medium brown
+    "#dfc27d",
+    // light brown
+    "#f6e8c3",
+    // neutral
+    "#80cdc1",
+    // light teal
+    "#35978f",
+    // medium teal
+    "#01665e"
+    // strong teal
+  ]
+};
+var DIVERGING_PALETTES = {
+  redBlue: [...DIVERGING_RED_BLUE.stops],
+  brownTeal: [...DIVERGING_BROWN_TEAL.stops]
+};
+
+// src/theme/dark-mode.ts
+import { hsl, rgb as rgb3 } from "d3-color";
+var DARK_BG = "#1a1a2e";
+var DARK_TEXT = "#e0e0e0";
+function adaptColorForDarkMode(color, lightBg, darkBg) {
+  const originalRatio = contrastRatio(color, lightBg);
+  const c = hsl(color);
+  if (c == null || Number.isNaN(c.h)) {
+    const r = rgb3(color);
+    if (r == null) return color;
+    const darkBgLum = _luminanceFromHex(darkBg);
+    const isLight = darkBgLum < 0.5;
+    if (isLight) return color;
+    const inverted = hsl(color);
+    if (inverted == null) return color;
+    inverted.l = 1 - inverted.l;
+    return inverted.formatHex();
+  }
+  let lo = 0;
+  let hi = 1;
+  let bestColor = color;
+  let bestDiff = Infinity;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const candidate = hsl(c.h, c.s, mid);
+    const hex = candidate.formatHex();
+    const ratio = contrastRatio(hex, darkBg);
+    const diff = Math.abs(ratio - originalRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestColor = hex;
+    }
+    if (ratio < originalRatio) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return bestColor;
+}
+function _luminanceFromHex(color) {
+  const c = rgb3(color);
+  if (c == null) return 0;
+  return (0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) / 255;
+}
+function adaptTheme(theme) {
+  const lightBg = theme.colors.background;
+  const darkBg = DARK_BG;
+  return {
+    ...theme,
+    isDark: true,
+    colors: {
+      ...theme.colors,
+      background: darkBg,
+      text: DARK_TEXT,
+      gridline: "#333344",
+      axis: "#888899",
+      annotationFill: "rgba(255,255,255,0.08)",
+      annotationText: "#bbbbcc",
+      categorical: theme.colors.categorical.map((c) => adaptColorForDarkMode(c, lightBg, darkBg))
+      // Sequential and diverging palettes are kept as-is since they're
+      // typically used for fills where the lightness range still works.
+      // If a specific use case needs adaptation, it can be done per-color.
+    },
+    chrome: {
+      title: { ...theme.chrome.title, color: DARK_TEXT },
+      subtitle: { ...theme.chrome.subtitle, color: "#aaaaaa" },
+      source: { ...theme.chrome.source, color: "#888888" },
+      byline: { ...theme.chrome.byline, color: "#888888" },
+      footer: { ...theme.chrome.footer, color: "#888888" }
+    }
+  };
+}
+
+// src/theme/defaults.ts
+var DEFAULT_THEME = {
+  colors: {
+    categorical: [...CATEGORICAL_PALETTE],
+    sequential: SEQUENTIAL_PALETTES,
+    diverging: DIVERGING_PALETTES,
+    background: "#ffffff",
+    text: "#1d1d1d",
+    gridline: "#e8e8e8",
+    axis: "#888888",
+    annotationFill: "rgba(0,0,0,0.04)",
+    annotationText: "#555555"
+  },
+  fonts: {
+    family: 'Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+    mono: '"JetBrains Mono", "Fira Code", "Cascadia Code", monospace',
+    sizes: {
+      title: 22,
+      subtitle: 15,
+      body: 13,
+      small: 11,
+      axisTick: 11
+    },
+    weights: {
+      normal: 400,
+      medium: 500,
+      semibold: 600,
+      bold: 700
+    }
+  },
+  spacing: {
+    padding: 12,
+    chromeGap: 4,
+    chromeToChart: 8,
+    chartToFooter: 8,
+    axisMargin: 6
+  },
+  borderRadius: 4,
+  chrome: {
+    title: {
+      fontSize: 22,
+      fontWeight: 700,
+      color: "#333333",
+      lineHeight: 1.3
+    },
+    subtitle: {
+      fontSize: 15,
+      fontWeight: 400,
+      color: "#666666",
+      lineHeight: 1.4
+    },
+    source: {
+      fontSize: 12,
+      fontWeight: 400,
+      color: "#999999",
+      lineHeight: 1.3
+    },
+    byline: {
+      fontSize: 12,
+      fontWeight: 400,
+      color: "#999999",
+      lineHeight: 1.3
+    },
+    footer: {
+      fontSize: 12,
+      fontWeight: 400,
+      color: "#999999",
+      lineHeight: 1.3
+    }
+  }
+};
+
+// src/theme/resolve.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== void 0 && sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && targetVal !== null && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function themeConfigToPartial(config) {
+  const partial = {};
+  if (config.colors) {
+    const colors = {};
+    if (config.colors.categorical) colors.categorical = config.colors.categorical;
+    if (config.colors.sequential) colors.sequential = config.colors.sequential;
+    if (config.colors.diverging) colors.diverging = config.colors.diverging;
+    if (config.colors.background) colors.background = config.colors.background;
+    if (config.colors.text) colors.text = config.colors.text;
+    if (config.colors.gridline) colors.gridline = config.colors.gridline;
+    if (config.colors.axis) colors.axis = config.colors.axis;
+    partial.colors = colors;
+  }
+  if (config.fonts) {
+    const fonts = {};
+    if (config.fonts.family) fonts.family = config.fonts.family;
+    if (config.fonts.mono) fonts.mono = config.fonts.mono;
+    partial.fonts = fonts;
+  }
+  if (config.spacing) {
+    const spacing = {};
+    if (config.spacing.padding !== void 0) spacing.padding = config.spacing.padding;
+    if (config.spacing.chromeGap !== void 0) spacing.chromeGap = config.spacing.chromeGap;
+    partial.spacing = spacing;
+  }
+  if (config.borderRadius !== void 0) {
+    partial.borderRadius = config.borderRadius;
+  }
+  return partial;
+}
+function relativeLuminance2(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return 0;
+  const r = parseInt(m[1].slice(0, 2), 16) / 255;
+  const g = parseInt(m[1].slice(2, 4), 16) / 255;
+  const b = parseInt(m[1].slice(4, 6), 16) / 255;
+  const toLinear = (c) => c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function isDarkBackground(hex) {
+  return relativeLuminance2(hex) < 0.2;
+}
+function adaptChromeForDarkBg(theme, textColor) {
+  const light = DEFAULT_THEME.chrome;
+  return {
+    ...theme,
+    chrome: {
+      title: {
+        ...theme.chrome.title,
+        color: theme.chrome.title.color === light.title.color ? textColor : theme.chrome.title.color
+      },
+      subtitle: {
+        ...theme.chrome.subtitle,
+        color: theme.chrome.subtitle.color === light.subtitle.color ? adjustOpacity(textColor, 0.7) : theme.chrome.subtitle.color
+      },
+      source: {
+        ...theme.chrome.source,
+        color: theme.chrome.source.color === light.source.color ? adjustOpacity(textColor, 0.5) : theme.chrome.source.color
+      },
+      byline: {
+        ...theme.chrome.byline,
+        color: theme.chrome.byline.color === light.byline.color ? adjustOpacity(textColor, 0.5) : theme.chrome.byline.color
+      },
+      footer: {
+        ...theme.chrome.footer,
+        color: theme.chrome.footer.color === light.footer.color ? adjustOpacity(textColor, 0.5) : theme.chrome.footer.color
+      }
+    }
+  };
+}
+function adjustOpacity(hex, opacity) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return hex;
+  const r = parseInt(m[1].slice(0, 2), 16);
+  const g = parseInt(m[1].slice(2, 4), 16);
+  const b = parseInt(m[1].slice(4, 6), 16);
+  const mix = (c) => Math.round(c * opacity + 128 * (1 - opacity));
+  const toHex = (n) => n.toString(16).padStart(2, "0");
+  return `#${toHex(mix(r))}${toHex(mix(g))}${toHex(mix(b))}`;
+}
+function resolveTheme(userTheme, base = DEFAULT_THEME) {
+  let merged = userTheme ? deepMerge(base, themeConfigToPartial(userTheme)) : { ...base };
+  const dark = isDarkBackground(merged.colors.background);
+  if (dark) {
+    merged = adaptChromeForDarkBg(merged, merged.colors.text);
+  }
+  return {
+    ...merged,
+    isDark: dark
+  };
+}
+
+// src/layout/text-measure.ts
+var AVG_CHAR_WIDTH_RATIO = 0.55;
+var WEIGHT_ADJUSTMENT = {
+  100: 0.9,
+  200: 0.92,
+  300: 0.95,
+  400: 1,
+  500: 1.02,
+  600: 1.05,
+  700: 1.08,
+  800: 1.1,
+  900: 1.12
+};
+function estimateTextWidth(text, fontSize, fontWeight = 400) {
+  const weightFactor = WEIGHT_ADJUSTMENT[fontWeight] ?? 1;
+  return text.length * fontSize * AVG_CHAR_WIDTH_RATIO * weightFactor;
+}
+function estimateTextHeight(fontSize, lineCount = 1, lineHeight = 1.3) {
+  return fontSize * lineHeight * lineCount;
+}
+
+// src/layout/chrome.ts
+function normalizeChromeText(value) {
+  if (value === void 0) return null;
+  if (typeof value === "string") return { text: value };
+  return { text: value.text, style: value.style, offset: value.offset };
+}
+function buildTextStyle(defaults, fontFamily, textColor, overrides) {
+  return {
+    fontFamily: overrides?.fontFamily ?? fontFamily,
+    fontSize: overrides?.fontSize ?? defaults.fontSize,
+    fontWeight: overrides?.fontWeight ?? defaults.fontWeight,
+    fill: overrides?.color ?? textColor ?? defaults.color,
+    lineHeight: defaults.lineHeight,
+    textAnchor: "start",
+    dominantBaseline: "hanging"
+  };
+}
+function measureWidth(text, style, measureText) {
+  if (measureText) {
+    return measureText(text, style.fontSize, style.fontWeight).width;
+  }
+  return estimateTextWidth(text, style.fontSize, style.fontWeight);
+}
+function estimateLineCount(text, style, maxWidth, measureText) {
+  const fullWidth = measureWidth(text, style, measureText);
+  if (fullWidth <= maxWidth) return 1;
+  return Math.ceil(fullWidth / maxWidth);
+}
+function computeChrome(chrome, theme, width, measureText) {
+  if (!chrome) {
+    return { topHeight: 0, bottomHeight: 0 };
+  }
+  const padding = theme.spacing.padding;
+  const chromeGap = theme.spacing.chromeGap;
+  const maxWidth = width - padding * 2;
+  const fontFamily = theme.fonts.family;
+  let topY = padding;
+  const topElements = {};
+  const titleNorm = normalizeChromeText(chrome.title);
+  if (titleNorm) {
+    const style = buildTextStyle(
+      theme.chrome.title,
+      fontFamily,
+      theme.chrome.title.color,
+      titleNorm.style
+    );
+    const lineCount = estimateLineCount(titleNorm.text, style, maxWidth, measureText);
+    const element = {
+      text: titleNorm.text,
+      x: padding + (titleNorm.offset?.dx ?? 0),
+      y: topY + (titleNorm.offset?.dy ?? 0),
+      maxWidth,
+      style
+    };
+    topElements.title = element;
+    topY += estimateTextHeight(style.fontSize, lineCount, style.lineHeight) + chromeGap;
+  }
+  const subtitleNorm = normalizeChromeText(chrome.subtitle);
+  if (subtitleNorm) {
+    const style = buildTextStyle(
+      theme.chrome.subtitle,
+      fontFamily,
+      theme.chrome.subtitle.color,
+      subtitleNorm.style
+    );
+    const lineCount = estimateLineCount(subtitleNorm.text, style, maxWidth, measureText);
+    const element = {
+      text: subtitleNorm.text,
+      x: padding + (subtitleNorm.offset?.dx ?? 0),
+      y: topY + (subtitleNorm.offset?.dy ?? 0),
+      maxWidth,
+      style
+    };
+    topElements.subtitle = element;
+    topY += estimateTextHeight(style.fontSize, lineCount, style.lineHeight) + chromeGap;
+  }
+  const hasTopChrome = titleNorm || subtitleNorm;
+  const topHeight = hasTopChrome ? topY - padding + theme.spacing.chromeToChart - chromeGap : 0;
+  const bottomElements = {};
+  let bottomHeight = 0;
+  const bottomItems = [];
+  const sourceNorm = normalizeChromeText(chrome.source);
+  if (sourceNorm) {
+    bottomItems.push({
+      key: "source",
+      norm: sourceNorm,
+      defaults: theme.chrome.source
+    });
+  }
+  const bylineNorm = normalizeChromeText(chrome.byline);
+  if (bylineNorm) {
+    bottomItems.push({
+      key: "byline",
+      norm: bylineNorm,
+      defaults: theme.chrome.byline
+    });
+  }
+  const footerNorm = normalizeChromeText(chrome.footer);
+  if (footerNorm) {
+    bottomItems.push({
+      key: "footer",
+      norm: footerNorm,
+      defaults: theme.chrome.footer
+    });
+  }
+  if (bottomItems.length > 0) {
+    bottomHeight += theme.spacing.chartToFooter;
+    for (const item of bottomItems) {
+      const style = buildTextStyle(item.defaults, fontFamily, item.defaults.color, item.norm.style);
+      const lineCount = estimateLineCount(item.norm.text, style, maxWidth, measureText);
+      const height = estimateTextHeight(style.fontSize, lineCount, style.lineHeight);
+      bottomElements[item.key] = {
+        text: item.norm.text,
+        x: padding + (item.norm.offset?.dx ?? 0),
+        y: bottomHeight + (item.norm.offset?.dy ?? 0),
+        // offset from where bottom chrome starts
+        maxWidth,
+        style
+      };
+      bottomHeight += height + chromeGap;
+    }
+    bottomHeight -= chromeGap;
+    bottomHeight += padding;
+  }
+  return {
+    topHeight,
+    bottomHeight,
+    ...topElements,
+    ...bottomElements
+  };
+}
+
+// src/responsive/breakpoints.ts
+var BREAKPOINT_COMPACT_MAX = 400;
+var BREAKPOINT_MEDIUM_MAX = 700;
+function getBreakpoint(width) {
+  if (width < BREAKPOINT_COMPACT_MAX) return "compact";
+  if (width <= BREAKPOINT_MEDIUM_MAX) return "medium";
+  return "full";
+}
+function getLayoutStrategy(breakpoint) {
+  switch (breakpoint) {
+    case "compact":
+      return {
+        labelMode: "none",
+        legendPosition: "top",
+        annotationPosition: "tooltip-only",
+        axisLabelDensity: "minimal"
+      };
+    case "medium":
+      return {
+        labelMode: "important",
+        legendPosition: "top",
+        annotationPosition: "inline",
+        axisLabelDensity: "reduced"
+      };
+    case "full":
+      return {
+        labelMode: "all",
+        legendPosition: "right",
+        annotationPosition: "inline",
+        axisLabelDensity: "full"
+      };
+  }
+}
+
+// src/labels/collision.ts
+var PRIORITY_ORDER = {
+  data: 0,
+  annotation: 1,
+  axis: 2
+};
+function detectCollision(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+var OFFSET_STRATEGIES = [
+  { dx: 0, dy: 0 },
+  // original position
+  { dx: 0, dy: -1.2 },
+  // above (factor of height)
+  { dx: 0, dy: 1.2 },
+  // below
+  { dx: 1.1, dy: 0 },
+  // right
+  { dx: -1.1, dy: 0 },
+  // left
+  { dx: 1.1, dy: -1.2 },
+  // upper-right
+  { dx: -1.1, dy: -1.2 }
+  // upper-left
+];
+function resolveCollisions(labels) {
+  const sorted = [...labels].sort(
+    (a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]
+  );
+  const placed = [];
+  const results = [];
+  for (const label of sorted) {
+    let bestRect = null;
+    let bestX = label.anchorX;
+    let bestY = label.anchorY;
+    for (const offset of OFFSET_STRATEGIES) {
+      const candidateX = label.anchorX + offset.dx * label.width;
+      const candidateY = label.anchorY + offset.dy * label.height;
+      const candidateRect = {
+        x: candidateX,
+        y: candidateY,
+        width: label.width,
+        height: label.height
+      };
+      const hasCollision = placed.some((p) => detectCollision(candidateRect, p));
+      if (!hasCollision) {
+        bestRect = candidateRect;
+        bestX = candidateX;
+        bestY = candidateY;
+        break;
+      }
+    }
+    if (bestRect) {
+      placed.push(bestRect);
+      const needsConnector = bestX !== label.anchorX || bestY !== label.anchorY;
+      results.push({
+        text: label.text,
+        x: bestX,
+        y: bestY,
+        style: label.style,
+        visible: true,
+        connector: needsConnector ? {
+          from: { x: bestX, y: bestY },
+          to: { x: label.anchorX, y: label.anchorY },
+          stroke: label.style.fill,
+          style: "straight"
+        } : void 0
+      });
+    } else {
+      results.push({
+        text: label.text,
+        x: label.anchorX,
+        y: label.anchorY,
+        style: label.style,
+        visible: false
+      });
+    }
+  }
+  return results;
+}
+
+// src/locale/format.ts
+import { format as d3Format } from "d3-format";
+import { timeFormat, utcFormat } from "d3-time-format";
+function formatNumber(value, _locale) {
+  if (!Number.isFinite(value)) return String(value);
+  if (Number.isInteger(value)) {
+    return d3Format(",")(value);
+  }
+  return d3Format(",.2f")(value);
+}
+var ABBREVIATIONS = [
+  { threshold: 1e12, suffix: "T", divisor: 1e12 },
+  { threshold: 1e9, suffix: "B", divisor: 1e9 },
+  { threshold: 1e6, suffix: "M", divisor: 1e6 },
+  { threshold: 1e3, suffix: "K", divisor: 1e3 }
+];
+function abbreviateNumber(value) {
+  if (!Number.isFinite(value)) return String(value);
+  const absValue = Math.abs(value);
+  const sign = value < 0 ? "-" : "";
+  for (const { threshold, suffix, divisor } of ABBREVIATIONS) {
+    if (absValue >= threshold) {
+      const abbreviated = absValue / divisor;
+      const formatted = abbreviated % 1 === 0 ? String(abbreviated) : d3Format(".1f")(abbreviated);
+      return `${sign}${formatted}${suffix}`;
+    }
+  }
+  return formatNumber(value);
+}
+var GRANULARITY_FORMATS = {
+  year: "%Y",
+  quarter: "",
+  // Quarter is always special-cased in formatDate() below
+  month: "%b %Y",
+  week: "%b %d",
+  day: "%b %d, %Y",
+  hour: "%b %d %H:%M",
+  minute: "%H:%M"
+};
+function formatDate(value, _locale, granularity) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  const gran = granularity ?? inferGranularity(date);
+  if (gran === "quarter") {
+    const q = Math.ceil((date.getMonth() + 1) / 3);
+    return `Q${q} ${date.getFullYear()}`;
+  }
+  const formatStr = GRANULARITY_FORMATS[gran];
+  if (["year", "month", "day"].includes(gran)) {
+    return utcFormat(formatStr)(date);
+  }
+  return timeFormat(formatStr)(date);
+}
+function inferGranularity(date) {
+  if (date.getHours() !== 0 || date.getMinutes() !== 0) {
+    return date.getMinutes() !== 0 ? "minute" : "hour";
+  }
+  if (date.getDate() !== 1) return "day";
+  if (date.getMonth() !== 0) return "month";
+  return "year";
+}
+
+// src/accessibility/alt-text.ts
+var CHART_TYPE_NAMES = {
+  line: "Line chart",
+  area: "Area chart",
+  bar: "Bar chart",
+  column: "Column chart",
+  pie: "Pie chart",
+  donut: "Donut chart",
+  dot: "Dot plot",
+  scatter: "Scatter plot"
+};
+function generateAltText(spec, data) {
+  const chartName = CHART_TYPE_NAMES[spec.type] ?? `${spec.type} chart`;
+  const parts = [chartName];
+  const title = spec.chrome?.title;
+  if (title) {
+    const titleText = typeof title === "string" ? title : title.text;
+    parts.push(`showing ${titleText}`);
+  }
+  if (spec.encoding.x && data.length > 0) {
+    const field = spec.encoding.x.field;
+    const values = data.map((d) => d[field]).filter((v) => v != null);
+    if (values.length > 0) {
+      if (spec.encoding.x.type === "temporal") {
+        const dates = values.map((v) => v instanceof Date ? v : new Date(String(v)));
+        const validDates = dates.filter((d) => !Number.isNaN(d.getTime()));
+        if (validDates.length >= 2) {
+          validDates.sort((a, b) => a.getTime() - b.getTime());
+          const first = validDates[0].getUTCFullYear();
+          const last = validDates[validDates.length - 1].getUTCFullYear();
+          if (first !== last) {
+            parts.push(`from ${first} to ${last}`);
+          }
+        }
+      } else if (spec.encoding.x.type === "nominal" || spec.encoding.x.type === "ordinal") {
+        const uniqueValues = [...new Set(values.map(String))];
+        parts.push(`across ${uniqueValues.length} categories`);
+      }
+    }
+  }
+  if (spec.encoding.color && data.length > 0) {
+    const colorField = spec.encoding.color.field;
+    const uniqueSeries = [...new Set(data.map((d) => String(d[colorField])).filter(Boolean))];
+    if (uniqueSeries.length > 0) {
+      parts.push(`with ${uniqueSeries.length} series (${uniqueSeries.join(", ")})`);
+    }
+  }
+  parts.push(`(${data.length} data points)`);
+  return parts.join(" ");
+}
+function generateDataTable(spec, data) {
+  const fields = [];
+  const encoding = spec.encoding;
+  if (encoding.x) fields.push(encoding.x.field);
+  if (encoding.y) fields.push(encoding.y.field);
+  if (encoding.color) fields.push(encoding.color.field);
+  if (encoding.size) fields.push(encoding.size.field);
+  const uniqueFields = [...new Set(fields)];
+  if (uniqueFields.length === 0) return [];
+  const headers = uniqueFields;
+  const rows = data.map((row) => uniqueFields.map((field) => row[field] ?? ""));
+  return [headers, ...rows];
+}
+
+// src/accessibility/aria.ts
+function generateAriaLabels(marks) {
+  const labels = /* @__PURE__ */ new Map();
+  for (let i = 0; i < marks.length; i++) {
+    const mark = marks[i];
+    const key = `mark-${i}`;
+    switch (mark.type) {
+      case "line": {
+        const series = mark.seriesKey ?? "Series";
+        const pointCount = mark.points.length;
+        labels.set(key, `Line series: ${series} with ${pointCount} points`);
+        break;
+      }
+      case "area": {
+        const series = mark.seriesKey ?? "Area";
+        labels.set(key, `Area series: ${series}`);
+        break;
+      }
+      case "rect": {
+        const dataEntries = Object.entries(mark.data).filter(([k]) => !k.startsWith("_"));
+        const description = dataEntries.map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ");
+        labels.set(key, `Data point: ${description}`);
+        break;
+      }
+      case "arc": {
+        const dataEntries = Object.entries(mark.data).filter(([k]) => !k.startsWith("_"));
+        const description = dataEntries.map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ");
+        labels.set(key, `Slice: ${description}`);
+        break;
+      }
+      case "point": {
+        const dataEntries = Object.entries(mark.data).filter(([k]) => !k.startsWith("_"));
+        const description = dataEntries.map(([k, v]) => `${k}: ${formatValue(v)}`).join(", ");
+        labels.set(key, `Data point: ${description}`);
+        break;
+      }
+    }
+  }
+  return labels;
+}
+function formatValue(value) {
+  if (value == null) return "N/A";
+  if (value instanceof Date) return value.toISOString().slice(0, 10);
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? String(value) : value.toFixed(2);
+  }
+  return String(value);
+}
+
+// src/helpers/spec-builders.ts
+var ISO_DATE_RE = /^\d{4}(-\d{2}(-\d{2}(T\d{2}(:\d{2}(:\d{2})?)?)?)?)?$/;
+function inferFieldType(data, field) {
+  const sampleSize = Math.min(data.length, 20);
+  let hasNumber = false;
+  let hasDateString = false;
+  let hasOtherString = false;
+  for (let i = 0; i < sampleSize; i++) {
+    const value = data[i][field];
+    if (value == null) continue;
+    if (typeof value === "number") {
+      hasNumber = true;
+    } else if (typeof value === "string") {
+      if (ISO_DATE_RE.test(value) && !Number.isNaN(Date.parse(value))) {
+        hasDateString = true;
+      } else {
+        hasOtherString = true;
+      }
+    } else if (value instanceof Date) {
+      hasDateString = true;
+    } else {
+      hasOtherString = true;
+    }
+  }
+  if (hasNumber && !hasDateString && !hasOtherString) return "quantitative";
+  if (hasDateString && !hasNumber && !hasOtherString) return "temporal";
+  return "nominal";
+}
+function resolveField(ref, data) {
+  if (typeof ref === "string") {
+    return { field: ref, type: inferFieldType(data, ref) };
+  }
+  return ref;
+}
+function buildEncoding(channels, options, data) {
+  const encoding = { ...channels };
+  if (options?.color && data) {
+    encoding.color = resolveField(options.color, data);
+  }
+  if (options?.size && data) {
+    encoding.size = resolveField(options.size, data);
+  }
+  return encoding;
+}
+function buildChartSpec(type, data, encoding, options) {
+  const spec = { type, data, encoding };
+  if (options?.chrome) spec.chrome = options.chrome;
+  if (options?.annotations) spec.annotations = options.annotations;
+  if (options?.responsive !== void 0) spec.responsive = options.responsive;
+  if (options?.theme) spec.theme = options.theme;
+  if (options?.darkMode) spec.darkMode = options.darkMode;
+  return spec;
+}
+function lineChart(data, x, y, options) {
+  const xChannel = resolveField(x, data);
+  const yChannel = resolveField(y, data);
+  const encoding = buildEncoding({ x: xChannel, y: yChannel }, options, data);
+  return buildChartSpec("line", data, encoding, options);
+}
+function barChart(data, category, value, options) {
+  const categoryChannel = resolveField(category, data);
+  const valueChannel = resolveField(value, data);
+  const encoding = buildEncoding({ x: valueChannel, y: categoryChannel }, options, data);
+  return buildChartSpec("bar", data, encoding, options);
+}
+function columnChart(data, x, y, options) {
+  const xChannel = resolveField(x, data);
+  const yChannel = resolveField(y, data);
+  const encoding = buildEncoding({ x: xChannel, y: yChannel }, options, data);
+  return buildChartSpec("column", data, encoding, options);
+}
+function pieChart(data, category, value, options) {
+  const categoryChannel = resolveField(category, data);
+  const valueChannel = resolveField(value, data);
+  const encoding = {
+    y: valueChannel,
+    color: categoryChannel
+  };
+  if (options?.size && data) {
+    encoding.size = resolveField(options.size, data);
+  }
+  return buildChartSpec("pie", data, encoding, options);
+}
+function areaChart(data, x, y, options) {
+  const xChannel = resolveField(x, data);
+  const yChannel = resolveField(y, data);
+  const encoding = buildEncoding({ x: xChannel, y: yChannel }, options, data);
+  return buildChartSpec("area", data, encoding, options);
+}
+function donutChart(data, category, value, options) {
+  const categoryChannel = resolveField(category, data);
+  const valueChannel = resolveField(value, data);
+  const encoding = {
+    y: valueChannel,
+    color: categoryChannel
+  };
+  if (options?.size && data) {
+    encoding.size = resolveField(options.size, data);
+  }
+  return buildChartSpec("donut", data, encoding, options);
+}
+function dotChart(data, x, y, options) {
+  const xChannel = resolveField(x, data);
+  const yChannel = resolveField(y, data);
+  const encoding = buildEncoding({ x: xChannel, y: yChannel }, options, data);
+  return buildChartSpec("dot", data, encoding, options);
+}
+function scatterChart(data, x, y, options) {
+  const xChannel = resolveField(x, data);
+  const yChannel = resolveField(y, data);
+  const encoding = buildEncoding({ x: xChannel, y: yChannel }, options, data);
+  return buildChartSpec("scatter", data, encoding, options);
+}
+function dataTable(data, options) {
+  let columns = options?.columns;
+  if (!columns && data.length > 0) {
+    columns = Object.keys(data[0]).map((key) => {
+      const fieldType = inferFieldType(data, key);
+      const align = fieldType === "quantitative" ? "right" : "left";
+      return {
+        key,
+        label: key,
+        align
+      };
+    });
+  }
+  const spec = {
+    type: "table",
+    data,
+    columns: columns ?? []
+  };
+  if (options?.rowKey) spec.rowKey = options.rowKey;
+  if (options?.chrome) spec.chrome = options.chrome;
+  if (options?.theme) spec.theme = options.theme;
+  if (options?.darkMode) spec.darkMode = options.darkMode;
+  if (options?.search !== void 0) spec.search = options.search;
+  if (options?.pagination !== void 0) spec.pagination = options.pagination;
+  if (options?.stickyFirstColumn !== void 0) spec.stickyFirstColumn = options.stickyFirstColumn;
+  if (options?.compact !== void 0) spec.compact = options.compact;
+  if (options?.responsive !== void 0) spec.responsive = options.responsive;
+  return spec;
+}
+export {
+  CATEGORICAL_PALETTE,
+  CHART_ENCODING_RULES,
+  CHART_TYPES,
+  DEFAULT_THEME,
+  DIVERGING_PALETTES,
+  GRAPH_ENCODING_RULES,
+  SEQUENTIAL_PALETTES,
+  abbreviateNumber,
+  adaptColorForDarkMode,
+  adaptTheme,
+  areaChart,
+  barChart,
+  checkPaletteDistinguishability,
+  columnChart,
+  computeChrome,
+  contrastRatio,
+  dataTable,
+  donutChart,
+  dotChart,
+  estimateTextWidth,
+  findAccessibleColor,
+  formatDate,
+  formatNumber,
+  generateAltText,
+  generateAriaLabels,
+  generateDataTable,
+  getBreakpoint,
+  getLayoutStrategy,
+  inferFieldType,
+  isChartSpec,
+  isGraphSpec,
+  isRangeAnnotation,
+  isRefLineAnnotation,
+  isTableSpec,
+  isTextAnnotation,
+  lineChart,
+  meetsAA,
+  pieChart,
+  resolveCollisions,
+  resolveTheme,
+  scatterChart,
+  simulateColorBlindness
+};
+//# sourceMappingURL=index.js.map