gloomberb 0.10.0 → 0.10.2

package/src/plugins/builtin/options/live-quotes.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, test } from "bun:test";
+import type { OptionContract, Quote } from "../../../types/financials";
+import type { QueryEntry } from "../../../market-data/result-types";
+import type { OptionTableRow } from "./types";
+import {
+  buildOptionQuoteKey,
+  buildOptionQuoteTargets,
+  hasLiveOptionQuote,
+  overlayOptionRowQuotes,
+} from "./live-quotes";
+
+function contract(strike: number, side: "C" | "P"): OptionContract {
+  return {
+    contractSymbol: `AAPL260731${side}${String(strike * 1000).padStart(8, "0")}`,
+    strike,
+    currency: "USD",
+    lastPrice: 1,
+    change: 0,
+    percentChange: 0,
+    volume: 10,
+    openInterest: 20,
+    bid: 0.9,
+    ask: 1.1,
+    impliedVolatility: 0.25,
+    inTheMoney: false,
+    expiration: 1_785_456_000,
+    lastTradeDate: 1_785_000_000,
+  };
+}
+
+function row(strike: number): OptionTableRow {
+  return {
+    strike,
+    call: contract(strike, "C"),
+    put: contract(strike, "P"),
+    isPositionStrike: false,
+  };
+}
+
+function readyQuote(quote: Quote): QueryEntry<Quote> {
+  return {
+    phase: "ready",
+    data: quote,
+    lastGoodData: quote,
+    source: quote.providerId ?? null,
+    fetchedAt: quote.lastUpdated,
+    staleAt: null,
+    error: null,
+    attempts: [],
+  };
+}
+
+describe("options live quotes", () => {
+  test("bounds selected-expiry subscriptions around the current strike", () => {
+    const rows = Array.from({ length: 100 }, (_, index) => row(50 + index));
+    const targets = buildOptionQuoteTargets(rows, 50, 14);
+
+    expect(targets).toHaveLength(16);
+    expect(
+      targets.every(
+        (target) => target.exchange === "OPTIONS" && target.surface === "options" && target.visible === true,
+      ),
+    ).toBe(true);
+    expect(targets.filter((target) => target.selected)).toHaveLength(2);
+    expect(targets.some((target) => target.symbol === rows[50]!.call!.contractSymbol)).toBe(true);
+    expect(targets.some((target) => target.symbol === rows[0]!.call!.contractSymbol)).toBe(false);
+    expect(targets.some((target) => target.symbol === rows.at(-1)!.put!.contractSymbol)).toBe(false);
+  });
+
+  test("overlays streamed quote fields while preserving chain-only Greeks and open interest", () => {
+    const original = row(100);
+    const symbol = original.call!.contractSymbol;
+    const quote: Quote = {
+      symbol,
+      providerId: "gloomberb-cloud",
+      price: 2.4,
+      mark: 2.5,
+      bid: 2.45,
+      ask: 2.55,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: 1_800_000_000_000,
+      receivedAt: 1_800_000_010_000,
+      dataSource: "live",
+      delivery: "stream",
+    };
+    const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
+    const freshness = {
+      chainAsOf: new Date(1_799_999_000_000).toISOString(),
+      chainDataSource: "live" as const,
+      now: 1_800_000_030_000,
+      subscriptionStartedAt: 1_799_999_500_000,
+    };
+
+    const overlaid = overlayOptionRowQuotes([original], entries, freshness)[0]!.call!;
+
+    expect(overlaid).toMatchObject({
+      lastPrice: 2.5,
+      bid: 2.45,
+      ask: 2.55,
+      lastUpdated: 1_800_000_000_000,
+      impliedVolatility: 0.25,
+      openInterest: 20,
+    });
+    expect(hasLiveOptionQuote(entries, freshness)).toBe(true);
+  });
+
+  test("rejects cached quotes from before this subscription or the current chain", () => {
+    const original = row(100);
+    const symbol = original.call!.contractSymbol;
+    const quote: Quote = {
+      symbol,
+      providerId: "gloomberb-cloud",
+      price: 9,
+      mark: 9,
+      bid: 8.9,
+      ask: 9.1,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: 1_800_000_000_000,
+      receivedAt: 1_800_000_010_000,
+      dataSource: "live",
+    };
+    const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
+
+    const beforeSubscription = {
+      chainAsOf: new Date(1_799_999_000_000).toISOString(),
+      now: 1_800_000_030_000,
+      subscriptionStartedAt: 1_800_000_020_000,
+    };
+    expect(overlayOptionRowQuotes([original], entries, beforeSubscription)[0]!.call!.lastPrice).toBe(1);
+    expect(hasLiveOptionQuote(entries, beforeSubscription)).toBe(false);
+
+    const olderThanChain = {
+      chainAsOf: new Date(1_800_000_005_000).toISOString(),
+      chainDataSource: "live" as const,
+      now: 1_800_000_030_000,
+      subscriptionStartedAt: 1_800_000_000_000,
+    };
+    expect(overlayOptionRowQuotes([original], entries, olderThanChain)[0]!.call!.lastPrice).toBe(1);
+    expect(hasLiveOptionQuote(entries, olderThanChain)).toBe(false);
+  });
+
+  test("accepts a freshly delivered delayed quote older than the delayed chain fetch", () => {
+    const original = row(100);
+    const symbol = original.call!.contractSymbol;
+    const quote: Quote = {
+      symbol,
+      providerId: "gloomberb-cloud",
+      price: 2.2,
+      mark: 2.25,
+      bid: 2.2,
+      ask: 2.3,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: 1_800_000_000_000,
+      receivedAt: 1_800_000_910_000,
+      dataSource: "delayed",
+      delivery: "poll",
+      stale: false,
+    };
+    const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
+    const freshness = {
+      chainAsOf: new Date(1_800_000_900_000).toISOString(),
+      chainDataSource: "delayed" as const,
+      now: 1_800_000_930_000,
+      subscriptionStartedAt: 1_800_000_905_000,
+    };
+
+    expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(2.25);
+    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+  });
+
+  test("overlays a valid polled quote without reporting a live stream", () => {
+    const original = row(100);
+    const symbol = original.call!.contractSymbol;
+    const quote: Quote = {
+      symbol,
+      providerId: "gloomberb-cloud",
+      price: 2.4,
+      mark: 2.5,
+      bid: 2.45,
+      ask: 2.55,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: 1_800_000_000_000,
+      receivedAt: 1_800_000_010_000,
+      dataSource: "live",
+      delivery: "poll",
+      stale: false,
+    };
+    const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
+    const freshness = {
+      chainAsOf: new Date(1_799_999_000_000).toISOString(),
+      chainDataSource: "live" as const,
+      now: 1_800_000_030_000,
+      subscriptionStartedAt: 1_799_999_500_000,
+    };
+
+    expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(2.5);
+    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+  });
+
+  test("rejects a freshly received quote marked stale by the server", () => {
+    const original = row(100);
+    const symbol = original.call!.contractSymbol;
+    const quote: Quote = {
+      symbol,
+      providerId: "gloomberb-cloud",
+      price: 9,
+      mark: 9,
+      bid: 8.9,
+      ask: 9.1,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: 1_800_000_900_000,
+      receivedAt: 1_800_000_910_000,
+      dataSource: "live",
+      delivery: "poll",
+      stale: true,
+    };
+    const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
+    const freshness = {
+      chainAsOf: new Date(1_800_000_800_000).toISOString(),
+      chainDataSource: "live" as const,
+      now: 1_800_000_930_000,
+      subscriptionStartedAt: 1_800_000_905_000,
+    };
+
+    expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(1);
+    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+  });
+});

