gloomberb 0.11.3 → 0.12.0

package/src/components/chart/native/raster/layout.ts

@@ -1,129 +0,0 @@
-import { computeGridLines, type ChartScene } from "../../core/renderer";
-import type { ChartColors, ChartRenderMode, ChartSessionBackgroundSpan } from "../../core/types";
-import {
-  clamp,
-  drawLine,
-  fillRect,
-  lerp,
-  parseHex,
-} from "./primitives";
-import type { PixelRect } from "./types";
-
-export function getChartPixelLayout(scene: ChartScene, pixelWidth: number, pixelHeight: number) {
-  const volumeHeight = scene.showVolume ? Math.max(Math.round((scene.volumeHeight / Math.max(scene.height, 1)) * pixelHeight), 1) : 0;
-  const plotHeight = Math.max(pixelHeight - volumeHeight, 1);
-  return {
-    plotLeft: 0,
-    plotTop: 0,
-    plotRight: Math.max(pixelWidth - 1, 0),
-    plotBottom: Math.max(plotHeight - 1, 0),
-    volumeTop: plotHeight,
-    volumeBottom: Math.max(pixelHeight - 1, plotHeight),
-  };
-}
-
-export function projectX(index: number, count: number, left: number, right: number): number {
-  if (count <= 1) return (left + right) / 2;
-  return lerp(left, right, index / (count - 1));
-}
-
-export function isOhlcLikeMode(mode: ChartRenderMode): boolean {
-  return mode === "ohlc" || mode === "hlc";
-}
-
-export function isHighLowMode(
-  mode: ChartRenderMode,
-): mode is Extract<ChartRenderMode, "candles" | "ohlc" | "hlc"> {
-  return mode === "candles" || isOhlcLikeMode(mode);
-}
-
-export function getNativeBarMetrics(count: number, width: number, mode: Extract<ChartRenderMode, "candles" | "ohlc" | "hlc">) {
-  const spacing = width / Math.max(count, 1);
-  if (mode === "candles") {
-    return {
-      bodyWidth: clamp(spacing * 0.58, 2, Math.max(spacing - 1, 2)),
-      tickLength: 0,
-      stemThickness: 1.2,
-    };
-  }
-
-  return {
-    bodyWidth: 0,
-    tickLength: clamp(spacing * 0.5, 3, Math.max(spacing * 0.62, 3)),
-    stemThickness: clamp(spacing * 0.12, 2, 3.2),
-  };
-}
-
-export function projectChartX(index: number, count: number, width: number, mode: ChartRenderMode): number {
-  if (!isHighLowMode(mode)) {
-    return projectX(index, count, 0, Math.max(width - 1, 0));
-  }
-
-  const { bodyWidth, tickLength, stemThickness } = getNativeBarMetrics(count, width, mode);
-  const horizontalPad = isOhlcLikeMode(mode)
-    ? Math.ceil(Math.max(tickLength - 1, stemThickness / 2, 0))
-    : Math.ceil(bodyWidth / 2);
-  return projectX(index, count, horizontalPad, Math.max(width - 1 - horizontalPad, horizontalPad));
-}
-
-function getProjectedPointBand(
-  index: number,
-  count: number,
-  width: number,
-  projectIndex: (targetIndex: number) => number,
-): PixelRect {
-  const currentX = projectIndex(index);
-  const previousX = index > 0 ? projectIndex(index - 1) : currentX;
-  const nextX = index < count - 1 ? projectIndex(index + 1) : currentX;
-  const left = index === 0 ? 0 : Math.floor((previousX + currentX) / 2) + 1;
-  const right = index === count - 1 ? Math.max(width - 1, 0) : Math.floor((currentX + nextX) / 2);
-  return {
-    x: clamp(left, 0, Math.max(width - 1, 0)),
-    y: 0,
-    width: Math.max(clamp(right, 0, Math.max(width - 1, 0)) - clamp(left, 0, Math.max(width - 1, 0)) + 1, 1),
-    height: 1,
-  };
-}
-
-export function drawSessionBackgroundSpans(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  spans: readonly ChartSessionBackgroundSpan[],
-  pointCount: number,
-  top: number,
-  bottom: number,
-  colors: Pick<ChartColors, "preMarketBgColor" | "postMarketBgColor">,
-  projectIndex: (targetIndex: number) => number,
-) {
-  if (spans.length === 0 || pointCount === 0) return;
-  for (const span of spans) {
-    const startIndex = clamp(span.startIndex, 0, pointCount - 1);
-    const endIndex = clamp(span.endIndex, startIndex, pointCount - 1);
-    const startBand = getProjectedPointBand(startIndex, pointCount, width, projectIndex);
-    const endBand = getProjectedPointBand(endIndex, pointCount, width, projectIndex);
-    const color = parseHex(span.kind === "pre" ? colors.preMarketBgColor : colors.postMarketBgColor, 1);
-    fillRect(data, width, height, startBand.x, top, endBand.x + endBand.width - 1, bottom, color, 1);
-  }
-}
-
-export function projectY(value: number, min: number, max: number, top: number, bottom: number): number {
-  const range = max - min || 1;
-  return lerp(bottom, top, (value - min) / range);
-}
-
-export function drawPriceGrid(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  scene: ChartScene,
-  top: number,
-  bottom: number,
-) {
-  const gridLines = computeGridLines(scene.min, scene.max, top, bottom, 3);
-  const color = parseHex(scene.colors.gridColor, 0.28);
-
-  for (const line of gridLines) {
-    drawLine(data, width, height, 0, line.y, width - 1, line.y, color, 1);
-  }
-}

