gloomberb 0.4.1 → 0.5.0

package/src/plugins/builtin/comparison-chart.test.tsx

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { act } from "react";
-import { testRender } from "@opentui/react/test-utils";
+import { act, type ReactElement } from "react";
+import { createTestRenderer } from "@opentui/core/testing";
+import { createRoot } from "@opentui/react";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
 import {
   AppContext,
@@ -23,8 +24,10 @@ import {
 
 const TEST_PANE_ID = "comparison-chart:test";
 
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
+let root: ReturnType<typeof createRoot> | undefined;
 let sharedCoordinator: MarketDataCoordinator | null = null;
+const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
 
 function makeTicker(symbol: string, currency: string): TickerRecord {
   return {
@@ -96,8 +99,16 @@ function createProvider(historyBySymbol: Record<string, number[]>, currencyBySym
 
 function createRegistrySpy(spy: { selected: string[]; focused: string[] }): PluginRegistry {
   return {
+    navigateTickerFn: (symbol: string) => {
+      spy.selected.push(symbol);
+      spy.focused.push("ticker-detail");
+    },
     selectTickerFn: (symbol: string) => { spy.selected.push(symbol); },
     focusPaneFn: (paneId: string) => { spy.focused.push(paneId); },
+    navigateTickerFn: (symbol: string) => {
+      spy.selected.push(symbol);
+      spy.focused.push("ticker-detail");
+    },
   } as unknown as PluginRegistry;
 }
 
@@ -132,7 +143,7 @@ function createComparisonHarness(
     focused: boolean;
     width: number;
     height: number;
-  }) => JSX.Element;
+  }) => ReactElement;
 
   return (
     <AppContext value={{ state, dispatch: () => {} }}>
@@ -153,12 +164,47 @@ async function flushFrames(count = 3) {
   for (let index = 0; index < count; index += 1) {
     await act(async () => {
       await Promise.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 0));
       await testSetup!.renderOnce();
+      await Promise.resolve();
     });
   }
 }
 
-afterEach(() => {
+async function mountComparisonHarness(
+  settings: Record<string, unknown>,
+  tickers: TickerRecord[],
+  financials: Array<[string, TickerFinancials]>,
+) {
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+  testSetup = await createTestRenderer({ width: 120, height: 20 });
+  root = createRoot(testSetup.renderer);
+  await act(async () => {
+    root!.render(
+      createComparisonHarness(settings, tickers, financials),
+    );
+    await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await testSetup!.renderOnce();
+  });
+}
+
+async function pressComparisonInput(action: () => void) {
+  await act(async () => {
+    action();
+    await testSetup!.renderOnce();
+    await Promise.resolve();
+  });
+}
+
+afterEach(async () => {
+  if (root) {
+    await act(async () => {
+      root!.unmount();
+      await Promise.resolve();
+    });
+    root = undefined;
+  }
   if (testSetup) {
     testSetup.renderer.destroy();
     testSetup = undefined;
@@ -172,7 +218,7 @@ afterEach(() => {
 describe("comparisonChartPlugin", () => {
   test("creates a configured comparison pane with percent as the default axis", () => {
     const template = comparisonChartPlugin.paneTemplates?.find((entry) => entry.id === COMPARISON_CHART_TEMPLATE_ID);
-    const paneDef = comparisonChartPlugin.panes.find((entry) => entry.id === COMPARISON_CHART_PANE_ID);
+    const paneDef = comparisonChartPlugin.panes?.find((entry) => entry.id === COMPARISON_CHART_PANE_ID);
 
     expect(template).toBeDefined();
     expect(paneDef?.defaultMode).toBe("floating");
@@ -223,30 +269,32 @@ describe("comparisonChartPlugin", () => {
     setSharedMarketDataCoordinator(sharedCoordinator);
     setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
 
-    testSetup = await testRender(
-      createComparisonHarness({
-        axisMode: "price",
-        symbols: ["AAPL", "7203"],
-        symbolsText: "AAPL, 7203",
-      }, [
-        makeTicker("AAPL", "USD"),
-        makeTicker("7203", "JPY"),
-      ], [
-        ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104, 106])],
-        ["7203", makeFinancials("7203", "JPY", [2000, 2020, 2050, 2100])],
-      ]),
-      { width: 120, height: 20 },
-    );
+    await mountComparisonHarness({
+      axisMode: "price",
+      symbols: ["AAPL", "7203"],
+      symbolsText: "AAPL, 7203",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("7203", "JPY"),
+    ], [
+      ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104, 106])],
+      ["7203", makeFinancials("7203", "JPY", [2000, 2020, 2050, 2100])],
+    ]);
 
     await flushFrames();
 
-    const frame = testSetup.captureCharFrame();
+    const frame = testSetup!.captureCharFrame();
     expect(frame).toContain("Mixed currencies detected; showing percent change.");
     expect(frame).toContain("1:1D");
     expect(frame).toContain("2:1W");
     expect(frame).toContain("1D");
     expect(frame).toContain("view:");
-    expect(frame).toContain("arrows legend");
+    expect(frame).toContain("[m]ode");
+    expect(frame).toContain("[r]es");
+    expect(frame).toContain("[up/down]legend");
+    expect(frame).not.toContain("arrows legend");
+    expect(frame).not.toContain("wheel pan");
+    expect(frame).not.toContain("wheel zoom");
     expect(frame).not.toContain("side by side");
   });
 
@@ -263,24 +311,21 @@ describe("comparisonChartPlugin", () => {
     setSharedMarketDataCoordinator(sharedCoordinator);
     setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
 
-    testSetup = await testRender(
-      createComparisonHarness({
-        axisMode: "price",
-        symbols: ["AAPL", "MSFT"],
-        symbolsText: "AAPL, MSFT",
-      }, [
-        makeTicker("AAPL", "USD"),
-        makeTicker("MSFT", "USD"),
-      ], [
-        ["AAPL", makeFinancials("AAPL", "USD", [])],
-        ["MSFT", makeFinancials("MSFT", "USD", [])],
-      ]),
-      { width: 120, height: 20 },
-    );
+    await mountComparisonHarness({
+      axisMode: "price",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+    ], [
+      ["AAPL", makeFinancials("AAPL", "USD", [])],
+      ["MSFT", makeFinancials("MSFT", "USD", [])],
+    ]);
 
     await flushFrames();
 
-    const frame = testSetup.captureCharFrame();
+    const frame = testSetup!.captureCharFrame();
     expect(frame).toContain("No chart data yet.");
     expect(frame).toContain("1:1D");
     expect(frame).toContain("2:1W");
@@ -303,28 +348,23 @@ describe("comparisonChartPlugin", () => {
     setSharedMarketDataCoordinator(sharedCoordinator);
     setSharedRegistryForTests(createRegistrySpy(spy));
 
-    testSetup = await testRender(
-      createComparisonHarness({
-        axisMode: "percent",
-        symbols: ["AAPL", "MSFT", "NVDA"],
-        symbolsText: "AAPL, MSFT, NVDA",
-      }, [
-        makeTicker("AAPL", "USD"),
-        makeTicker("MSFT", "USD"),
-        makeTicker("NVDA", "USD"),
-      ], [
-        ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104])],
-        ["MSFT", makeFinancials("MSFT", "USD", [200, 202, 204])],
-        ["NVDA", makeFinancials("NVDA", "USD", [300, 305, 310])],
-      ]),
-      { width: 120, height: 20 },
-    );
+    await mountComparisonHarness({
+      axisMode: "percent",
+      symbols: ["AAPL", "MSFT", "NVDA"],
+      symbolsText: "AAPL, MSFT, NVDA",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+      makeTicker("NVDA", "USD"),
+    ], [
+      ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104])],
+      ["MSFT", makeFinancials("MSFT", "USD", [200, 202, 204])],
+      ["NVDA", makeFinancials("NVDA", "USD", [300, 305, 310])],
+    ]);
 
     await flushFrames();
-    testSetup.mockInput.pressArrow("right");
-    await flushFrames();
-    testSetup.mockInput.pressEnter();
-    await flushFrames();
+    await pressComparisonInput(() => testSetup!.mockInput.pressArrow("right"));
+    await pressComparisonInput(() => testSetup!.mockInput.pressEnter());
 
     expect(spy.selected).toEqual(["MSFT"]);
     expect(spy.focused).toEqual(["ticker-detail"]);

package/src/plugins/builtin/comparison-chart.tsx

@@ -106,8 +106,7 @@ function ComparisonChartPane({ paneId, focused, width, height }: PaneProps) {
   const settings = useMemo(() => getComparisonChartPaneSettings(pane?.settings), [pane?.settings]);
 
   const openTicker = useCallback((symbol: string) => {
-    registry?.selectTickerFn(symbol);
-    registry?.focusPaneFn("ticker-detail");
+    registry?.navigateTickerFn(symbol);
   }, [registry]);
 
   if (settings.symbols.length === 0) {

package/src/plugins/builtin/correlation/compute.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import {
+  alignDatedReturns,
+  computeDatedReturns,
+  computeReturns,
+  correlateDatedReturns,
+  formatCorrelation,
+  pearsonCorrelation,
+} from "./compute";
+
+describe("computeReturns", () => {
+  test("computes simple returns", () => {
+    const returns = computeReturns([100, 110, 105, 115]);
+    expect(returns).toHaveLength(3);
+    expect(returns[0]).toBeCloseTo(0.1, 5);
+    expect(returns[1]).toBeCloseTo(-0.0455, 3);
+    expect(returns[2]).toBeCloseTo(0.0952, 3);
+  });
+
+  test("returns empty for single value", () => {
+    expect(computeReturns([100])).toEqual([]);
+  });
+
+  test("skips zero or invalid previous closes", () => {
+    expect(computeReturns([0, 10, 20, Number.NaN, 30])).toEqual([1]);
+  });
+});
+
+describe("computeDatedReturns", () => {
+  test("keys returns by the current close date", () => {
+    const returns = computeDatedReturns([
+      { date: new Date("2024-01-01T00:00:00Z"), close: 100 },
+      { date: new Date("2024-01-02T00:00:00Z"), close: 110 },
+      { date: new Date("2024-01-03T00:00:00Z"), close: 121 },
+    ]);
+
+    expect(returns).toEqual([
+      { dateKey: "2024-01-02", value: 0.1 },
+      { dateKey: "2024-01-03", value: 0.1 },
+    ]);
+  });
+
+  test("sorts points before computing returns", () => {
+    const returns = computeDatedReturns([
+      { date: new Date("2024-01-03T00:00:00Z"), close: 121 },
+      { date: new Date("2024-01-01T00:00:00Z"), close: 100 },
+      { date: new Date("2024-01-02T00:00:00Z"), close: 110 },
+    ]);
+
+    expect(returns.map((entry) => entry.dateKey)).toEqual(["2024-01-02", "2024-01-03"]);
+  });
+});
+
+describe("alignDatedReturns", () => {
+  test("aligns series by shared date keys", () => {
+    const aligned = alignDatedReturns(
+      [
+        { dateKey: "2024-01-02", value: 1 },
+        { dateKey: "2024-01-03", value: 2 },
+        { dateKey: "2024-01-04", value: 3 },
+      ],
+      [
+        { dateKey: "2024-01-01", value: 99 },
+        { dateKey: "2024-01-02", value: 10 },
+        { dateKey: "2024-01-04", value: 30 },
+      ],
+    );
+
+    expect(aligned).toEqual({
+      x: [1, 3],
+      y: [10, 30],
+      sampleSize: 2,
+    });
+  });
+});
+
+describe("pearsonCorrelation", () => {
+  test("perfect positive correlation", () => {
+    const x = [1, 2, 3, 4, 5];
+    const y = [2, 4, 6, 8, 10];
+    expect(pearsonCorrelation(x, y)).toBeCloseTo(1.0, 5);
+  });
+
+  test("perfect negative correlation", () => {
+    const x = [1, 2, 3, 4, 5];
+    const y = [10, 8, 6, 4, 2];
+    expect(pearsonCorrelation(x, y)).toBeCloseTo(-1.0, 5);
+  });
+
+  test("returns null for insufficient data", () => {
+    expect(pearsonCorrelation([1, 2], [3, 4])).toBeNull();
+  });
+
+  test("returns null for zero variance", () => {
+    expect(pearsonCorrelation([5, 5, 5, 5, 5], [1, 2, 3, 4, 5])).toBeNull();
+  });
+});
+
+describe("correlateDatedReturns", () => {
+  test("correlates only shared trading dates", () => {
+    const result = correlateDatedReturns(
+      [
+        { dateKey: "2024-01-02", value: 1 },
+        { dateKey: "2024-01-03", value: 2 },
+        { dateKey: "2024-01-04", value: 3 },
+        { dateKey: "2024-01-05", value: 4 },
+        { dateKey: "2024-01-06", value: 5 },
+      ],
+      [
+        { dateKey: "2024-01-01", value: 999 },
+        { dateKey: "2024-01-02", value: 2 },
+        { dateKey: "2024-01-03", value: 4 },
+        { dateKey: "2024-01-04", value: 6 },
+        { dateKey: "2024-01-05", value: 8 },
+        { dateKey: "2024-01-06", value: 10 },
+      ],
+    );
+
+    expect(result.sampleSize).toBe(5);
+    expect(result.correlation).toBeCloseTo(1, 5);
+  });
+
+  test("returns sample size even when shared observations are insufficient", () => {
+    expect(correlateDatedReturns(
+      [
+        { dateKey: "2024-01-02", value: 1 },
+        { dateKey: "2024-01-03", value: 2 },
+      ],
+      [
+        { dateKey: "2024-01-02", value: 1 },
+        { dateKey: "2024-01-03", value: 2 },
+      ],
+    )).toEqual({ correlation: null, sampleSize: 2 });
+  });
+});
+
+describe("formatCorrelation", () => {
+  test("formats positive", () => {
+    expect(formatCorrelation(0.85)).toContain("0.85");
+  });
+  test("formats negative", () => {
+    expect(formatCorrelation(-0.42)).toContain("-0.42");
+  });
+  test("formats null as dash", () => {
+    expect(formatCorrelation(null)).toContain("—");
+  });
+});

package/src/plugins/builtin/correlation/compute.ts

@@ -0,0 +1,115 @@
+import type { PricePoint } from "../../../types/financials";
+
+export interface DatedReturn {
+  dateKey: string;
+  value: number;
+}
+
+export interface CorrelationResult {
+  correlation: number | null;
+  sampleSize: number;
+}
+
+function getPointTimestamp(point: PricePoint): number {
+  const value = point.date as Date | string | number | null | undefined;
+  if (value instanceof Date) return value.getTime();
+  if (value == null) return Number.NaN;
+  return new Date(value).getTime();
+}
+
+function toDateKey(point: PricePoint): string | null {
+  const timestamp = getPointTimestamp(point);
+  if (!Number.isFinite(timestamp)) return null;
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+
+function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
+  return getPointTimestamp(left) - getPointTimestamp(right);
+}
+
+export function computeReturns(closes: number[]): number[] {
+  const returns: number[] = [];
+  for (let i = 1; i < closes.length; i++) {
+    const previous = closes[i - 1]!;
+    const current = closes[i]!;
+    if (!Number.isFinite(previous) || !Number.isFinite(current) || previous === 0) continue;
+    returns.push((current - previous) / previous);
+  }
+  return returns;
+}
+
+export function computeDatedReturns(points: PricePoint[]): DatedReturn[] {
+  const sorted = [...points]
+    .filter((point) => Number.isFinite(getPointTimestamp(point)) && Number.isFinite(point.close))
+    .sort(comparePricePointsByDate);
+  const byDate = new Map<string, number>();
+
+  for (let i = 1; i < sorted.length; i++) {
+    const previous = sorted[i - 1]!;
+    const current = sorted[i]!;
+    if (previous.close === 0) continue;
+    const value = (current.close - previous.close) / previous.close;
+    const dateKey = toDateKey(current);
+    if (!dateKey || !Number.isFinite(value)) continue;
+    byDate.set(dateKey, value);
+  }
+
+  return [...byDate.entries()].map(([dateKey, value]) => ({ dateKey, value }));
+}
+
+export function alignDatedReturns(x: DatedReturn[], y: DatedReturn[]): { x: number[]; y: number[]; sampleSize: number } {
+  const yByDate = new Map(y.map((entry) => [entry.dateKey, entry.value] as const));
+  const alignedX: number[] = [];
+  const alignedY: number[] = [];
+
+  for (const left of x) {
+    const rightValue = yByDate.get(left.dateKey);
+    if (rightValue === undefined) continue;
+    alignedX.push(left.value);
+    alignedY.push(rightValue);
+  }
+
+  return {
+    x: alignedX,
+    y: alignedY,
+    sampleSize: alignedX.length,
+  };
+}
+
+export function pearsonCorrelation(x: number[], y: number[], minObservations = 5): number | null {
+  const n = Math.min(x.length, y.length);
+  if (n < minObservations) return null;
+
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += x[i]!;
+    sumY += y[i]!;
+    sumXY += x[i]! * y[i]!;
+    sumX2 += x[i]! * x[i]!;
+    sumY2 += y[i]! * y[i]!;
+  }
+
+  const denom = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+  if (denom === 0) return null;
+  return (n * sumXY - sumX * sumY) / denom;
+}
+
+export function correlateDatedReturns(x: DatedReturn[], y: DatedReturn[], minObservations = 5): CorrelationResult {
+  const aligned = alignDatedReturns(x, y);
+  return {
+    correlation: pearsonCorrelation(aligned.x, aligned.y, minObservations),
+    sampleSize: aligned.sampleSize,
+  };
+}
+
+export function formatCorrelation(r: number | null): string {
+  if (r === null) return "  —  ";
+  return r >= 0 ? ` ${r.toFixed(2)}` : r.toFixed(2);
+}
+
+export function correlationColor(r: number | null, positive: string, negative: string, neutral: string): string {
+  if (r === null) return neutral;
+  if (r > 0.7) return positive;
+  if (r < -0.7) return negative;
+  return neutral;
+}