gloomberb 0.11.3 → 0.12.0

package/src/components/chart/core/projection.ts

@@ -1,357 +0,0 @@
-import type { PricePoint } from "../../../types/financials";
-import type { ChartRenderMode } from "./types";
-
-export interface ProjectedChartPoint {
-  date: Date;
-  open: number;
-  high: number;
-  low: number;
-  close: number;
-  volume: number;
-}
-
-export interface ChartProjection {
-  points: ProjectedChartPoint[];
-  requestedMode: ChartRenderMode;
-  effectiveMode: ChartRenderMode;
-  fallbackMode: ChartRenderMode | null;
-}
-
-export interface ProjectChartDataOptions {
-  ohlcBucketWidth?: number;
-  ohlcSourceBucketSize?: number;
-  ohlcTargetBucketCount?: number;
-  sourceIndexOffset?: number;
-}
-
-export interface IndexProjectionBucket {
-  index: number;
-  start: number;
-  end: number;
-}
-
-interface StableOhlcProjectionOptionsInput {
-  pointCount: number;
-  sourceIndexOffset: number;
-  bucketWidth: number;
-  navigationPointCount?: number;
-  countRatioTolerance?: number;
-}
-
-const DEFAULT_OHLC_COUNT_RATIO_TOLERANCE = 1.2;
-
-function coerceDate(value: Date | string | number): Date {
-  return value instanceof Date ? value : new Date(value);
-}
-
-function getRequestedRenderMode(mode?: ChartRenderMode, compact = false): ChartRenderMode {
-  if (compact) return "area";
-  return mode ?? "area";
-}
-
-function isOhlcProjectionMode(mode: ChartRenderMode): boolean {
-  return mode === "candles" || mode === "ohlc" || mode === "hlc";
-}
-
-export function resolveRenderMode(
-  mode: ChartRenderMode | undefined,
-  chartWidth: number,
-  compact = false,
-): { requestedMode: ChartRenderMode; effectiveMode: ChartRenderMode; fallbackMode: ChartRenderMode | null } {
-  const requestedMode = getRequestedRenderMode(mode, compact);
-  if (compact) {
-    return {
-      requestedMode,
-      effectiveMode: "area",
-      fallbackMode: null,
-    };
-  }
-
-  let effectiveMode = requestedMode;
-  switch (requestedMode) {
-    case "candles":
-      if (chartWidth < 28) effectiveMode = "line";
-      else if (chartWidth < 40) effectiveMode = "ohlc";
-      break;
-    case "ohlc":
-    case "hlc":
-      if (chartWidth < 28) effectiveMode = "line";
-      break;
-  }
-
-  return {
-    requestedMode,
-    effectiveMode,
-    fallbackMode: effectiveMode === requestedMode ? null : effectiveMode,
-  };
-}
-
-function normalizePoint(point: PricePoint): ProjectedChartPoint {
-  const open = point.open ?? point.close;
-  const high = point.high ?? point.close;
-  const low = point.low ?? point.close;
-
-  return {
-    date: coerceDate(point.date as Date | string | number),
-    open,
-    high,
-    low,
-    close: point.close,
-    volume: point.volume ?? 0,
-  };
-}
-
-function getMinimumPositiveDateGapMs(points: readonly ProjectedChartPoint[]): number | null {
-  let minimum = Number.POSITIVE_INFINITY;
-  for (let index = 1; index < points.length; index += 1) {
-    const previous = points[index - 1]!.date.getTime();
-    const current = points[index]!.date.getTime();
-    const gap = current - previous;
-    if (Number.isFinite(gap) && gap > 0 && gap < minimum) {
-      minimum = gap;
-    }
-  }
-  return Number.isFinite(minimum) ? minimum : null;
-}
-
-function aggregateOhlcBucket(bucket: readonly ProjectedChartPoint[]): ProjectedChartPoint {
-  const first = bucket[0]!;
-  const last = bucket[bucket.length - 1]!;
-  let high = first.high;
-  let low = first.low;
-  let volume = 0;
-
-  for (const point of bucket) {
-    high = Math.max(high, point.high);
-    low = Math.min(low, point.low);
-    volume += point.volume;
-  }
-
-  return {
-    date: last.date,
-    open: first.open,
-    high,
-    low,
-    close: last.close,
-    volume,
-  };
-}
-
-export function buildIndexProjectionBuckets(
-  itemCount: number,
-  targetWidth: number,
-): IndexProjectionBucket[] {
-  const normalizedItemCount = Math.max(Math.floor(itemCount), 0);
-  if (normalizedItemCount === 0) return [];
-
-  const bucketCount = Math.min(normalizedItemCount, Math.max(Math.floor(targetWidth), 1));
-  const bucketSize = normalizedItemCount / bucketCount;
-
-  return Array.from({ length: bucketCount }, (_, index) => {
-    const start = Math.floor(index * bucketSize);
-    const end = Math.min(
-      normalizedItemCount,
-      Math.max(Math.floor((index + 1) * bucketSize), start + 1),
-    );
-    return { index, start, end };
-  });
-}
-
-export function selectRepresentativeCloseValue<T>(
-  bucket: readonly T[],
-  index: number,
-  getClose: (item: T) => number,
-): T {
-  let best = bucket[0] as T;
-  if (index % 2 === 0) {
-    for (const item of bucket) {
-      if (getClose(item) > getClose(best)) best = item;
-    }
-  } else {
-    for (const item of bucket) {
-      if (getClose(item) < getClose(best)) best = item;
-    }
-  }
-  return best;
-}
-
-function bucketOhlcBySourceIndex(
-  normalizedPoints: readonly ProjectedChartPoint[],
-  bucketSize: number,
-  sourceIndexOffset: number,
-  targetBucketCount?: number,
-): ProjectedChartPoint[] {
-  const normalizedBucketSize = Math.max(Math.floor(bucketSize), 1);
-  const normalizedSourceIndexOffset = Math.max(Math.floor(sourceIndexOffset), 0);
-  const maximumBucketCount = targetBucketCount === undefined
-    ? Number.POSITIVE_INFINITY
-    : Math.max(Math.floor(targetBucketCount), 1);
-  const result: ProjectedChartPoint[] = [];
-  const firstBucketStart = Math.floor(normalizedSourceIndexOffset / normalizedBucketSize) * normalizedBucketSize;
-  const endSourceIndex = normalizedSourceIndexOffset + normalizedPoints.length;
-
-  for (
-    let bucketStart = firstBucketStart;
-    bucketStart < endSourceIndex && result.length < maximumBucketCount;
-    bucketStart += normalizedBucketSize
-  ) {
-    const bucketEnd = bucketStart + normalizedBucketSize;
-    const start = Math.max(bucketStart - normalizedSourceIndexOffset, 0);
-    const end = Math.min(bucketEnd - normalizedSourceIndexOffset, normalizedPoints.length);
-    if (end <= start) continue;
-    const bucket = normalizedPoints.slice(start, end);
-    if (bucket.length === 0) continue;
-    result.push(aggregateOhlcBucket(bucket));
-  }
-
-  return result;
-}
-
-export function resolveStableOhlcProjectionOptions({
-  pointCount,
-  sourceIndexOffset,
-  bucketWidth,
-  navigationPointCount = 0,
-  countRatioTolerance = DEFAULT_OHLC_COUNT_RATIO_TOLERANCE,
-}: StableOhlcProjectionOptionsInput): ProjectChartDataOptions {
-  const ohlcBucketWidth = Math.max(Math.floor(bucketWidth), 1);
-  const ohlcProjectionWidth = Math.max(Math.floor(ohlcBucketWidth / 2), 1);
-  const normalizedPointCount = Math.max(Math.floor(pointCount), 0);
-  const normalizedNavigationPointCount = Math.max(Math.floor(navigationPointCount), 0);
-  const canUseNavigationCount = normalizedNavigationPointCount > 0
-    && normalizedPointCount > 0
-    && Math.max(normalizedNavigationPointCount, normalizedPointCount)
-      / Math.max(Math.min(normalizedNavigationPointCount, normalizedPointCount), 1)
-      <= countRatioTolerance;
-  const stableSourceCount = canUseNavigationCount
-    ? normalizedNavigationPointCount
-    : normalizedPointCount;
-  const ohlcSourceBucketSize = Math.max(Math.ceil(stableSourceCount / ohlcProjectionWidth), 1);
-  const ohlcTargetBucketCount = Math.max(Math.ceil(stableSourceCount / ohlcSourceBucketSize), 1);
-
-  return {
-    ohlcBucketWidth,
-    ohlcSourceBucketSize,
-    ohlcTargetBucketCount,
-    sourceIndexOffset,
-  };
-}
-
-/**
- * Downsample close-driven chart data to fit the target width.
- * Uses representative closes so line/area charts preserve the broad shape.
- */
-function projectCloseSeries(
-  points: PricePoint[],
-  targetWidth: number,
-): ProjectedChartPoint[] {
-  if (points.length === 0) return [];
-  return buildIndexProjectionBuckets(points.length, targetWidth).map((bucket) => (
-    normalizePoint(selectRepresentativeCloseValue(
-      points.slice(bucket.start, bucket.end),
-      bucket.index,
-      (point) => point.close,
-    ))
-  ));
-}
-
-/**
- * Bucket OHLC data so each rendered column preserves open, close, high, low, and volume.
- *
- * The default path aligns buckets by timestamp. Interactive manual panning can pass
- * ohlcSourceBucketSize/ohlcTargetBucketCount to align buckets by source bar index,
- * which keeps the rendered candle count stable as partial edge buckets enter/leave.
- */
-export function bucketOhlcSeries(
-  points: PricePoint[],
-  targetWidth: number,
-  options: ProjectChartDataOptions = {},
-): ProjectedChartPoint[] {
-  if (points.length === 0) return [];
-  const normalizedPoints = points.map(normalizePoint);
-  if (points.length <= targetWidth) return normalizedPoints;
-  if (options.ohlcSourceBucketSize !== undefined) {
-    return bucketOhlcBySourceIndex(
-      normalizedPoints,
-      options.ohlcSourceBucketSize,
-      options.sourceIndexOffset ?? 0,
-      options.ohlcTargetBucketCount,
-    );
-  }
-
-  const result: ProjectedChartPoint[] = [];
-  const minimumGapMs = getMinimumPositiveDateGapMs(normalizedPoints);
-  const firstTime = normalizedPoints[0]!.date.getTime();
-  const lastTime = normalizedPoints[normalizedPoints.length - 1]!.date.getTime();
-  if (
-    minimumGapMs
-    && Number.isFinite(firstTime)
-    && Number.isFinite(lastTime)
-    && lastTime > firstTime
-  ) {
-    const spanMs = Math.max(lastTime - firstTime, minimumGapMs);
-    const rawBucketDurationMs = spanMs / Math.max(targetWidth, 1);
-    const bucketDurationMs = Math.max(Math.ceil(rawBucketDurationMs / minimumGapMs) * minimumGapMs, minimumGapMs);
-    let currentBucketKey: number | null = null;
-    let currentBucket: ProjectedChartPoint[] = [];
-
-    for (const point of normalizedPoints) {
-      const time = point.date.getTime();
-      const bucketKey = Math.floor(time / bucketDurationMs);
-      if (currentBucketKey !== null && bucketKey !== currentBucketKey) {
-        result.push(aggregateOhlcBucket(currentBucket));
-        currentBucket = [];
-      }
-      currentBucketKey = bucketKey;
-      currentBucket.push(point);
-    }
-
-    if (currentBucket.length > 0) {
-      result.push(aggregateOhlcBucket(currentBucket));
-    }
-
-    return result;
-  }
-
-  const bucketSize = Math.max(Math.ceil(normalizedPoints.length / Math.max(targetWidth, 1)), 1);
-  const sourceIndexOffset = Math.max(Math.floor(options.sourceIndexOffset ?? 0), 0);
-  const firstBucketStart = Math.floor(sourceIndexOffset / bucketSize) * bucketSize;
-  const endSourceIndex = sourceIndexOffset + normalizedPoints.length;
-
-  for (let bucketStart = firstBucketStart; bucketStart < endSourceIndex; bucketStart += bucketSize) {
-    const bucketEnd = bucketStart + bucketSize;
-    const start = Math.max(bucketStart - sourceIndexOffset, 0);
-    const end = Math.min(bucketEnd - sourceIndexOffset, normalizedPoints.length);
-    if (end <= start) continue;
-    const bucket = normalizedPoints.slice(start, end);
-    if (bucket.length === 0) continue;
-    result.push(aggregateOhlcBucket(bucket));
-  }
-
-  return result;
-}
-
-export function projectChartData(
-  points: PricePoint[],
-  targetWidth: number,
-  mode: ChartRenderMode | undefined,
-  compact = false,
-  options: ProjectChartDataOptions = {},
-): ChartProjection {
-  const { requestedMode, effectiveMode, fallbackMode } = resolveRenderMode(mode, targetWidth, compact);
-  const ohlcBucketWidth = options.ohlcBucketWidth ?? targetWidth;
-  const projectionWidth = isOhlcProjectionMode(effectiveMode)
-    ? Math.max(Math.floor(ohlcBucketWidth / 2), 1)
-    : targetWidth;
-
-  const projectedPoints = isOhlcProjectionMode(effectiveMode)
-    ? bucketOhlcSeries(points, projectionWidth, options)
-    : projectCloseSeries(points, projectionWidth);
-
-  return {
-    points: projectedPoints,
-    requestedMode,
-    effectiveMode,
-    fallbackMode,
-  };
-}

