gloomberb 0.10.2 → 0.10.4

package/src/plugins/builtin/news/wire/news/footer.ts

@@ -1,10 +1,10 @@
-import { useCallback, useMemo } from "react";
+import { useMemo } from "react";
 import type { PaneFooterSegment } from "../../../../../components";
-import { useShortcut } from "../../../../../react/input";
-import { useRendererHost } from "../../../../../ui";
-import { apiClient } from "../../../../../api-client";
+import { t, tf } from "../../../../../i18n";
+import { useAppLanguage } from "../../../../../i18n/react";
+import { useCloudAccessFooter } from "../../../shared/cloud-upgrade";
+import { CLOUD_NEWS_DELAY_HOURS } from "../../../shared/plan-access";
 import { usePaneStatusLinkFooter } from "../../../shared/pane-footer";
-import { CLOUD_UPGRADE_URL } from "../../../shared/cloud-upgrade";
 
 interface NewsFooterArticle {
   source?: string | null;
@@ -20,11 +20,6 @@ interface UseNewsArticleFooterOptions {
   error?: string | null;
 }
 
-function hasRealtimeNewsAccess(): boolean {
-  const user = apiClient.getCurrentUser();
-  return user?.emailVerified === true && user.plan === "pro";
-}
-
 export function useNewsArticleFooter({
   registrationId,
   focused,
@@ -33,35 +28,20 @@ export function useNewsArticleFooter({
   loading = false,
   error,
 }: UseNewsArticleFooterOptions) {
-  const rendererHost = useRendererHost();
-  const hasRealtimeAccess = hasRealtimeNewsAccess();
-  const showAccessFooter = !article;
-  const openUpgrade = useCallback(() => {
-    void rendererHost.openExternal(CLOUD_UPGRADE_URL);
-  }, [rendererHost]);
-
-  useShortcut((event) => {
-    const key = (event.name ?? event.key ?? "").toLowerCase();
-    if (!focused || !showAccessFooter || hasRealtimeAccess || key !== "u") return;
-    event.stopPropagation();
-    event.preventDefault();
-    openUpgrade();
-  }, { scope: `${registrationId}:news-upgrade` });
+  const language = useAppLanguage();
+  const { access, segment } = useCloudAccessFooter({
+    delayLabel: tf("{count}h", { count: CLOUD_NEWS_DELAY_HOURS }),
+    focused,
+    segmentId: "news-access",
+    shortcutScope: `${registrationId}:news-upgrade`,
+  });
 
-  const accessInfo = useMemo<PaneFooterSegment[]>(() => (
-    !showAccessFooter
-      ? []
-      : hasRealtimeAccess
-      ? [{
-        id: "news-access",
-        parts: [{ text: "realtime news", tone: "positive" }],
-      }]
-      : [{
-        id: "news-access",
-        onPress: openUpgrade,
-        parts: [{ text: "delayed 12h, upgrade for realtime", tone: "warning" }],
-      }]
-  ), [hasRealtimeAccess, openUpgrade, showAccessFooter]);
+  const accessInfo = useMemo<PaneFooterSegment[]>(() => {
+    if (access.isPayingPro) {
+      return [{ id: "news-access", parts: [{ text: t("real-time news"), tone: "positive" }] }];
+    }
+    return segment ? [segment] : [];
+  }, [access.isPayingPro, language, segment]);
   const footerInfo = useMemo(() => [...accessInfo, ...(info ?? [])], [accessInfo, info]);
 
   usePaneStatusLinkFooter({

package/src/plugins/builtin/options/footer.test.ts

@@ -1,115 +1,23 @@
 import { describe, expect, test } from "bun:test";
-import type { OptionsChain } from "../../../types/financials";
-import { buildOptionsAccessFooterSegment, resolveOptionsAccessFooterState } from "./footer";
-
-function chain(overrides: Partial<OptionsChain> = {}): OptionsChain {
-  return {
-    underlyingSymbol: "AAPL",
-    expirationDates: [],
-    calls: [],
-    puts: [],
-    ...overrides,
-  };
-}
-
-describe("options access footer", () => {
-  test("offers free users the exact delayed upgrade state with a clickable segment", () => {
-    const state = resolveOptionsAccessFooterState({
-      chain: chain({
-        dataSource: "delayed",
-        delayMinutes: 15,
-        realtimeEligible: false,
-      }),
-      clientPlan: "free",
-      hasLiveQuote: false,
-    });
-    let upgrades = 0;
-    const segment = buildOptionsAccessFooterSegment(state, () => {
-      upgrades += 1;
-    });
-
-    expect(state).toEqual({
-      canUpgrade: true,
-      text: "15-minute delayed options, upgrade for real-time",
-      tone: "warning",
-    });
-    segment.onPress?.();
-    expect(upgrades).toBe(1);
-  });
-
-  test("claims real-time only for a Pro user with a fresh live stream", () => {
-    expect(
-      resolveOptionsAccessFooterState({
-        chain: chain({
-          dataSource: "delayed",
-          delayMinutes: 15,
-          realtimeEligible: true,
-        }),
-        clientPlan: "pro",
-        hasLiveQuote: false,
-      }),
-    ).toMatchObject({
-      canUpgrade: false,
-      text: "options delayed fallback",
-      tone: "warning",
-    });
-
-    expect(
-      resolveOptionsAccessFooterState({
-        chain: chain({
-          dataSource: "live",
-          delayMinutes: 0,
-          realtimeEligible: true,
-        }),
-        clientPlan: "pro",
-        hasLiveQuote: false,
-      }),
-    ).toMatchObject({
-      canUpgrade: false,
-      text: "options delayed fallback",
-      tone: "warning",
-    });
-
-    expect(
-      resolveOptionsAccessFooterState({
-        chain: chain({ realtimeEligible: false }),
-        clientPlan: "pro",
-        hasLiveQuote: true,
-      }).text,
-    ).toBe("real-time options");
-  });
-
-  test("makes the current plan authoritative over cached chain metadata", () => {
-    expect(
-      resolveOptionsAccessFooterState({
-        chain: chain({
-          dataSource: "live",
-          delayMinutes: 0,
-          realtimeEligible: true,
-        }),
-        clientPlan: "free",
-        hasLiveQuote: true,
-      }),
-    ).toMatchObject({
-      canUpgrade: true,
-      text: "15-minute delayed options, upgrade for real-time",
-      tone: "warning",
-    });
-
-    expect(
-      resolveOptionsAccessFooterState({
-        chain: chain({
-          dataSource: "delayed",
-          delayMinutes: 15,
-          realtimeEligible: false,
-        }),
-        clientPlan: "pro",
-        hasLiveQuote: true,
-      }),
-    ).toMatchObject({
-      canUpgrade: false,
-      text: "real-time options",
-      tone: "positive",
-    });
+import { resolveOptionsDelayLabel } from "./footer";
+
+describe("options delay label", () => {
+  test("prefers the chain delay and falls back to the cloud default", () => {
+    expect(resolveOptionsDelayLabel({
+      underlyingSymbol: "AAPL",
+      expirationDates: [],
+      calls: [],
+      puts: [],
+      delayMinutes: 20,
+    })).toBe("20m");
+    // A live chain reports 0, and a cached chain may omit the field entirely.
+    expect(resolveOptionsDelayLabel({
+      underlyingSymbol: "AAPL",
+      expirationDates: [],
+      calls: [],
+      puts: [],
+      delayMinutes: 0,
+    })).toBe("15m");
+    expect(resolveOptionsDelayLabel(null)).toBe("15m");
   });
 });

package/src/plugins/builtin/options/footer.ts

@@ -1,110 +1,67 @@
-import { useCallback, useMemo } from "react";
+import { useMemo } from "react";
 import type { PaneFooterSegment } from "../../../components";
-import { apiClient } from "../../../api-client";
 import { t, tf } from "../../../i18n";
-import { useShortcut } from "../../../react/input";
 import type { OptionsChain } from "../../../types/financials";
-import { useRendererHost } from "../../../ui";
-import { CLOUD_UPGRADE_URL } from "../shared/cloud-upgrade";
+import { useCloudAccessFooter } from "../shared/cloud-upgrade";
 import { usePaneStatusFooter } from "../shared/pane-footer";
+import { CLOUD_QUOTE_DELAY_MINUTES } from "../shared/plan-access";
+import type { OptionQuoteCoverage, OptionQuoteCoverageStatus } from "./live-quotes";
 
-export interface OptionsAccessFooterState {
-  canUpgrade: boolean;
+export interface OptionsCoverageState {
   text: string;
-  tone: "positive" | "warning";
+  tone: "muted" | "positive" | "warning";
 }
 
-export function resolveOptionsAccessFooterState({
-  chain,
-  clientPlan,
-  hasLiveQuote,
-}: {
-  chain: OptionsChain | null | undefined;
-  clientPlan: "free" | "pro" | null;
-  hasLiveQuote: boolean;
-}): OptionsAccessFooterState {
-  if (clientPlan !== "pro") {
-    const delayMinutes = chain?.delayMinutes && chain.delayMinutes > 0 ? chain.delayMinutes : 15;
-    return {
-      canUpgrade: true,
-      text: tf("{count}-minute delayed options, upgrade for real-time", {
-        count: delayMinutes,
-      }),
-      tone: "warning",
-    };
-  }
-
-  if (hasLiveQuote) {
-    return {
-      canUpgrade: false,
-      text: t("real-time options"),
-      tone: "positive",
-    };
-  }
-
-  return {
-    canUpgrade: false,
-    text: t("options delayed fallback"),
-    tone: "warning",
-  };
+/** Stream coverage the pane reports once the account is entitled to real-time options. */
+export function resolveOptionsCoverageState(status: OptionQuoteCoverageStatus): OptionsCoverageState {
+  if (status === "live") return { text: t("real-time options"), tone: "positive" };
+  if (status === "mixed") return { text: t("mixed real-time and delayed options"), tone: "warning" };
+  if (status === "connecting") return { text: t("connecting real-time options"), tone: "muted" };
+  return { text: t("options delayed fallback"), tone: "warning" };
 }
 
-export function buildOptionsAccessFooterSegment(
-  state: OptionsAccessFooterState,
-  openUpgrade: () => void,
-): PaneFooterSegment {
-  return {
-    id: "options-access",
-    ...(state.canUpgrade ? { onPress: openUpgrade } : {}),
-    parts: [{ text: state.text, tone: state.tone }],
-  };
+export function resolveOptionsDelayLabel(chain: OptionsChain | null | undefined): string {
+  const delayMinutes = chain?.delayMinutes && chain.delayMinutes > 0
+    ? chain.delayMinutes
+    : CLOUD_QUOTE_DELAY_MINUTES;
+  return tf("{count}m", { count: delayMinutes });
 }
 
 export function useOptionsAccessFooter({
   chain,
   error,
   focused,
-  hasLiveQuote,
   loading,
+  quoteCoverage,
 }: {
   chain: OptionsChain | null | undefined;
   error?: string | null;
   focused: boolean;
-  hasLiveQuote: boolean;
   loading?: boolean;
-}): OptionsAccessFooterState {
-  const rendererHost = useRendererHost();
-  const user = apiClient.getCurrentUser();
-  const clientPlan = user?.emailVerified === true && user.plan === "pro" ? "pro" : "free";
-  const state = resolveOptionsAccessFooterState({
-    chain,
-    clientPlan,
-    hasLiveQuote,
+  quoteCoverage: Pick<OptionQuoteCoverage, "status">;
+}): void {
+  const { access, segment } = useCloudAccessFooter({
+    delayLabel: resolveOptionsDelayLabel(chain),
+    focused,
+    segmentId: "options-access",
+    shortcutScope: "options:upgrade",
   });
-  const openUpgrade = useCallback(() => {
-    void rendererHost.openExternal(CLOUD_UPGRADE_URL);
-  }, [rendererHost]);
+  // Trial accounts stream real-time too, but the countdown is the status worth the row.
+  const coverage = access.hasProAccess && !access.isTrialActive
+    ? resolveOptionsCoverageState(quoteCoverage.status)
+    : null;
 
-  useShortcut(
-    (event) => {
-      const key = (event.name ?? event.key ?? "").toLowerCase();
-      if (!focused || !state.canUpgrade || key !== "u") return;
-      event.stopPropagation();
-      event.preventDefault();
-      openUpgrade();
-    },
-    { scope: "options:upgrade" },
-  );
+  const info = useMemo<PaneFooterSegment[]>(() => {
+    if (coverage) {
+      return [{ id: "options-access", parts: [{ text: coverage.text, tone: coverage.tone }] }];
+    }
+    return segment ? [segment] : [];
+  }, [coverage?.text, coverage?.tone, segment]);
 
-  const info = useMemo(
-    () => [buildOptionsAccessFooterSegment(state, openUpgrade)],
-    [openUpgrade, state.canUpgrade, state.text, state.tone],
-  );
   usePaneStatusFooter({
     registrationId: "options",
     loading,
     error,
     info,
   });
-  return state;
 }

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

@@ -1,6 +1,10 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { OptionsView } from "./view";
+import {
+  LIVE_STREAMING_QUICK_SETTING,
+  withLiveStreamingSetting,
+} from "../shared/live-streaming";
 
 export const optionsModule: PluginModule = {
   panes: [
@@ -12,6 +16,8 @@ export const optionsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 112, height: 28 },
+      quickSettings: [LIVE_STREAMING_QUICK_SETTING],
+      settings: (context) => withLiveStreamingSetting({ fields: [] }, context.settings),
     },
   ],
 

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

@@ -5,8 +5,8 @@ import type { OptionTableRow } from "./types";
 import {
   buildOptionQuoteKey,
   buildOptionQuoteTargets,
-  hasLiveOptionQuote,
   overlayOptionRowQuotes,
+  resolveOptionQuoteCoverage,
 } from "./live-quotes";
 
 function contract(strike: number, side: "C" | "P"): OptionContract {
@@ -51,22 +51,92 @@ function readyQuote(quote: Quote): QueryEntry<Quote> {
 }
 
 describe("options live quotes", () => {
-  test("bounds selected-expiry subscriptions around the current strike", () => {
+  test("subscribes every visible contract plus non-visible overscan", () => {
     const rows = Array.from({ length: 100 }, (_, index) => row(50 + index));
-    const targets = buildOptionQuoteTargets(rows, 50, 14);
+    const targets = buildOptionQuoteTargets(rows, {
+      fallbackHeight: 14,
+      selectedIndex: 50,
+      visibleRange: { start: 40, end: 64 },
+    });
+    const visibleTargets = targets.filter((target) => target.visible === true);
 
-    expect(targets).toHaveLength(16);
+    expect(targets).toHaveLength(64);
+    expect(visibleTargets).toHaveLength(48);
     expect(
       targets.every(
-        (target) => target.exchange === "OPTIONS" && target.surface === "options" && target.visible === true,
+        (target) => target.exchange === "OPTIONS" && target.surface === "options",
       ),
     ).toBe(true);
     expect(targets.filter((target) => target.selected)).toHaveLength(2);
     expect(targets.some((target) => target.symbol === rows[50]!.call!.contractSymbol)).toBe(true);
+    expect(visibleTargets.some((target) => target.symbol === rows[40]!.call!.contractSymbol)).toBe(true);
+    expect(visibleTargets.some((target) => target.symbol === rows[63]!.put!.contractSymbol)).toBe(true);
+    expect(targets.find((target) => target.symbol === rows[36]!.call!.contractSymbol)?.visible).toBe(false);
     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("requires fresh live stream metadata for every visible contract", () => {
+    const rows = [row(100), row(105), row(110)];
+    const targets = buildOptionQuoteTargets(rows, {
+      fallbackHeight: 14,
+      selectedIndex: 1,
+      visibleRange: { start: 1, end: 2 },
+    });
+    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 visibleRow = rows[1]!;
+    const quote = (symbol: string): 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",
+      stale: false,
+    });
+    const entries = new Map([
+      [buildOptionQuoteKey(visibleRow.call!.contractSymbol), readyQuote(quote(visibleRow.call!.contractSymbol))],
+      [buildOptionQuoteKey(visibleRow.put!.contractSymbol), readyQuote(quote(visibleRow.put!.contractSymbol))],
+      [buildOptionQuoteKey(rows[0]!.call!.contractSymbol), readyQuote(quote(rows[0]!.call!.contractSymbol))],
+    ]);
+
+    expect(resolveOptionQuoteCoverage(targets, entries, freshness)).toEqual({
+      fallbackCount: 0,
+      liveCount: 2,
+      status: "live",
+      totalCount: 2,
+    });
+
+    entries.delete(buildOptionQuoteKey(visibleRow.put!.contractSymbol));
+    expect(resolveOptionQuoteCoverage(targets, entries, freshness)).toMatchObject({
+      liveCount: 1,
+      status: "mixed",
+      totalCount: 2,
+    });
+
+    entries.clear();
+    entries.set(
+      buildOptionQuoteKey(rows[0]!.call!.contractSymbol),
+      readyQuote(quote(rows[0]!.call!.contractSymbol)),
+    );
+    expect(resolveOptionQuoteCoverage(targets, entries, {
+      ...freshness,
+      now: freshness.subscriptionStartedAt + 1_000,
+    })).toMatchObject({ liveCount: 0, status: "connecting", totalCount: 2 });
+  });
+
   test("overlays streamed quote fields while preserving chain-only Greeks and open interest", () => {
     const original = row(100);
     const symbol = original.call!.contractSymbol;
@@ -103,10 +173,9 @@ describe("options live quotes", () => {
       impliedVolatility: 0.25,
       openInterest: 20,
     });
-    expect(hasLiveOptionQuote(entries, freshness)).toBe(true);
   });
 
-  test("rejects cached quotes from before this subscription or the current chain", () => {
+  test("rejects quotes from before this subscription without comparing contracts to a global chain timestamp", () => {
     const original = row(100);
     const symbol = original.call!.contractSymbol;
     const quote: Quote = {
@@ -122,6 +191,8 @@ describe("options live quotes", () => {
       lastUpdated: 1_800_000_000_000,
       receivedAt: 1_800_000_010_000,
       dataSource: "live",
+      delivery: "stream",
+      stale: false,
     };
     const entries = new Map([[buildOptionQuoteKey(symbol), readyQuote(quote)]]);
 
@@ -131,16 +202,33 @@ describe("options live quotes", () => {
       subscriptionStartedAt: 1_800_000_020_000,
     };
     expect(overlayOptionRowQuotes([original], entries, beforeSubscription)[0]!.call!.lastPrice).toBe(1);
-    expect(hasLiveOptionQuote(entries, beforeSubscription)).toBe(false);
+    const targets = buildOptionQuoteTargets([original], {
+      fallbackHeight: 14,
+      selectedIndex: 0,
+      visibleRange: { start: 0, end: 1 },
+    });
+    expect(resolveOptionQuoteCoverage(targets, entries, beforeSubscription).status).not.toBe("live");
 
-    const olderThanChain = {
+    const heterogeneousChainSnapshot = {
       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);
+    expect(overlayOptionRowQuotes([original], entries, heterogeneousChainSnapshot)[0]!.call!.lastPrice).toBe(9);
+    expect(resolveOptionQuoteCoverage(targets, entries, heterogeneousChainSnapshot)).toMatchObject({
+      liveCount: 1,
+      status: "mixed",
+    });
+
+    const newerContract = row(100);
+    newerContract.call = {
+      ...newerContract.call!,
+      lastUpdated: 1_800_000_005_000,
+    };
+    expect(
+      overlayOptionRowQuotes([newerContract], entries, heterogeneousChainSnapshot)[0]!.call!.lastPrice,
+    ).toBe(1);
   });
 
   test("accepts a freshly delivered delayed quote older than the delayed chain fetch", () => {
@@ -171,7 +259,12 @@ describe("options live quotes", () => {
     };
 
     expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(2.25);
-    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+    const targets = buildOptionQuoteTargets([original], {
+      fallbackHeight: 14,
+      selectedIndex: 0,
+      visibleRange: { start: 0, end: 1 },
+    });
+    expect(resolveOptionQuoteCoverage(targets, entries, freshness).status).toBe("delayed");
   });
 
   test("overlays a valid polled quote without reporting a live stream", () => {
@@ -202,7 +295,12 @@ describe("options live quotes", () => {
     };
 
     expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(2.5);
-    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+    const targets = buildOptionQuoteTargets([original], {
+      fallbackHeight: 14,
+      selectedIndex: 0,
+      visibleRange: { start: 0, end: 1 },
+    });
+    expect(resolveOptionQuoteCoverage(targets, entries, freshness).status).toBe("delayed");
   });
 
   test("rejects a freshly received quote marked stale by the server", () => {
@@ -233,6 +331,11 @@ describe("options live quotes", () => {
     };
 
     expect(overlayOptionRowQuotes([original], entries, freshness)[0]!.call!.lastPrice).toBe(1);
-    expect(hasLiveOptionQuote(entries, freshness)).toBe(false);
+    const targets = buildOptionQuoteTargets([original], {
+      fallbackHeight: 14,
+      selectedIndex: 0,
+      visibleRange: { start: 0, end: 1 },
+    });
+    expect(resolveOptionQuoteCoverage(targets, entries, freshness).status).toBe("delayed");
   });
 });