gloomberb 0.6.1 → 0.7.1

package/src/components/chart/chart-data.ts

@@ -1,6 +1,5 @@
 import type { PricePoint } from "../../types/financials";
-import type { ChartRenderMode, ChartViewState, VisibleWindow } from "./chart-types";
-import { getVisiblePointCount } from "./chart-viewport";
+import type { ChartRenderMode } from "./chart-types";
 
 export interface ProjectedChartPoint {
   date: Date;
@@ -76,34 +75,6 @@ export function resolveRenderMode(
   };
 }
 
-/**
- * Apply zoom and pan to get the visible data window.
- */
-export function getVisibleWindow(
-  history: PricePoint[],
-  viewState: ChartViewState,
-  chartWidth: number,
-): VisibleWindow {
-  if (history.length === 0) {
-    return { points: [], startIdx: 0, endIdx: 0 };
-  }
-
-  const visibleCount = getVisiblePointCount(history.length, viewState.zoomLevel);
-
-  // Clamp pan offset
-  const maxPan = Math.max(history.length - visibleCount, 0);
-  const pan = Math.min(Math.max(viewState.panOffset, 0), maxPan);
-
-  const endIdx = history.length - pan;
-  const startIdx = Math.max(endIdx - visibleCount, 0);
-
-  return {
-    points: history.slice(startIdx, endIdx),
-    startIdx,
-    endIdx,
-  };
-}
-
 function normalizePoint(point: PricePoint): ProjectedChartPoint {
   const open = point.open ?? point.close;
   const high = point.high ?? point.close;
@@ -334,7 +305,6 @@ export function bucketOhlcSeries(
   return result;
 }
 
-const MS_HOUR = 3600_000;
 const MS_DAY = 86400_000;
 
 /**

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

@@ -157,10 +157,14 @@ export function createPixelBuffer(width: number, heightPixels: number): PixelBuf
 }
 
 function setPixel(buf: PixelBuffer, x: number, y: number, color: string, layer: number) {
-  if (x >= 0 && x < buf.width && y >= 0 && y < buf.height) {
-    const existing = buf.pixels[y]![x];
+  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) {
-      buf.pixels[y]![x] = { color, layer };
+      row[px] = { color, layer };
     }
   }
 }
@@ -178,17 +182,22 @@ export function drawLine(
   color: string,
   layer: number = LAYER_DATA,
 ) {
-  let dx = Math.abs(x1 - x0);
-  let dy = Math.abs(y1 - y0);
-  const sx = x0 < x1 ? 1 : -1;
-  const sy = y0 < y1 ? 1 : -1;
+  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 = x0;
-  let y = y0;
+  let x = startX;
+  let y = startY;
 
   while (true) {
     setPixel(buf, x, y, color, layer);
-    if (x === x1 && y === y1) break;
+    if (x === endX && y === endY) break;
     const e2 = 2 * err;
     if (e2 > -dy) {
       err -= dy;
@@ -492,11 +501,14 @@ export function drawGridLines(
   yPositions: number[],
   color: string,
 ) {
-  for (const y of yPositions) {
+  for (const rawY of yPositions) {
+    const y = Math.round(rawY);
     if (y < 0 || y >= buf.height) continue;
     // Dotted horizontal line — dot every 6th column (≈ every 3 terminal columns)
+    const row = buf.pixels[y];
+    if (!row) continue;
     for (let x = 0; x < buf.width; x++) {
-      if (x % 6 === 0 && !buf.pixels[y]![x]) {
+      if (x % 6 === 0 && !row[x]) {
         setPixel(buf, x, y, color, LAYER_GRID);
       }
     }
@@ -918,6 +930,76 @@ function writeAxisLabel(axis: string[], start: number, label: string) {
   }
 }
 
+export interface AxisLabelSegment {
+  text: string;
+  highlighted: boolean;
+}
+
+function formatCursorTimeAxisValue(
+  value: Date | string | number,
+  dates: Array<Date | string | number>,
+  width: number,
+): string {
+  const date = value instanceof Date ? value : new Date(value);
+  if (isNaN(date.getTime())) return "—";
+
+  const normalizedDates = dates.map((entry) => (entry instanceof Date ? entry : new Date(entry)));
+  const validDates = normalizedDates.filter((entry) => !isNaN(entry.getTime()));
+  if (validDates.length === 0) return formatDateShort(date);
+
+  const first = validDates[0]!;
+  const last = validDates[validDates.length - 1]!;
+  const spanMs = Math.max(last.getTime() - first.getTime(), 1);
+  const roughLabelCount = Math.max(Math.floor(normalizeCount(width, 0) / 10), 2);
+  const minGapMs = getMinPositiveGapMs(validDates);
+  const effectiveStepMs = Math.max(spanMs / Math.max(roughLabelCount - 1, 1), minGapMs || 0);
+  const unit = resolveAxisLabelUnit(effectiveStepMs);
+  const counterpart = isSameCalendarDay(first, last)
+    ? first
+    : isSameCalendarDay(date, first)
+      ? last
+      : first;
+
+  return formatTimeAxisBoundaryLabel(date, unit, counterpart);
+}
+
+export function buildCursorTimeAxisSegments({
+  timeLabels,
+  width,
+  cursorColumn,
+  cursorDate,
+  dates,
+}: {
+  timeLabels: string;
+  width: number;
+  cursorColumn: number | null;
+  cursorDate: Date | string | number | null;
+  dates: Array<Date | string | number>;
+}): AxisLabelSegment[] {
+  const axisWidth = normalizeCount(width, 0);
+  if (axisWidth <= 0) return [];
+
+  const base = timeLabels.padEnd(axisWidth).slice(0, axisWidth);
+  if (cursorColumn === null || cursorDate === null) {
+    return [{ text: base, highlighted: false }];
+  }
+
+  const label = formatCursorTimeAxisValue(cursorDate, dates, axisWidth);
+  if (!label) return [{ text: base, highlighted: false }];
+
+  const axis = base.split("");
+  const column = Math.max(Math.min(Math.round(cursorColumn), axisWidth - 1), 0);
+  const start = resolveAxisLabelStart(column, label, axisWidth);
+  const end = Math.min(start + label.length, axisWidth);
+  writeAxisLabel(axis, start, label);
+
+  return [
+    { text: axis.slice(0, start).join(""), highlighted: false },
+    { text: axis.slice(start, end).join(""), highlighted: true },
+    { text: axis.slice(end).join(""), highlighted: false },
+  ].filter((segment) => segment.text.length > 0);
+}
+
 export function buildTimeAxis(dates: Array<Date | string | number>, width: number): string {
   const axisWidth = normalizeCount(width, 0);
   if (dates.length === 0 || axisWidth <= 0) return "";

package/src/components/chart/chart-resolution.test.ts

@@ -3,10 +3,8 @@ import {
   CHART_RESOLUTION_STEP_MS,
   clampTimeRangeForResolution,
   getActiveRangePreset,
-  getBestSupportedResolutionForDateWindow,
   getBestSupportedResolutionForVisibleWindow,
   getPresetResolution,
-  intersectChartResolutions,
   isRangePresetSupported,
   normalizeChartResolution,
   sortChartResolutions,
@@ -30,14 +28,6 @@ describe("chart-resolution", () => {
     expect(getActiveRangePreset("1Y", "1d", 1, 2)).toBeNull();
   });
 
-  test("intersects and sorts provider capabilities", () => {
-    expect(intersectChartResolutions([
-      ["1d", "5m", "1wk", "nope"],
-      ["1wk", "1d", "1mo"],
-      ["1d", "1wk"],
-    ])).toEqual(["1d", "1wk"]);
-  });
-
   test("checks whether a range preset is supported by the visible capability set", () => {
     expect(isRangePresetSupported("1Y", ["1d", "1wk"])).toBe(true);
     expect(isRangePresetSupported("ALL", ["1d", "1wk"])).toBe(false);
@@ -57,32 +47,6 @@ describe("chart-resolution", () => {
     expect(sortChartResolutions(["1wk", "auto", "15m", "1d"])).toEqual(["auto", "15m", "1d", "1wk"]);
   });
 
-  test("picks the best supported resolution for the current visible date window", () => {
-    const support = [
-      { resolution: "1m", maxRange: "1D" },
-      { resolution: "5m", maxRange: "1W" },
-      { resolution: "15m", maxRange: "1M" },
-      { resolution: "1h", maxRange: "3M" },
-      { resolution: "1d", maxRange: "5Y" },
-      { resolution: "1wk", maxRange: "ALL" },
-    ] as const;
-
-    expect(getBestSupportedResolutionForDateWindow({
-      start: new Date("2026-01-08T10:00:00Z"),
-      end: new Date("2026-01-08T16:00:00Z"),
-    }, support)).toBe("1m");
-
-    expect(getBestSupportedResolutionForDateWindow({
-      start: new Date("2026-01-01T00:00:00Z"),
-      end: new Date("2026-01-08T00:00:00Z"),
-    }, support)).toBe("5m");
-
-    expect(getBestSupportedResolutionForDateWindow({
-      start: new Date("2021-01-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support)).toBe("1wk");
-  });
-
   test("picks a denser supported resolution as the visible window narrows", () => {
     const support = [
       { resolution: "1m", maxRange: "1D" },

package/src/components/chart/chart-resolution.ts

@@ -151,24 +151,6 @@ export function sortChartResolutions<T extends ChartResolution>(resolutions: rea
   ));
 }
 
-function normalizeManualChartResolutions(resolutions: readonly string[]): ManualChartResolution[] {
-  const seen = new Set<ManualChartResolution>();
-  for (const resolution of resolutions) {
-    if (isManualChartResolution(resolution)) {
-      seen.add(resolution);
-    }
-  }
-  return sortChartResolutions([...seen]);
-}
-
-export function intersectChartResolutions(resolutionSets: Array<readonly string[]>): ManualChartResolution[] {
-  if (resolutionSets.length === 0) return [];
-  const [first = new Set<ManualChartResolution>(), ...rest] = resolutionSets.map((set) => new Set(normalizeManualChartResolutions(set)));
-  return sortChartResolutions(
-    [...first].filter((resolution) => rest.every((set) => set.has(resolution))),
-  );
-}
-
 function sortChartResolutionSupport(support: readonly ChartResolutionSupport[]): ChartResolutionSupport[] {
   return [...support].sort((left, right) => (
     CHART_RESOLUTION_ORDER.indexOf(left.resolution) - CHART_RESOLUTION_ORDER.indexOf(right.resolution)
@@ -324,15 +306,6 @@ export function getBestSupportedResolutionForPreset(
   return supportedResolutions[supportedResolutions.length - 1] ?? null;
 }
 
-export function getBestSupportedResolutionForDateWindow(
-  window: { start: Date | null; end: Date | null } | null,
-  support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
-): ManualChartResolution | null {
-  if (!window?.start || !window.end) return null;
-  const range = getTimeRangeForDateWindow(window);
-  return getBestSupportedResolutionForPreset(range, support);
-}
-
 export function getTimeRangeForDateWindow(
   window: { start: Date | null; end: Date | null } | null,
 ): TimeRange {

package/src/components/chart/chart.test.ts

@@ -1,15 +1,16 @@
 import { describe, expect, test } from "bun:test";
 import {
   bucketOhlcSeries,
-  getVisibleWindow,
   projectChartData,
   resolveRenderMode,
   resolveStableOhlcProjectionOptions,
 } from "./chart-data";
 import { stepCursorTowards } from "./cursor-motion";
-import { buildChartScene, buildTimeAxis, formatAxisValue, formatCursorAxisValue, renderChart, resolveChartAxisWidth, resolveChartPalette } from "./chart-renderer";
+import { buildChartScene, buildCursorTimeAxisSegments, buildTimeAxis, formatAxisValue, formatCursorAxisValue, renderChart, resolveChartAxisWidth, resolveChartPalette } from "./chart-renderer";
+import { buildCursorTimeAxisOverlay } from "./time-axis-label";
+import { buildCursorPriceAxisOverlay } from "./price-axis-labels";
 import type { PricePoint } from "../../types/financials";
-import type { ChartRenderMode, ChartViewState } from "./chart-types";
+import type { ChartRenderMode } from "./chart-types";
 
 const aggregationFixture: PricePoint[] = [
   { date: new Date("2024-01-02"), close: 10, volume: 100 },
@@ -225,48 +226,6 @@ describe("resolveRenderMode", () => {
   });
 });
 
-describe("getVisibleWindow", () => {
-  test("shows the full selected range at default zoom and lets the renderer downsample it", () => {
-    const history = buildDenseHistory(252);
-    const viewState: ChartViewState = {
-      presetRange: "1Y",
-      bufferRange: "1Y",
-      activePreset: "1Y",
-      resolution: "auto",
-      panOffset: 0,
-      zoomLevel: 1,
-      cursorX: null,
-      cursorY: null,
-    };
-
-    const window = getVisibleWindow(history, viewState, 80);
-
-    expect(window.points).toHaveLength(history.length);
-    expect(window.points[0]?.date.toISOString()).toBe(history[0]!.date.toISOString());
-    expect(window.points.at(-1)?.date.toISOString()).toBe(history.at(-1)!.date.toISOString());
-  });
-
-  test("zooms into the selected range instead of pinning the default view to chart width", () => {
-    const history = buildDenseHistory(252);
-    const viewState: ChartViewState = {
-      presetRange: "1Y",
-      bufferRange: "1Y",
-      activePreset: "1Y",
-      resolution: "auto",
-      panOffset: 0,
-      zoomLevel: 2,
-      cursorX: null,
-      cursorY: null,
-    };
-
-    const window = getVisibleWindow(history, viewState, 80);
-
-    expect(window.points).toHaveLength(126);
-    expect(window.points[0]?.date.toISOString()).toBe(history[126]!.date.toISOString());
-    expect(window.points.at(-1)?.date.toISOString()).toBe(history.at(-1)!.date.toISOString());
-  });
-});
-
 describe("renderChart", () => {
   test("sizes the y-axis to the visible label width instead of a fixed gutter", () => {
     expect(resolveChartAxisWidth(["$18", "$17", "$16", "$14"], 4, 10)).toBe(4);
@@ -457,6 +416,62 @@ describe("renderChart", () => {
     );
   });
 
+  test("overlays the cursor date on the x-axis without changing its width", () => {
+    const dates = Array.from({ length: 13 }, (_, index) => new Date(2026, 0, 5, 9, 30 + index * 30));
+    const width = 72;
+    const segments = buildCursorTimeAxisSegments({
+      timeLabels: buildTimeAxis(dates, width),
+      width,
+      cursorColumn: 36,
+      cursorDate: dates[6]!,
+      dates,
+    });
+
+    expect(segments.map((segment) => segment.text).join("")).toHaveLength(width);
+    expect(segments.find((segment) => segment.highlighted)?.text).toBe("12:30");
+  });
+
+  test("positions desktop cursor x-axis overlay from exact pixels", () => {
+    const dates = Array.from({ length: 13 }, (_, index) => new Date(2026, 0, 5, 9, 30 + index * 30));
+    const width = 72;
+    const cursorPixelX = 291.5;
+    const cellWidthPx = 8;
+    const segments = buildCursorTimeAxisSegments({
+      timeLabels: buildTimeAxis(dates, width),
+      width,
+      cursorColumn: 36,
+      cursorDate: dates[6]!,
+      dates,
+    });
+    const overlay = buildCursorTimeAxisOverlay({
+      segments,
+      width,
+      cursorPixelX,
+      cellWidthPx,
+    });
+
+    expect(overlay.label).toBe("12:30");
+    expect(overlay.baseText).toHaveLength(width);
+    expect(overlay.leftPercent).toBeCloseTo((cursorPixelX / (width * cellWidthPx - 1)) * 100, 5);
+  });
+
+  test("positions desktop cursor y-axis overlay from exact pixels", () => {
+    const height = 8;
+    const cellHeightPx = 18;
+    const cursorPixelY = 45.25;
+    const overlay = buildCursorPriceAxisOverlay({
+      axisWidth: 7,
+      axisSectionWidth: 8,
+      height,
+      cursorPixelY,
+      cursorLabel: "$214.03",
+      cellHeightPx,
+    });
+
+    expect(overlay.labelText).toBe("$214.03 ");
+    expect(overlay.topPercent).toBeCloseTo((cursorPixelY / (height * cellHeightPx - 1)) * 100, 5);
+  });
+
   test("shows second precision when the visible window reaches second-level data", () => {
     const dates = Array.from({ length: 6 }, (_, index) => new Date(2026, 0, 5, 9, 30, index * 10));
 

package/src/components/chart/comparison-chart-data.test.ts

@@ -25,10 +25,9 @@ describe("projectComparisonChartData", () => {
     const window = getVisibleComparisonWindow([
       makeSeries("AAPL", "USD", closes),
     ], {
-      timeRange: "ALL",
       panOffset: 0,
       zoomLevel: 1,
-    }, 40);
+    });
 
     expect(window.dates).toHaveLength(120);
     expect(window.dates[0]?.toISOString()).toBe("2024-01-01T00:00:00.000Z");
@@ -48,7 +47,6 @@ describe("projectComparisonChartData", () => {
         ["2024-01-05", 22],
       ]),
     ], 8, {
-      timeRange: "ALL",
       panOffset: 0,
       zoomLevel: 1,
       renderMode: "line",
@@ -72,7 +70,6 @@ describe("projectComparisonChartData", () => {
         ["2024-01-04", 60],
       ]),
     ], 8, {
-      timeRange: "ALL",
       panOffset: 0,
       zoomLevel: 1,
       renderMode: "line",
@@ -94,7 +91,6 @@ describe("projectComparisonChartData", () => {
         ["2024-01-03", 2100],
       ]),
     ], 8, {
-      timeRange: "ALL",
       panOffset: 0,
       zoomLevel: 1,
       renderMode: "line",

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

@@ -83,9 +83,7 @@ function getUniqueSortedDates(series: ComparisonChartSeries[]): Date[] {
 
 export function getMaxComparisonPanOffset(
   series: ComparisonChartSeries[],
-  _timeRange: TimeRange,
   zoomLevel: number,
-  chartWidth: number,
 ): number {
   const dates = getUniqueSortedDates(series);
   const visibleCount = getVisiblePointCount(dates.length, zoomLevel);
@@ -95,7 +93,6 @@ export function getMaxComparisonPanOffset(
 export function getVisibleComparisonWindow(
   series: ComparisonChartSeries[],
   viewState: Pick<ComparisonChartViewState, "panOffset" | "zoomLevel">,
-  chartWidth: number,
 ): ComparisonVisibleWindow {
   const dates = getUniqueSortedDates(series);
 
@@ -214,7 +211,7 @@ export function projectComparisonChartData(
   requestedAxisMode: ChartAxisMode,
 ): ComparisonChartProjection {
   const normalizedSeries = series.map((entry) => ({ ...entry, points: normalizeSeriesPoints(entry.points) }));
-  const window = getVisibleComparisonWindow(normalizedSeries, viewState, chartWidth);
+  const window = getVisibleComparisonWindow(normalizedSeries, viewState);
   const axisResolution = resolveComparisonAxisMode(requestedAxisMode, normalizedSeries, window.dates);
   const requestedMode = normalizeComparisonMode(viewState.renderMode);
   if (window.dates.length === 0) {

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

@@ -119,6 +119,32 @@ describe("renderComparisonChart", () => {
     expect(result.activeDate?.toISOString()).toBe("2024-01-03T00:00:00.000Z");
   });
 
+  test("renders when precise desktop layout passes a fractional chart height", () => {
+    const projection = projectComparisonChartData([
+      makeSeries("AAPL", "#00ff00", [10, 12, 11, 13]),
+    ], 12, {
+      panOffset: 0,
+      zoomLevel: 1,
+      renderMode: "area",
+    }, "percent");
+
+    const result = renderComparisonChart(projection, {
+      width: 12,
+      height: 6.5,
+      cursorX: null,
+      cursorY: null,
+      selectedSymbol: "AAPL",
+      colors: {
+        bgColor: "#000000",
+        gridColor: "#333333",
+        crosshairColor: "#ffffff",
+      },
+    });
+
+    expect(result.lines.length).toBeGreaterThan(0);
+    expect(textLines(result).some((line) => /[^\s]/.test(line))).toBe(true);
+  });
+
   test("keeps terminal comparison chart cells transparent", () => {
     const projection = projectComparisonChartData([
       makeSeries("AAPL", "#00ff00", [10, 12, 11, 13]),

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

@@ -80,6 +80,11 @@ 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));
@@ -260,15 +265,17 @@ export function buildComparisonChartScene(
 
   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, opts.width, opts.cursorX);
+  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 = opts.height;
+  const chartRows = height;
   const range = max - min || 1;
   const cursorX = opts.cursorX === null
     ? null
-    : clamp(opts.cursorX, 0, Math.max(opts.width - 1, 0));
+    : clamp(opts.cursorX, 0, Math.max(width - 1, 0));
   const fallbackValue = selectedPoint?.value ?? selectedSeries?.latestValue ?? min;
   const cursorY = cursorX === null
     ? null
@@ -282,7 +289,7 @@ export function buildComparisonChartScene(
   const cursorColumn = cursorX === null ? null : Math.round(cursorX);
   const cursorDotX = cursorX === null
     ? null
-    : Math.round((cursorX / Math.max(opts.width - 1, 1)) * Math.max(opts.width * 2 - 1, 0));
+    : 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
@@ -291,8 +298,8 @@ export function buildComparisonChartScene(
   return {
     dates: projection.dates,
     series: projection.series,
-    width: opts.width,
-    height: opts.height,
+    width,
+    height,
     chartRows,
     mode: projection.effectiveMode,
     axisMode: projection.effectiveAxisMode,