@ggterm/core 0.2.7 → 0.2.10

package/dist/cli-plot.js

@@ -652,7 +652,7 @@ function isCategoricalField(data, field) {
   for (const row of data) {
     const value = row[field];
     if (value !== null && value !== undefined) {
-      if (typeof value === "string" && isNaN(Number(value))) {
+      if (typeof value === "string") {
         return true;
       }
     }
@@ -1049,6 +1049,44 @@ function getPointColor(row, aes, colorScale) {
   }
   return DEFAULT_POINT_COLOR;
 }
+function parseColorToRgba(color, fallback = { r: 128, g: 128, b: 128, a: 1 }) {
+  if (!color)
+    return fallback;
+  if (typeof color === "object" && color !== null && "r" in color) {
+    return color;
+  }
+  if (typeof color === "string") {
+    if (color.startsWith("#")) {
+      const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+      if (result) {
+        return {
+          r: parseInt(result[1], 16),
+          g: parseInt(result[2], 16),
+          b: parseInt(result[3], 16),
+          a: 1
+        };
+      }
+    }
+    const namedColors = {
+      red: { r: 255, g: 0, b: 0, a: 1 },
+      blue: { r: 0, g: 0, b: 255, a: 1 },
+      green: { r: 0, g: 128, b: 0, a: 1 },
+      black: { r: 0, g: 0, b: 0, a: 1 },
+      white: { r: 255, g: 255, b: 255, a: 1 },
+      gray: { r: 128, g: 128, b: 128, a: 1 },
+      grey: { r: 128, g: 128, b: 128, a: 1 },
+      yellow: { r: 255, g: 255, b: 0, a: 1 },
+      orange: { r: 255, g: 165, b: 0, a: 1 },
+      purple: { r: 128, g: 0, b: 128, a: 1 },
+      cyan: { r: 0, g: 255, b: 255, a: 1 },
+      magenta: { r: 255, g: 0, b: 255, a: 1 }
+    };
+    const named = namedColors[color.toLowerCase()];
+    if (named)
+      return named;
+  }
+  return fallback;
+}
 function renderGeomPoint(data, geom, aes, scales, canvas) {
   const defaultShape = getPointShape(geom.params.shape);
   const positionType = getPositionType(geom.position);
@@ -1447,7 +1485,7 @@ function renderGeomHLine(_data, geom, _aes, scales, canvas) {
   if (yintercept === undefined)
     return;
   const cy = Math.round(scales.y.map(yintercept));
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   const startX = Math.round(scales.x.range[0]);
   const endX = Math.round(scales.x.range[1]);
   canvas.drawHLine(startX, cy, endX - startX + 1, "─", color);
@@ -1457,7 +1495,7 @@ function renderGeomVLine(_data, geom, _aes, scales, canvas) {
   if (xintercept === undefined)
     return;
   const cx = Math.round(scales.x.map(xintercept));
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   const startY = Math.round(Math.min(scales.y.range[0], scales.y.range[1]));
   const endY = Math.round(Math.max(scales.y.range[0], scales.y.range[1]));
   canvas.drawVLine(cx, startY, endY - startY + 1, "│", color);
@@ -1768,6 +1806,120 @@ function renderGeomViolin(data, geom, _aes, scales, canvas) {
     }
   }
 }
+function renderGeomRidgeline(data, geom, aes, scales, canvas) {
+  const scaleFactor = geom.params.scale ?? 0.9;
+  const alpha = geom.params.alpha ?? 0.8;
+  const showOutline = geom.params.outline ?? true;
+  const fixedFill = geom.params.fill;
+  const fixedColor = geom.params.color;
+  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 groups = new Map;
+  const groupKeys = [];
+  for (const row of data) {
+    const key = String(row.y ?? "default");
+    if (!groups.has(key)) {
+      groups.set(key, { data: [], index: Number(row.yIndex) ?? groupKeys.length });
+      groupKeys.push(key);
+    }
+    groups.get(key).data.push(row);
+  }
+  const numGroups = groupKeys.length;
+  if (numGroups === 0)
+    return;
+  const plotHeight = Math.abs(plotBottom - plotTop);
+  const ridgeBaseHeight = plotHeight / numGroups;
+  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 }
+  ];
+  let parsedFillColor = null;
+  if (fixedFill) {
+    parsedFillColor = parseColorToRgba(fixedFill);
+  }
+  const sortedKeys = [...groupKeys].sort((a, b) => {
+    const idxA = groups.get(a)?.index ?? 0;
+    const idxB = groups.get(b)?.index ?? 0;
+    return idxB - idxA;
+  });
+  for (const groupKey of sortedKeys) {
+    const group = groups.get(groupKey);
+    if (!group)
+      continue;
+    const groupIndex = group.index;
+    const groupData = group.data;
+    const sorted = [...groupData].sort((a, b) => {
+      const ax = Number(a.x) || 0;
+      const bx = Number(b.x) || 0;
+      return ax - bx;
+    });
+    if (sorted.length < 2)
+      continue;
+    const baseline = plotTop + (groupIndex + 0.5) * ridgeBaseHeight;
+    let fillColor;
+    if (parsedFillColor) {
+      fillColor = parsedFillColor;
+    } else if ((aes.fill || aes.color) && scales.color) {
+      const mappedColor = scales.color.map(groupKey);
+      if (typeof mappedColor === "object" && "r" in mappedColor) {
+        fillColor = mappedColor;
+      } else {
+        fillColor = defaultColors[groupIndex % defaultColors.length];
+      }
+    } else {
+      fillColor = defaultColors[groupIndex % defaultColors.length];
+    }
+    const alphaFillColor = {
+      r: Math.round(fillColor.r * alpha + 255 * (1 - alpha) * 0.1),
+      g: Math.round(fillColor.g * alpha + 255 * (1 - alpha) * 0.1),
+      b: Math.round(fillColor.b * alpha + 255 * (1 - alpha) * 0.1),
+      a: 1
+    };
+    const maxRidgeHeight = ridgeBaseHeight * scaleFactor * 1.5;
+    const outlinePoints = [];
+    for (const row of sorted) {
+      const xVal = Number(row.x);
+      const scaled = Number(row.scaled) || 0;
+      const px = Math.round(scales.x.map(xVal));
+      const ridgeHeight = scaled * maxRidgeHeight;
+      const py = Math.round(baseline - ridgeHeight);
+      if (px < plotLeft || px > plotRight)
+        continue;
+      const fillTop = Math.max(plotTop, py);
+      const fillBottom = Math.min(plotBottom, Math.round(baseline));
+      for (let y = fillTop;y <= fillBottom; y++) {
+        canvas.drawChar(px, y, "█", alphaFillColor);
+      }
+      if (showOutline) {
+        outlinePoints.push({ x: px, y: Math.max(plotTop, py) });
+      }
+    }
+    if (showOutline && outlinePoints.length > 1) {
+      const outlineColor = fixedColor ? parseColorToRgba(fixedColor) : { r: Math.min(255, fillColor.r + 40), g: Math.min(255, fillColor.g + 40), b: Math.min(255, fillColor.b + 40), a: 1 };
+      for (let i = 0;i < outlinePoints.length - 1; i++) {
+        const p1 = outlinePoints[i];
+        const p2 = outlinePoints[i + 1];
+        if (Math.abs(p2.x - p1.x) <= 1) {
+          if (p1.y >= plotTop && p1.y <= plotBottom) {
+            canvas.drawChar(p1.x, p1.y, "▄", outlineColor);
+          }
+        }
+      }
+      const last = outlinePoints[outlinePoints.length - 1];
+      if (last.y >= plotTop && last.y <= plotBottom) {
+        canvas.drawChar(last.x, last.y, "▄", outlineColor);
+      }
+    }
+  }
+}
 function renderGeomTile(data, geom, aes, scales, canvas) {
   const alpha = geom.params.alpha ?? 1;
   const plotLeft = Math.round(scales.x.range[0]);
@@ -2016,7 +2168,7 @@ function renderGeomAbline(_data, geom, _aes, scales, canvas) {
   const intercept = geom.params.intercept ?? 0;
   const linetype = geom.params.linetype ?? "solid";
   const lineChar = linetype === "dotted" ? "·" : linetype === "dashed" ? "╌" : "─";
-  const color = geom.params.color ?? { r: 128, g: 128, b: 128, a: 1 };
+  const color = parseColorToRgba(geom.params.color);
   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]));
