gloomberb 0.7.4 → 0.8.0

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

@@ -1,437 +0,0 @@
-import type {
-  ComparisonChartProjection,
-  ComparisonProjectedPoint,
-  ComparisonProjectedSeries,
-} from "./comparison-chart-data";
-import {
-  buildTimeAxis,
-  bufferToBrailleLines,
-  computeGridLines,
-  createPixelBuffer,
-  drawCrosshair,
-  drawGridLines,
-  drawLine,
-  formatPrice,
-  resolveAxisFractionDigits,
-  type StyledContent,
-} from "./chart-renderer";
-import type { ChartAxisMode, ChartColors, ChartMarketSession, ChartSessionBackgroundSpan, ComparisonChartRenderMode } from "./chart-types";
-import { resolveExtendedHoursBackgroundSpans } from "./market-session";
-
-const LAYER_FILL = 1;
-const LAYER_DATA = 2;
-type ComparisonChartColors = Pick<ChartColors, "bgColor" | "gridColor" | "crosshairColor" | "preMarketBgColor" | "postMarketBgColor">;
-
-export interface ComparisonChartScene {
-  dates: Date[];
-  series: ComparisonProjectedSeries[];
-  width: number;
-  height: number;
-  chartRows: number;
-  mode: ComparisonChartRenderMode;
-  axisMode: ChartAxisMode;
-  selectedSymbol: string | null;
-  colors: ComparisonChartColors;
-  sessionBackgroundSpans: ChartSessionBackgroundSpan[];
-  min: number;
-  max: number;
-  activeIdx: number;
-  activeDate: Date;
-  selectedSeries: ComparisonProjectedSeries | null;
-  selectedPoint: ComparisonProjectedPoint | null;
-  crosshairValue: number | null;
-  timeLabels: string;
-  cursorX: number | null;
-  cursorY: number | null;
-  cursorColumn: number | null;
-  cursorRow: number | null;
-  cursorDotX: number | null;
-}
-
-export interface RenderComparisonChartOptions {
-  width: number;
-  height: number;
-  cursorX: number | null;
-  cursorY: number | null;
-  selectedSymbol: string | null;
-  colors: ComparisonChartColors;
-  marketSession?: ChartMarketSession | null;
-}
-
-export interface RenderComparisonChartResult {
-  lines: StyledContent[];
-  axisLabels: { row: number; label: string }[];
-  timeLabels: string;
-  activeDate: Date | null;
-  selectedSeries: ComparisonProjectedSeries | null;
-  selectedPoint: ComparisonProjectedPoint | null;
-  crosshairValue: number | null;
-  cursorColumn: number | null;
-  cursorRow: number | null;
-  axisFractionDigits: number | null;
-  priceRange: number | null;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function normalizeCount(value: number, min: number): number {
-  if (!Number.isFinite(value)) return min;
-  return Math.max(Math.floor(value), min);
-}
-
-function getComparisonDotX(index: number, count: number, width: number): number {
-  if (count <= 1) return Math.round(Math.max(width - 1, 0) / 2);
-  return Math.round((index / (count - 1)) * Math.max(width - 1, 0));
-}
-
-function getComparisonPointBand(index: number, pointCount: number, width: number): { left: number; right: number } {
-  const currentX = getComparisonDotX(index, pointCount, width);
-  const previousX = index > 0 ? getComparisonDotX(index - 1, pointCount, width) : currentX;
-  const nextX = index < pointCount - 1 ? getComparisonDotX(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),
-  };
-}
-
-function getScaledY(value: number, min: number, max: number, chartTop: number, chartBottom: number): number {
-  const range = max - min || 1;
-  const chartHeight = chartBottom - chartTop;
-  return chartTop + Math.round((1 - (value - min) / range) * chartHeight);
-}
-
-function formatPercentAxisValue(value: number): string {
-  const abs = Math.abs(value);
-  const decimals = abs >= 100 ? 0 : abs >= 10 ? 1 : 2;
-  const prefix = value > 0 ? "+" : "";
-  return `${prefix}${value.toFixed(decimals)}%`;
-}
-
-function getComparisonAxisFractionDigitFloor(priceRange: number | undefined): number {
-  if (priceRange === undefined || !Number.isFinite(priceRange) || priceRange <= 0) return 0;
-  const visibleStep = priceRange / 3;
-  if (!Number.isFinite(visibleStep) || visibleStep <= 0) return 0;
-  return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + 1);
-}
-
-export function formatComparisonAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  priceRange?: number,
-  fixedFractionDigits?: number,
-): string {
-  return axisMode === "percent"
-    ? formatPercentAxisValue(value)
-    : formatPrice(value, undefined, priceRange, 0, 0, fixedFractionDigits);
-}
-
-export function formatComparisonCursorAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  priceRange?: number,
-): string {
-  return axisMode === "percent"
-    ? formatPercentAxisValue(value)
-    : formatPrice(value, undefined, priceRange, 2, Math.abs(value) >= 1 ? 2 : 4);
-}
-
-function fillColumn(
-  buf: ReturnType<typeof createPixelBuffer>,
-  x: number,
-  y0: number,
-  y1: number,
-  color: string,
-  layer: number,
-) {
-  drawLine(buf, x, Math.min(y0, y1), x, Math.max(y0, y1), color, layer);
-}
-
-function drawComparisonLineSeries(
-  buf: ReturnType<typeof createPixelBuffer>,
-  points: ComparisonProjectedPoint[],
-  chartTop: number,
-  chartBottom: number,
-  color: string,
-  min: number,
-  max: number,
-) {
-  let previousIndex: number | null = null;
-  let previousY: number | null = null;
-  let previousX: number | null = null;
-
-  for (let index = 0; index < points.length; index += 1) {
-    const value = points[index]!.value;
-    if (value === null) {
-      previousIndex = null;
-      previousY = null;
-      previousX = null;
-      continue;
-    }
-
-    const x = getComparisonDotX(index, points.length, buf.width);
-    const y = getScaledY(value, min, max, chartTop, chartBottom);
-
-    if (previousIndex !== null && previousY !== null && previousX !== null) {
-      drawLine(buf, previousX, previousY, x, y, color, LAYER_DATA);
-    } else {
-      drawLine(buf, x, y, x, y, color, LAYER_DATA);
-    }
-
-    previousIndex = index;
-    previousY = y;
-    previousX = x;
-  }
-}
-
-function drawComparisonAreaSeries(
-  buf: ReturnType<typeof createPixelBuffer>,
-  points: ComparisonProjectedPoint[],
-  chartTop: number,
-  chartBottom: number,
-  lineColor: string,
-  fillColor: string,
-  min: number,
-  max: number,
-) {
-  let previousY: number | null = null;
-  let previousX: number | null = null;
-
-  for (let index = 0; index < points.length; index += 1) {
-    const value = points[index]!.value;
-    if (value === null) {
-      previousY = null;
-      previousX = null;
-      continue;
-    }
-
-    const x = getComparisonDotX(index, points.length, buf.width);
-    const y = getScaledY(value, min, max, chartTop, chartBottom);
-    fillColumn(buf, x, y + 1, chartBottom, fillColor, LAYER_FILL);
-
-    if (previousY !== null && previousX !== null) {
-      const left = Math.min(previousX, x);
-      const right = Math.max(previousX, x);
-      for (let column = left; column <= right; column += 1) {
-        if (column === previousX || column === x) continue;
-        const t = x === previousX ? 0 : (column - previousX) / (x - previousX);
-        const interpolatedY = Math.round(previousY + t * (y - previousY));
-        fillColumn(buf, column, interpolatedY + 1, chartBottom, fillColor, LAYER_FILL);
-      }
-      drawLine(buf, previousX, previousY, x, y, lineColor, LAYER_DATA);
-    } else {
-      drawLine(buf, x, y, x, y, lineColor, LAYER_DATA);
-    }
-
-    previousY = y;
-    previousX = x;
-  }
-}
-
-function drawSessionBackgrounds(
-  buf: ReturnType<typeof createPixelBuffer>,
-  spans: readonly ChartSessionBackgroundSpan[],
-  pointCount: number,
-  yTop: number,
-  yBottom: number,
-  colors: ComparisonChartColors,
-) {
-  if (spans.length === 0 || pointCount === 0) return;
-  for (const span of spans) {
-    const startIndex = Math.max(Math.min(span.startIndex, pointCount - 1), 0);
-    const endIndex = Math.max(Math.min(span.endIndex, pointCount - 1), startIndex);
-    const startBand = getComparisonPointBand(startIndex, pointCount, buf.width);
-    const endBand = getComparisonPointBand(endIndex, pointCount, buf.width);
-    const color = span.kind === "pre" ? colors.preMarketBgColor : colors.postMarketBgColor;
-    for (let y = Math.max(yTop, 0); y <= Math.min(yBottom, Math.max(buf.height - 1, 0)); y += 1) {
-      for (let x = Math.max(startBand.left, 0); x <= Math.min(endBand.right, Math.max(buf.width - 1, 0)); x += 1) {
-        buf.backgrounds[y]![x] = color;
-      }
-    }
-  }
-}
-
-function getActiveIndex(pointCount: number, width: number, cursorX: number | null): number {
-  if (pointCount <= 0) return 0;
-  if (cursorX === null || cursorX < 0 || cursorX >= width) {
-    return pointCount - 1;
-  }
-
-  let bestIndex = pointCount - 1;
-  let bestDistance = Number.POSITIVE_INFINITY;
-
-  for (let index = 0; index < pointCount; index += 1) {
-    const pointColumn = Math.min(Math.max(Math.floor(getComparisonDotX(index, pointCount, width * 2) / 2), 0), width - 1);
-    const distance = Math.abs(pointColumn - cursorX);
-    if (distance <= bestDistance) {
-      bestDistance = distance;
-      bestIndex = index;
-    }
-  }
-
-  return bestIndex;
-}
-
-function getSelectedSeries(series: ComparisonProjectedSeries[], selectedSymbol: string | null): ComparisonProjectedSeries | null {
-  if (series.length === 0) return null;
-  if (!selectedSymbol) return series[0] ?? null;
-  return series.find((entry) => entry.symbol === selectedSymbol) ?? series[0] ?? null;
-}
-
-export function buildComparisonChartScene(
-  projection: ComparisonChartProjection,
-  opts: RenderComparisonChartOptions,
-): ComparisonChartScene | null {
-  if (projection.dates.length === 0 || projection.series.length === 0) {
-    return null;
-  }
-
-  const values = projection.series.flatMap((entry) => entry.points.map((point) => point.value).filter((value): value is number => value !== null));
-  if (values.length === 0) {
-    return null;
-  }
-
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  const width = normalizeCount(opts.width, 1);
-  const height = normalizeCount(opts.height, 1);
-  const selectedSeries = getSelectedSeries(projection.series, opts.selectedSymbol);
-  const activeIdx = getActiveIndex(projection.dates.length, width, opts.cursorX);
-  const activeDate = projection.dates[activeIdx] ?? projection.dates[projection.dates.length - 1]!;
-  const selectedPoint = selectedSeries?.points[activeIdx] ?? null;
-  const chartRows = height;
-  const range = max - min || 1;
-  const cursorX = opts.cursorX === null
-    ? null
-    : clamp(opts.cursorX, 0, Math.max(width - 1, 0));
-  const fallbackValue = selectedPoint?.value ?? selectedSeries?.latestValue ?? min;
-  const cursorY = cursorX === null
-    ? null
-    : opts.cursorY !== null
-      ? clamp(opts.cursorY, 0, Math.max(chartRows - 1, 0))
-      : clamp(
-        Math.round((1 - ((fallbackValue ?? min) - min) / range) * Math.max(chartRows - 1, 0)),
-        0,
-        Math.max(chartRows - 1, 0),
-      );
-  const cursorColumn = cursorX === null ? null : Math.round(cursorX);
-  const cursorDotX = cursorX === null
-    ? null
-    : Math.round((cursorX / Math.max(width - 1, 1)) * Math.max(width * 2 - 1, 0));
-  const cursorRow = cursorY === null ? null : Math.round(cursorY);
-  const crosshairValue = cursorY === null
-    ? null
-    : max - (cursorY / Math.max(chartRows - 1, 1)) * range;
-  const sessionBackgroundSpans = resolveExtendedHoursBackgroundSpans(projection.dates, opts.marketSession);
-
-  return {
-    dates: projection.dates,
-    series: projection.series,
-    width,
-    height,
-    chartRows,
-    mode: projection.effectiveMode,
-    axisMode: projection.effectiveAxisMode,
-    selectedSymbol: selectedSeries?.symbol ?? null,
-    colors: opts.colors,
-    sessionBackgroundSpans,
-    min,
-    max,
-    activeIdx,
-    activeDate,
-    selectedSeries,
-    selectedPoint,
-    crosshairValue,
-    timeLabels: buildTimeAxis(projection.dates, opts.width),
-    cursorX,
-    cursorY,
-    cursorColumn,
-    cursorRow,
-    cursorDotX,
-  };
-}
-
-export function renderComparisonChart(
-  projection: ComparisonChartProjection,
-  opts: RenderComparisonChartOptions,
-): RenderComparisonChartResult {
-  const scene = buildComparisonChartScene(projection, opts);
-  if (!scene) {
-    return {
-      lines: [],
-      axisLabels: [],
-      timeLabels: "",
-      activeDate: null,
-      selectedSeries: null,
-      selectedPoint: null,
-      crosshairValue: null,
-      cursorColumn: null,
-      cursorRow: null,
-      axisFractionDigits: null,
-      priceRange: null,
-    };
-  }
-
-  const dotWidth = scene.width * 2;
-  const chartDotBottom = scene.chartRows * 4 - 1;
-  const priceRange = scene.max - scene.min;
-  const buf = createPixelBuffer(dotWidth, scene.height * 4);
-  const gridLines = computeGridLines(scene.min, scene.max, 0, chartDotBottom, 3);
-  const axisFractionDigits = scene.axisMode === "price"
-    ? resolveAxisFractionDigits(
-      gridLines.map((line) => line.price),
-      (price, fixedFractionDigits) => formatComparisonAxisValue(price, scene.axisMode, priceRange, fixedFractionDigits),
-      getComparisonAxisFractionDigitFloor(priceRange),
-    )
-    : null;
-  drawSessionBackgrounds(
-    buf,
-    scene.sessionBackgroundSpans,
-    scene.dates.length,
-    0,
-    chartDotBottom,
-    scene.colors,
-  );
-  drawGridLines(buf, gridLines.map((line) => line.y), scene.colors.gridColor);
-
-  const selectedSeries = getSelectedSeries(scene.series, scene.selectedSymbol);
-  const orderedSeries = [
-    ...scene.series.filter((entry) => entry.symbol !== selectedSeries?.symbol),
-    ...(selectedSeries ? [selectedSeries] : []),
-  ];
-
-  for (const series of orderedSeries) {
-    if (scene.mode === "area") {
-      drawComparisonAreaSeries(buf, series.points, 0, chartDotBottom, series.color, series.fillColor, scene.min, scene.max);
-    } else {
-      drawComparisonLineSeries(buf, series.points, 0, chartDotBottom, series.color, scene.min, scene.max);
-    }
-  }
-
-  if (scene.cursorDotX !== null) {
-    drawCrosshair(buf, scene.cursorDotX, 0, chartDotBottom, scene.colors.crosshairColor);
-  }
-
-  const axisLabelsByRow = new Map<number, string>();
-  for (const line of gridLines) {
-    axisLabelsByRow.set(
-      Math.min(Math.floor(line.y / 4), Math.max(scene.chartRows - 1, 0)),
-      formatComparisonAxisValue(line.price, scene.axisMode, priceRange, axisFractionDigits ?? undefined),
-    );
-  }
-
-  return {
-    lines: bufferToBrailleLines(buf),
-    axisLabels: [...axisLabelsByRow.entries()].map(([row, label]) => ({ row, label })),
-    timeLabels: scene.timeLabels,
-    activeDate: scene.activeDate,
-    selectedSeries: scene.selectedSeries,
-    selectedPoint: scene.selectedPoint,
-    crosshairValue: scene.crosshairValue,
-    cursorColumn: scene.cursorColumn,
-    cursorRow: scene.cursorRow,
-    axisFractionDigits,
-    priceRange,
-  };
-}

