gloomberb 0.11.2 → 0.12.0

package/src/components/chart/market-session.ts

@@ -1,176 +0,0 @@
-import type { ChartMarketSession, ChartSessionBackgroundKind, ChartSessionBackgroundSpan } from "./core/types";
-
-const INTRADAY_SESSION_GAP_MS = 6 * 60 * 60_000;
-const MAX_SESSION_BACKGROUND_WINDOW_MS = 10 * 24 * 60 * 60_000;
-
-const US_EXTENDED_HOURS_SESSION: ChartMarketSession = {
-  timeZone: "America/New_York",
-  preMarketStartMinutes: 4 * 60,
-  regularStartMinutes: 9 * 60 + 30,
-  regularEndMinutes: 16 * 60,
-  postMarketEndMinutes: 20 * 60,
-};
-
-const US_EXCHANGE_PATTERN = /\b(NASDAQ|NYSE|AMEX|ARCA|BATS|IEX|NMS|XNAS|XNYS|ARCX|XASE|NYSEARCA|NASDAQGS|NASDAQGM|NASDAQCM)\b/i;
-const EQUITY_LIKE_ASSET_CATEGORIES = new Set(["", "STK", "ETF", "ADR", "EQUITY"]);
-
-interface MarketSessionSource {
-  exchange?: string | null;
-  primaryExchange?: string | null;
-  currency?: string | null;
-  assetCategory?: string | null;
-}
-
-interface ZonedDateTime {
-  dayKey: string;
-  minutes: number;
-}
-
-const zonedFormatterCache = new Map<string, Intl.DateTimeFormat>();
-
-function getZonedFormatter(timeZone: string): Intl.DateTimeFormat {
-  const cached = zonedFormatterCache.get(timeZone);
-  if (cached) return cached;
-
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    hourCycle: "h23",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-  });
-  zonedFormatterCache.set(timeZone, formatter);
-  return formatter;
-}
-
-function normalizeDate(value: Date | string | number): Date | null {
-  const date = value instanceof Date ? value : new Date(value);
-  return Number.isNaN(date.getTime()) ? null : date;
-}
-
-function getMinPositiveGapMs(dates: readonly Date[]): number {
-  let minGapMs = Number.POSITIVE_INFINITY;
-  for (let index = 1; index < dates.length; index += 1) {
-    const gapMs = Math.abs(dates[index]!.getTime() - dates[index - 1]!.getTime());
-    if (gapMs > 0 && gapMs < minGapMs) {
-      minGapMs = gapMs;
-    }
-  }
-  return Number.isFinite(minGapMs) ? minGapMs : 0;
-}
-
-function isIntradaySeries(dates: readonly Date[]): boolean {
-  if (dates.length < 2) return false;
-  const minGapMs = getMinPositiveGapMs(dates);
-  return minGapMs > 0 && minGapMs <= INTRADAY_SESSION_GAP_MS;
-}
-
-function getDateSpanMs(dates: readonly Date[]): number {
-  let minTime = Number.POSITIVE_INFINITY;
-  let maxTime = Number.NEGATIVE_INFINITY;
-  for (const date of dates) {
-    const time = date.getTime();
-    if (time < minTime) minTime = time;
-    if (time > maxTime) maxTime = time;
-  }
-  return Number.isFinite(minTime) && Number.isFinite(maxTime) ? maxTime - minTime : 0;
-}
-
-function shouldShowSessionBackgrounds(dates: readonly Date[]): boolean {
-  return isIntradaySeries(dates) && getDateSpanMs(dates) <= MAX_SESSION_BACKGROUND_WINDOW_MS;
-}
-
-function getZonedDateTime(date: Date, timeZone: string): ZonedDateTime | null {
-  const values = new Map<string, string>();
-  for (const part of getZonedFormatter(timeZone).formatToParts(date)) {
-    if (part.type !== "literal") values.set(part.type, part.value);
-  }
-
-  const year = values.get("year");
-  const month = values.get("month");
-  const day = values.get("day");
-  const hour = values.get("hour");
-  const minute = values.get("minute");
-  if (!year || !month || !day || !hour || !minute) return null;
-
-  return {
-    dayKey: `${year}-${month}-${day}`,
-    minutes: Number.parseInt(hour, 10) * 60 + Number.parseInt(minute, 10),
-  };
-}
-
-function getSessionBackgroundKind(minutes: number, session: ChartMarketSession): ChartSessionBackgroundKind | null {
-  if (minutes >= session.preMarketStartMinutes && minutes < session.regularStartMinutes) return "pre";
-  if (minutes >= session.regularEndMinutes && minutes < session.postMarketEndMinutes) return "post";
-  return null;
-}
-
-function isEquityLike(assetCategory: string | null | undefined): boolean {
-  return EQUITY_LIKE_ASSET_CATEGORIES.has((assetCategory ?? "").trim().toUpperCase());
-}
-
-function hasUsExchange(source: MarketSessionSource): boolean {
-  const exchangeText = [
-    source.exchange,
-    source.primaryExchange,
-  ].filter(Boolean).join(" ");
-  return US_EXCHANGE_PATTERN.test(exchangeText);
-}
-
-function isExplicitNonUsSource(source: MarketSessionSource): boolean {
-  const exchangeText = [
-    source.exchange,
-    source.primaryExchange,
-  ].filter(Boolean).join(" ");
-  return exchangeText.length > 0 && !US_EXCHANGE_PATTERN.test(exchangeText) && (source.currency ?? "").toUpperCase() !== "USD";
-}
-
-export function resolveChartMarketSession(sources: readonly MarketSessionSource[]): ChartMarketSession | null {
-  if (sources.length === 0) return null;
-  if (sources.some((source) => !isEquityLike(source.assetCategory))) return null;
-  if (sources.some(isExplicitNonUsSource)) return null;
-
-  const hasSupportedSource = sources.some((source) => hasUsExchange(source) || (source.currency ?? "").toUpperCase() === "USD");
-  return hasSupportedSource ? US_EXTENDED_HOURS_SESSION : null;
-}
-
-export function resolveExtendedHoursBackgroundSpans(
-  values: readonly (Date | string | number)[],
-  session: ChartMarketSession | null | undefined,
-): ChartSessionBackgroundSpan[] {
-  if (!session) return [];
-
-  const dates = values.map(normalizeDate);
-  const validDates = dates.filter((date): date is Date => date !== null);
-  if (!shouldShowSessionBackgrounds(validDates)) return [];
-
-  const spans: ChartSessionBackgroundSpan[] = [];
-  let active: ChartSessionBackgroundSpan | null = null;
-  let activeDayKey: string | null = null;
-
-  for (let index = 0; index < dates.length; index += 1) {
-    const date = dates[index];
-    const zoned = date ? getZonedDateTime(date, session.timeZone) : null;
-    const kind = zoned ? getSessionBackgroundKind(zoned.minutes, session) : null;
-    if (!kind) {
-      if (active) spans.push(active);
-      active = null;
-      activeDayKey = null;
-      continue;
-    }
-
-    if (active && active.kind === kind && activeDayKey === zoned!.dayKey) {
-      active.endIndex = index;
-      continue;
-    }
-
-    if (active) spans.push(active);
-    active = { kind, startIndex: index, endIndex: index };
-    activeDayKey = zoned!.dayKey;
-  }
-
-  if (active) spans.push(active);
-  return spans;
-}

