gloomberb 0.7.5 → 0.8.1

package/src/components/chart/rendering/chart-draw.ts

@@ -0,0 +1,270 @@
+import type { ProjectedChartPoint } from "../core/data";
+import type {
+  ChartColors,
+  ChartIndicatorOverlays,
+  ChartRenderMode,
+  ChartSessionBackgroundSpan,
+  PixelBuffer,
+} from "../core/types";
+import type { ResolvedChartPalette } from "../core/palette";
+import {
+  drawLine,
+  fillBackgroundRect,
+  fillColumn,
+  fillRect,
+  LAYER_DATA,
+  LAYER_FILL,
+  LAYER_OVERLAY,
+  setPixel,
+} from "./pixel-buffer";
+import {
+  getBarHalfWidth,
+  getCandleHalfWidth,
+  getDotX,
+  getOhlcStemWidth,
+  getOhlcTickLength,
+  getScaledY,
+  getTimePointBand,
+} from "./geometry";
+
+type VolumeTrendMode = "previousClose" | "openClose";
+
+function drawWickOutsideBody(
+  buf: PixelBuffer,
+  x: number,
+  highY: number,
+  lowY: number,
+  bodyTop: number,
+  bodyBottom: number,
+  color: string,
+) {
+  if (highY < bodyTop) {
+    drawLine(buf, x, highY, x, bodyTop, color, LAYER_DATA);
+  }
+  if (bodyBottom < lowY) {
+    drawLine(buf, x, bodyBottom, x, lowY, color, LAYER_DATA);
+  }
+}
+
+function getSessionBackgroundColor(span: ChartSessionBackgroundSpan, colors: ChartColors): string {
+  return span.kind === "pre" ? colors.preMarketBgColor : colors.postMarketBgColor;
+}
+
+export function drawSessionBackgrounds(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  spans: readonly ChartSessionBackgroundSpan[],
+  yTop: number,
+  yBottom: number,
+  colors: ChartColors,
+) {
+  if (spans.length === 0 || points.length === 0) return;
+  for (const span of spans) {
+    const startIndex = Math.max(Math.min(span.startIndex, points.length - 1), 0);
+    const endIndex = Math.max(Math.min(span.endIndex, points.length - 1), startIndex);
+    const startBand = getTimePointBand(startIndex, points.length, buf.width);
+    const endBand = getTimePointBand(endIndex, points.length, buf.width);
+    fillBackgroundRect(buf, startBand.left, yTop, endBand.right, yBottom, getSessionBackgroundColor(span, colors));
+  }
+}
+
+export function drawLineSeries(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  chartTop: number,
+  chartBottom: number,
+  lineColor: string,
+  min: number,
+  max: number,
+) {
+  if (points.length === 0) return;
+
+  for (let i = 0; i < points.length; i++) {
+    const x = getDotX(i, points.length, buf.width, "line");
+    const y = getScaledY(points[i]!.close, min, max, chartTop, chartBottom);
+    if (i < points.length - 1) {
+      const x1 = getDotX(i + 1, points.length, buf.width, "line");
+      const y1 = getScaledY(points[i + 1]!.close, min, max, chartTop, chartBottom);
+      drawLine(buf, x, y, x1, y1, lineColor, LAYER_DATA);
+    } else {
+      setPixel(buf, x, y, lineColor, LAYER_DATA);
+    }
+  }
+}
+
+export function drawAreaChart(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  chartTop: number,
+  chartBottom: number,
+  lineColor: string,
+  fillColor: string,
+  min: number,
+  max: number,
+) {
+  if (points.length === 0) return;
+
+  for (let i = 0; i < points.length; i++) {
+    const x = getDotX(i, points.length, buf.width, "area");
+    const y = getScaledY(points[i]!.close, min, max, chartTop, chartBottom);
+
+    fillColumn(buf, x, y + 1, chartBottom, fillColor, LAYER_FILL);
+
+    if (i < points.length - 1) {
+      const x1 = getDotX(i + 1, points.length, buf.width, "area");
+      const y1 = getScaledY(points[i + 1]!.close, min, max, chartTop, chartBottom);
+
+      for (let cx = Math.min(x, x1); cx <= Math.max(x, x1); cx++) {
+        if (cx === x || cx === x1) continue;
+        const t = (cx - x) / Math.max(Math.abs(x1 - x), 1);
+        const iy = Math.round(y + t * (y1 - y));
+        fillColumn(buf, cx, iy + 1, chartBottom, fillColor, LAYER_FILL);
+      }
+
+      drawLine(buf, x, y, x1, y1, lineColor, LAYER_DATA);
+    } else {
+      setPixel(buf, x, y, lineColor, LAYER_DATA);
+    }
+  }
+}
+
+export function drawCandlestickChart(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  chartTop: number,
+  chartBottom: number,
+  palette: ResolvedChartPalette,
+  min: number,
+  max: number,
+) {
+  const halfW = getCandleHalfWidth(points.length, buf.width);
+
+  for (let i = 0; i < points.length; i++) {
+    const point = points[i]!;
+    const x = getDotX(i, points.length, buf.width, "candles");
+    const highY = getScaledY(point.high, min, max, chartTop, chartBottom);
+    const lowY = getScaledY(point.low, min, max, chartTop, chartBottom);
+    const openY = getScaledY(point.open, min, max, chartTop, chartBottom);
+    const closeY = getScaledY(point.close, min, max, chartTop, chartBottom);
+    const isUp = point.close >= point.open;
+    const wickColor = isUp ? palette.wickUp : palette.wickDown;
+    const bodyColor = isUp ? palette.candleUp : palette.candleDown;
+
+    const bodyTop = Math.min(openY, closeY);
+    const bodyBottom = Math.max(openY, closeY);
+    if (bodyTop === bodyBottom) {
+      drawLine(buf, x, highY, x, lowY, wickColor, LAYER_DATA);
+      const dojiBottom = Math.min(bodyBottom + 1, chartBottom);
+      const dojiTop = Math.max(chartTop, dojiBottom - 1);
+      fillRect(buf, x - halfW, dojiTop, x + halfW, dojiBottom, bodyColor, LAYER_DATA);
+    } else {
+      drawWickOutsideBody(buf, x, highY, lowY, bodyTop, bodyBottom, wickColor);
+      fillRect(buf, x - halfW, bodyTop, x + halfW, bodyBottom, bodyColor, LAYER_DATA);
+    }
+  }
+}
+
+export function drawOhlcChart(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  chartTop: number,
+  chartBottom: number,
+  palette: ResolvedChartPalette,
+  min: number,
+  max: number,
+  mode: Extract<ChartRenderMode, "ohlc" | "hlc">,
+) {
+  const tickLen = getOhlcTickLength(points.length, buf.width);
+  const stemWidth = getOhlcStemWidth(points.length, buf.width);
+  const stemLeft = Math.floor((stemWidth - 1) / 2);
+  const stemRight = Math.ceil((stemWidth - 1) / 2);
+
+  for (let i = 0; i < points.length; i++) {
+    const point = points[i]!;
+    const x = getDotX(i, points.length, buf.width, mode);
+    const highY = getScaledY(point.high, min, max, chartTop, chartBottom);
+    const lowY = getScaledY(point.low, min, max, chartTop, chartBottom);
+    const openY = getScaledY(point.open, min, max, chartTop, chartBottom);
+    const closeY = getScaledY(point.close, min, max, chartTop, chartBottom);
+    const isUp = point.close >= point.open;
+    const color = isUp ? palette.candleUp : palette.candleDown;
+
+    for (let dx = -stemLeft; dx <= stemRight; dx++) {
+      drawLine(buf, x + dx, highY, x + dx, lowY, color, LAYER_DATA);
+    }
+
+    if (mode === "ohlc") {
+      for (let dx = 0; dx < tickLen; dx++) {
+        setPixel(buf, x - dx, openY, color, LAYER_DATA);
+      }
+    }
+    for (let dx = 0; dx < tickLen; dx++) {
+      setPixel(buf, x + dx, closeY, color, LAYER_DATA);
+    }
+  }
+}
+
+export function drawVolumeBars(
+  buf: PixelBuffer,
+  points: ProjectedChartPoint[],
+  yTop: number,
+  yBottom: number,
+  upColor: string,
+  downColor: string,
+  trendMode: VolumeTrendMode,
+  mode: ChartRenderMode,
+) {
+  const volumes = points.map((point) => point.volume);
+  const maxVol = Math.max(...volumes, 1);
+  const volH = yBottom - yTop;
+  const halfW = getBarHalfWidth(points.length, buf.width);
+
+  for (let i = 0; i < points.length; i++) {
+    const point = points[i]!;
+    const x = getDotX(i, points.length, buf.width, mode);
+    const barH = Math.round((point.volume / maxVol) * volH);
+    if (barH === 0) continue;
+
+    const isUp = trendMode === "openClose"
+      ? point.close >= point.open
+      : i === 0 || point.close >= points[i - 1]!.close;
+    const color = isUp ? upColor : downColor;
+
+    fillRect(buf, x - halfW, yBottom - barH, x + halfW, yBottom, color, LAYER_FILL);
+  }
+}
+
+export function drawIndicatorOverlays(
+  buf: PixelBuffer,
+  indicators: ChartIndicatorOverlays,
+  pointCount: number,
+  dotTop: number,
+  dotBottom: number,
+  min: number,
+  max: number,
+  mode: ChartRenderMode,
+): void {
+  const drawOverlay = (overlayPoints: { index: number; value: number }[], color: string) => {
+    for (let i = 0; i < overlayPoints.length - 1; i++) {
+      const p0 = overlayPoints[i]!;
+      const p1 = overlayPoints[i + 1]!;
+      const x0 = getDotX(p0.index, pointCount, buf.width, mode);
+      const y0 = getScaledY(p0.value, min, max, dotTop, dotBottom);
+      const x1 = getDotX(p1.index, pointCount, buf.width, mode);
+      const y1 = getScaledY(p1.value, min, max, dotTop, dotBottom);
+      drawLine(buf, x0, y0, x1, y1, color, LAYER_OVERLAY);
+    }
+  };
+
+  for (const sma of indicators.smaLines) {
+    drawOverlay(sma.points, sma.color);
+  }
+  for (const ema of indicators.emaLines) {
+    drawOverlay(ema.points, ema.color);
+  }
+  if (indicators.bollinger) {
+    drawOverlay(indicators.bollinger.upper, indicators.bollinger.color);
+    drawOverlay(indicators.bollinger.middle, indicators.bollinger.color);
+    drawOverlay(indicators.bollinger.lower, indicators.bollinger.color);
+  }
+}