package/src/components/chart/native/kitty-adapter.ts

@@ -1,9 +0,0 @@
-import { type NativeRendererHost as CliRenderer } from "../../../ui";
-
-export function writeRendererRaw(renderer: CliRenderer, data: string | Uint8Array): boolean {
-  if (renderer.isDestroyed) {
-    return false;
-  }
-
-  return renderer.write?.(data) ?? false;
-}

package/src/components/chart/native/kitty-manager.ts

@@ -1,142 +0,0 @@
-import { type NativeRendererHost as CliRenderer } from "../../../ui";
-import type { NativeChartBitmap, NativePlacement } from "./chart-rasterizer";
-import { writeRendererRaw } from "./kitty-adapter";
-import { encodeKittyDeleteImage, encodeKittyPlacement, encodeKittyTransmitRgba } from "./kitty-protocol";
-
-let nextImageId = 2000;
-let nextPlacementId = 1;
-
-function allocateImageId(): number {
-  const id = nextImageId;
-  nextImageId += 1;
-  return id;
-}
-
-function allocatePlacementId(): number {
-  const id = nextPlacementId;
-  nextPlacementId += 1;
-  return id;
-}
-
-function serializePlacement(placement: NativePlacement): string {
-  return [
-    placement.column,
-    placement.row,
-    placement.cols,
-    placement.rows,
-    placement.cropX,
-    placement.cropY,
-    placement.cropWidth,
-    placement.cropHeight,
-  ].join(":");
-}
-
-function asPlacementArray(placement: NativePlacement | NativePlacement[]): NativePlacement[] {
-  return Array.isArray(placement) ? placement : [placement];
-}
-
-export class KittyImageManager {
-  private readonly imageIds = [allocateImageId(), allocateImageId()] as const;
-  private readonly placementIds: number[] = [];
-  private activeSlot: 0 | 1 | null = null;
-  private lastBitmapKey: string | null = null;
-  private lastPlacementKeys: string[] = [];
-
-  constructor(private readonly renderer: CliRenderer) {}
-
-  render(bitmap: NativeChartBitmap, placement: NativePlacement | NativePlacement[], bitmapKey: string) {
-    const placements = asPlacementArray(placement);
-    if (this.activeSlot !== null && this.lastBitmapKey === bitmapKey) {
-      this.placeActive(placements);
-      return;
-    }
-
-    const nextSlot: 0 | 1 = this.activeSlot === 0 ? 1 : 0;
-    const imageId = this.imageIds[nextSlot];
-    const placementIds = this.ensurePlacementIds(placements.length);
-    const sequences = [
-      ...encodeKittyTransmitRgba({
-        imageId,
-        width: bitmap.width,
-        height: bitmap.height,
-        rgba: bitmap.pixels,
-      }),
-      ...placements.map((entry, index) => encodeKittyPlacement({
-        imageId,
-        placementId: placementIds[index]!,
-        column: entry.column,
-        row: entry.row,
-        cols: entry.cols,
-        rows: entry.rows,
-        cropX: entry.cropX,
-        cropY: entry.cropY,
-        cropWidth: entry.cropWidth,
-        cropHeight: entry.cropHeight,
-      })),
-    ];
-
-    if (this.activeSlot !== null) {
-      sequences.push(encodeKittyDeleteImage(this.imageIds[this.activeSlot]));
-    }
-
-    writeRendererRaw(this.renderer, sequences.join(""));
-    this.activeSlot = nextSlot;
-    this.lastBitmapKey = bitmapKey;
-    this.lastPlacementKeys = placements.map(serializePlacement);
-  }
-
-  placeActive(placement: NativePlacement | NativePlacement[]) {
-    if (this.activeSlot === null) return;
-    const placements = asPlacementArray(placement);
-    const imageId = this.imageIds[this.activeSlot];
-    const placementIds = this.ensurePlacementIds(placements.length);
-    const sequences: string[] = [];
-
-    placements.forEach((entry, index) => {
-      const placementKey = serializePlacement(entry);
-      if (placementKey === this.lastPlacementKeys[index]) return;
-      sequences.push(encodeKittyPlacement({
-        imageId,
-        placementId: placementIds[index]!,
-        column: entry.column,
-        row: entry.row,
-        cols: entry.cols,
-        rows: entry.rows,
-        cropX: entry.cropX,
-        cropY: entry.cropY,
-        cropWidth: entry.cropWidth,
-        cropHeight: entry.cropHeight,
-      }));
-    });
-
-    for (let index = placements.length; index < this.lastPlacementKeys.length; index += 1) {
-      sequences.push(encodeKittyDeleteImage(imageId, placementIds[index]!));
-    }
-
-    if (sequences.length === 0) return;
-
-    writeRendererRaw(this.renderer, sequences.join(""));
-    this.lastPlacementKeys = placements.map(serializePlacement);
-  }
-
-  clear() {
-    writeRendererRaw(
-      this.renderer,
-      `${encodeKittyDeleteImage(this.imageIds[0])}${encodeKittyDeleteImage(this.imageIds[1])}`,
-    );
-    this.activeSlot = null;
-    this.lastBitmapKey = null;
-    this.lastPlacementKeys = [];
-  }
-
-  destroy() {
-    this.clear();
-  }
-
-  private ensurePlacementIds(count: number): number[] {
-    while (this.placementIds.length < count) {
-      this.placementIds.push(allocatePlacementId());
-    }
-    return this.placementIds;
-  }
-}

