@ggterm/core 0.2.10 → 0.2.12

package/dist/cli.js

@@ -2309,6 +2309,521 @@ function parseColor(color) {
   }
   return { r: 128, g: 128, b: 128, a: 1 };
 }
+function renderGeomBeeswarm(data, geom, aes, scales, canvas) {
+  const alpha = geom.params.alpha ?? 1;
+  const fixedColor = geom.params.color;
+  const shape = getPointShape(geom.params.shape);
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 },
+    { r: 255, g: 153, b: 153, a: 1 },
+    { r: 170, g: 170, b: 170, a: 1 }
+  ];
+  const categories = new Set;
+  for (const row of data) {
+    categories.add(String(row.xOriginal ?? row[aes.x] ?? "default"));
+  }
+  const categoryList = [...categories];
+  for (const row of data) {
+    const xVal = row.x;
+    const yVal = row.y;
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const numGroups = categoryList.length;
+    const xRange = plotRight - plotLeft;
+    const xNormalized = (Number(xVal) + 0.5) / numGroups;
+    const cx = Math.round(plotLeft + xNormalized * xRange);
+    const cy = Math.round(scales.y.map(yVal));
+    let color;
+    if (fixedColor) {
+      color = parseColorToRgba(fixedColor);
+    } else if (scales.color && aes.color) {
+      color = getPointColor(row, aes, scales.color);
+    } else {
+      const category = String(row.xOriginal ?? row[aes.x] ?? "default");
+      const categoryIdx = categoryList.indexOf(category);
+      color = defaultColors[categoryIdx % defaultColors.length];
+    }
+    if (alpha < 1) {
+      color = { ...color, a: alpha };
+    }
+    if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(cx, cy, shape, color);
+    }
+  }
+}
+function renderGeomDumbbell(data, geom, aes, scales, canvas) {
+  const lineColor = parseColorToRgba(geom.params.lineColor ?? "#666666");
+  const alpha = geom.params.alpha ?? 1;
+  const shape = getPointShape(geom.params.shape);
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 }
+  ];
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const xVal = row[aes.x];
+    const xendVal = row["xend"] ?? row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const x1 = Math.round(scales.x.map(xVal));
+    const x2 = Math.round(scales.x.map(xendVal));
+    const cy = Math.round(scales.y.map(yVal));
+    let startColor;
+    let endColor;
+    if (geom.params.color) {
+      startColor = parseColorToRgba(geom.params.color);
+    } else if (scales.color && aes.color) {
+      startColor = getPointColor(row, aes, scales.color);
+    } else {
+      startColor = defaultColors[0];
+    }
+    if (geom.params.colorEnd) {
+      endColor = parseColorToRgba(geom.params.colorEnd);
+    } else {
+      endColor = geom.params.color ? startColor : defaultColors[1];
+    }
+    if (alpha < 1) {
+      startColor = { ...startColor, a: alpha };
+      endColor = { ...endColor, a: alpha };
+    }
+    if (cy >= plotTop && cy <= plotBottom) {
+      const left = Math.max(plotLeft, Math.min(x1, x2));
+      const right = Math.min(plotRight, Math.max(x1, x2));
+      for (let x = left;x <= right; x++) {
+        canvas.drawChar(x, cy, "─", lineColor);
+      }
+    }
+    if (x1 >= plotLeft && x1 <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(x1, cy, shape, startColor);
+    }
+    if (x2 >= plotLeft && x2 <= plotRight && cy >= plotTop && cy <= plotBottom) {
+      canvas.drawChar(x2, cy, shape, endColor);
+    }
+  }
+}
+function renderGeomLollipop(data, geom, aes, scales, canvas) {
+  const alpha = geom.params.alpha ?? 1;
+  const baseline = geom.params.baseline ?? 0;
+  const direction = geom.params.direction ?? "vertical";
+  const shape = getPointShape(geom.params.shape);
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 }
+  ];
+  const xValues = [...new Set(data.map((row) => row[aes.x]))];
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const xVal = row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      continue;
+    }
+    const cx = Math.round(scales.x.map(xVal));
+    const cy = Math.round(scales.y.map(yVal));
+    let color;
+    if (geom.params.color) {
+      color = parseColorToRgba(geom.params.color);
+    } else if (scales.color && aes.color) {
+      color = getPointColor(row, aes, scales.color);
+    } else {
+      const categoryIdx = xValues.indexOf(xVal);
+      color = defaultColors[categoryIdx % defaultColors.length];
+    }
+    let lineColor;
+    if (geom.params.lineColor) {
+      lineColor = parseColorToRgba(geom.params.lineColor);
+    } else {
+      lineColor = {
+        r: Math.round(color.r * 0.7),
+        g: Math.round(color.g * 0.7),
+        b: Math.round(color.b * 0.7),
+        a: color.a
+      };
+    }
+    if (alpha < 1) {
+      color = { ...color, a: alpha };
+      lineColor = { ...lineColor, a: alpha };
+    }
+    if (direction === "vertical") {
+      let baselineY = Math.round(scales.y.map(baseline));
+      baselineY = Math.max(plotTop, Math.min(plotBottom, baselineY));
+      if (cx >= plotLeft && cx <= plotRight) {
+        const top = Math.min(cy, baselineY);
+        const bottom = Math.max(cy, baselineY);
+        for (let y = top;y <= bottom; y++) {
+          if (y >= plotTop && y <= plotBottom) {
+            canvas.drawChar(cx, y, "│", lineColor);
+          }
+        }
+      }
+      if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+        canvas.drawChar(cx, cy, shape, color);
+      }
+    } else {
+      let baselineX = Math.round(scales.x.map(baseline));
+      baselineX = Math.max(plotLeft, Math.min(plotRight, baselineX));
+      if (cy >= plotTop && cy <= plotBottom) {
+        const left = Math.min(cx, baselineX);
+        const right = Math.max(cx, baselineX);
+        for (let x = left;x <= right; x++) {
+          if (x >= plotLeft && x <= plotRight) {
+            canvas.drawChar(x, cy, "─", lineColor);
+          }
+        }
+      }
+      if (cx >= plotLeft && cx <= plotRight && cy >= plotTop && cy <= plotBottom) {
+        canvas.drawChar(cx, cy, shape, color);
+      }
+    }
+  }
+}
+function renderGeomWaffle(data, geom, aes, scales, canvas) {
+  const rows = geom.params.rows ?? 10;
+  const cols = geom.params.cols ?? 10;
+  const fillChar = geom.params.fill_char ?? "█";
+  const emptyChar = geom.params.empty_char ?? "░";
+  const showLegend = geom.params.show_legend ?? true;
+  const flip = geom.params.flip ?? false;
+  const gap = geom.params.gap ?? 0;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 },
+    { r: 204, g: 102, b: 204, a: 1 },
+    { r: 255, g: 200, b: 87, a: 1 },
+    { r: 138, g: 201, b: 222, a: 1 },
+    { r: 255, g: 153, b: 153, a: 1 },
+    { r: 170, g: 170, b: 170, a: 1 }
+  ];
+  const fillField = aes.fill || aes.color || "category";
+  const valueField = aes.y || "value";
+  const categories = new Map;
+  let totalValue = 0;
+  for (const row of data) {
+    const cat = String(row[fillField] ?? "default");
+    const val = Number(row[valueField]) || 1;
+    categories.set(cat, (categories.get(cat) ?? 0) + val);
+    totalValue += val;
+  }
+  const cellsPerCategory = [];
+  const categoryList = [...categories.keys()];
+  let cellsAssigned = 0;
+  for (let i = 0;i < categoryList.length; i++) {
+    const cat = categoryList[i];
+    const val = categories.get(cat);
+    const proportion = val / totalValue;
+    const cells = Math.round(proportion * rows * cols);
+    const color = scales.color?.map(cat) ?? defaultColors[i % defaultColors.length];
+    cellsPerCategory.push({ category: cat, cells, color });
+    cellsAssigned += cells;
+  }
+  if (cellsAssigned < rows * cols && cellsPerCategory.length > 0) {
+    cellsPerCategory[0].cells += rows * cols - cellsAssigned;
+  }
+  const grid = [];
+  for (const { cells, color } of cellsPerCategory) {
+    for (let i = 0;i < cells; i++) {
+      grid.push({ char: fillChar, color });
+    }
+  }
+  const emptyColor = { r: 80, g: 80, b: 80, a: 0.3 };
+  while (grid.length < rows * cols) {
+    grid.push({ char: emptyChar, color: emptyColor });
+  }
+  const availableWidth = plotRight - plotLeft - (showLegend ? 15 : 0);
+  const availableHeight = plotBottom - plotTop;
+  const cellWidth = Math.max(1, Math.floor(availableWidth / cols)) + gap;
+  const cellHeight = Math.max(1, Math.floor(availableHeight / rows)) + gap;
+  for (let row = 0;row < rows; row++) {
+    for (let col = 0;col < cols; col++) {
+      let idx;
+      if (flip) {
+        idx = row * cols + col;
+      } else {
+        idx = col * rows + (rows - 1 - row);
+      }
+      if (idx >= grid.length)
+        continue;
+      const cell = grid[idx];
+      const x = plotLeft + col * cellWidth;
+      const y = plotTop + row * cellHeight;
+      if (x >= plotLeft && x < plotRight - (showLegend ? 15 : 0) && y >= plotTop && y <= plotBottom) {
+        canvas.drawChar(x, y, cell.char, cell.color);
+      }
+    }
+  }
+  if (showLegend) {
+    const legendX = plotRight - 12;
+    let legendY = plotTop;
+    for (let i = 0;i < cellsPerCategory.length && legendY < plotBottom; i++) {
+      const { category, cells, color } = cellsPerCategory[i];
+      const pct = Math.round(cells / (rows * cols) * 100);
+      const label = `${category.slice(0, 6)} ${pct}%`;
+      canvas.drawChar(legendX, legendY, "█", color);
+      canvas.drawString(legendX + 2, legendY, label, { r: 180, g: 180, b: 180, a: 1 });
+      legendY += 2;
+    }
+  }
+}
+function renderGeomSparkline(data, geom, aes, scales, canvas) {
+  const sparkType = geom.params.sparkType ?? "bar";
+  const width = geom.params.width ?? 20;
+  const showMinmax = geom.params.show_minmax ?? false;
+  const normalize = geom.params.normalize ?? true;
+  const minColor = parseColorToRgba(geom.params.min_color ?? "#e74c3c");
+  const maxColor = parseColorToRgba(geom.params.max_color ?? "#2ecc71");
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const SPARK_CHARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const defaultColor = { r: 79, g: 169, b: 238, a: 1 };
+  const groupField = aes.group || aes.color;
+  const groups = new Map;
+  if (groupField) {
+    for (const row of data) {
+      const key = String(row[groupField] ?? "default");
+      if (!groups.has(key))
+        groups.set(key, []);
+      groups.get(key).push(row);
+    }
+  } else {
+    groups.set("default", [...data]);
+  }
+  let currentY = plotTop;
+  for (const [groupKey, groupData] of groups) {
+    const sorted = aes.x ? [...groupData].sort((a, b) => Number(a[aes.x]) - Number(b[aes.x])) : groupData;
+    const values = sorted.map((row) => Number(row[aes.y]) || 0);
+    if (values.length === 0)
+      continue;
+    const minVal = Math.min(...values);
+    const maxVal = Math.max(...values);
+    const minIdx = values.indexOf(minVal);
+    const maxIdx = values.indexOf(maxVal);
+    const range = maxVal - minVal || 1;
+    const color = scales.color?.map(groupKey) ?? defaultColor;
+    const sparkValues = [];
+    if (values.length <= width) {
+      sparkValues.push(...values);
+    } else {
+      for (let i = 0;i < width; i++) {
+        const idx = Math.floor(i * values.length / width);
+        sparkValues.push(values[idx]);
+      }
+    }
+    for (let i = 0;i < sparkValues.length; i++) {
+      const val = sparkValues[i];
+      const normalized = normalize ? (val - minVal) / range : val / (maxVal || 1);
+      const charIdx = Math.min(7, Math.max(0, Math.floor(normalized * 8)));
+      const char = sparkType === "dot" ? "•" : SPARK_CHARS[charIdx];
+      const x = plotLeft + i;
+      const y = currentY;
+      let pointColor = color;
+      if (showMinmax) {
+        const origIdx = Math.floor(i * values.length / sparkValues.length);
+        if (origIdx === minIdx)
+          pointColor = minColor;
+        else if (origIdx === maxIdx)
+          pointColor = maxColor;
+      }
+      if (x < plotLeft + width && y >= plotTop && y <= plotBottom) {
+        canvas.drawChar(x, y, char, pointColor);
+      }
+    }
+    if (groupField && groups.size > 1) {
+      const labelX = plotLeft + width + 1;
+      canvas.drawString(labelX, currentY, groupKey.slice(0, 8), { r: 180, g: 180, b: 180, a: 1 });
+    }
+    currentY += 2;
+  }
+}
+function renderGeomBullet(data, geom, aes, scales, canvas) {
+  const width = geom.params.width ?? 40;
+  const targetChar = geom.params.target_char ?? "│";
+  const barChar = geom.params.bar_char ?? "█";
+  const rangeChars = geom.params.range_chars ?? ["░", "▒", "▓"];
+  const showValues = geom.params.show_values ?? true;
+  const targetColor = parseColorToRgba(geom.params.target_color ?? "#e74c3c");
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const defaultColors = [
+    { r: 79, g: 169, b: 238, a: 1 },
+    { r: 238, g: 136, b: 102, a: 1 },
+    { r: 102, g: 204, b: 153, a: 1 }
+  ];
+  const rangeColors = [
+    { r: 60, g: 60, b: 60, a: 1 },
+    { r: 90, g: 90, b: 90, a: 1 },
+    { r: 120, g: 120, b: 120, a: 1 }
+  ];
+  let currentY = plotTop;
+  for (let i = 0;i < data.length; i++) {
+    const row = data[i];
+    const label = aes.x ? String(row[aes.x]).slice(0, 10) : `Item ${i + 1}`;
+    const value = Number(row[aes.y]) || 0;
+    const target = Number(row["target"]) || null;
+    const maxValue = Number(row["max"]) || Math.max(value, target || 0) * 1.2;
+    const ranges = row["ranges"] ?? [maxValue * 0.6, maxValue * 0.8, maxValue];
+    const color = scales.color?.map(label) ?? defaultColors[i % defaultColors.length];
+    const labelWidth = 12;
+    canvas.drawString(plotLeft, currentY, label.padEnd(labelWidth), { r: 180, g: 180, b: 180, a: 1 });
+    const barStart = plotLeft + labelWidth;
+    const barWidth = Math.min(width, scales.x.range[1] - barStart - (showValues ? 8 : 0));
+    for (let r = ranges.length - 1;r >= 0; r--) {
+      const rangeWidth = Math.round(ranges[r] / maxValue * barWidth);
+      for (let x = 0;x < rangeWidth; x++) {
+        if (barStart + x <= scales.x.range[1]) {
+          canvas.drawChar(barStart + x, currentY, rangeChars[r], rangeColors[r]);
+        }
+      }
+    }
+    const valueWidth = Math.round(value / maxValue * barWidth);
+    for (let x = 0;x < valueWidth; x++) {
+      if (barStart + x <= scales.x.range[1]) {
+        canvas.drawChar(barStart + x, currentY, barChar, color);
+      }
+    }
+    if (target !== null) {
+      const targetX = barStart + Math.round(target / maxValue * barWidth);
+      if (targetX >= barStart && targetX <= barStart + barWidth) {
+        canvas.drawChar(targetX, currentY, targetChar, targetColor);
+      }
+    }
+    if (showValues) {
+      const valueStr = value.toFixed(0);
+      canvas.drawString(barStart + barWidth + 2, currentY, valueStr, { r: 180, g: 180, b: 180, a: 1 });
+    }
+    currentY += 2;
+    if (currentY > plotBottom)
+      break;
+  }
+}
+function renderGeomBraille(data, geom, aes, scales, canvas) {
+  const brailleType = geom.params.brailleType ?? "point";
+  const fill = geom.params.fill ?? false;
+  const alpha = geom.params.alpha ?? 1;
+  const BRAILLE_BASE = 10240;
+  const DOTS = [
+    [1, 2, 4, 64],
+    [8, 16, 32, 128]
+  ];
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
+  const plotBottom = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
+  const plotWidth = plotRight - plotLeft;
+  const plotHeight = plotBottom - plotTop;
+  const brailleWidth = plotWidth;
+  const brailleHeight = plotHeight;
+  const buffer = [];
+  for (let y = 0;y < brailleHeight; y++) {
+    buffer[y] = new Array(brailleWidth).fill(0);
+  }
+  const defaultColor = { r: 79, g: 169, b: 238, a: 1 };
+  const color = geom.params.color ? parseColorToRgba(geom.params.color) : defaultColor;
+  const finalColor = alpha < 1 ? { ...color, a: alpha } : color;
+  const sorted = aes.x ? [...data].sort((a, b) => Number(a[aes.x]) - Number(b[aes.x])) : data;
+  const setDot = (canvasX, canvasY) => {
+    const subX = (canvasX - plotLeft) * 2;
+    const subY = (canvasY - plotTop) * 4;
+    const cellX = Math.floor(subX / 2);
+    const cellY = Math.floor(subY / 4);
+    const dotCol = subX % 2;
+    const dotRow = subY % 4;
+    if (cellX >= 0 && cellX < brailleWidth && cellY >= 0 && cellY < brailleHeight) {
+      if (dotCol >= 0 && dotCol < 2 && dotRow >= 0 && dotRow < 4) {
+        buffer[cellY][cellX] |= DOTS[dotCol][dotRow];
+      }
+    }
+  };
+  let prevCx = null;
+  let prevCy = null;
+  for (const row of sorted) {
+    const xVal = row[aes.x];
+    const yVal = row[aes.y];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined) {
+      prevCx = null;
+      prevCy = null;
+      continue;
+    }
+    const cx = Math.round(scales.x.map(xVal));
+    const cy = Math.round(scales.y.map(yVal));
+    if (brailleType === "line" && prevCx !== null && prevCy !== null) {
+      const dx = Math.abs(cx - prevCx);
+      const dy = Math.abs(cy - prevCy);
+      const sx = prevCx < cx ? 1 : -1;
+      const sy = prevCy < cy ? 1 : -1;
+      let err = dx - dy;
+      let x = prevCx;
+      let y = prevCy;
+      while (true) {
+        if (x >= plotLeft && x < plotRight && y >= plotTop && y < plotBottom) {
+          setDot(x, y);
+          if (fill) {
+            for (let fy = y;fy < plotBottom; fy++) {
+              setDot(x, fy);
+            }
+          }
+        }
+        if (x === cx && y === cy)
+          break;
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+          err -= dy;
+          x += sx;
+        }
+        if (e2 < dx) {
+          err += dx;
+          y += sy;
+        }
+      }
+    } else {
+      if (cx >= plotLeft && cx < plotRight && cy >= plotTop && cy < plotBottom) {
+        setDot(cx, cy);
+      }
+    }
+    prevCx = cx;
+    prevCy = cy;
+  }
+  for (let y = 0;y < brailleHeight; y++) {
+    for (let x = 0;x < brailleWidth; x++) {
+      if (buffer[y][x] > 0) {
+        const char = String.fromCharCode(BRAILLE_BASE + buffer[y][x]);
+        canvas.drawChar(plotLeft + x, plotTop + y, char, finalColor);
+      }
+    }
+  }
+}
 function renderGeom(data, geom, aes, scales, canvas, coordType) {
   switch (geom.type) {
     case "point":
@@ -2390,6 +2905,28 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "smooth":
       renderGeomSmooth(data, geom, aes, scales, canvas);
       break;
+    case "beeswarm":
+    case "quasirandom":
+      renderGeomBeeswarm(data, geom, aes, scales, canvas);
+      break;
+    case "dumbbell":
+      renderGeomDumbbell(data, geom, aes, scales, canvas);
+      break;
+    case "lollipop":
+      renderGeomLollipop(data, geom, aes, scales, canvas);
+      break;
+    case "waffle":
+      renderGeomWaffle(data, geom, aes, scales, canvas);
+      break;
+    case "sparkline":
+      renderGeomSparkline(data, geom, aes, scales, canvas);
+      break;
+    case "bullet":
+      renderGeomBullet(data, geom, aes, scales, canvas);
+      break;
+    case "braille":
+      renderGeomBraille(data, geom, aes, scales, canvas);
+      break;
     default:
       break;
   }
@@ -3517,6 +4054,224 @@ function stat_xdensity(params = {}) {
   };
 }
 