package/src/components/chart/core/render-utils.ts

@@ -1,4 +0,0 @@
-export function normalizeCount(value: number, min: number): number {
-  if (!Number.isFinite(value)) return min;
-  return Math.max(Math.floor(value), min);
-}

package/src/components/chart/core/renderer.ts

@@ -1,244 +0,0 @@
-import type { PixelBuffer } from "./types";
-import type { ProjectedChartPoint } from "./data";
-import { buildTimeAxis } from "./time-axis";
-import {
-  formatAxisValue,
-  getAxisFractionDigitFloor,
-  resolveAxisFractionDigits,
-} from "./axis-format";
-import {
-  bufferToBrailleLines,
-  createPixelBuffer,
-  drawCrosshair,
-  drawGridLines,
-  type StyledContent,
-} from "../rendering/pixel-buffer";
-import {
-  isHighLowMode,
-} from "../rendering/geometry";
-import {
-  drawAreaChart,
-  drawCandlestickChart,
-  drawIndicatorOverlays,
-  drawLineSeries,
-  drawOhlcChart,
-  drawSessionBackgrounds,
-  drawVolumeBars,
-} from "../rendering/chart-draw";
-import {
-  buildChartScene,
-  type RenderChartOptions,
-} from "./scene";
-
-export { buildCursorTimeAxisSegments, buildTimeAxis } from "./time-axis";
-export {
-  formatAxisCell,
-  formatAxisValue,
-  formatCursorAxisValue,
-  formatPrice,
-  resolveAxisFractionDigits,
-  resolveChartAxisWidth,
-} from "./axis-format";
-export { resolveChartPalette } from "./palette";
-export type { ResolvedChartPalette } from "./palette";
-export {
-  bufferToBrailleLines,
-  createPixelBuffer,
-  drawCrosshair,
-  drawGridLines,
-  drawLine,
-} from "../rendering/pixel-buffer";
-export { getPointTerminalColumn } from "../rendering/geometry";
-export type { StyledContent } from "../rendering/pixel-buffer";
-export {
-  buildChartScene,
-  getActivePointIndex,
-  type ChartScene,
-  type RenderChartOptions,
-} from "./scene";
-
-// ---------------------------------------------------------------------------
-// Grid lines & price axis
-// ---------------------------------------------------------------------------
-
-export function computeGridLines(
-  min: number,
-  max: number,
-  chartTop: number,
-  chartBottom: number,
-  numLines: number,
-): { y: number; price: number }[] {
-  const range = max - min || 1;
-  const chartH = chartBottom - chartTop;
-  const result: { y: number; price: number }[] = [];
-
-  for (let i = 0; i <= numLines; i++) {
-    const frac = i / numLines;
-    result.push({
-      y: chartTop + Math.round(frac * chartH),
-      price: max - frac * range,
-    });
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Main render entry point
-// ---------------------------------------------------------------------------
-
-export interface RenderChartResult {
-  lines: StyledContent[];
-  axisLabels: { row: number; label: string }[];
-  timeLabels: string;
-  activePoint: ProjectedChartPoint | null;
-  priceAtCursor: number | null;
-  crosshairPrice: number | null;
-  dateAtCursor: Date | null;
-  changeAtCursor: number | null;
-  changePctAtCursor: number | null;
-  cursorColumn: number | null;
-  cursorRow: number | null;
-  axisFractionDigits: number | null;
-  priceRange: number | null;
-  /** Raw pixel buffer for GPU/Kitty rendering path */
-  pixelBuffer: PixelBuffer | null;
-}
-
-export function renderChart(
-  points: ProjectedChartPoint[],
-  opts: RenderChartOptions,
-): RenderChartResult {
-  const scene = buildChartScene(points, opts);
-  if (!scene) {
-    return {
-      lines: [],
-      axisLabels: [],
-      timeLabels: "",
-      activePoint: null,
-      priceAtCursor: null,
-      crosshairPrice: null,
-      dateAtCursor: null,
-      changeAtCursor: null,
-      changePctAtCursor: null,
-      cursorColumn: null,
-      cursorRow: null,
-      axisFractionDigits: null,
-      priceRange: null,
-      pixelBuffer: null,
-    };
-  }
-
-  const { width, height, showVolume, volumeHeight, colors: palette, mode } = scene;
-  const axisMode = opts.axisMode ?? "price";
-  const currency = opts.currency ?? "USD";
-  const assetCategory = opts.assetCategory;
-
-  // Braille resolution: 2 dot-columns per terminal column, 4 dot-rows per terminal row
-  const dotWidth = width * 2;
-  const volTermRows = showVolume ? volumeHeight : 0;
-  const chartTermRows = height - volTermRows;
-  const totalDotH = height * 4;
-  const chartDotBottom = chartTermRows * 4 - 1;
-  const volDotTop = chartTermRows * 4;
-  const volDotBottom = totalDotH - 1;
-
-  const buf = createPixelBuffer(dotWidth, totalDotH);
-  const { min, max } = scene;
-  const priceRange = max - min;
-
-  const gridLines = computeGridLines(min, max, 0, chartDotBottom, 3);
-  const axisFractionDigits = axisMode === "price"
-    ? resolveAxisFractionDigits(
-      gridLines.map((line) => line.price),
-      (price, fixedFractionDigits) => formatAxisValue(
-        price,
-        axisMode,
-        points[0]!.close,
-        currency,
-        assetCategory,
-        priceRange,
-        fixedFractionDigits,
-      ),
-      getAxisFractionDigitFloor(assetCategory, priceRange),
-    )
-    : null;
-  drawSessionBackgrounds(
-    buf,
-    points,
-    scene.sessionBackgroundSpans,
-    0,
-    showVolume ? volDotBottom : chartDotBottom,
-    palette,
-  );
-  drawGridLines(buf, gridLines.map((line) => line.y), palette.gridColor);
-
-  switch (mode) {
-    case "area":
-      drawAreaChart(buf, points, 0, chartDotBottom, palette.lineColor, palette.fillColor, min, max);
-      break;
-    case "line":
-      drawLineSeries(buf, points, 0, chartDotBottom, palette.lineColor, min, max);
-      break;
-    case "candles":
-      drawCandlestickChart(buf, points, 0, chartDotBottom, palette, min, max);
-      break;
-    case "ohlc":
-      drawOhlcChart(buf, points, 0, chartDotBottom, palette, min, max, "ohlc");
-      break;
-    case "hlc":
-      drawOhlcChart(buf, points, 0, chartDotBottom, palette, min, max, "hlc");
-      break;
-  }
-
-  if (showVolume && volTermRows > 0) {
-    drawVolumeBars(
-      buf,
-      points,
-      volDotTop,
-      volDotBottom,
-      palette.volumeUp,
-      palette.volumeDown,
-      isHighLowMode(mode) ? "openClose" : "previousClose",
-      mode,
-    );
-  }
-
-  if (opts.indicators) {
-    drawIndicatorOverlays(buf, opts.indicators, points.length, 0, chartDotBottom, min, max, mode);
-  }
-
-  // Cursor mapping stays in terminal-column space
-  const { activePoint, priceAtCursor, crosshairPrice, dateAtCursor, changeAtCursor, changePctAtCursor } = scene;
-
-  if (scene.cursorDotX !== null) {
-    drawCrosshair(buf, scene.cursorDotX, 0, showVolume ? volDotBottom : chartDotBottom, palette.crosshairColor);
-  }
-
-  const axisLabelsByRow = new Map<number, string>();
-  for (const line of gridLines) {
-    axisLabelsByRow.set(
-      Math.min(Math.floor(line.y / 4), Math.max(chartTermRows - 1, 0)),
-      formatAxisValue(line.price, axisMode, points[0]!.close, currency, assetCategory, priceRange, axisFractionDigits ?? undefined),
-    );
-  }
-
-  const timeAxisDates = opts.timeAxisDates ?? points.map((point) => point.date);
-
-  return {
-    lines: bufferToBrailleLines(buf),
-    axisLabels: [...axisLabelsByRow.entries()].map(([row, label]) => ({ row, label })),
-    timeLabels: buildTimeAxis(timeAxisDates, width),
-    activePoint,
-    priceAtCursor,
-    crosshairPrice,
-    dateAtCursor,
-    changeAtCursor,
-    changePctAtCursor,
-    cursorColumn: scene.cursorColumn,
-    cursorRow: scene.cursorRow,
-    axisFractionDigits,
-    priceRange,
-    pixelBuffer: buf,
-  };
-}