@@ -2206,6 +2358,10 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "violin":
       renderGeomViolin(data, geom, aes, scales, canvas);
       break;
+    case "ridgeline":
+    case "joy":
+      renderGeomRidgeline(data, geom, aes, scales, canvas);
+      break;
     case "tile":
     case "raster":
     case "bin2d":
@@ -3314,6 +3470,52 @@ function stat_ydensity(params = {}) {
     }
   };
 }
+function stat_xdensity(params = {}) {
+  return {
+    type: "xdensity",
+    compute(data, aes) {
+      const groups = new Map;
+      const groupOrder = [];
+      for (const row of data) {
+        const groupKey = String(row[aes.y] ?? "default");
+        const xVal = row[aes.x];
+        if (xVal === null || xVal === undefined)
+          continue;
+        const numX = Number(xVal);
+        if (isNaN(numX))
+          continue;
+        if (!groups.has(groupKey)) {
+          groups.set(groupKey, []);
+          groupOrder.push(groupKey);
+        }
+        groups.get(groupKey).push(numX);
+      }
+      const result = [];
+      let groupIndex = 0;
+      for (const groupKey of groupOrder) {
+        const xValues = groups.get(groupKey);
+        if (xValues.length < 2) {
+          groupIndex++;
+          continue;
+        }
+        const tempData = xValues.map((v) => ({ x: v }));
+        const densityResult = computeDensity(tempData, "x", params);
+        for (const d of densityResult) {
+          result.push({
+            x: d.x,
+            y: groupKey,
+            yIndex: groupIndex,
+            density: d.density,
+            scaled: d.scaled,
+            height: d.scaled
+          });
+        }
+        groupIndex++;
+      }
+      return result;
+    }
+  };
+}
 
 // src/stats/smooth.ts
 function linearRegression(xs, ys) {
@@ -3791,6 +3993,124 @@ function stat_qq_line(params = {}) {
   };
 }
 