+// src/stats/beeswarm.ts
+function swarmArrange(yValues, params) {
+  const n = yValues.length;
+  if (n === 0)
+    return { offsets: [], indices: [] };
+  const cex = params.cex ?? 1;
+  const spacing = params.spacing ?? 1;
+  const side = params.side ?? 0;
+  const yRange = Math.max(...yValues) - Math.min(...yValues);
+  const pointSize = yRange / Math.max(n, 10) * cex * spacing;
+  let indices = yValues.map((_, i) => i);
+  const priority = params.priority ?? "ascending";
+  switch (priority) {
+    case "ascending":
+      indices.sort((a, b) => yValues[a] - yValues[b]);
+      break;
+    case "descending":
+      indices.sort((a, b) => yValues[b] - yValues[a]);
+      break;
+    case "random":
+      for (let i = indices.length - 1;i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [indices[i], indices[j]] = [indices[j], indices[i]];
+      }
+      break;
+    case "density":
+      const median = yValues.slice().sort((a, b) => a - b)[Math.floor(n / 2)];
+      indices.sort((a, b) => Math.abs(yValues[a] - median) - Math.abs(yValues[b] - median));
+      break;
+  }
+  const placed = [];
+  const offsets = new Array(n).fill(0);
+  for (const idx of indices) {
+    const y = yValues[idx];
+    let bestOffset = 0;
+    if (placed.length > 0) {
+      const nearby = placed.filter((p) => Math.abs(p.y - y) < pointSize * 2);
+      if (nearby.length > 0) {
+        const maxOffset = nearby.length * pointSize;
+        let foundSpot = false;
+        for (let tryOffset = 0;tryOffset <= maxOffset && !foundSpot; tryOffset += pointSize * 0.5) {
+          if (side >= 0) {
+            let collision = false;
+            for (const p of nearby) {
+              const dx = tryOffset - p.x;
+              const dy = y - p.y;
+              const dist = Math.sqrt(dx * dx + dy * dy);
+              if (dist < pointSize) {
+                collision = true;
+                break;
+              }
+            }
+            if (!collision) {
+              bestOffset = tryOffset;
+              foundSpot = true;
+              break;
+            }
+          }
+          if (side <= 0 && tryOffset > 0 && !foundSpot) {
+            let collision = false;
+            for (const p of nearby) {
+              const dx = -tryOffset - p.x;
+              const dy = y - p.y;
+              const dist = Math.sqrt(dx * dx + dy * dy);
+              if (dist < pointSize) {
+                collision = true;
+                break;
+              }
+            }
+            if (!collision) {
+              bestOffset = -tryOffset;
+              foundSpot = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+    offsets[idx] = bestOffset;
+    placed.push({ y, x: bestOffset });
+  }
+  const maxAbsOffset = Math.max(...offsets.map(Math.abs), 0.001);
+  const dodge = params.dodge ?? 0.8;
+  const scale = dodge * 0.5 / maxAbsOffset;
+  for (let i = 0;i < offsets.length; i++) {
+    offsets[i] *= scale;
+  }
+  return { offsets, indices };
+}
+function centerArrange(yValues, params) {
+  const n = yValues.length;
+  if (n === 0)
+    return { offsets: [], indices: [] };
+  const dodge = params.dodge ?? 0.8;
+  const side = params.side ?? 0;
+  const indices = yValues.map((_, i) => i);
+  indices.sort((a, b) => yValues[a] - yValues[b]);
+  const offsets = new Array(n).fill(0);
+  const maxOffset = dodge * 0.4;
+  for (let i = 0;i < indices.length; i++) {
+    const idx = indices[i];
+    const layer = Math.floor(i / 2) + 1;
+    const offset = layer / Math.ceil(n / 2) * maxOffset;
+    if (side === 0) {
+      offsets[idx] = i % 2 === 0 ? offset : -offset;
+    } else {
+      offsets[idx] = side * offset;
+    }
+  }
+  return { offsets, indices };
+}
+function squareArrange(yValues, params) {
+  const n = yValues.length;
+  if (n === 0)
+    return { offsets: [], indices: [] };
+  const dodge = params.dodge ?? 0.8;
+  const side = params.side ?? 0;
+  const indices = yValues.map((_, i) => i);
+  indices.sort((a, b) => yValues[a] - yValues[b]);
+  const offsets = new Array(n).fill(0);
+  const yRange = Math.max(...yValues) - Math.min(...yValues);
+  const binSize = yRange / Math.max(Math.sqrt(n), 3);
+  const bins = new Map;
+  for (let i = 0;i < indices.length; i++) {
+    const idx = indices[i];
+    const y = yValues[idx];
+    const binKey = Math.floor(y / binSize);
+    if (!bins.has(binKey)) {
+      bins.set(binKey, []);
+    }
+    bins.get(binKey).push(idx);
+  }
+  for (const binIndices of bins.values()) {
+    const binN = binIndices.length;
+    const maxOffset = dodge * 0.4;
+    for (let i = 0;i < binN; i++) {
+      const idx = binIndices[i];
+      const offset = (i - (binN - 1) / 2) * (maxOffset * 2 / Math.max(binN - 1, 1));
+      if (side === 0) {
+        offsets[idx] = offset;
+      } else if (side > 0) {
+        offsets[idx] = Math.abs(offset);
+      } else {
+        offsets[idx] = -Math.abs(offset);
+      }
+    }
+  }
+  return { offsets, indices };
+}
+function computeBeeswarm(data, _xField, yField, groupKey, groupIndex, params = {}) {
+  const yValues = [];
+  const originalRows = [];
+  for (const row of data) {
+    const yVal = row[yField];
+    if (yVal === null || yVal === undefined)
+      continue;
+    const numY = Number(yVal);
+    if (isNaN(numY))
+      continue;
+    yValues.push(numY);
+    originalRows.push(row);
+  }
+  if (yValues.length === 0)
+    return [];
+  const method = params.method ?? "swarm";
+  let result;
+  switch (method) {
+    case "center":
+      result = centerArrange(yValues, params);
+      break;
+    case "square":
+      result = squareArrange(yValues, params);
+      break;
+    case "swarm":
+    default:
+      result = swarmArrange(yValues, params);
+  }
+  const output = [];
+  for (let i = 0;i < yValues.length; i++) {
+    const originalRow = originalRows[i];
+    output.push({
+      x: groupIndex + result.offsets[i],
+      y: yValues[i],
+      xOriginal: groupKey,
+      yOriginal: yValues[i],
+      xOffset: result.offsets[i],
+      ...originalRow
+    });
+  }
+  return output;
+}
+function stat_beeswarm(params = {}) {
+  return {
+    type: "beeswarm",
+    compute(data, aes) {
+      const groups = new Map;
+      const groupOrder = [];
+      for (const row of data) {
+        const groupKey = String(row[aes.x] ?? "default");
+        if (!groups.has(groupKey)) {
+          groups.set(groupKey, []);
+          groupOrder.push(groupKey);
+        }
+        groups.get(groupKey).push(row);
+      }
+      const result = [];
+      let groupIndex = 0;
+      for (const groupKey of groupOrder) {
+        const groupData = groups.get(groupKey);
+        const swarmResult = computeBeeswarm(groupData, aes.x, aes.y, groupKey, groupIndex, params);
+        result.push(...swarmResult);
+        groupIndex++;
+      }
+      return result;
+    }
+  };
+}
+
 // src/stats/smooth.ts
 function linearRegression(xs, ys) {
   const n = xs.length;
@@ -4396,6 +5151,15 @@ function applyStatTransform(data, geom, aes) {
       adjust: geom.params.adjust
     });
     return xdensityStat.compute(data, aes);
+  } else if (geom.stat === "beeswarm") {
+    const beeswarmStat = stat_beeswarm({
+      method: geom.params.method,
+      cex: geom.params.cex,
+      side: geom.params.side,
+      priority: geom.params.priority,
+      dodge: geom.params.dodge
+    });
+    return beeswarmStat.compute(data, aes);
   } else if (geom.stat === "smooth") {
     const smoothStat = stat_smooth({
       method: geom.params.method,
@@ -4522,6 +5286,10 @@ function renderToCanvas(spec, options) {
       scaleData = applyStatTransform(spec.data, geom, spec.aes);
       scaleAes = { ...spec.aes, x: "x", y: "y" };
       break;
+    } else if (geom.stat === "beeswarm") {
+      scaleData = spec.data;
+      scaleAes = spec.aes;
+      break;
     }
   }
   scaleData = applyCoordTransform(scaleData, scaleAes, spec.coord);
@@ -4562,6 +5330,8 @@ function renderToCanvas(spec, options) {
         geomAes = { ...spec.aes, x: "x", y: "y" };
       } else if (geom.stat === "xdensity") {
         geomAes = { ...spec.aes, x: "x", y: "y" };
+      } else if (geom.stat === "beeswarm") {
+        geomAes = { ...spec.aes, x: "x", y: "y" };
       }
       geomData = applyCoordTransform(geomData, geomAes, spec.coord);
     }
@@ -5501,9 +6271,159 @@ var init_ridgeline = __esm(() => {
   geom_joy = geom_ridgeline;
 });
 
+// src/geoms/beeswarm.ts
+function geom_beeswarm(options = {}) {
+  return {
+    type: "beeswarm",
+    stat: "beeswarm",
+    position: "identity",
+    params: {
+      method: options.method ?? "swarm",
+      size: options.size ?? 1,
+      cex: options.cex ?? 1,
+      alpha: options.alpha ?? 1,
+      color: options.color,
+      shape: options.shape ?? "circle",
+      side: options.side ?? 0,
+      priority: options.priority ?? "ascending",
+      dodge: options.dodge ?? 0.8
+    }
+  };
+}
+function geom_quasirandom(options = {}) {
+  return geom_beeswarm({ ...options, method: "center" });
+}
+
+// src/geoms/dumbbell.ts
+function geom_dumbbell(options = {}) {
+  return {
+    type: "dumbbell",
+    stat: "identity",
+    position: "identity",
+    params: {
+      size: options.size ?? 2,
+      sizeEnd: options.sizeEnd ?? options.size ?? 2,
+      color: options.color,
+      colorEnd: options.colorEnd ?? options.color,
+      lineColor: options.lineColor ?? "#666666",
+      lineWidth: options.lineWidth ?? 1,
+      alpha: options.alpha ?? 1,
+      shape: options.shape ?? "circle"
+    }
+  };
+}
+
+// src/geoms/lollipop.ts
+function geom_lollipop(options = {}) {
+  return {
+    type: "lollipop",
+    stat: "identity",
+    position: "identity",
+    params: {
+      size: options.size ?? 2,
+      color: options.color,
+      lineColor: options.lineColor,
+      lineWidth: options.lineWidth ?? 1,
+      alpha: options.alpha ?? 1,
+      shape: options.shape ?? "circle",
+      direction: options.direction ?? "vertical",
+      baseline: options.baseline ?? 0
+    }
+  };
+}
+
+// src/geoms/waffle.ts
+function geom_waffle(options = {}) {
+  return {
+    type: "waffle",
+    stat: "identity",
+    position: "identity",
+    params: {
+      rows: options.rows ?? 10,
+      cols: options.cols ?? 10,
+      n_total: options.n_total ?? 100,
+      fill_char: options.fill_char ?? "█",
+      empty_char: options.empty_char ?? "░",
+      alpha: options.alpha ?? 1,
+      show_legend: options.show_legend ?? true,
+      flip: options.flip ?? false,
+      gap: options.gap ?? 0
+    }
+  };
+}
+
+// src/geoms/sparkline.ts
+function geom_sparkline(options = {}) {
+  return {
+    type: "sparkline",
+    stat: "identity",
+    position: "identity",
+    params: {
+      sparkType: options.type ?? "bar",
+      width: options.width ?? 20,
+      height: options.height ?? 1,
+      show_minmax: options.show_minmax ?? false,
+      color: options.color,
+      min_color: options.min_color ?? "#e74c3c",
+      max_color: options.max_color ?? "#2ecc71",
+      normalize: options.normalize ?? true
+    }
+  };
+}
+var SPARK_BARS, SPARK_DOTS;
+var init_sparkline = __esm(() => {
+  SPARK_BARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  SPARK_DOTS = ["⠀", "⢀", "⢠", "⢰", "⢸", "⣸", "⣾", "⣿"];
+});
+
+// src/geoms/bullet.ts
+function geom_bullet(options = {}) {
+  return {
+    type: "bullet",
+    stat: "identity",
+    position: "identity",
+    params: {
+      width: options.width ?? 40,
+      height: options.height ?? 1,
+      target_char: options.target_char ?? "│",
+      bar_char: options.bar_char ?? "█",
+      range_chars: options.range_chars ?? ["░", "▒", "▓"],
+      show_values: options.show_values ?? true,
+      color: options.color,
+      target_color: options.target_color ?? "#e74c3c",
+      orientation: options.orientation ?? "horizontal"
+    }
+  };
+}
+
+// src/geoms/braille.ts
+function geom_braille(options = {}) {
+  return {
+    type: "braille",
+    stat: "identity",
+    position: "identity",
+    params: {
+      brailleType: options.type ?? "point",
+      color: options.color,
+      fill: options.fill ?? false,
+      alpha: options.alpha ?? 1,
+      dot_size: options.dot_size ?? 1
+    }
+  };
+}
+var BRAILLE_BASE = 10240, BRAILLE_DOTS;
+var init_braille = __esm(() => {
+  BRAILLE_DOTS = [
+    [1, 2, 4, 64],
+    [8, 16, 32, 128]
+  ];
+});
+
 // src/geoms/index.ts
 var init_geoms = __esm(() => {
   init_ridgeline();
+  init_sparkline();
+  init_braille();
 });
 
 // src/scales/continuous.ts