package/src/components/chart/multi-line/renderer.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  buildMultiLineChartScene,
-  renderMultiLineChart,
-  renderMultiLineTimeAxis,
-  renderNativeMultiLineChart,
-  resolveMultiLineCursorDate,
-} from "./renderer";
-
-const dates = ["2026-01-01", "2026-01-02", "2026-01-03", "2026-01-04"]
-  .map((date) => new Date(`${date}T00:00:00Z`));
-
-describe("multi-line chart renderer", () => {
-  test("aligns sparse series to a shared axis and renders a cursor", () => {
-    const scene = buildMultiLineChartScene([
-      {
-        id: "AMD",
-        label: "AMD",
-        color: "#00ff66",
-        points: [
-          { date: dates[0]!, value: 100 },
-          { date: dates[1]!, value: 102 },
-          { date: dates[2]!, value: 101 },
-          { date: dates[3]!, value: 104 },
-        ],
-      },
-      {
-        id: "NVDA",
-        label: "NVDA",
-        color: "#4dabf7",
-        points: [
-          { date: dates[0]!, value: 100 },
-          { date: dates[2]!, value: 106 },
-          { date: dates[3]!, value: 108 },
-        ],
-      },
-    ], {
-      width: 24,
-      height: 8,
-      colors: {
-        bgColor: "#000000",
-        gridColor: "#333333",
-        axisColor: "#666666",
-        crosshairColor: "#ffffff",
-      },
-      dates,
-      cursorDate: dates[2],
-    });
-
-    expect(scene).not.toBeNull();
-    expect(scene!.dates).toHaveLength(4);
-    expect(scene!.series[1]?.points[1]).toBeNull();
-    expect(resolveMultiLineCursorDate(scene!, scene!.cursorX ?? 0)?.toISOString().slice(0, 10)).toBe("2026-01-03");
-    expect(renderMultiLineChart(scene!).join("\n")).toContain("│");
-    expect(renderMultiLineTimeAxis(scene!)).toContain("Jan");
-  });
-
-  test("renders native bitmap output", () => {
-    const scene = buildMultiLineChartScene([
-      {
-        id: "ratio",
-        label: "Ratio",
-        color: "#f6c85f",
-        points: dates.map((date, index) => ({ date, value: 1 + index / 10 })),
-      },
-    ], {
-      width: 20,
-      height: 8,
-      colors: {
-        bgColor: "#000000",
-        gridColor: "#333333",
-        axisColor: "#666666",
-        crosshairColor: "#ffffff",
-      },
-      cursorDate: dates[3],
-    })!;
-
-    const bitmap = renderNativeMultiLineChart(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/multi-line/renderer.ts

@@ -1,161 +0,0 @@
-import { buildTimeAxis } from "../core/renderer";
-import type { NativeChartBitmap } from "../native/chart-rasterizer";
-import { fillRect, parseHex } from "../native/raster/primitives";
-import { valueToPixelY, type MultiLineChartScene, type MultiLineProjectedPoint } from "./scene";
-
-export {
-  buildMultiLineChartScene,
-  resolveMultiLineCursorDate,
-  valueToPixelY,
-} from "./scene";
-export type {
-  MultiLineChartColors,
-  MultiLineChartScene,
-  MultiLineChartSeries,
-} from "./scene";
-
-const TEXT_SERIES_MARKS = ["●", "◆", "■", "▲", "✦", "•"];
-
-function drawNativeLine(
-  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.7, y - 0.7, x + 0.7, y + 0.7, color, opacity);
-  }
-}
-
-function drawTextLine(rows: string[][], x0: number, y0: number, x1: number, y1: number, mark: string) {
-  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);
-    if (!rows[y]?.[x]) continue;
-    rows[y]![x] = mark;
-  }
-}
-
-export function renderMultiLineChart(scene: MultiLineChartScene): string[] {
-  const rows = Array.from({ length: scene.height }, () => Array(scene.width).fill(" "));
-  for (let i = 1; i <= 3; i++) {
-    const row = Math.round((scene.height - 1) * (i / 4));
-    for (let x = 0; x < scene.width; x += 3) rows[row]![x] = "·";
-  }
-
-  scene.series.forEach((item, seriesIndex) => {
-    const mark = TEXT_SERIES_MARKS[seriesIndex % TEXT_SERIES_MARKS.length]!;
-    let previous: MultiLineProjectedPoint | null = null;
-    for (const point of item.points) {
-      if (!point) {
-        previous = null;
-        continue;
-      }
-      if (previous) drawTextLine(rows, previous.x, previous.y, point.x, point.y, mark);
-      rows[point.y]![point.x] = mark;
-      previous = point;
-    }
-  });
-
-  if (scene.cursorX !== null) {
-    for (let y = 0; y < scene.height; y++) {
-      const current = rows[y]![scene.cursorX];
-      rows[y]![scene.cursorX] = current === " " || current === "·" ? "│" : "╋";
-    }
-  }
-
-  return rows.map((row) => row.join(""));
-}
-
-export function renderMultiLineTimeAxis(scene: MultiLineChartScene): string {
-  return buildTimeAxis(scene.dates, scene.width);
-}
-
-export function renderNativeMultiLineChart(
-  scene: MultiLineChartScene,
-  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 crosshair = parseHex(scene.colors.crosshairColor, 0.9);
-
-  fillRect(data, width, height, 0, 0, width - 1, height - 1, bg, 1);
-
-  for (let i = 1; i <= 3; i++) {
-    const y = (height - 1) * (i / 4);
-    fillRect(data, width, height, 0, y, width - 1, y + 0.7, grid, 0.45);
-  }
-
-  const projectX = (x: number) => (x / Math.max(scene.width - 1, 1)) * (width - 1);
-  const projectIndexX = (index: number) => (
-    scene.dates.length <= 1
-      ? (width - 1) / 2
-      : (index / (scene.dates.length - 1)) * (width - 1)
-  );
-  const projectValueY = (value: number) => valueToPixelY(value, scene.min, scene.max, height);
-
-  for (const item of scene.series) {
-    const color = parseHex(item.color, 0.96);
-    let previous: { x: number; y: number } | null = null;
-    item.points.forEach((point, index) => {
-      if (!point) {
-        previous = null;
-        return;
-      }
-      const current = {
-        x: projectIndexX(index),
-        y: projectValueY(point.value),
-      };
-      if (previous) {
-        drawNativeLine(
-          data,
-          width,
-          height,
-          previous.x,
-          previous.y,
-          current.x,
-          current.y,
-          color,
-          0.92,
-        );
-      }
-      previous = current;
-    });
-  }
-
-  if (scene.cursorX !== null) {
-    const cursorIndex = scene.cursorIndex;
-    const x = cursorIndex === null ? projectX(scene.cursorX) : projectIndexX(cursorIndex);
-    fillRect(data, width, height, x - 0.6, 0, x + 0.6, height - 1, crosshair, 0.82);
-    if (cursorIndex === null) return { width, height, pixels: data };
-    for (const item of scene.series) {
-      const point = item.points[cursorIndex] ?? null;
-      if (!point) continue;
-      const color = parseHex(item.color, 1);
-      const pointX = projectIndexX(cursorIndex);
-      const pointY = projectValueY(point.value);
-      fillRect(data, width, height, pointX - 2.2, pointY - 2.2, pointX + 2.2, pointY + 2.2, color, 1);
-    }
-  }
-
-  return { width, height, pixels: data };
-}

package/src/components/chart/multi-line/scene.ts

@@ -1,188 +0,0 @@
-interface MultiLineChartPoint {
-  date: Date;
-  value: number | null;
-}
-
-export interface MultiLineChartSeries {
-  id: string;
-  label: string;
-  color: string;
-  points: MultiLineChartPoint[];
-}
-
-export interface MultiLineChartColors {
-  bgColor: string;
-  gridColor: string;
-  axisColor: string;
-  crosshairColor: string;
-}
-
-export interface MultiLineChartSceneOptions {
-  width: number;
-  height: number;
-  colors: MultiLineChartColors;
-  dates?: Date[];
-  cursorDate?: Date | null;
-  yDomain?: { min: number; max: number } | null;
-}
-
-export interface MultiLineProjectedPoint {
-  seriesId: string;
-  date: Date;
-  value: number;
-  x: number;
-  y: number;
-  color: string;
-}
-
-interface MultiLineProjectedSeries {
-  id: string;
-  label: string;
-  color: string;
-  points: Array<MultiLineProjectedPoint | null>;
-}
-
-export interface MultiLineChartScene {
-  width: number;
-  height: number;
-  dates: Date[];
-  series: MultiLineProjectedSeries[];
-  min: number;
-  max: number;
-  cursorIndex: number | null;
-  cursorX: number | null;
-  colors: MultiLineChartColors;
-}
-
-const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(max, value));
-
-function dateKey(date: Date): number {
-  return date.getTime();
-}
-
-function collectDates(series: MultiLineChartSeries[], forcedDates?: Date[]): Date[] {
-  if (forcedDates && forcedDates.length > 0) {
-    return forcedDates
-      .filter((date) => Number.isFinite(date.getTime()))
-      .sort((left, right) => left.getTime() - right.getTime());
-  }
-
-  const byTime = new Map<number, Date>();
-  for (const item of series) {
-    for (const point of item.points) {
-      const time = point.date.getTime();
-      if (Number.isFinite(time)) byTime.set(time, point.date);
-    }
-  }
-  return [...byTime.values()].sort((left, right) => left.getTime() - right.getTime());
-}
-
-function paddedRange(values: number[], yDomain: MultiLineChartSceneOptions["yDomain"]): { min: number; max: number } {
-  if (yDomain && Number.isFinite(yDomain.min) && Number.isFinite(yDomain.max) && yDomain.min !== yDomain.max) {
-    return { min: yDomain.min, max: yDomain.max };
-  }
-  if (values.length === 0) return { min: 0, 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.08;
-  return { min: rawMin - padding, max: rawMax + padding };
-}
-
-function valueToRow(value: number, min: number, max: number, height: number): number {
-  const t = (value - min) / (max - min || 1);
-  return clamp(Math.round((1 - t) * (height - 1)), 0, height - 1);
-}
-
-export function valueToPixelY(value: number, min: number, max: number, height: number): number {
-  const t = (value - min) / (max - min || 1);
-  return clamp((1 - t) * (height - 1), 0, height - 1);
-}
-
-function indexToColumn(index: number, count: number, width: number): number {
-  if (count <= 1) return Math.round((width - 1) / 2);
-  return clamp(Math.round((index / (count - 1)) * (width - 1)), 0, width - 1);
-}
-
-function cursorIndexForDate(dates: Date[], cursorDate: Date | null | undefined): number | null {
-  if (!cursorDate || dates.length === 0) return null;
-  const target = cursorDate.getTime();
-  if (!Number.isFinite(target)) return null;
-  let bestIndex = 0;
-  let bestDistance = Infinity;
-  dates.forEach((date, index) => {
-    const distance = Math.abs(date.getTime() - target);
-    if (distance < bestDistance) {
-      bestDistance = distance;
-      bestIndex = index;
-    }
-  });
-  return bestIndex;
-}
-
-export function buildMultiLineChartScene(
-  series: MultiLineChartSeries[],
-  options: MultiLineChartSceneOptions,
-): MultiLineChartScene | null {
-  const width = Math.max(1, Math.floor(options.width));
-  const height = Math.max(1, Math.floor(options.height));
-  const dates = collectDates(series, options.dates);
-  if (dates.length === 0) return null;
-
-  const values = series.flatMap((item) => item.points)
-    .map((point) => point.value)
-    .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
-  if (values.length === 0) return null;
-
-  const { min, max } = paddedRange(values, options.yDomain);
-  const projectedSeries = series.map((item): MultiLineProjectedSeries => {
-    const valuesByDate = new Map<number, number>();
-    for (const point of item.points) {
-      if (typeof point.value !== "number" || !Number.isFinite(point.value)) continue;
-      valuesByDate.set(dateKey(point.date), point.value);
-    }
-
-    return {
-      id: item.id,
-      label: item.label,
-      color: item.color,
-      points: dates.map((date, index) => {
-        const value = valuesByDate.get(dateKey(date));
-        if (typeof value !== "number" || !Number.isFinite(value)) return null;
-        return {
-          seriesId: item.id,
-          date,
-          value,
-          x: indexToColumn(index, dates.length, width),
-          y: valueToRow(value, min, max, height),
-          color: item.color,
-        };
-      }),
-    };
-  });
-
-  const cursorIndex = cursorIndexForDate(dates, options.cursorDate);
-  return {
-    width,
-    height,
-    dates,
-    series: projectedSeries,
-    min,
-    max,
-    cursorIndex,
-    cursorX: cursorIndex === null ? null : indexToColumn(cursorIndex, dates.length, width),
-    colors: options.colors,
-  };
-}
-
-export function resolveMultiLineCursorDate(scene: MultiLineChartScene, localCellX: number): Date | null {
-  if (scene.dates.length === 0) return null;
-  const x = clamp(localCellX, 0, Math.max(scene.width - 1, 0));
-  const index = scene.width <= 1
-    ? 0
-    : clamp(Math.round((x / Math.max(scene.width - 1, 1)) * (scene.dates.length - 1)), 0, scene.dates.length - 1);
-  return scene.dates[index] ?? null;
-}