gloomberb 0.11.2 → 0.12.0

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

@@ -4,7 +4,7 @@ import type { QuoteSubscriptionTarget } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import { debugLog } from "../../utils/debug-log";
 import { normalizeSymbol } from "../../utils/exchanges";
-import { getSharedMarketDataCoordinator } from "../../market-data/coordinator";
+import { getSharedMarketDataCoordinator, type MarketDataCoordinator } from "../../market-data/coordinator";
 import { useQuoteEntries } from "../../market-data/hooks";
 import type { InstrumentRef } from "../../market-data/request-types";
 import type { QueryEntry } from "../../market-data/result-types";
@@ -33,12 +33,11 @@ export function normalizeQuoteStreamSubscriptionTarget(target: QuoteSubscription
   };
 }
 
-export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {
+export function buildQuoteStreamSubscriptionIdentityKey(target: QuoteSubscriptionTarget): string {
   const contractKey = target.context?.instrument?.conId
     ?? target.context?.instrument?.localSymbol
     ?? target.context?.instrument?.symbol
     ?? "";
-  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
   return [
     target.symbol,
     target.exchange ?? "",
@@ -46,6 +45,13 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     target.context?.brokerInstanceId ?? "",
     contractKey,
     target.route ?? "auto",
+  ].join("|");
+}
+
+export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {
+  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
+  return [
+    buildQuoteStreamSubscriptionIdentityKey(target),
     target.surface ?? "",
     target.visible ? "visible" : "",
     target.selected ? "selected" : "",
@@ -53,6 +59,37 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
   ].join("|");
 }
 
+type CoordinatorQuoteTargets = Parameters<MarketDataCoordinator["subscribeQuotes"]>[0];
+type UpdateableQuoteSubscription = (() => void) & {
+  update?: (targets: CoordinatorQuoteTargets) => void;
+};
+
+interface ActiveQuoteSubscription {
+  identityKey: string;
+  subscriptionKey: string;
+  count: number;
+  dispose: UpdateableQuoteSubscription;
+}
+
+function toCoordinatorQuoteTargets(targets: QuoteSubscriptionTarget[]): CoordinatorQuoteTargets {
+  return targets.map((target) => ({
+    instrument: {
+      symbol: target.symbol,
+      exchange: target.exchange,
+      brokerId: target.context?.brokerId,
+      brokerInstanceId: target.context?.brokerInstanceId,
+      instrument: target.context?.instrument ?? null,
+    },
+    priority: {
+      route: target.route,
+      surface: target.surface,
+      visible: target.visible,
+      selected: target.selected,
+      weight: target.weight,
+    },
+  }));
+}
+
 export function useQuoteStreaming(
   targets: QuoteSubscriptionTarget[],
   { enabled = true }: QuoteStreamingOptions = {},
@@ -70,48 +107,86 @@ export function useQuoteStreaming(
   const sortedEntries = [...normalizedEntries.entries()].sort(([left], [right]) => left.localeCompare(right));
   const normalizedTargets = sortedEntries.map(([, target]) => target);
   const subscriptionKey = sortedEntries.map(([key]) => key).join("|");
+  const identityKey = [...new Set(normalizedTargets.map(buildQuoteStreamSubscriptionIdentityKey))]
+    .sort()
+    .join("\u001f");
+  const coordinatorTargets = toCoordinatorQuoteTargets(normalizedTargets);
+  const latestSubscriptionRef = useRef({
+    identityKey,
+    subscriptionKey,
+    targets: coordinatorTargets,
+  });
+  latestSubscriptionRef.current = {
+    identityKey,
+    subscriptionKey,
+    targets: coordinatorTargets,
+  };
+  const activeSubscriptionRef = useRef<ActiveQuoteSubscription | null>(null);
 
   useEffect(() => {
+    const latest = latestSubscriptionRef.current;
     if (!enabled || !appActive) {
-      if (normalizedTargets.length > 0) {
+      if (latest.targets.length > 0) {
         quoteStreamLog.info("skipping subscription", {
           reason: enabled ? "inactive" : "disabled",
-          targets: subscriptionKey,
+          targets: latest.subscriptionKey,
         });
       }
       return;
     }
-    if (!coordinator || normalizedTargets.length === 0) return;
+    if (!coordinator || latest.targets.length === 0) return;
     quoteStreamLog.info("subscribe", {
       providerId: "market-data",
-      count: normalizedTargets.length,
-      targets: subscriptionKey,
+      count: latest.targets.length,
+      targets: latest.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,
-      },
-      priority: {
-        route: target.route,
-        surface: target.surface,
-        visible: target.visible,
-        selected: target.selected,
-        weight: target.weight,
-      },
-    })));
+    const active: ActiveQuoteSubscription = {
+      identityKey: latest.identityKey,
+      subscriptionKey: latest.subscriptionKey,
+      count: latest.targets.length,
+      dispose: coordinator.subscribeQuotes(latest.targets) as UpdateableQuoteSubscription,
+    };
+    activeSubscriptionRef.current = active;
     return () => {
+      if (activeSubscriptionRef.current === active) {
+        activeSubscriptionRef.current = null;
+      }
       quoteStreamLog.info("unsubscribe", {
         providerId: "market-data",
-        count: normalizedTargets.length,
-        targets: subscriptionKey,
+        count: active.count,
+        targets: active.subscriptionKey,
       });
-      unsubscribe?.();
+      active.dispose();
     };
-  }, [appActive, coordinator, enabled, subscriptionKey]);
+  }, [appActive, coordinator, enabled, identityKey]);
+
+  useEffect(() => {
+    if (!enabled || !appActive || !coordinator) return;
+    const active = activeSubscriptionRef.current;
+    const latest = latestSubscriptionRef.current;
+    if (
+      !active
+      || active.identityKey !== latest.identityKey
+      || active.subscriptionKey === latest.subscriptionKey
+    ) {
+      return;
+    }
+
+    quoteStreamLog.info("update subscription", {
+      providerId: "market-data",
+      count: latest.targets.length,
+      targets: latest.subscriptionKey,
+    });
+    if (typeof active.dispose.update === "function") {
+      active.dispose.update(latest.targets);
+    } else {
+      const previousDispose = active.dispose;
+      active.dispose = coordinator.subscribeQuotes(latest.targets) as UpdateableQuoteSubscription;
+      previousDispose();
+    }
+    active.subscriptionKey = latest.subscriptionKey;
+    active.count = latest.targets.length;
+  }, [appActive, coordinator, enabled, identityKey, subscriptionKey]);
 }
 
 export function useQuoteUpdates(
@@ -195,8 +270,9 @@ export function useLiveQuoteEntries(
     const normalized = normalizeQuoteStreamSubscriptionTarget(target);
     return normalized ? [normalized] : [];
   });