package/src/components/chart/native/kitty-support.ts

@@ -1,71 +0,0 @@
-import { type NativeRendererHost as CliRenderer } from "../../../ui";
-import { writeRendererRaw } from "./kitty-adapter";
-import { buildKittyGraphicsQuery } from "./kitty-protocol";
-
-interface RendererCapabilities {
-  kitty_graphics?: boolean;
-}
-
-interface SupportCacheEntry {
-  value: boolean | null;
-  promise?: Promise<boolean>;
-}
-
-const supportCache = new WeakMap<CliRenderer, SupportCacheEntry>();
-const QUERY_TIMEOUT_MS = 250;
-
-function readKnownSupport(renderer: CliRenderer): boolean | null {
-  const capabilities = renderer.capabilities as RendererCapabilities | null;
-  return typeof capabilities?.kitty_graphics === "boolean" ? capabilities.kitty_graphics : null;
-}
-
-export function getCachedKittySupport(renderer: CliRenderer): boolean | null {
-  const cached = supportCache.get(renderer)?.value ?? null;
-  if (cached !== null) return cached;
-  return readKnownSupport(renderer);
-}
-
-export function ensureKittySupport(renderer: CliRenderer): Promise<boolean> {
-  const known = readKnownSupport(renderer);
-  if (known !== null) {
-    supportCache.set(renderer, { value: known });
-    return Promise.resolve(known);
-  }
-
-  const cached = supportCache.get(renderer);
-  if (cached?.promise) return cached.promise;
-
-  const nextEntry: SupportCacheEntry = { value: null };
-  const promise = new Promise<boolean>((resolve) => {
-    let settled = false;
-
-    const finish = (value: boolean) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      renderer.off("capabilities", onCapabilities);
-      nextEntry.value = value;
-      nextEntry.promise = undefined;
-      resolve(value);
-    };
-
-    const onCapabilities = () => {
-      const supported = readKnownSupport(renderer);
-      if (supported !== null) finish(supported);
-    };
-
-    const timer = setTimeout(() => finish(false), QUERY_TIMEOUT_MS);
-    renderer.on("capabilities", onCapabilities);
-    if (!writeRendererRaw(renderer, `${buildKittyGraphicsQuery()}\x1b[c`)) {
-      finish(false);
-      return;
-    }
-    const supported = readKnownSupport(renderer);
-    if (supported !== null) finish(supported);
-  });
-
-  nextEntry.promise = promise;
-  supportCache.set(renderer, nextEntry);
-  return promise;
-}
-