+// src/stats/density2d.ts
+function gaussian2d(dx, dy, hx, hy) {
+  const ux = dx / hx;
+  const uy = dy / hy;
+  return Math.exp(-0.5 * (ux * ux + uy * uy)) / (2 * Math.PI * hx * hy);
+}
+function scottBandwidth2d(values) {
+  const n = values.length;
+  if (n < 2)
+    return 1;
+  const mean = values.reduce((a, b) => a + b, 0) / n;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1);
+  const std = Math.sqrt(variance);
+  return std * Math.pow(n, -1 / 6);
+}
+function computeDensity2d(data, xField, yField, params = {}) {
+  const points = [];
+  const xValues = [];
+  const yValues = [];
+  for (const row of data) {
+    const xVal = row[xField];
+    const yVal = row[yField];
+    if (xVal === null || xVal === undefined || yVal === null || yVal === undefined)
+      continue;
+    const x = Number(xVal);
+    const y = Number(yVal);
+    if (isNaN(x) || isNaN(y))
+      continue;
+    points.push({ x, y });
+    xValues.push(x);
+    yValues.push(y);
+  }
+  if (points.length < 3) {
+    return [];
+  }
+  const n = params.n ?? 50;
+  const nx = params.nx ?? n;
+  const ny = params.ny ?? n;
+  const adjust = params.adjust ?? 1;
+  let hx, hy;
+  if (Array.isArray(params.h)) {
+    hx = params.h[0] * adjust;
+    hy = params.h[1] * adjust;
+  } else if (params.h !== undefined) {
+    hx = params.h * adjust;
+    hy = params.h * adjust;
+  } else {
+    hx = scottBandwidth2d(xValues) * adjust;
+    hy = scottBandwidth2d(yValues) * adjust;
+  }
+  if (hx <= 0)
+    hx = 1;
+  if (hy <= 0)
+    hy = 1;
+  const xMin = Math.min(...xValues);
+  const xMax = Math.max(...xValues);
+  const yMin = Math.min(...yValues);
+  const yMax = Math.max(...yValues);
+  const xPad = 3 * hx;
+  const yPad = 3 * hy;
+  const gridXMin = xMin - xPad;
+  const gridXMax = xMax + xPad;
+  const gridYMin = yMin - yPad;
+  const gridYMax = yMax + yPad;
+  const xStep = (gridXMax - gridXMin) / (nx - 1);
+  const yStep = (gridYMax - gridYMin) / (ny - 1);
+  const results = [];
+  const nPoints = points.length;
+  for (let i = 0;i < nx; i++) {
+    const gx = gridXMin + i * xStep;
+    for (let j = 0;j < ny; j++) {
+      const gy = gridYMin + j * yStep;
+      let density = 0;
+      for (const pt of points) {
+        density += gaussian2d(gx - pt.x, gy - pt.y, hx, hy);
+      }
+      density /= nPoints;
+      results.push({
+        x: gx,
+        y: gy,
+        z: density,
+        density,
+        level: density
+      });
+    }
+  }
+  return results;
+}
+function stat_density_2d(params = {}) {
+  return {
+    type: "density_2d",
+    compute(data, aes) {
+      if (aes.color) {
+        const groups = new Map;
+        for (const row of data) {
+          const group = String(row[aes.color] ?? "default");
+          if (!groups.has(group)) {
+            groups.set(group, []);
+          }
+          groups.get(group).push(row);
+        }
+        const result = [];
+        for (const [group, groupData] of groups) {
+          const density = computeDensity2d(groupData, aes.x, aes.y, params);
+          for (const d of density) {
+            result.push({
+              ...d,
+              [aes.color]: group
+            });
+          }
+        }
+        return result;
+      }
+      return computeDensity2d(data, aes.x, aes.y, params);
+    }
+  };
+}
+
 // src/facets/index.ts
 function as_labeller(labels) {
   return (value) => labels[value] ?? value;
@@ -4068,6 +4388,14 @@ function applyStatTransform(data, geom, aes) {
       adjust: geom.params.adjust
     });
     return ydensityStat.compute(data, aes);