-  const targetKey = normalizedTargets
-    .map((target) => buildQuoteStreamSubscriptionKey(target))
+  const targetKey = [...new Set(
+    normalizedTargets.map((target) => buildQuoteStreamSubscriptionIdentityKey(target)),
+  )]
     .sort()
     .join("\u001f");
   const liveStreaming = options.liveStreaming !== false;

package/src/state/pane-table-export-registry.ts

@@ -0,0 +1,50 @@
+import { createCsvExportFilename } from "../utils/csv";
+
+export type PaneTableExporter = (filename: string) => Promise<string>;
+
+const exporters = new Map<string, Map<symbol, PaneTableExporter>>();
+
+export function registerPaneTableExporter(
+  paneId: string,
+  exporter: PaneTableExporter,
+): () => void {
+  const token = Symbol(paneId);
+  const paneExporters = exporters.get(paneId) ?? new Map<symbol, PaneTableExporter>();
+  paneExporters.set(token, exporter);
+  exporters.set(paneId, paneExporters);
+
+  return () => {
+    const current = exporters.get(paneId);
+    current?.delete(token);
+    if (current?.size === 0) exporters.delete(paneId);
+  };
+}
+
+export function hasPaneTableExporter(paneId: string): boolean {
+  return exporters.get(paneId)?.size === 1;
+}
+
+export async function exportPaneTable(paneId: string, filename: string): Promise<string> {
+  const paneExporters = exporters.get(paneId);
+  if (paneExporters?.size !== 1) {
+    throw new Error("This pane does not have one active exportable table.");
+  }
+  return [...paneExporters.values()][0]!(filename);
+}
+
+/**
+ * Shared entry point for the pane menu, the keyboard shortcut, and pane settings so
+ * every surface produces the same filename and the same success/failure notification.
+ */
+export async function exportPaneTableCsv(
+  paneId: string,
+  title: string,
+  notify: (notification: { body: string; type: "success" | "error" }) => void,
+): Promise<void> {
+  try {
+    const location = await exportPaneTable(paneId, createCsvExportFilename(title));
+    notify({ body: `Exported to ${location}`, type: "success" });
+  } catch {
+    notify({ body: "Failed to export CSV", type: "error" });
+  }
+}