package/src/components/chart/rendering/geometry.ts

@@ -0,0 +1,95 @@
+import type { ChartRenderMode } from "../core/types";
+
+function getSeriesPosition(
+  index: number,
+  pointCount: number,
+  width: number,
+  startPadding = 0,
+  endPadding = startPadding,
+): number {
+  const start = Math.max(startPadding, 0);
+  const end = Math.max(start, width - 1 - Math.max(endPadding, 0));
+  if (pointCount <= 1) return Math.round((start + end) / 2);
+  return Math.round(start + (index / (pointCount - 1)) * (end - start));
+}
+
+export function getScaledY(value: number, min: number, max: number, chartTop: number, chartBottom: number): number {
+  const range = max - min || 1;
+  const chartH = chartBottom - chartTop;
+  return chartTop + Math.round((1 - (value - min) / range) * chartH);
+}
+
+export function getCandleHalfWidth(pointCount: number, bufWidth: number): number {
+  if (pointCount <= 1) return 2;
+  const spacing = bufWidth / pointCount;
+  const bodyW = Math.min(Math.max(Math.round(spacing * 0.55), 2), 10);
+  return Math.floor(bodyW / 2);
+}
+
+export function getBarHalfWidth(pointCount: number, bufWidth: number): number {
+  if (pointCount <= 1) return 2;
+  const spacing = bufWidth / pointCount;
+  const barW = Math.min(Math.max(Math.round(spacing * 0.45), 1), 10);
+  return Math.floor(barW / 2);
+}
+
+function isOhlcLikeMode(mode: ChartRenderMode): boolean {
+  return mode === "ohlc" || mode === "hlc";
+}
+
+export function isHighLowMode(mode: ChartRenderMode): boolean {
+  return mode === "candles" || isOhlcLikeMode(mode);
+}
+
+export function getOhlcTickLength(pointCount: number, bufWidth: number): number {
+  if (pointCount <= 1) return 4;
+  const spacing = bufWidth / pointCount;
+  return Math.min(Math.max(Math.round(spacing * 0.45), 3), 5);
+}
+
+export function getOhlcStemWidth(pointCount: number, bufWidth: number): number {
+  if (pointCount <= 1) return 3;
+  const spacing = bufWidth / pointCount;
+  return Math.min(Math.max(Math.round(spacing * 0.2), 2), 3);
+}
+
+function getOhlcHorizontalPad(pointCount: number, bufWidth: number): number {
+  const tickLen = getOhlcTickLength(pointCount, bufWidth);
+  const stemWidth = getOhlcStemWidth(pointCount, bufWidth);
+  return Math.max(tickLen - 1, Math.ceil((stemWidth - 1) / 2), 0);
+}
+
+export function getDotX(index: number, pointCount: number, width: number, mode: ChartRenderMode): number {
+  switch (mode) {
+    case "candles": {
+      const pad = getCandleHalfWidth(pointCount, width);
+      return getSeriesPosition(index, pointCount, width, pad, pad);
+    }
+    case "ohlc":
+    case "hlc": {
+      const pad = getOhlcHorizontalPad(pointCount, width);
+      return getSeriesPosition(index, pointCount, width, pad, pad);
+    }
+    default:
+      return getSeriesPosition(index, pointCount, width);
+  }
+}
+
+function getPointDotX(index: number, pointCount: number, width: number, mode: ChartRenderMode): number {
+  return getDotX(index, pointCount, Math.max(width * 2, 1), mode);
+}
+
+export function getPointTerminalColumn(index: number, pointCount: number, width: number, mode: ChartRenderMode): number {
+  if (width <= 1) return 0;
+  return Math.min(Math.max(Math.floor(getPointDotX(index, pointCount, width, mode) / 2), 0), width - 1);
+}
+
+export function getTimePointBand(index: number, pointCount: number, width: number): { left: number; right: number } {
+  const currentX = getSeriesPosition(index, pointCount, width);
+  const previousX = index > 0 ? getSeriesPosition(index - 1, pointCount, width) : currentX;
+  const nextX = index < pointCount - 1 ? getSeriesPosition(index + 1, pointCount, width) : currentX;
+  return {
+    left: index === 0 ? 0 : Math.floor((previousX + currentX) / 2) + 1,
+    right: index === pointCount - 1 ? Math.max(width - 1, 0) : Math.floor((currentX + nextX) / 2),
+  };
+}

