gloomberb 0.4.1 → 0.5.0

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

@@ -2,8 +2,14 @@ import { describe, expect, test } from "bun:test";
 import type { BoxRenderable, CliRenderer } from "@opentui/core";
 import {
   getLocalPlotPointer,
+  computeProjectedIndicatorOverlays,
   projectCellCursorToLocalPixels,
+  resolveAutoDisplayState,
+  resolveAutoZoomWindow,
   resolveAdjacentSelectionCursorX,
+  resolveChartKeyboardKey,
+  resolveIndicatorBufferRange,
+  resolveVisibleChartDateWindow,
   resolveSelectionDisplayCursorState,
 } from "./stock-chart";
 import { getPointTerminalColumn } from "./chart-renderer";
@@ -21,6 +27,13 @@ const renderable = {
   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({
@@ -105,3 +118,229 @@ describe("stock chart pointer helpers", () => {
     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 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("derives the visible label window from the actual visible chart points", () => {
+    const visibleWindow = resolveVisibleChartDateWindow([
+      { date: new Date("2026-01-03T00:00:00Z") },
+      { date: new Date("2026-01-06T00:00:00Z") },
+    ], {
+      start: new Date("2026-01-01T00:00:00Z"),
+      end: new Date("2026-01-08T00:00:00Z"),
+    });
+
+    expect(visibleWindow).toEqual({
+      start: new Date("2026-01-03T00:00:00Z"),
+      end: new Date("2026-01-06T00:00:00Z"),
+    });
+  });
+
+  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-08T00: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-06T00: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-27T00: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-09T08: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);
+  });
+
+  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");
+  });
+});