gloomberb 0.1.0 → 0.3.1

package/src/state/use-quote-streaming.test.tsx

@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
+import { useQuoteStreaming } from "./use-quote-streaming";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let bumpHarness: (() => void) | null = null;
+
+function QuoteStreamingHarness() {
+  const [tick, setTick] = useState(0);
+  bumpHarness = () => setTick((current) => current + 1);
+
+  useQuoteStreaming([{
+    symbol: "AAPL",
+    exchange: "NASDAQ",
+  }]);
+
+  return <text>{String(tick)}</text>;
+}
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  bumpHarness = null;
+  setSharedMarketDataCoordinator(null);
+});
+
+describe("useQuoteStreaming", () => {
+  test("does not resubscribe when the component rerenders with the same targets", async () => {
+    let subscribeCalls = 0;
+    let unsubscribeCalls = 0;
+    const coordinator = {
+      subscribeQuotes: () => {
+        subscribeCalls += 1;
+        return () => {
+          unsubscribeCalls += 1;
+        };
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<QuoteStreamingHarness />, {
+      width: 20,
+      height: 1,
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(subscribeCalls).toBe(1);
+    expect(unsubscribeCalls).toBe(0);
+
+    await act(async () => {
+      bumpHarness?.();
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(subscribeCalls).toBe(1);
+    expect(unsubscribeCalls).toBe(0);
+  });
+});

package/src/state/use-quote-streaming.ts

@@ -0,0 +1,80 @@
+import { useEffect } from "react";
+import { useAppActive } from "./app-activity";
+import type { QuoteSubscriptionTarget } from "../types/data-provider";
+import { debugLog } from "../utils/debug-log";
+import { getSharedMarketDataCoordinator } from "../market-data/coordinator";
+
+const quoteStreamLog = debugLog.createLogger("quote-stream");
+
+function normalizeTarget(target: QuoteSubscriptionTarget): QuoteSubscriptionTarget | null {
+  const symbol = target.symbol.trim().toUpperCase();
+  if (!symbol) return null;
+  return {
+    ...target,
+    symbol,
+    exchange: target.exchange?.trim().toUpperCase() ?? "",
+  };
+}
+
+export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {
+  const contractKey = target.context?.instrument?.conId
+    ?? target.context?.instrument?.localSymbol
+    ?? target.context?.instrument?.symbol
+    ?? "";
+  return [
+    target.symbol,
+    target.exchange ?? "",
+    target.context?.brokerId ?? "",
+    target.context?.brokerInstanceId ?? "",
+    contractKey,
+    target.route ?? "auto",
+  ].join("|");
+}
+
+export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
+  const appActive = useAppActive();
+  const coordinator = getSharedMarketDataCoordinator();
+
+  const normalizedEntries = new Map<string, QuoteSubscriptionTarget>();
+  for (const target of targets) {
+    const normalized = normalizeTarget(target);
+    if (!normalized) continue;
+    const key = buildQuoteStreamSubscriptionKey(normalized);
+    normalizedEntries.set(key, normalized);
+  }
+  const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
+  const normalizedTargets = sortedEntries.map(([, target]) => target);
+  const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
+
+  useEffect(() => {
+    if (!appActive) {
+      if (normalizedTargets.length > 0) {
+        quoteStreamLog.info("skipping subscription while inactive", { targets: subscriptionKey });
+      }
+      return;
+    }
+    if (!coordinator || normalizedTargets.length === 0) return;
+    quoteStreamLog.info("subscribe", {
+      providerId: "market-data",
+      count: normalizedTargets.length,
+      targets: subscriptionKey,
+    });
+    const unsubscribe = coordinator.subscribeQuotes(normalizedTargets.map((target) => ({
+      instrument: {
+        symbol: target.symbol,
+        exchange: target.exchange,
+        brokerId: target.context?.brokerId,
+        brokerInstanceId: target.context?.brokerInstanceId,
+        instrument: target.context?.instrument ?? null,
+      },
+    })));
+    return () => {
+      quoteStreamLog.info("unsubscribe", {
+        providerId: "market-data",
+        count: normalizedTargets.length,
+        targets: subscriptionKey,
+      });
+      unsubscribe?.();
+    };
+  }, [appActive, coordinator, subscriptionKey]);
+}

package/src/state/use-session-snapshot.ts

@@ -0,0 +1,84 @@
+import { useEffect, useRef } from "react";
+import type { SessionStore } from "../data/session-store";
+import {
+  buildAppSessionSnapshot,
+  type AppSessionSnapshot,
+} from "./session-persistence";
+import type { AppState } from "./app-context";
+
+export function usePersistSessionSnapshot(
+  sessionStore: SessionStore | undefined,
+  state: AppState,
+  sessionId: string,
+  schemaVersion: number,
+): void {
+  const latestRef = useRef({
+    sessionStore,
+    state,
+    sessionId,
+    schemaVersion,
+  });
+  latestRef.current = {
+    sessionStore,
+    state,
+    sessionId,
+    schemaVersion,
+  };
+
+  const saveSnapshotRef = useRef<() => void>(() => {});
+  saveSnapshotRef.current = () => {
+    const {
+      sessionStore: currentStore,
+      state: currentState,
+      sessionId: currentSessionId,
+      schemaVersion: currentSchemaVersion,
+    } = latestRef.current;
+
+    if (!currentStore) return;
+    if (!currentState.initialized && currentState.tickers.size === 0) return;
+
+    try {
+      currentStore.set(currentSessionId, buildAppSessionSnapshot({
+        config: currentState.config,
+        paneState: currentState.paneState,
+        focusedPaneId: currentState.focusedPaneId,
+        activePanel: currentState.activePanel,
+        statusBarVisible: currentState.statusBarVisible,
+        recentTickers: currentState.recentTickers,
+        tickers: currentState.tickers,
+        exchangeRates: currentState.exchangeRates,
+      }) satisfies AppSessionSnapshot, currentSchemaVersion);
+    } catch {
+      // Snapshot persistence is best-effort during teardown.
+    }
+  };
+
+  useEffect(() => {
+    if (!sessionStore) return;
+    if (!state.initialized && state.tickers.size === 0) return;
+    const timer = setTimeout(() => {
+      saveSnapshotRef.current();
+    }, 250);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [
+    sessionStore,
+    sessionId,
+    schemaVersion,
+    state.initialized,
+    state.tickers,
+    state.config,
+    state.paneState,
+    state.focusedPaneId,
+    state.activePanel,
+    state.statusBarVisible,
+    state.recentTickers,
+  ]);
+
+  useEffect(() => {
+    return () => {
+      saveSnapshotRef.current();
+    };
+  }, []);
+}

package/src/test-support/data-provider.ts

@@ -0,0 +1,22 @@
+import type { DataProvider } from "../types/data-provider";
+import type { InstrumentSearchResult } from "../types/instrument";
+import type { Quote, TickerFinancials } from "../types/financials";
+
+function unused<T>(name: string): Promise<T> {
+  return Promise.reject(new Error(`${name} is unused in this test`));
+}
+
+export function createTestDataProvider(overrides: Partial<DataProvider> = {}): DataProvider {
+  return {
+    id: "test-provider",
+    name: "Test Provider",
+    getTickerFinancials: async () => unused<TickerFinancials>("getTickerFinancials"),
+    getQuote: async () => unused<Quote>("getQuote"),
+    getExchangeRate: async () => 1,
+    search: async () => [] satisfies InstrumentSearchResult[],
+    getNews: async () => [],
+    getArticleSummary: async () => null,
+    getPriceHistory: async () => [],
+    ...overrides,
+  };
+}

package/src/theme/color-utils.ts

@@ -0,0 +1,67 @@
+export function blendHex(a: string, b: string, ratio: number): string {
+  const parse = (hex: string) => {
+    const h = hex.replace("#", "");
+    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)] as const;
+  };
+  const [ar, ag, ab] = parse(a);
+  const [br, bg, bb] = parse(b);
+  const mix = (x: number, y: number) => Math.round(x + (y - x) * ratio).toString(16).padStart(2, "0");
+  return `#${mix(ar, br)}${mix(ag, bg)}${mix(ab, bb)}`;
+}
+
+function relativeLuminance(hex: string): number {
+  const h = hex.replace("#", "");
+  const toLinear = (value: string) => {
+    const normalized = parseInt(value, 16) / 255;
+    return normalized <= 0.03928
+      ? normalized / 12.92
+      : Math.pow((normalized + 0.055) / 1.055, 2.4);
+  };
+  const r = toLinear(h.slice(0, 2));
+  const g = toLinear(h.slice(2, 4));
+  const b = toLinear(h.slice(4, 6));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+export function contrastRatio(a: string, b: string): number {
+  const lighter = Math.max(relativeLuminance(a), relativeLuminance(b));
+  const darker = Math.min(relativeLuminance(a), relativeLuminance(b));
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+const CONTRAST_BLEND_STEPS = [0, 0.08, 0.14, 0.2, 0.28, 0.36, 0.48, 0.62, 0.78, 1] as const;
+
+export function blendForContrast(base: string, against: string, fallback: string, minContrast: number): string {
+  let candidate = base;
+
+  for (const ratio of CONTRAST_BLEND_STEPS) {
+    candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
+    if (contrastRatio(candidate, against) >= minContrast) {
+      return candidate;
+    }
+  }
+
+  return candidate;
+}
+
+export function blendForContrastOnSurfaces(
+  base: string,
+  surfaces: readonly string[],
+  fallback: string,
+  minContrast: number,
+): string {
+  let candidate = base;
+
+  for (const ratio of CONTRAST_BLEND_STEPS) {
+    candidate = ratio === 0 ? base : blendHex(base, fallback, ratio);
+    if (surfaces.every((surface) => contrastRatio(candidate, surface) >= minContrast)) {
+      return candidate;
+    }
+  }
+
+  return candidate;
+}
+
+export function higherContrast(a: string, b: string, against: string): string {
+  return contrastRatio(a, against) >= contrastRatio(b, against) ? a : b;
+}

package/src/theme/colors.ts

@@ -0,0 +1,128 @@
+import { blendForContrast, blendHex, higherContrast } from "./color-utils";
+import { getTheme, DEFAULT_THEME, type Theme } from "./themes";
+
+// Mutable colors object — properties are updated in-place when the theme changes.
+// React components re-read these on each render triggered by the SET_THEME action.
+export const colors: Omit<Theme, "name" | "description"> = { ...getTheme(DEFAULT_THEME) };
+
+let currentThemeId = DEFAULT_THEME;
+
+export function getCurrentThemeId(): string {
+  return currentThemeId;
+}
+
+export function applyTheme(id: string): void {
+  const theme = getTheme(id);
+  currentThemeId = id;
+  // Mutate in-place so every existing import sees the new values
+  Object.assign(colors, theme);
+}
+
+export type ColorKey = keyof typeof colors;
+
+export { blendHex } from "./color-utils";
+
+const COMPARISON_SERIES_COLORS = [
+  "#5bc0eb",
+  "#f6ae2d",
+  "#f26419",
+  "#6f2dbd",
+  "#00a896",
+  "#ef476f",
+  "#118ab2",
+  "#8ac926",
+  "#ff7f51",
+  "#4361ee",
+] as const;
+
+export function getComparisonSeriesColor(index: number): string {
+  return COMPARISON_SERIES_COLORS[((index % COMPARISON_SERIES_COLORS.length) + COMPARISON_SERIES_COLORS.length) % COMPARISON_SERIES_COLORS.length]!;
+}
+
+/** Returns a hover background color derived from bg and selected */
+export function hoverBg(): string {
+  return blendHex(colors.bg, colors.selected, 0.5);
+}
+
+export function commandBarBg(): string {
+  const base = higherContrast(colors.commandBg, colors.panel, colors.bg);
+  const accent = higherContrast(colors.textBright, colors.borderFocused, base);
+  return blendForContrast(base, colors.bg, accent, 1.45);
+}
+
+export function commandBarSelectedBg(): string {
+  const base = commandBarBg();
+  const accent = higherContrast(colors.selectedText, colors.textBright, colors.selected);
+  return blendForContrast(colors.selected, base, accent, 1.6);
+}
+
+export function commandBarHoverBg(): string {
+  return blendHex(commandBarBg(), commandBarSelectedBg(), 0.45);
+}
+
+export function commandBarText(): string {
+  const base = commandBarBg();
+  const fallback = higherContrast(colors.textBright, "#f2f2f2", base);
+  return blendForContrast(colors.text, base, fallback, 5.4);
+}
+
+export function commandBarHeadingText(): string {
+  const base = commandBarBg();
+  return blendForContrast("#8f959e", base, "#b7bec8", 3.6);
+}
+
+export function commandBarSubtleText(): string {
+  const base = commandBarBg();
+  const fallback = higherContrast(commandBarText(), "#d8d8d8", base);
+  return blendForContrast(colors.textDim, base, fallback, 4.1);
+}
+
+export function commandBarSelectedText(): string {
+  const base = commandBarSelectedBg();
+  const preferred = higherContrast(colors.selectedText, colors.text, base);
+  const fallback = higherContrast(colors.textBright, "#f2f2f2", base);
+  return blendForContrast(preferred, base, fallback, 4.5);
+}
+
+/** Background for docked pane bodies */
+export function paneBg(focused: boolean): string {
+  if (focused) return colors.bg;
+  return colors.panel;
+}
+
+/** Background for floating pane bodies — elevated above docked panes */
+export function floatingPaneBg(focused: boolean): string {
+  if (focused) return blendHex(colors.bg, colors.border, 0.12);
+  return blendHex(colors.panel, colors.border, 0.35);
+}
+
+/** Background for pane title bars */
+export function paneTitleBg(focused: boolean): string {
+  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.15);
+  return blendHex(colors.panel, colors.border, 0.25);
+}
+
+/** Background for floating pane title bars */
+export function floatingPaneTitleBg(focused: boolean): string {
+  if (focused) return blendHex(colors.bg, colors.borderFocused, 0.18);
+  return blendHex(colors.panel, colors.border, 0.4);
+}
+
+/** Title text color for panes */
+export function paneTitleText(focused: boolean, floating = false): string {
+  const background = floating ? floatingPaneTitleBg(focused) : paneTitleBg(focused);
+  const preferred = focused
+    ? higherContrast(colors.textBright, colors.headerText, background)
+    : colors.textDim;
+  const fallback = focused
+    ? higherContrast(colors.text, "#f2f2f2", background)
+    : higherContrast(colors.text, colors.textBright, background);
+  return blendForContrast(preferred, background, fallback, focused ? 5.2 : 4.5);
+}
+
+/** Returns green for positive, red for negative, neutral for zero */
+export function priceColor(value: number): string {
+  if (value > 0) return colors.positive;
+  if (value < 0) return colors.negative;
+  return colors.neutral;
+}

package/src/theme/themes.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, test } from "bun:test";
+import { applyTheme, floatingPaneTitleBg, paneTitleBg, paneTitleText } from "./colors";
+import { contrastRatio } from "./color-utils";
+import { DEFAULT_THEME, themes } from "./themes";
+
+const BODY_TEXT_MIN = 4.5;
+const SUBTLE_TEXT_MIN = 3.6;
+const CHROME_TEXT_MIN = 4.5;
+
+function assertMinContrast(themeId: string, label: string, fg: string, bg: string, min: number): void {
+  const ratio = contrastRatio(fg, bg);
+  if (ratio < min) {
+    throw new Error(`${themeId} ${label} contrast ${ratio.toFixed(2)} is below ${min}`);
+  }
+}
+
+afterEach(() => {
+  applyTheme(DEFAULT_THEME);
+});
+
+describe("theme contrast", () => {
+  test("keeps shared text roles readable on body surfaces", () => {
+    for (const [id, theme] of Object.entries(themes)) {
+      for (const [surfaceLabel, surface] of [["bg", theme.bg], ["panel", theme.panel]] as const) {
+        assertMinContrast(id, `text/${surfaceLabel}`, theme.text, surface, BODY_TEXT_MIN);
+        assertMinContrast(id, `textDim/${surfaceLabel}`, theme.textDim, surface, BODY_TEXT_MIN);
+        assertMinContrast(id, `textMuted/${surfaceLabel}`, theme.textMuted, surface, SUBTLE_TEXT_MIN);
+        assertMinContrast(id, `positive/${surfaceLabel}`, theme.positive, surface, SUBTLE_TEXT_MIN);
+        assertMinContrast(id, `negative/${surfaceLabel}`, theme.negative, surface, SUBTLE_TEXT_MIN);
+        assertMinContrast(id, `neutral/${surfaceLabel}`, theme.neutral, surface, SUBTLE_TEXT_MIN);
+      }
+
+      assertMinContrast(id, "headerText/header", theme.headerText, theme.header, BODY_TEXT_MIN);
+      assertMinContrast(id, "selectedText/selected", theme.selectedText, theme.selected, BODY_TEXT_MIN);
+    }
+  });
+
+  test("keeps unfocused pane chrome readable", () => {
+    for (const id of Object.keys(themes)) {
+      applyTheme(id);
+      assertMinContrast(id, "paneTitleText/unfocused", paneTitleText(false), paneTitleBg(false), CHROME_TEXT_MIN);
+      assertMinContrast(id, "floatingPaneTitleText/unfocused", paneTitleText(false, true), floatingPaneTitleBg(false), CHROME_TEXT_MIN);
+    }
+  });
+});