package/src/theme/color-utils.ts

@@ -10,7 +10,7 @@ export function blendHex(a: string, b: string, ratio: number): string {
   return `#${mix(ar, br)}${mix(ag, bg)}${mix(ab, bb)}`;
 }
 
-function relativeLuminance(hex: string): number {
+export function relativeLuminance(hex: string): number {
   const h = hex.replace("#", "");
   const toLinear = (value: string) => {
     const normalized = parseInt(value, 16) / 255;

package/src/theme/colors.ts

@@ -193,6 +193,56 @@ export function commandBarAccentText(palette: ThemeColors = colors): string {
   );
 }
 
+/**
+ * Matched terms inside a result row's snippet. It has to stay legible on the
+ * selected row too, so contrast is checked against the selection background as
+ * well as the two panel surfaces.
+ */
+export function commandBarMatchText(palette: ThemeColors = colors): string {
+  const surfaces = [
+    commandBarBg(palette),
+    commandBarPanelBg(palette),
+    commandBarSelectedBg(palette),
+  ] as const;
+  return blendForContrastOnSurfaces(
+    palette.warning,
+    surfaces,
+    higherContrast("#ffffff", "#000000", surfaces[0]),
+    3.6,
+  );
+}
+
+export type CommandBarBadgeTone = "command" | "instrument" | "document" | "assist";
+
+function commandBarBadgeHue(tone: CommandBarBadgeTone, palette: ThemeColors): string {
+  if (tone === "instrument") return palette.warning;
+  if (tone === "document") return palette.neutral;
+  if (tone === "assist") return ASSIST_ACCENT;
+  return palette.borderFocused;
+}
+
+/**
+ * Text-only tag left of a result label. One hue per family so commands,
+ * instruments, documents and AI answers scan apart without a filled box, pulled
+ * towards the subtle text so the tag stays quieter than the label, then pushed
+ * only until it clears every surface it can land on, the selected row included.
+ */
+export function commandBarBadgeText(tone: CommandBarBadgeTone, palette: ThemeColors = colors): string {
+  const surfaces = [
+    commandBarBg(palette),
+    commandBarPanelBg(palette),
+    commandBarHoverBg(palette),
+    commandBarSelectedBg(palette),
+  ] as const;
+  const muted = blendHex(commandBarBadgeHue(tone, palette), commandBarSubtleText(palette), 0.4);
+  return blendForContrastOnSurfaces(
+    muted,
+    surfaces,
+    higherContrast("#ffffff", "#000000", surfaces[0]),
+    3.6,
+  );
+}
+
 export function commandBarSelectedText(palette: ThemeColors = colors): string {
   const base = commandBarSelectedBg(palette);
   const preferred = higherContrast(palette.selectedText, palette.text, base);

package/src/theme/themes.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 import {
   applyTheme,
   commandBarAccentText,
@@ -16,7 +16,7 @@ import {
   paneTitleText,
 } from "./colors";
 import { contrastRatio } from "./color-utils";
-import { DEFAULT_THEME, themes } from "./themes";
+import { DEFAULT_THEME, getThemeIds, isDarkTheme, themes } from "./themes";
 
 const BODY_TEXT_MIN = 4.5;
 const SUBTLE_TEXT_MIN = 3.6;
@@ -34,6 +34,19 @@ afterEach(() => {
   applyTheme(DEFAULT_THEME);
 });
 
+/**
+ * The theme picker marks the dark half of its list with a moon, so a palette
+ * that lands on the wrong side of this shows the wrong glyph, and the whole
+ * gutter stops meaning anything. Pinning the light set catches a palette drifting
+ * across the line when someone retunes its colours.
+ */
+describe("theme appearance", () => {
+  test("reads every light theme as light and everything else as dark", () => {
+    const light = getThemeIds().filter((id) => !isDarkTheme(id)).sort();
+    expect(light).toEqual(["github-light", "gruvbox-light", "nord-light", "paper", "solarized-light"]);
+  });
+});
+
 describe("theme contrast", () => {
   test("keeps shared text roles readable on body surfaces", () => {
     for (const [id, theme] of Object.entries(themes)) {

package/src/theme/themes.ts

@@ -1,4 +1,11 @@
-import { blendForContrast, blendForContrastOnSurfaces, blendHex, contrastRatio, higherContrast } from "./color-utils";
+import {
+  blendForContrast,
+  blendForContrastOnSurfaces,
+  blendHex,
+  contrastRatio,
+  higherContrast,
+  relativeLuminance,
+} from "./color-utils";
 
 export interface Theme {
   name: string;
@@ -638,6 +645,17 @@ export function getThemeIds(): string[] {
   return Object.keys(themes);
 }
 
+/**
+ * A theme is dark when its text sits lighter than its background. That is the
+ * definition, and it beats thresholding the background on its own, which
+ * mislabels the mid-tone palettes sitting near whatever cutoff you pick.
+ */
+export function isDarkTheme(themeId: string): boolean {
+  const theme = themes[themeId];
+  if (!theme) return true;
+  return relativeLuminance(theme.text) > relativeLuminance(theme.bg);
+}
+
 export function getTheme(id: string): Theme {
   return themes[id] ?? themes[DEFAULT_THEME]!;
 }

package/src/tickers/search/index.test.ts

@@ -359,6 +359,32 @@ describe("ticker-search utilities", () => {
     expect(rankTickerSearchItems([...candidates].reverse(), "Apple").map((item) => item.symbol)).toEqual(expected);
   });
 
+  test("ranks the primary listing above leveraged and depositary look-alikes", () => {
+    const make = (symbol: string, right: string, providerRank: number) => ({
+      id: symbol,
+      label: symbol,
+      symbol,
+      detail: "NVIDIA Corporation",
+      right,
+      category: "Other Listings",
+      kind: "search" as const,
+      instrumentClass: "equity" as const,
+      providerRank,
+    });
+    // Provider order puts the Milan 4x product first; every text signal ties.
+    const candidates = [make("4NVDA", "MTA", 0), make("NVDA", "NASDAQ", 1), make("NVDC34", "BOVESPA", 2)];
+
+    expect(rankTickerSearchItems(candidates, "nvidia").map((item) => item.symbol))
+      .toEqual(["NVDA", "4NVDA", "NVDC34"]);
+
+    // All-digit symbols are Tokyo, Shanghai and Hong Kong primaries, not look-alikes.
+    const toyota = [
+      { ...make("7203", "TSE", 0), detail: "Toyota Motor Corporation" },
+      { ...make("TM", "NYSE", 1), detail: "Toyota Motor Corporation" },
+    ];
+    expect(rankTickerSearchItems(toyota, "toyota").map((item) => item.symbol)).toEqual(["7203", "TM"]);
+  });
+
   test("normalizes punctuated legal suffixes before applying same-issuer provider order", () => {
     const results = buildTickerSearchCandidates({
       query: "Acme",

package/src/tickers/search/index.ts

@@ -117,6 +117,7 @@ export async function searchTickerCandidates({
   localLimit = 6,
   totalLimit = 8,
   includeOptionContracts = true,
+  onPartial,
 }: {
   query: string;
   tickers: ReadonlyMap<string, TickerRecord>;
@@ -125,15 +126,23 @@ export async function searchTickerCandidates({
   localLimit?: number;
   totalLimit?: number;
   includeOptionContracts?: boolean;
+  /** Called when a slower, richer source improves results already returned. */
+  onPartial?: (candidates: TickerSearchCandidate[]) => void;
 }): Promise<TickerSearchCandidate[]> {
-  return buildTickerSearchCandidates({
+  const assemble = (providerResults: InstrumentSearchResult[]) => buildTickerSearchCandidates({
     query,
     tickers,
-    providerResults: await searchProviderResults(dataProvider, query, searchContext),
+    providerResults,
     localLimit,
     totalLimit,
     includeOptionContracts,
   });
+  return assemble(await searchProviderResults(
+    dataProvider,
+    query,
+    searchContext,
+    onPartial ? (results) => onPartial(assemble(results)) : undefined,
+  ));
 }
 
 export function buildTickerSearchCandidates({
@@ -233,27 +242,43 @@ async function searchProviderResults(
   dataProvider: DataProvider,
   query: string,
   searchContext?: SearchRequestContext,
+  onPartial?: (results: InstrumentSearchResult[]) => void,
 ): Promise<InstrumentSearchResult[]> {
-  const merged: InstrumentSearchResult[] = [];
-  const seen = new Set<string>();
+  // A Map rather than a list plus a seen set, because a later source can send
+  // back a richer version of a symbol already recorded. Overwriting a key keeps
+  // its original position, so an upgrade does not reorder the list.
+  const byKey = new Map<string, InstrumentSearchResult>();
+  const add = (results: InstrumentSearchResult[], upgrade = false) => {
+    for (const result of results) {
+      const key = buildProviderSearchResultKey(result);
+      if (!upgrade && byKey.has(key)) continue;
+      byKey.set(key, result);
+    }
+  };
 
-  for (const searchQuery of buildProviderSearchQueries(query)) {
-    let results: InstrumentSearchResult[] = [];
+  // The variants are independent lookups of the same words, so they run
+  // together. Awaited in turn they multiplied every per-source timeout by the
+  // number of spellings tried.
+  await Promise.all(buildProviderSearchQueries(query).map(async (searchQuery) => {
     try {
-      results = await dataProvider.search(searchQuery, searchContext);
+      const results = await dataProvider.search(searchQuery, {
+        ...searchContext,
+        ...(onPartial
+          ? {
+            onPartial: (upgraded: InstrumentSearchResult[]) => {
+              add(upgraded, true);
+              onPartial([...byKey.values()]);
+            },
+          }
+          : {}),
+      });
+      add(results);
     } catch {
-      results = [];
+      // One spelling failing must not lose the others.
     }
+  }));
 
-    for (const result of results) {
-      const key = buildProviderSearchResultKey(result);
-      if (seen.has(key)) continue;
-      seen.add(key);
-      merged.push(result);
-    }
-  }
-
-  return merged;
+  return [...byKey.values()];
 }
 
 function buildProviderSearchQueries(query: string): string[] {

package/src/tickers/search/ranking.ts

@@ -225,6 +225,15 @@ export function rankTickerSearchItems<T extends Pick<TickerSearchRankableItem, "
       a.issuerGroupKey
       && a.issuerGroupKey === b.issuerGroupKey
     ) {
+      // Letters mixed with digits (4NVDA, NVDC34, 0R1I) mark a leveraged
+      // product, a depositary receipt or a secondary venue's code filed under
+      // the issuer's name, never its primary listing. All-digit symbols are
+      // Tokyo, Shanghai and Hong Kong primaries and must not be touched.
+      // Provider order is trusted for real listings of one issuer, but it put
+      // a Milan 4x product above NVDA, so mixed codes yield first.
+      const aSynthetic = isMixedCode(a.item.label);
+      const bSynthetic = isMixedCode(b.item.label);
+      if (aSynthetic !== bSynthetic) return aSynthetic ? 1 : -1;
       const aProviderRank = a.item.providerRank ?? Number.POSITIVE_INFINITY;
       const bProviderRank = b.item.providerRank ?? Number.POSITIVE_INFINITY;
       if (aProviderRank !== bProviderRank) return aProviderRank - bProviderRank;
@@ -438,6 +447,11 @@ function scoreExchangePreference(
   return matchesHint ? 2_000 : -800;
 }
 
+function isMixedCode(label: string): boolean {
+  const symbol = label.split(".")[0] ?? label;
+  return /\d/.test(symbol) && /[A-Za-z]/.test(symbol);
+}
+
 function scoreListingPriority(item: Pick<TickerSearchRankableItem, "label"> & Partial<TickerSearchRankableItem>): number {
   const instrumentClass = item.instrumentClass || "other";
   if (instrumentClass !== "equity") return 0;