package/src/plugins/builtin/options/live-quotes.ts

@@ -0,0 +1,147 @@
+import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
+import type { OptionContract, Quote } from "../../../types/financials";
+import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
+import type { QueryEntry } from "../../../market-data/result-types";
+import type { OptionTableRow } from "./types";
+
+export const OPTIONS_QUOTE_EXCHANGE = "OPTIONS";
+export const OPTIONS_CHAIN_REFRESH_INTERVAL_MS = 10 * 60_000;
+export const OPTIONS_STREAM_FRESHNESS_MS = 2 * 60_000;
+
+const OPTIONS_STREAM_MAX_TARGETS = 16;
+const OPTIONS_STREAM_MAX_ROWS = OPTIONS_STREAM_MAX_TARGETS / 2;
+const OPTIONS_STREAM_OVERSCAN_ROWS = 4;
+
+export interface OptionsQuoteFreshness {
+  chainAsOf?: string;
+  chainDataSource?: "live" | "delayed";
+  now: number;
+  subscriptionStartedAt: number;
+}
+
+function isFiniteNumber(value: number | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function optionStreamRowCount(height: number): number {
+  const visibleRows = Math.max(1, Math.floor(height) - 3);
+  return Math.min(
+    OPTIONS_STREAM_MAX_ROWS,
+    visibleRows + OPTIONS_STREAM_OVERSCAN_ROWS,
+  );
+}
+
+function optionStreamWindow(totalRows: number, selectedIndex: number, height: number): [number, number] {
+  const count = Math.min(totalRows, optionStreamRowCount(height));
+  const clampedIndex = Math.max(0, Math.min(selectedIndex, Math.max(0, totalRows - 1)));
+  const start = Math.max(0, Math.min(clampedIndex - Math.floor(count / 2), totalRows - count));
+  return [start, start + count];
+}
+
+export function buildOptionQuoteTargets(
+  rows: readonly OptionTableRow[],
+  selectedIndex: number,
+  height: number,
+): QuoteSubscriptionTarget[] {
+  if (rows.length === 0) return [];
+  const [start, end] = optionStreamWindow(rows.length, selectedIndex, height);
+  const targets = new Map<string, QuoteSubscriptionTarget>();
+
+  for (let index = start; index < end; index += 1) {
+    const row = rows[index];
+    if (!row) continue;
+    const selected = index === selectedIndex;
+    const distance = Math.abs(index - selectedIndex);
+    for (const contract of [row.call, row.put]) {
+      const symbol = contract?.contractSymbol.trim().toUpperCase();
+      if (!symbol) continue;
+      targets.set(symbol, {
+        symbol,
+        exchange: OPTIONS_QUOTE_EXCHANGE,
+        surface: "options",
+        visible: true,
+        selected,
+        weight: Math.max(50, 100 - distance),
+      });
+    }
+  }
+
+  return [...targets.values()];
+}
+
+export function buildOptionQuoteKey(contractSymbol: string): string {
+  return buildQuoteKey({
+    symbol: contractSymbol,
+    exchange: OPTIONS_QUOTE_EXCHANGE,
+  });
+}
+
+export function overlayOptionContractQuote(
+  contract: OptionContract | undefined,
+  quote: Quote | null | undefined,
+): OptionContract | undefined {
+  if (!contract || !quote) return contract;
+  if (contract.lastUpdated != null && quote.lastUpdated < contract.lastUpdated) return contract;
+
+  const streamedPrice = isFiniteNumber(quote.mark) ? quote.mark : quote.price;
+  return {
+    ...contract,
+    lastPrice: isFiniteNumber(streamedPrice) ? streamedPrice : contract.lastPrice,
+    bid: isFiniteNumber(quote.bid) ? quote.bid : contract.bid,
+    ask: isFiniteNumber(quote.ask) ? quote.ask : contract.ask,
+    lastUpdated: quote.lastUpdated,
+  };
+}
+
+function freshOptionQuote(entry: QueryEntry<Quote> | undefined, freshness: OptionsQuoteFreshness): Quote | null {
+  const quote = resolveEntryData(entry);
+  if (!quote || quote.stale === true) return null;
+  const receivedAt = quote.receivedAt ?? 0;
+  if (
+    !Number.isFinite(receivedAt) ||
+    receivedAt <= freshness.subscriptionStartedAt ||
+    freshness.now - receivedAt > OPTIONS_STREAM_FRESHNESS_MS
+  ) {
+    return null;
+  }
+  const chainAsOf = freshness.chainAsOf ? Date.parse(freshness.chainAsOf) : Number.NaN;
+  if (
+    freshness.chainDataSource === "live" &&
+    quote.dataSource === "live" &&
+    Number.isFinite(chainAsOf) &&
+    Number.isFinite(quote.lastUpdated) &&
+    quote.lastUpdated < chainAsOf
+  ) {
+    return null;
+  }
+  return quote;
+}
+
+export function overlayOptionRowQuotes(
+  rows: readonly OptionTableRow[],
+  quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
+  freshness: OptionsQuoteFreshness,
+): OptionTableRow[] {
+  return rows.map((row) => ({
+    ...row,
+    call: overlayOptionContractQuote(
+      row.call,
+      row.call ? freshOptionQuote(quoteEntries.get(buildOptionQuoteKey(row.call.contractSymbol)), freshness) : null,
+    ),
+    put: overlayOptionContractQuote(
+      row.put,
+      row.put ? freshOptionQuote(quoteEntries.get(buildOptionQuoteKey(row.put.contractSymbol)), freshness) : null,
+    ),
+  }));
+}
+
+export function hasLiveOptionQuote(
+  quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
+  freshness: OptionsQuoteFreshness,
+): boolean {
+  for (const entry of quoteEntries.values()) {
+    const quote = freshOptionQuote(entry, freshness);
+    if (quote?.dataSource === "live" && quote.delivery === "stream") return true;
+  }
+  return false;
+}

package/src/plugins/builtin/options/view.test.tsx

@@ -6,7 +6,8 @@ import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../
 import { AppContext, PaneInstanceProvider, createInitialState } from "../../../state/app/context";
 import { createTestDataProvider } from "../../../test-support/data-provider";
 import { cloneLayout, createDefaultConfig } from "../../../types/config";
-import type { OptionContract, OptionsChain, TickerFinancials } from "../../../types/financials";
+import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
+import type { OptionContract, OptionsChain, Quote, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import { formatExpDate } from "../../../utils/options";
 import { OptionsView } from "./view";
@@ -163,6 +164,75 @@ test("defaults the table around the nearest strike to the current quote", async
   expect(frame).not.toContain(" 50 ");
 });
 
+test("streams a bounded options window and overlays live contract quotes", async () => {
+  const strikes = Array.from({ length: 100 }, (_, index) => 50 + index);
+  const subscriptions: QuoteSubscriptionTarget[][] = [];
+  let emitQuote:
+    | ((target: QuoteSubscriptionTarget, quote: Quote) => void)
+    | null = null;
+  const provider = createTestDataProvider({
+    getOptionsChain: async () => makeChain(strikes, 120),
+    subscribeQuotes: (targets, onQuote) => {
+      subscriptions.push(targets);
+      emitQuote = onQuote;
+      return () => {};
+    },
+  });
+  const coordinator = new MarketDataCoordinator(provider);
+  setSharedMarketDataCoordinator(coordinator);
+
+  await act(async () => {
+    testSetup = await testRender(
+      <OptionsHarness ticker={makeTicker("AAPL")} quotePrice={120.2} />,
+      {
+        width: 124,
+        height: 16,
+      },
+    );
+  });
+  await renderSettled();
+
+  const targets = subscriptions.at(-1) ?? [];
+  expect(targets.length).toBeGreaterThan(0);
+  expect(targets.length).toBeLessThanOrEqual(80);
+  expect(
+    targets.every(
+      (target) => target.exchange === "OPTIONS" && target.surface === "options",
+    ),
+  ).toBe(true);
+  const selectedCall = targets.find(
+    (target) => target.symbol === makeContract(120, "C").contractSymbol,
+  );
+  expect(selectedCall).toMatchObject({ selected: true });
+
+  await act(async () => {
+    emitQuote?.(selectedCall!, {
+      symbol: selectedCall!.symbol,
+      providerId: "gloomberb-cloud",
+      price: 99.9,
+      mark: 99.99,
+      bid: 99.98,
+      ask: 100,
+      currency: "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: Date.now(),
+      dataSource: "live",
+    });
+    await Promise.resolve();
+    await testSetup!.renderOnce();
+  });
+  await renderSettled();
+
+  expect(
+    coordinator.getQuoteEntry({
+      symbol: selectedCall!.symbol,
+      exchange: "OPTIONS",
+    }).data?.mark,
+  ).toBe(99.99);
+  expect(testSetup!.captureCharFrame()).toContain("99.99");
+});
+
 test("lets the expiration tab row use the full available width", async () => {
   const expirationDates = Array.from({ length: 9 }, (_, index) => (
     Math.floor(Date.UTC(2026, index, 20) / 1000)

package/src/plugins/builtin/options/view.tsx

@@ -5,21 +5,27 @@ import { colors } from "../../../theme/colors";
 import { isPlainKey } from "../../../utils/keyboard";
 import { formatExpDate, resolveOptionsTarget } from "../../../utils/options";
 import { useOptionsQuery, useResolvedEntryValue } from "../../../market-data/hooks";
-import { DataTableView, Spinner, Tabs, usePaneFooter, type DataTableKeyEvent } from "../../../components";
+import { DataTableView, Spinner, Tabs, type DataTableKeyEvent } from "../../../components";
 import { useShortcut } from "../../../react/input";
+import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import {
   OPTION_COLUMNS,
   buildStrikeList,
   findNearestStrikeIndex,
-  formatIv,
-  formatStrikeLabel,
   optionColumnColor,
   renderOptionCell,
   resolveDefaultStrikeTarget,
 } from "./table";
 import type { OptionColumn, OptionTableRow, OptionsViewProps } from "./types";
+import {
+  buildOptionQuoteTargets,
+  hasLiveOptionQuote,
+  OPTIONS_CHAIN_REFRESH_INTERVAL_MS,
+  overlayOptionRowQuotes,
+} from "./live-quotes";
+import { useOptionsAccessFooter } from "./footer";
 
-export function OptionsView({ width, focused, onCapture = () => {} }: OptionsViewProps) {
+export function OptionsView({ width, height, focused, onCapture = () => {} }: OptionsViewProps) {
   const { ticker, financials } = usePaneTicker();
   const [expIdx, setExpIdx] = useState(0);
   const [strikeIdx, setStrikeIdx] = useState(0);
@@ -52,6 +58,7 @@ export function OptionsView({ width, focused, onCapture = () => {} }: OptionsVie
     baseRequest && selectedExpiration != null
       ? { ...baseRequest, expirationDate: selectedExpiration }
       : null,
+    { refreshIntervalMs: OPTIONS_CHAIN_REFRESH_INTERVAL_MS },
   );
   const expirationChain = useResolvedEntryValue(expirationChainEntry);
   const chain = expirationChain ?? initialChain;
@@ -118,38 +125,46 @@ export function OptionsView({ width, focused, onCapture = () => {} }: OptionsVie
     () => new Map(chain?.puts.map((p) => [p.strike, p]) ?? []),
     [chain],
   );
-  const rows = useMemo<OptionTableRow[]>(() => strikes.map((strike) => ({
+  const snapshotRows = useMemo<OptionTableRow[]>(() => strikes.map((strike) => ({
     strike,
     call: callsByStrike.get(strike),
     put: putsByStrike.get(strike),
     isPositionStrike: !!parsed && Math.abs(strike - parsed.strike) < 0.01,
   })), [callsByStrike, parsed, putsByStrike, strikes]);
-  const selectedStrike = strikes[strikeIdx];
-  const selectedCall = selectedStrike != null ? callsByStrike.get(selectedStrike) : undefined;
-  const selectedPut = selectedStrike != null ? putsByStrike.get(selectedStrike) : undefined;
+  const optionQuoteTargets = useMemo(
+    () => buildOptionQuoteTargets(snapshotRows, strikeIdx, height),
+    [height, snapshotRows, strikeIdx],
+  );
+  const {
+    entries: optionQuoteEntries,
+    freshnessNow,
+    subscriptionStartedAt,
+  } = useLiveQuoteEntries(optionQuoteTargets);
+  const optionQuoteFreshness = useMemo(
+    () => ({
+      chainAsOf: chain?.asOf,
+      chainDataSource: chain?.dataSource,
+      now: freshnessNow,
+      subscriptionStartedAt,
+    }),
+    [chain?.asOf, chain?.dataSource, freshnessNow, subscriptionStartedAt],
+  );
+  const rows = useMemo(
+    () => overlayOptionRowQuotes(snapshotRows, optionQuoteEntries, optionQuoteFreshness),
+    [optionQuoteEntries, optionQuoteFreshness, snapshotRows],
+  );
   const optionColumns: OptionColumn[] = OPTION_COLUMNS.map((column) => ({
     ...column,
     headerColor: optionColumnColor(column.id, colors.panel),
   }));
 
-  usePaneFooter("options", () => {
-    const info = [
-      ...(selectedExpiration != null ? [{ id: "exp", parts: [{ text: formatExpDate(selectedExpiration), tone: "muted" as const }] }] : []),
-      ...(selectedStrike != null ? [{ id: "strike", parts: [{ text: `Strike ${formatStrikeLabel(selectedStrike)}`, tone: "value" as const, bold: true }] }] : []),
-      ...(selectedCall ? [{ id: "call-iv", parts: [{ text: "Call IV", tone: "label" as const }, { text: formatIv(selectedCall.impliedVolatility), tone: "value" as const }] }] : []),
-      ...(selectedPut ? [{ id: "put-iv", parts: [{ text: "Put IV", tone: "label" as const }, { text: formatIv(selectedPut.impliedVolatility), tone: "value" as const }] }] : []),
-      ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
-      ...(error ? [{ id: "error", parts: [{ text: "error", tone: "warning" as const }] }] : []),
-    ];
-    return info.length > 0 ? { info } : null;
-  }, [
+  useOptionsAccessFooter({
+    chain,
     error,
+    focused,
+    hasLiveQuote: hasLiveOptionQuote(optionQuoteEntries, optionQuoteFreshness),
     loading,
-    selectedCall?.impliedVolatility,
-    selectedExpiration,
-    selectedPut?.impliedVolatility,
-    selectedStrike,
-  ]);
+  });
 
   useEffect(() => {
     setStrikeIdx((index) => {