package/src/components/chart/rendering/pixel-buffer.ts

@@ -0,0 +1,267 @@
+import { RGBA } from "../../../ui";
+import type { Pixel, PixelBuffer } from "../core/types";
+import { normalizeCount } from "../core/render-utils";
+
+interface StyledChunk {
+  __isChunk: true;
+  text: string;
+  fg?: RGBA;
+  bg?: RGBA;
+  attributes: number;
+}
+
+export interface StyledContent {
+  chunks: StyledChunk[];
+}
+
+const LAYER_GRID = 0;
+export const LAYER_FILL = 1;
+export const LAYER_DATA = 2;
+export const LAYER_OVERLAY = 1;
+const LAYER_CROSSHAIR = 3;
+
+const BRAILLE_BASE = 0x2800;
+const BRAILLE_DOT: number[][] = [
+  [0x01, 0x08],
+  [0x02, 0x10],
+  [0x04, 0x20],
+  [0x40, 0x80],
+];
+
+function makeChunk(text: string, fgColor?: string, bgColor?: string): StyledChunk {
+  const chunk: StyledChunk = {
+    __isChunk: true,
+    text,
+    attributes: 0,
+  };
+  if (fgColor) chunk.fg = RGBA.fromHex(fgColor);
+  if (bgColor) chunk.bg = RGBA.fromHex(bgColor);
+  return chunk;
+}
+
+export function createPixelBuffer(width: number, heightPixels: number): PixelBuffer {
+  const bufferWidth = normalizeCount(width, 0);
+  const bufferHeight = normalizeCount(heightPixels, 0);
+  const pixels: (Pixel | null)[][] = [];
+  const backgrounds: (string | null)[][] = [];
+  for (let y = 0; y < bufferHeight; y++) {
+    pixels.push(new Array(bufferWidth).fill(null));
+    backgrounds.push(new Array(bufferWidth).fill(null));
+  }
+  return { width: bufferWidth, height: bufferHeight, pixels, backgrounds };
+}
+
+export function setPixel(buf: PixelBuffer, x: number, y: number, color: string, layer: number) {
+  const px = Math.round(x);
+  const py = Math.round(y);
+  if (px >= 0 && px < buf.width && py >= 0 && py < buf.height) {
+    const row = buf.pixels[py];
+    if (!row) return;
+    const existing = row[px];
+    if (!existing || layer >= existing.layer) {
+      row[px] = { color, layer };
+    }
+  }
+}
+
+export function drawLine(
+  buf: PixelBuffer,
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  color: string,
+  layer: number = LAYER_DATA,
+) {
+  const startX = Math.round(x0);
+  const startY = Math.round(y0);
+  const endX = Math.round(x1);
+  const endY = Math.round(y1);
+  if (![startX, startY, endX, endY].every(Number.isFinite)) return;
+  let dx = Math.abs(endX - startX);
+  let dy = Math.abs(endY - startY);
+  const sx = startX < endX ? 1 : -1;
+  const sy = startY < endY ? 1 : -1;
+  let err = dx - dy;
+  let x = startX;
+  let y = startY;
+
+  while (true) {
+    setPixel(buf, x, y, color, layer);
+    if (x === endX && y === endY) break;
+    const e2 = 2 * err;
+    if (e2 > -dy) {
+      err -= dy;
+      x += sx;
+    }
+    if (e2 < dx) {
+      err += dx;
+      y += sy;
+    }
+  }
+}
+
+export function fillColumn(buf: PixelBuffer, x: number, y0: number, y1: number, color: string, layer: number) {
+  const start = Math.min(y0, y1);
+  const end = Math.max(y0, y1);
+  for (let y = start; y <= end; y++) {
+    setPixel(buf, x, y, color, layer);
+  }
+}
+
+export function fillRect(buf: PixelBuffer, x0: number, y0: number, x1: number, y1: number, color: string, layer: number) {
+  for (let x = Math.min(x0, x1); x <= Math.max(x0, x1); x++) {
+    fillColumn(buf, x, y0, y1, color, layer);
+  }
+}
+
+function setBackgroundPixel(buf: PixelBuffer, x: number, y: number, color: string) {
+  const px = Math.round(x);
+  const py = Math.round(y);
+  if (px < 0 || px >= buf.width || py < 0 || py >= buf.height) return;
+  const row = buf.backgrounds[py];
+  if (!row) return;
+  row[px] = color;
+}
+
+export function fillBackgroundRect(buf: PixelBuffer, x0: number, y0: number, x1: number, y1: number, color: string) {
+  const left = Math.max(Math.min(Math.round(x0), Math.round(x1)), 0);
+  const right = Math.min(Math.max(Math.round(x0), Math.round(x1)), Math.max(buf.width - 1, 0));
+  const top = Math.max(Math.min(Math.round(y0), Math.round(y1)), 0);
+  const bottom = Math.min(Math.max(Math.round(y0), Math.round(y1)), Math.max(buf.height - 1, 0));
+  for (let y = top; y <= bottom; y += 1) {
+    for (let x = left; x <= right; x += 1) {
+      setBackgroundPixel(buf, x, y, color);
+    }
+  }
+}
+
+export function drawCrosshair(
+  buf: PixelBuffer,
+  x: number,
+  yTop: number,
+  yBottom: number,
+  color: string,
+) {
+  if (x < 0 || x >= buf.width) return;
+  for (let y = yTop; y <= yBottom; y++) {
+    if (y % 4 < 2) {
+      setPixel(buf, x, y, color, LAYER_CROSSHAIR);
+    }
+  }
+}
+
+export function drawGridLines(
+  buf: PixelBuffer,
+  yPositions: number[],
+  color: string,
+) {
+  for (const rawY of yPositions) {
+    const y = Math.round(rawY);
+    if (y < 0 || y >= buf.height) continue;
+    const row = buf.pixels[y];
+    if (!row) continue;
+    for (let x = 0; x < buf.width; x++) {
+      if (x % 6 === 0 && !row[x]) {
+        setPixel(buf, x, y, color, LAYER_GRID);
+      }
+    }
+  }
+}
+
+export function bufferToBrailleLines(buf: PixelBuffer): StyledContent[] {
+  const lines: StyledContent[] = [];
+  const termCols = Math.ceil(buf.width / 2);
+  const termRows = Math.ceil(buf.height / 4);
+
+  for (let row = 0; row < termRows; row++) {
+    const chunks: StyledChunk[] = [];
+    let runChar = "";
+    let runFg: string | undefined;
+    let runBg: string | undefined;
+    let runLen = 0;
+
+    const flushRun = () => {
+      if (runLen > 0) {
+        chunks.push(makeChunk(runChar.repeat(runLen), runFg, runBg));
+        runLen = 0;
+      }
+    };
+
+    for (let col = 0; col < termCols; col++) {
+      let topLayer = -1;
+      const dotsByLayer: Map<number, number> = new Map();
+      const colorByLayer: Map<number, Map<string, number>> = new Map();
+      const backgroundCounts: Map<string, number> = new Map();
+
+      for (let dy = 0; dy < 4; dy++) {
+        for (let dx = 0; dx < 2; dx++) {
+          const px = col * 2 + dx;
+          const py = row * 4 + dy;
+          if (px >= buf.width || py >= buf.height) continue;
+          const bg = buf.backgrounds[py]?.[px] ?? null;
+          if (bg) {
+            backgroundCounts.set(bg, (backgroundCounts.get(bg) || 0) + 1);
+          }
+          const pixel = buf.pixels[py]?.[px] ?? null;
+          if (pixel) {
+            const bit = BRAILLE_DOT[dy]![dx]!;
+            dotsByLayer.set(pixel.layer, (dotsByLayer.get(pixel.layer) || 0) | bit);
+            if (!colorByLayer.has(pixel.layer)) colorByLayer.set(pixel.layer, new Map());
+            const counts = colorByLayer.get(pixel.layer)!;
+            counts.set(pixel.color, (counts.get(pixel.color) || 0) + 1);
+            if (pixel.layer > topLayer) {
+              topLayer = pixel.layer;
+            }
+          }
+        }
+      }
+
+      let char: string;
+      let cellFg: string | undefined;
+      let cellBg: string | undefined;
+      let bestBackgroundCount = 0;
+      for (const [bg, count] of backgroundCounts) {
+        if (count > bestBackgroundCount) {
+          bestBackgroundCount = count;
+          cellBg = bg;
+        }
+      }
+
+      if (topLayer < 0) {
+        char = " ";
+        cellFg = undefined;
+      } else {
+        const pattern = dotsByLayer.get(topLayer) || 0;
+        char = String.fromCharCode(BRAILLE_BASE + pattern);
+
+        const topCounts: Map<string, number> = colorByLayer.get(topLayer) ?? new Map();
+        let topColor = "";
+        let bestCount = 0;
+        for (const [c, n] of topCounts) {
+          if (n > bestCount) {
+            bestCount = n;
+            topColor = c;
+          }
+        }
+
+        cellFg = topColor;
+      }
+
+      if (char === runChar && cellFg === runFg && cellBg === runBg) {
+        runLen++;
+      } else {
+        flushRun();
+        runChar = char;
+        runFg = cellFg;
+        runBg = cellBg;
+        runLen = 1;
+      }
+    }
+
+    flushRun();
+    lines.push({ chunks });
+  }
+
+  return lines;
+}

package/src/components/chart/scatter-chart-renderer.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { buildScatterChartScene, renderNativeScatterChart, renderScatterChart } from "./scatter-chart-renderer";
+
+describe("scatter chart renderer", () => {
+  test("renders text fallback and native bitmap with regression", () => {
+    const scene = buildScatterChartScene([
+      { x: -1, y: -2 },
+      { x: 0, y: 0, highlight: true },
+      { x: 1, y: 2 },
+    ], {
+      width: 20,
+      height: 8,
+      colors: {
+        bgColor: "#000000",
+        gridColor: "#333333",
+        axisColor: "#666666",
+        pointColor: "#b197fc",
+        highlightColor: "#ff0000",
+      },
+      regression: { slope: 2, intercept: 0, color: "#ffff00" },
+    });
+
+    expect(scene).not.toBeNull();
+    expect(renderScatterChart(scene!).join("\n")).toContain("●");
+
+    const bitmap = renderNativeScatterChart(scene!, 80, 48);
+    expect(bitmap.width).toBe(80);
+    expect(bitmap.height).toBe(48);
+    expect(bitmap.pixels.some((value) => value > 0)).toBe(true);
+  });
+});