+  } else if (geom.stat === "xdensity") {
+    const xdensityStat = stat_xdensity({
+      bw: geom.params.bw,
+      kernel: geom.params.kernel,
+      n: geom.params.n,
+      adjust: geom.params.adjust
+    });
+    return xdensityStat.compute(data, aes);
   } else if (geom.stat === "smooth") {
     const smoothStat = stat_smooth({
       method: geom.params.method,
@@ -4109,6 +4437,15 @@ function applyStatTransform(data, geom, aes) {
       drop: geom.params.drop
     });
     return bin2dStat.compute(data, aes);
+  } else if (geom.stat === "density_2d") {
+    const density2dStat = stat_density_2d({
+      h: geom.params.bandwidth,
+      n: geom.params.n,
+      nx: geom.params.nx,
+      ny: geom.params.ny,
+      adjust: geom.params.adjust
+    });
+    return density2dStat.compute(data, aes);
   }
   return data;
 }
@@ -4177,6 +4514,14 @@ function renderToCanvas(spec, options) {
       scaleData = applyStatTransform(spec.data, geom, spec.aes);
       scaleAes = { ...spec.aes, x: "x", y: "y", fill: "fill" };
       break;
+    } else if (geom.stat === "density_2d") {
+      scaleData = applyStatTransform(spec.data, geom, spec.aes);
+      scaleAes = { ...spec.aes, x: "x", y: "y" };
+      break;
+    } else if (geom.stat === "xdensity") {
+      scaleData = applyStatTransform(spec.data, geom, spec.aes);
+      scaleAes = { ...spec.aes, x: "x", y: "y" };
+      break;
     }
   }
   scaleData = applyCoordTransform(scaleData, scaleAes, spec.coord);
