gloomberb 0.7.5 → 0.8.0

package/src/components/chart/stock-chart/index.test.ts

@@ -0,0 +1,500 @@
+import { describe, expect, test } from "bun:test";
+import type { BoxRenderable, CliRenderer } from "@opentui/core";
+import {
+  computeProjectedIndicatorOverlays,
+  isAutoWindowOverridePending,
+  resolveAutoDisplayState,
+  resolveAutoPlanningWindow,
+  resolveAutoZoomWindow,
+  resolveAdjacentSelectionCursorX,
+  resolveChartKeyboardKey,
+  resolveIndicatorBufferRange,
+} from "./index";
+import { colors, getChartIndicatorColor } from "../../../theme/colors";
+import {
+  getLocalPlotPointer,
+  projectCellCursorToLocalPixels,
+  resolveSelectionDisplayCursorState,
+} from "../core/pointer";
+import { getPointTerminalColumn } from "../core/renderer";
+import { CHART_ZOOM_STEP_FACTOR, getVisiblePointCount, RIGHT_EDGE_ANCHOR_RATIO } from "../core/viewport";
+import { applyZoomStepAroundAnchor } from "./viewport";
+
+const renderer = {
+  resolution: { width: 1200, height: 800 },
+  terminalWidth: 120,
+  terminalHeight: 40,
+} as Pick<CliRenderer, "resolution" | "terminalWidth" | "terminalHeight">;
+
+const renderable = {
+  x: 10,
+  y: 5,
+  width: 40,
+  height: 12,
+} as BoxRenderable;
+
+function makeDailyHistory(startDay: number, length: number) {
+  return Array.from({ length }, (_, index) => ({
+    date: new Date(Date.UTC(2026, 0, startDay + index)),
+    close: 100 + index,
+  }));
+}
+
+describe("stock chart pointer helpers", () => {
+  test("returns both cell and pixel coordinates when pixel mouse is available", () => {
+    const pointer = getLocalPlotPointer({
+      x: 24,
+      y: 10,
+      pixelX: 245,
+      pixelY: 205,
+      modifiers: { shift: false, alt: false, ctrl: false },
+    }, renderable, renderer);
+
+    expect(pointer).not.toBeNull();
+    expect(pointer).toMatchObject({
+      hasPixelPrecision: true,
+      pixelX: 145,
+      pixelY: 105,
+    });
+    expect(pointer!.cellX).toBeCloseTo(14.17, 2);
+    expect(pointer!.cellY).toBeCloseTo(4.83, 2);
+  });
+
+  test("returns null pixel coordinates when only cell mouse data exists", () => {
+    const pointer = getLocalPlotPointer({
+      x: 24,
+      y: 10,
+      modifiers: { shift: false, alt: false, ctrl: false },
+    }, renderable, renderer);
+
+    expect(pointer).toEqual({
+      cellX: 14,
+      cellY: 5,
+      pixelX: null,
+      pixelY: null,
+      hasPixelPrecision: false,
+    });
+  });
+
+  test("can derive local pixels from cell coordinates for non-pixel fallbacks", () => {
+    const pixels = projectCellCursorToLocalPixels(14, 5, renderable, renderer);
+
+    expect(pixels).not.toBeNull();
+    expect(pixels!.pixelX).toBeCloseTo(143.23, 2);
+    expect(pixels!.pixelY).toBeCloseTo(108.64, 2);
+  });
+
+  test("keeps a visible display cursor for keyboard selection when only cursorX is explicit", () => {
+    const cursor = resolveSelectionDisplayCursorState(14, null, 14, 5, renderable, renderer);
+
+    expect(cursor).toMatchObject({
+      cellX: 14,
+      cellY: 5,
+    });
+    expect(cursor.pixelX).toBeCloseTo(143.23, 2);
+    expect(cursor.pixelY).toBeCloseTo(108.64, 2);
+  });
+
+  test("prefers the explicit selection cursorY over the derived fallback", () => {
+    const cursor = resolveSelectionDisplayCursorState(14, 3, 17, 5, renderable, renderer);
+
+    expect(cursor).toMatchObject({
+      cellX: 14,
+      cellY: 3,
+    });
+    expect(cursor.pixelY).toBeCloseTo(65.18, 2);
+  });
+
+  test("can snap keyboard display cursor x to the active chart point", () => {
+    const cursor = resolveSelectionDisplayCursorState(14, null, 17, 5, renderable, renderer);
+
+    expect(cursor).toMatchObject({
+      cellX: 17,
+      cellY: 5,
+    });
+  });
+
+  test("moves keyboard selection between snapped chart points", () => {
+    const width = 40;
+    const pointCount = 20;
+    const rightmost = getPointTerminalColumn(pointCount - 1, pointCount, width, "candles");
+    const previous = getPointTerminalColumn(pointCount - 2, pointCount, width, "candles");
+
+    expect(resolveAdjacentSelectionCursorX(width - 1, -1, pointCount, width, "candles")).toBe(previous);
+    expect(resolveAdjacentSelectionCursorX(previous, 1, pointCount, width, "candles")).toBe(rightmost);
+  });
+});
+
+describe("stock chart keyboard helpers", () => {
+  test("normalizes terminal zoom key variants", () => {
+    expect(resolveChartKeyboardKey({ sequence: "+" })).toBe("zoom-in");
+    expect(resolveChartKeyboardKey({ sequence: "=" })).toBe("zoom-in");
+    expect(resolveChartKeyboardKey({ name: "plus" })).toBe("zoom-in");
+    expect(resolveChartKeyboardKey({ sequence: "-" })).toBe("zoom-out");
+    expect(resolveChartKeyboardKey({ name: "minus" })).toBe("zoom-out");
+    expect(resolveChartKeyboardKey({ name: "A" })).toBe("a");
+  });
+});
+
+describe("stock chart viewport helpers", () => {
+  test("zooms from the displayed window when the render cache lags viewport state", () => {
+    const history = makeDailyHistory(1, 90);
+    const displayedDateWindow = {
+      start: history[30]!.date,
+      end: history[89]!.date,
+    };
+    const stalePendingView = {
+      presetRange: "3M" as const,
+      bufferRange: "6M" as const,
+      activePreset: null,
+      dateWindow: null,
+      panOffset: 0,
+      zoomLevel: 18,
+      cursorX: null,
+      cursorY: null,
+      renderMode: "area" as const,
+    };
+
+    const nextView = applyZoomStepAroundAnchor(
+      stalePendingView,
+      CHART_ZOOM_STEP_FACTOR,
+      RIGHT_EDGE_ANCHOR_RATIO,
+      history.map((point) => point.date),
+      displayedDateWindow,
+    );
+
+    expect(nextView.zoomLevel).toBeCloseTo(1.8);
+    expect(nextView.panOffset).toBe(0);
+    expect(getVisiblePointCount(history.length, nextView.zoomLevel)).toBe(50);
+  });
+
+  test("keeps one zoom step modest on multi-year windows", () => {
+    const dates = Array.from(
+      { length: 2094 },
+      (_, index) => new Date(Date.UTC(2020, 8, 1 + index)),
+    );
+    const displayedDateWindow = {
+      start: dates[0]!,
+      end: dates[dates.length - 1]!,
+    };
+    const view = {
+      presetRange: "5Y" as const,
+      bufferRange: "ALL" as const,
+      activePreset: null,
+      dateWindow: displayedDateWindow,
+      panOffset: 0,
+      zoomLevel: 1,
+      cursorX: null,
+      cursorY: null,
+      renderMode: "area" as const,
+    };
+
+    const nextView = applyZoomStepAroundAnchor(
+      view,
+      CHART_ZOOM_STEP_FACTOR,
+      RIGHT_EDGE_ANCHOR_RATIO,
+      dates,
+      displayedDateWindow,
+      displayedDateWindow,
+    );
+
+    expect(nextView.dateWindow?.end.getTime()).toBe(displayedDateWindow.end.getTime());
+    expect(nextView.dateWindow?.start.getTime()).toBeLessThan(new Date("2021-09-01T00:00:00Z").getTime());
+  });
+
+  test("keeps manual zoom windows at least one rendered bar wide", () => {
+    const history = makeDailyHistory(1, 90);
+    const dates = history.map((point) => point.date);
+    const displayedDateWindow = {
+      start: history[89]!.date,
+      end: history[89]!.date,
+    };
+    const stalePendingView = {
+      presetRange: "3M" as const,
+      bufferRange: "6M" as const,
+      activePreset: null,
+      dateWindow: displayedDateWindow,
+      panOffset: 0,
+      zoomLevel: 45,
+      cursorX: null,
+      cursorY: null,
+      renderMode: "area" as const,
+    };
+
+    const nextView = applyZoomStepAroundAnchor(
+      stalePendingView,
+      1 / CHART_ZOOM_STEP_FACTOR,
+      RIGHT_EDGE_ANCHOR_RATIO,
+      dates,
+      displayedDateWindow,
+      { start: history[0]!.date, end: history[89]!.date },
+      24 * 60 * 60_000,
+    );
+
+    expect(nextView.dateWindow?.end.getTime()).toBe(history[89]!.date.getTime());
+    expect(nextView.dateWindow?.start.getTime()).toBe(history[88]!.date.getTime());
+    expect(getVisiblePointCount(history.length, nextView.zoomLevel)).toBe(2);
+  });
+});
+
+describe("stock chart auto helpers", () => {
+  test("keeps planned auto data and the visible window in sync once fresh data is ready", () => {
+    const renderedAutoView = {
+      window: {
+        start: new Date("2026-01-01T00:00:00Z"),
+        end: new Date("2026-01-08T00:00:00Z"),
+      },
+      resolution: "1d" as const,
+      data: [{
+        date: new Date("2026-01-02T00:00:00Z"),
+        close: 101,
+      }],
+    };
+    const plannedBodyState = {
+      data: [{
+        date: new Date("2026-01-09T00:00:00Z"),
+        close: 102,
+      }],
+      blocking: false,
+      updating: false,
+      emptyMessage: null,
+      errorMessage: null,
+    };
+    const plannedWindow = {
+      start: new Date("2026-01-09T00:00:00Z"),
+      end: new Date("2026-01-10T00:00:00Z"),
+    };
+
+    const nextState = resolveAutoDisplayState({
+      shouldUseRenderedAutoView: false,
+      renderedAutoView,
+      isRenderedAutoViewUpdating: false,
+      plannedRenderBodyState: plannedBodyState,
+      plannedResolvedManualResolution: "1h",
+      plannedDateWindow: plannedWindow,
+    });
+
+    expect(nextState.bodyState).toBe(plannedBodyState);
+    expect(nextState.resolution).toBe("1h");
+    expect(nextState.window).toEqual(plannedWindow);
+  });
+
+  test("keeps showing the committed auto view while a replacement is still pending", () => {
+    const renderedAutoView = {
+      window: {
+        start: new Date("2026-01-01T00:00:00Z"),
+        end: new Date("2026-01-08T00:00:00Z"),
+      },
+      resolution: "1d" as const,
+      data: [{
+        date: new Date("2026-01-02T00:00:00Z"),
+        close: 101,
+      }],
+    };
+    const plannedBodyState = {
+      data: null,
+      blocking: true,
+      updating: false,
+      emptyMessage: null,
+      errorMessage: null,
+    };
+
+    const nextState = resolveAutoDisplayState({
+      shouldUseRenderedAutoView: true,
+      renderedAutoView,
+      isRenderedAutoViewUpdating: true,
+      plannedRenderBodyState: plannedBodyState,
+      plannedResolvedManualResolution: "1h",
+      plannedDateWindow: {
+        start: new Date("2026-01-09T00:00:00Z"),
+        end: new Date("2026-01-10T00:00:00Z"),
+      },
+    });
+
+    expect(nextState.bodyState).toEqual({
+      data: renderedAutoView.data,
+      blocking: false,
+      updating: true,
+      emptyMessage: null,
+      errorMessage: null,
+    });
+    expect(nextState.resolution).toBe("1d");
+    expect(nextState.window).toEqual(renderedAutoView.window);
+  });
+
+  test("plans the auto view from the latest canonical window when no custom window is active", () => {
+    const renderedAutoView = {
+      window: {
+        start: new Date("2026-01-01T00:00:00Z"),
+        end: new Date("2026-01-08T00:00:00Z"),
+      },
+    };
+    const canonicalAutoWindow = {
+      start: new Date("2026-01-02T00:00:00Z"),
+      end: new Date("2026-01-09T00:00:00Z"),
+    };
+
+    expect(resolveAutoPlanningWindow({
+      pendingAutoWindowOverride: null,
+      renderedAutoView,
+      canonicalAutoWindow,
+    })).toBe(canonicalAutoWindow);
+  });
+
+  test("keeps a custom auto window from snapping to the latest data", () => {
+    const customWindow = {
+      start: new Date("2026-01-03T00:00:00Z"),
+      end: new Date("2026-01-04T00:00:00Z"),
+    };
+    const canonicalAutoWindow = {
+      start: new Date("2026-01-02T00:00:00Z"),
+      end: new Date("2026-01-09T00:00:00Z"),
+    };
+
+    expect(resolveAutoPlanningWindow({
+      pendingAutoWindowOverride: customWindow,
+      renderedAutoView: null,
+      canonicalAutoWindow,
+    })).toBe(customWindow);
+  });
+
+  test("keeps a committed custom auto window from looking pending", () => {
+    const customWindow = {
+      start: new Date("2026-01-03T00:00:00Z"),
+      end: new Date("2026-01-04T00:00:00Z"),
+    };
+
+    expect(isAutoWindowOverridePending(customWindow, {
+      window: customWindow,
+      resolution: "1d" as const,
+      data: [],
+    })).toBe(false);
+    expect(isAutoWindowOverridePending(customWindow, {
+      window: {
+        start: new Date("2026-01-02T00:00:00Z"),
+        end: new Date("2026-01-09T00:00:00Z"),
+      },
+      resolution: "1d" as const,
+      data: [],
+    })).toBe(true);
+  });
+
+  test("zooms in by at least one visible point on every auto step when more detail is available", () => {
+    const history = makeDailyHistory(1, 10);
+
+    const nextWindow = resolveAutoZoomWindow({
+      historyPoints: history,
+      boundsDates: history.map((point) => point.date),
+      currentWindow: {
+        start: new Date("2026-01-06T00:00:00Z"),
+        end: new Date("2026-01-10T00:00:00Z"),
+      },
+      direction: "in",
+      anchorRatio: 1,
+    });
+
+    expect(nextWindow).toEqual({
+      start: new Date("2026-01-07T00:00:00Z"),
+      end: new Date("2026-01-10T00:00:00Z"),
+    });
+  });
+
+  test("zooms out into broader bounds data even when the current rendered history is already fully visible", () => {
+    const history = makeDailyHistory(8, 3);
+    const boundsDates = makeDailyHistory(1, 10).map((point) => point.date);
+
+    const nextWindow = resolveAutoZoomWindow({
+      historyPoints: history,
+      boundsDates,
+      currentWindow: {
+        start: new Date("2026-01-08T00:00:00Z"),
+        end: new Date("2026-01-10T00:00:00Z"),
+      },
+      direction: "out",
+      anchorRatio: 1,
+    });
+
+    expect(nextWindow).toEqual({
+      start: new Date("2026-01-07T00:00:00Z"),
+      end: new Date("2026-01-10T00:00:00Z"),
+    });
+  });
+
+  test("zooms out beyond the currently loaded bounds so auto can request a wider buffer", () => {
+    const history = makeDailyHistory(1, 10);
+    const boundsDates = history.map((point) => point.date);
+
+    const nextWindow = resolveAutoZoomWindow({
+      historyPoints: history,
+      boundsDates,
+      currentWindow: {
+        start: new Date("2026-01-01T00:00:00Z"),
+        end: new Date("2026-01-10T00:00:00Z"),
+      },
+      direction: "out",
+      anchorRatio: 1,
+    });
+
+    expect(nextWindow?.start?.getTime()).toBeLessThan(boundsDates[0]!.getTime());
+    expect(nextWindow).toEqual({
+      start: new Date("2025-12-30T00:00:00.000Z"),
+      end: new Date("2026-01-10T00:00:00.000Z"),
+    });
+  });
+
+  test("keeps shrinking the auto time span once only two visible points remain", () => {
+    const history = makeDailyHistory(1, 10);
+
+    const nextWindow = resolveAutoZoomWindow({
+      historyPoints: history,
+      boundsDates: history.map((point) => point.date),
+      currentWindow: {
+        start: new Date("2026-01-09T00:00:00Z"),
+        end: new Date("2026-01-10T00:00:00Z"),
+      },
+      direction: "in",
+      anchorRatio: 1,
+    });
+
+    expect(nextWindow).toEqual({
+      start: new Date("2026-01-09T04:00:00Z"),
+      end: new Date("2026-01-10T00:00:00Z"),
+    });
+  });
+});
+
+describe("stock chart indicator helpers", () => {
+  test("computes indicators from warmup history and reindexes them onto the visible projection", () => {
+    const source = makeDailyHistory(1, 30);
+    const projected = source.slice(20).map((point) => ({
+      date: point.date,
+      open: point.close,
+      high: point.close,
+      low: point.close,
+      close: point.close,
+      volume: 0,
+    }));
+
+    const overlays = computeProjectedIndicatorOverlays(source, projected, {
+      sma: [20],
+      bollinger: { period: 20, stdDev: 2 },
+    });
+
+    expect(overlays.smaLines[0]?.points).toHaveLength(projected.length);
+    expect(overlays.smaLines[0]?.points[0]?.index).toBe(0);
+    expect(overlays.smaLines[0]?.points.at(-1)?.index).toBe(projected.length - 1);
+    expect(overlays.bollinger?.upper[0]?.index).toBe(0);
+    expect(overlays.smaLines[0]?.color).toBe(getChartIndicatorColor(0));
+    expect(overlays.bollinger?.color).toBe(getChartIndicatorColor(1));
+    expect(new Set([overlays.smaLines[0]?.color, overlays.bollinger?.color]).size).toBe(2);
+    expect([colors.positive, colors.negative]).not.toContain(overlays.smaLines[0]?.color);
+    expect([colors.positive, colors.negative]).not.toContain(overlays.bollinger?.color);
+  });
+
+  test("widens the data buffer enough for selected indicator warmup periods", () => {
+    expect(resolveIndicatorBufferRange("3M", "3M", { sma: [20] })).toBe("6M");
+    expect(resolveIndicatorBufferRange("3M", "6M", { sma: [20] })).toBe("6M");
+    expect(resolveIndicatorBufferRange("3M", "3M", { sma: [200] })).toBe("5Y");
+    expect(resolveIndicatorBufferRange("3M", "3M", {})).toBe("3M");
+  });
+});

package/src/components/chart/stock-chart/index.tsx

@@ -0,0 +1,29 @@
+import { usePaneTicker } from "../../../state/app/context";
+import { ResolvedStockChart } from "./resolved";
+import type { StockChartProps } from "./types";
+
+export type {
+  StockChartProps,
+} from "./types";
+
+export { ResolvedStockChart } from "./resolved";
+
+export {
+  isAutoWindowOverridePending,
+  resolveAutoDisplayState,
+  resolveAutoPlanningWindow,
+  resolveAutoZoomWindow,
+} from "./auto";
+export {
+  computeProjectedIndicatorOverlays,
+  resolveIndicatorBufferRange,
+} from "./indicators";
+export {
+  resolveAdjacentSelectionCursorX,
+  resolveChartKeyboardKey,
+} from "./keyboard";
+
+export function StockChart(props: StockChartProps) {
+  const { ticker, financials } = usePaneTicker();
+  return <ResolvedStockChart {...props} ticker={ticker} financials={financials} />;
+}