gloomberb 0.11.2 → 0.12.0

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

@@ -1,95 +0,0 @@
-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

@@ -1,267 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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);
-  });
-});

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

@@ -1,223 +0,0 @@
-import type { NativeChartBitmap } from "./native/chart-rasterizer";
-import { fillRect, parseHex } from "./native/raster/primitives";
-
-export interface ScatterChartPoint {
-  x: number;
-  y: number;
-  highlight?: boolean;
-}
-
-export interface ScatterRegressionLine {
-  slope: number;
-  intercept: number;
-  color: string;
-}
-
-export interface ScatterChartColors {
-  bgColor: string;
-  gridColor: string;
-  axisColor: string;
-  pointColor: string;
-  highlightColor: string;
-}
-
-export interface ScatterChartSceneOptions {
-  width: number;
-  height: number;
-  colors: ScatterChartColors;
-  regression?: ScatterRegressionLine | null;
-}
-
-export interface ScatterChartScene {
-  width: number;
-  height: number;
-  points: ScatterChartPoint[];
-  xMin: number;
-  xMax: number;
-  yMin: number;
-  yMax: number;
-  zeroX: number | null;
-  zeroY: number | null;
-  colors: ScatterChartColors;
-  regression: ScatterRegressionLine | null;
-}
-
-const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
-
-function drawLine(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  x0: number,
-  y0: number,
-  x1: number,
-  y1: number,
-  color: ReturnType<typeof parseHex>,
-  opacity = 1,
-) {
-  const dx = Math.abs(x1 - x0);
-  const dy = Math.abs(y1 - y0);
-  const steps = Math.max(dx, dy, 1);
-  for (let i = 0; i <= steps; i++) {
-    const t = i / steps;
-    const x = Math.round(x0 + (x1 - x0) * t);
-    const y = Math.round(y0 + (y1 - y0) * t);
-    fillRect(data, width, height, x - 0.6, y - 0.6, x + 0.6, y + 0.6, color, opacity);
-  }
-}
-
-function paddedRange(values: number[]): { min: number; max: number } {
-  if (values.length === 0) return { min: -1, max: 1 };
-  const rawMin = Math.min(...values);
-  const rawMax = Math.max(...values);
-  if (rawMin === rawMax) {
-    const delta = Math.max(Math.abs(rawMin) * 0.1, 1);
-    return { min: rawMin - delta, max: rawMax + delta };
-  }
-  const padding = (rawMax - rawMin) * 0.12;
-  return { min: rawMin - padding, max: rawMax + padding };
-}
-
-function valueToColumn(value: number, min: number, max: number, width: number): number {
-  return clamp(Math.round(((value - min) / (max - min || 1)) * (width - 1)), 0, width - 1);
-}
-
-function valueToRow(value: number, min: number, max: number, height: number): number {
-  return clamp(Math.round((1 - ((value - min) / (max - min || 1))) * (height - 1)), 0, height - 1);
-}
-
-export function buildScatterChartScene(
-  points: ScatterChartPoint[],
-  options: ScatterChartSceneOptions,
-): ScatterChartScene | null {
-  const normalized = points.filter((point) => (
-    Number.isFinite(point.x) && Number.isFinite(point.y)
-  ));
-  if (normalized.length === 0) return null;
-
-  const width = Math.max(1, Math.floor(options.width));
-  const height = Math.max(1, Math.floor(options.height));
-  const xRange = paddedRange(normalized.map((point) => point.x));
-  const yRange = paddedRange(normalized.map((point) => point.y));
-  const zeroX = xRange.min <= 0 && xRange.max >= 0
-    ? valueToColumn(0, xRange.min, xRange.max, width)
-    : null;
-  const zeroY = yRange.min <= 0 && yRange.max >= 0
-    ? valueToRow(0, yRange.min, yRange.max, height)
-    : null;
-
-  return {
-    width,
-    height,
-    points: normalized,
-    xMin: xRange.min,
-    xMax: xRange.max,
-    yMin: yRange.min,
-    yMax: yRange.max,
-    zeroX,
-    zeroY,
-    colors: options.colors,
-    regression: options.regression ?? null,
-  };
-}
-
-export function renderScatterChart(scene: ScatterChartScene): string[] {
-  const rows = Array.from({ length: scene.height }, () => Array(scene.width).fill(" "));
-  if (scene.zeroY !== null) {
-    for (let x = 0; x < scene.width; x++) rows[scene.zeroY]![x] = "─";
-  }
-  if (scene.zeroX !== null) {
-    for (let y = 0; y < scene.height; y++) rows[y]![scene.zeroX] = "│";
-  }
-
-  if (scene.regression) {
-    for (let x = 0; x < scene.width; x++) {
-      const valueX = scene.xMin + (x / Math.max(scene.width - 1, 1)) * (scene.xMax - scene.xMin);
-      const valueY = scene.regression.slope * valueX + scene.regression.intercept;
-      if (!Number.isFinite(valueY)) continue;
-      const y = valueToRow(valueY, scene.yMin, scene.yMax, scene.height);
-      if (rows[y]![x] === " ") rows[y]![x] = "·";
-    }
-  }
-
-  for (const point of scene.points) {
-    const x = valueToColumn(point.x, scene.xMin, scene.xMax, scene.width);
-    const y = valueToRow(point.y, scene.yMin, scene.yMax, scene.height);
-    rows[y]![x] = point.highlight ? "●" : "•";
-  }
-
-  return rows.map((row) => row.join(""));
-}
-
-export function renderNativeScatterChart(
-  scene: ScatterChartScene,
-  pixelWidth: number,
-  pixelHeight: number,
-): NativeChartBitmap {
-  const width = Math.max(1, Math.floor(pixelWidth));
-  const height = Math.max(1, Math.floor(pixelHeight));
-  const data = new Uint8Array(width * height * 4);
-  const bg = parseHex(scene.colors.bgColor, 1);
-  const grid = parseHex(scene.colors.gridColor, 0.35);
-  const axis = parseHex(scene.colors.axisColor, 0.72);
-  const pointColor = parseHex(scene.colors.pointColor, 0.9);
-  const highlightColor = parseHex(scene.colors.highlightColor, 1);
-
-  fillRect(data, width, height, 0, 0, width - 1, height - 1, bg, 1);
-
-  for (let i = 1; i <= 3; i++) {
-    const x = (width - 1) * (i / 4);
-    const y = (height - 1) * (i / 4);
-    fillRect(data, width, height, x, 0, x + 0.7, height - 1, grid, 0.45);
-    fillRect(data, width, height, 0, y, width - 1, y + 0.7, grid, 0.45);
-  }
-
-  if (scene.zeroX !== null) {
-    const x = (scene.zeroX / Math.max(scene.width - 1, 1)) * (width - 1);
-    fillRect(data, width, height, x, 0, x + 1.1, height - 1, axis, 0.8);
-  }
-  if (scene.zeroY !== null) {
-    const y = (scene.zeroY / Math.max(scene.height - 1, 1)) * (height - 1);
-    fillRect(data, width, height, 0, y, width - 1, y + 1.1, axis, 0.8);
-  }
-
-  if (scene.regression) {
-    const x0 = scene.xMin;
-    const x1 = scene.xMax;
-    const y0 = scene.regression.slope * x0 + scene.regression.intercept;
-    const y1 = scene.regression.slope * x1 + scene.regression.intercept;
-    if (Number.isFinite(y0) && Number.isFinite(y1)) {
-      const lineColor = parseHex(scene.regression.color, 0.95);
-      drawLine(
-        data,
-        width,
-        height,
-        valueToColumn(x0, scene.xMin, scene.xMax, width),
-        valueToRow(y0, scene.yMin, scene.yMax, height),
-        valueToColumn(x1, scene.xMin, scene.xMax, width),
-        valueToRow(y1, scene.yMin, scene.yMax, height),
-        lineColor,
-        0.9,
-      );
-    }
-  }
-
-  for (const point of scene.points) {
-    const x = valueToColumn(point.x, scene.xMin, scene.xMax, width);
-    const y = valueToRow(point.y, scene.yMin, scene.yMax, height);
-    const radius = point.highlight ? 3 : 2;
-    fillRect(
-      data,
-      width,
-      height,
-      x - radius,
-      y - radius,
-      x + radius,
-      y + radius,
-      point.highlight ? highlightColor : pointColor,
-      point.highlight ? 1 : 0.82,
-    );
-  }
-
-  return { width, height, pixels: data };
-}