@@ -4213,6 +4558,10 @@ function renderToCanvas(spec, options) {
         geomAes = { ...spec.aes, x: "x", y: "y", xend: "xend", yend: "yend" };
       } else if (geom.stat === "bin2d") {
         geomAes = { ...spec.aes, x: "x", y: "y", fill: "fill" };
+      } else if (geom.stat === "density_2d") {
+        geomAes = { ...spec.aes, x: "x", y: "y" };
+      } else if (geom.stat === "xdensity") {
+        geomAes = { ...spec.aes, x: "x", y: "y" };
       }
       geomData = applyCoordTransform(geomData, geomAes, spec.coord);
     }
@@ -5135,8 +5484,32 @@ function geom_qq_line(options = {}) {
   };
 }
 
+// src/geoms/ridgeline.ts
+function geom_ridgeline(options = {}) {
+  return {
+    type: "ridgeline",
+    stat: "xdensity",
+    position: "identity",
+    params: {
+      scale: options.scale ?? 0.9,
+      alpha: options.alpha ?? 0.8,
+      fill: options.fill,
+      color: options.color,
+      adjust: options.adjust ?? 1,
+      n: options.n ?? 128,
+      outline: options.outline ?? true
+    }
+  };
+}
+var geom_joy;
+var init_ridgeline = __esm(() => {
+  geom_joy = geom_ridgeline;
+});
+
 // src/geoms/index.ts
-var init_geoms = () => {};
+var init_geoms = __esm(() => {
+  init_ridgeline();
+});
 
 // src/stats/index.ts
 var init_stats = __esm(() => {
@@ -9645,6 +10018,7 @@ __export(exports_src, {
   geom_smooth: () => geom_smooth,
   geom_segment: () => geom_segment,
   geom_rug: () => geom_rug,
+  geom_ridgeline: () => geom_ridgeline,
   geom_ribbon: () => geom_ribbon,
   geom_rect: () => geom_rect,
   geom_raster: () => geom_raster,
@@ -9656,6 +10030,7 @@ __export(exports_src, {
   geom_linerange: () => geom_linerange,
   geom_line: () => geom_line,
   geom_label: () => geom_label,
+  geom_joy: () => geom_joy,
   geom_hline: () => geom_hline,
   geom_histogram: () => geom_histogram,
   geom_freqpoly: () => geom_freqpoly,
@@ -10564,6 +10939,8 @@ var GEOM_TYPES = [
   "freqpoly",
   "boxplot",
   "violin",
+  "ridgeline",
+  "joy",
   "area",
   "ribbon",
   "rug",
@@ -10958,7 +11335,7 @@ Error: Unknown geometry type "${geomType}"`);
 Available geom types:`);
     console.error(`  Points/Lines: point, line, path, step, smooth, segment`);
     console.error(`  Bars/Areas:   bar, col, histogram, freqpoly, area, ribbon`);
-    console.error(`  Distributions: boxplot, violin, qq, density_2d`);
+    console.error(`  Distributions: boxplot, violin, ridgeline, joy, qq, density_2d`);
     console.error(`  Uncertainty:  errorbar, errorbarh, crossbar, linerange, pointrange`);
     console.error(`  2D:           tile, rect, raster, bin2d, contour, contour_filled`);
     console.error(`  Text:         text, label`);
@@ -11103,6 +11480,10 @@ If you want a univariate plot, try: histogram, bar, qq, or freqpoly`);
     case "violin":
       plot = plot.geom(geom_violin());
       break;
+    case "ridgeline":
+    case "joy":
+      plot = plot.geom(geom_ridgeline());
+      break;
     case "bar":
       plot = plot.geom(geom_bar());
       break;