package/src/components/chart/native/raster/price-chart.ts

@@ -1,244 +0,0 @@
-import { measurePerf } from "../../../../utils/perf-marks";
-import type { ChartScene } from "../../core/renderer";
-import type { ChartRenderMode } from "../../core/types";
-import {
-  clamp,
-  drawAreaFill,
-  drawLine,
-  fillRect,
-  lerp,
-  parseHex,
-  type RgbaColor,
-} from "./primitives";
-import type { NativeChartBitmap } from "./types";
-import {
-  drawPriceGrid,
-  drawSessionBackgroundSpans,
-  getChartPixelLayout,
-  getNativeBarMetrics,
-  isHighLowMode,
-  isOhlcLikeMode,
-  projectChartX,
-  projectX,
-  projectY,
-} from "./layout";
-
-function drawWickOutsideBody(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  x: number,
-  highY: number,
-  lowY: number,
-  bodyTop: number,
-  bodyBottom: number,
-  color: RgbaColor,
-) {
-  if (highY < bodyTop) {
-    drawLine(data, width, height, x, highY, x, bodyTop, color, 1.2);
-  }
-  if (bodyBottom < lowY) {
-    drawLine(data, width, height, x, bodyBottom, x, lowY, color, 1.2);
-  }
-}
-
-function drawLineSeries(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  scene: ChartScene,
-  top: number,
-  bottom: number,
-) {
-  const glow = parseHex(scene.colors.lineColor, 0.2);
-  const line = parseHex(scene.colors.lineColor, 0.95);
-  const fill = parseHex(scene.colors.fillColor, 0.7);
-  const yByColumn = new Float32Array(width).fill(Number.POSITIVE_INFINITY);
-
-  for (let index = 0; index < scene.points.length - 1; index++) {
-    const current = scene.points[index]!;
-    const next = scene.points[index + 1]!;
-    const x0 = projectX(index, scene.points.length, 0, width - 1);
-    const x1 = projectX(index + 1, scene.points.length, 0, width - 1);
-    const y0 = projectY(current.close, scene.min, scene.max, top, bottom);
-    const y1 = projectY(next.close, scene.min, scene.max, top, bottom);
-
-    const start = Math.max(Math.floor(Math.min(x0, x1)), 0);
-    const end = Math.min(Math.ceil(Math.max(x0, x1)), width - 1);
-    for (let x = start; x <= end; x++) {
-      const t = x1 === x0 ? 0 : (x - x0) / (x1 - x0);
-      const y = lerp(y0, y1, clamp(t, 0, 1));
-      yByColumn[x] = Math.min(yByColumn[x]!, y);
-    }
-
-    if (scene.mode === "area") {
-      drawLine(data, width, height, x0, y0, x1, y1, glow, 4);
-      drawLine(data, width, height, x0, y0, x1, y1, line, 1.75);
-    } else {
-      drawLine(data, width, height, x0, y0, x1, y1, glow, 3.2);
-      drawLine(data, width, height, x0, y0, x1, y1, line, 1.4);
-    }
-  }
-
-  if (scene.mode === "area") {
-    drawAreaFill(data, width, height, yByColumn, bottom, fill);
-  }
-}
-
-function drawCandles(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  scene: ChartScene,
-  top: number,
-  bottom: number,
-  mode: Extract<ChartRenderMode, "candles" | "ohlc" | "hlc">,
-) {
-  const { bodyWidth, tickLength, stemThickness } = getNativeBarMetrics(scene.points.length, width, mode);
-  const horizontalPad = isOhlcLikeMode(mode)
-    ? Math.ceil(Math.max(tickLength - 1, stemThickness / 2, 0))
-    : Math.ceil(bodyWidth / 2);
-  const plotLeft = horizontalPad;
-  const plotRight = Math.max(width - 1 - horizontalPad, plotLeft);
-
-  for (let index = 0; index < scene.points.length; index++) {
-    const point = scene.points[index]!;
-    const x = projectX(index, scene.points.length, plotLeft, plotRight);
-    const highY = projectY(point.high, scene.min, scene.max, top, bottom);
-    const lowY = projectY(point.low, scene.min, scene.max, top, bottom);
-    const openY = projectY(point.open, scene.min, scene.max, top, bottom);
-    const closeY = projectY(point.close, scene.min, scene.max, top, bottom);
-    const isUp = point.close >= point.open;
-
-    const wickColor = parseHex(isUp ? scene.colors.wickUp : scene.colors.wickDown, 0.92);
-    const bodyColor = parseHex(isUp ? scene.colors.candleUp : scene.colors.candleDown, 1);
-
-    if (isOhlcLikeMode(mode)) {
-      drawLine(data, width, height, x, highY, x, lowY, wickColor, stemThickness);
-      if (mode === "ohlc") {
-        drawLine(data, width, height, x - tickLength, openY, x, openY, bodyColor, Math.max(stemThickness, 1.4));
-      }
-      drawLine(data, width, height, x, closeY, x + tickLength, closeY, bodyColor, Math.max(stemThickness, 1.4));
-      continue;
-    }
-
-    const bodyTop = Math.min(openY, closeY);
-    const bodyBottom = Math.max(openY, closeY);
-    if (Math.abs(bodyBottom - bodyTop) < 1.25) {
-      drawLine(data, width, height, x, highY, x, lowY, wickColor, 1.2);
-      drawLine(data, width, height, x - bodyWidth / 2, bodyTop, x + bodyWidth / 2, bodyTop, bodyColor, 1.5);
-    } else {
-      drawWickOutsideBody(data, width, height, x, highY, lowY, bodyTop, bodyBottom, wickColor);
-      fillRect(data, width, height, x - bodyWidth / 2, bodyTop, x + bodyWidth / 2, bodyBottom, bodyColor, 1);
-    }
-  }
-}
-
-function drawVolume(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  scene: ChartScene,
-  top: number,
-  bottom: number,
-) {
-  if (!scene.showVolume || bottom < top) return;
-
-  const volumes = scene.points.map((point) => point.volume);
-  const maxVolume = Math.max(...volumes, 1);
-  const spacing = width / Math.max(scene.points.length, 1);
-  const barWidth = clamp(spacing * 0.72, 1, Math.max(spacing, 1));
-
-  for (let index = 0; index < scene.points.length; index++) {
-    const point = scene.points[index]!;
-    const heightRatio = point.volume / maxVolume;
-    if (heightRatio <= 0) continue;
-    const x = projectX(index, scene.points.length, 0, width - 1);
-    const barTop = lerp(bottom, top, heightRatio);
-    const isUp = isHighLowMode(scene.mode)
-      ? point.close >= point.open
-      : index === 0 || point.close >= scene.points[index - 1]!.close;
-    const color = parseHex(isUp ? scene.colors.volumeUp : scene.colors.volumeDown, 0.6);
-    fillRect(data, width, height, x - barWidth / 2, barTop, x + barWidth / 2, bottom, color, 0.8);
-  }
-}
-
-function drawIndicatorOverlays(
-  data: Uint8Array,
-  width: number,
-  height: number,
-  scene: ChartScene,
-  top: number,
-  bottom: number,
-) {
-  if (!scene.indicators) return;
-
-  const drawOverlay = (points: { index: number; value: number }[], color: string) => {
-    const lineColor = parseHex(color, 0.95);
-    for (let index = 0; index < points.length - 1; index += 1) {
-      const p0 = points[index]!;
-      const p1 = points[index + 1]!;
-      const x0 = projectChartX(p0.index, scene.points.length, width, scene.mode);
-      const y0 = projectY(p0.value, scene.min, scene.max, top, bottom);
-      const x1 = projectChartX(p1.index, scene.points.length, width, scene.mode);
-      const y1 = projectY(p1.value, scene.min, scene.max, top, bottom);
-      drawLine(data, width, height, x0, y0, x1, y1, lineColor, 1.2);
-    }
-  };
-
-  for (const sma of scene.indicators.smaLines) {
-    drawOverlay(sma.points, sma.color);
-  }
-  for (const ema of scene.indicators.emaLines) {
-    drawOverlay(ema.points, ema.color);
-  }
-  if (scene.indicators.bollinger) {
-    drawOverlay(scene.indicators.bollinger.upper, scene.indicators.bollinger.color);
-    drawOverlay(scene.indicators.bollinger.middle, scene.indicators.bollinger.color);
-    drawOverlay(scene.indicators.bollinger.lower, scene.indicators.bollinger.color);
-  }
-}
-
-export function renderNativeChartBase(scene: ChartScene, pixelWidth: number, pixelHeight: number): NativeChartBitmap {
-  return measurePerf("chart.native.base", () => {
-    const pixels = new Uint8Array(pixelWidth * pixelHeight * 4);
-    if (scene.points.length === 0 || pixelWidth <= 0 || pixelHeight <= 0) {
-      return { width: Math.max(pixelWidth, 1), height: Math.max(pixelHeight, 1), pixels };
-    }
-
-    const layout = getChartPixelLayout(scene, pixelWidth, pixelHeight);
-    drawSessionBackgroundSpans(
-      pixels,
-      pixelWidth,
-      pixelHeight,
-      scene.sessionBackgroundSpans,
-      scene.points.length,
-      layout.plotTop,
-      scene.showVolume ? layout.volumeBottom : layout.plotBottom,
-      scene.colors,
-      (index) => projectX(index, scene.points.length, 0, Math.max(pixelWidth - 1, 0)),
-    );
-    drawPriceGrid(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom);
-    drawIndicatorOverlays(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom);
-
-    switch (scene.mode) {
-      case "area":
-      case "line":
-        drawLineSeries(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom);
-        break;
-      case "candles":
-        drawCandles(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom, "candles");
-        break;
-      case "ohlc":
-        drawCandles(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom, "ohlc");
-        break;
-      case "hlc":
-        drawCandles(pixels, pixelWidth, pixelHeight, scene, layout.plotTop, layout.plotBottom, "hlc");
-        break;
-    }
-
-    drawVolume(pixels, pixelWidth, pixelHeight, scene, layout.volumeTop, layout.volumeBottom);
-
-    return { width: pixelWidth, height: pixelHeight, pixels };
-  }, { pixelWidth, pixelHeight, points: scene.points.length, mode: scene.mode });
-}

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

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