gloomberb 0.8.1 → 0.9.0

package/src/plugins/builtin/portfolio-list/pane/supplemental.ts

@@ -0,0 +1,281 @@
+import { useEffect, useMemo, useRef, useState, type Dispatch, type SetStateAction } from "react";
+import type { ColumnConfig } from "../../../../types/config";
+import type { AnalystResearchData, CorporateActionsData } from "../../../../types/financials";
+import type { DataProvider, EarningsEvent } from "../../../../types/data-provider";
+import type { TickerRecord } from "../../../../types/ticker";
+import { useAssetData } from "../../../runtime";
+import { loadEarningsCalendar } from "../../earnings/data/cache";
+
+const SUPPLEMENTAL_BATCH_LIMIT = 6;
+const ANALYST_COLUMN_IDS = new Set(["target", "target_pct", "rating"]);
+const CORPORATE_COLUMN_IDS = new Set(["ex_div", "next_earn"]);
+const EARNINGS_COLUMN_IDS = new Set(["next_earn"]);
+
+interface SupplementalTarget {
+  symbol: string;
+  exchange: string;
+}
+
+export interface PortfolioSupplementalData {
+  analystResearch: Map<string, AnalystResearchData | null>;
+  corporateActions: Map<string, CorporateActionsData | null>;
+  earningsEvents: Map<string, EarningsEvent | null>;
+  version: number;
+}
+
+type SupplementalState = PortfolioSupplementalData;
+
+function targetKey(targets: SupplementalTarget[]): string {
+  return targets.map((target) => `${target.symbol}:${target.exchange}`).join("|");
+}
+
+function targetsFromTickers(tickers: TickerRecord[]): SupplementalTarget[] {
+  return tickers.map((ticker) => ({
+    symbol: ticker.metadata.ticker,
+    exchange: ticker.metadata.exchange ?? "",
+  }));
+}
+
+function needsAnyColumn(columns: ColumnConfig[], ids: Set<string>): boolean {
+  return columns.some((column) => ids.has(column.id));
+}
+
+function pickMissingBatch<T>(
+  targets: SupplementalTarget[],
+  values: Map<string, T | null>,
+  inFlight: Set<string>,
+): SupplementalTarget[] {
+  const batch: SupplementalTarget[] = [];
+  for (const target of targets) {
+    if (values.has(target.symbol) || inFlight.has(target.symbol)) continue;
+    batch.push(target);
+    if (batch.length >= SUPPLEMENTAL_BATCH_LIMIT) break;
+  }
+  return batch;
+}
+
+function markMissing<T>(
+  targets: SupplementalTarget[],
+  values: Map<string, T | null>,
+): Map<string, T | null> | null {
+  let changed = false;
+  const next = new Map(values);
+  for (const target of targets) {
+    if (next.has(target.symbol)) continue;
+    next.set(target.symbol, null);
+    changed = true;
+  }
+  return changed ? next : null;
+}
+
+function setAnalystValues(
+  current: SupplementalState,
+  entries: Array<readonly [string, AnalystResearchData | null]>,
+): SupplementalState {
+  const analystResearch = new Map(current.analystResearch);
+  for (const [symbol, data] of entries) {
+    analystResearch.set(symbol, data);
+  }
+  return { ...current, analystResearch, version: current.version + 1 };
+}
+
+function setCorporateValues(
+  current: SupplementalState,
+  entries: Array<readonly [string, CorporateActionsData | null]>,
+): SupplementalState {
+  const corporateActions = new Map(current.corporateActions);
+  for (const [symbol, data] of entries) {
+    corporateActions.set(symbol, data);
+  }
+  return { ...current, corporateActions, version: current.version + 1 };
+}
+
+function setEarningsValues(
+  current: SupplementalState,
+  symbols: string[],
+  events: EarningsEvent[],
+): SupplementalState {
+  const eventsBySymbol = new Map<string, EarningsEvent>();
+  const now = Date.now();
+  for (const event of events) {
+    const symbol = event.symbol.trim().toUpperCase();
+    if (!symbol || event.earningsDate.getTime() < now) continue;
+    const currentEvent = eventsBySymbol.get(symbol);
+    if (!currentEvent || event.earningsDate < currentEvent.earningsDate) {
+      eventsBySymbol.set(symbol, event);
+    }
+  }
+
+  const earningsEvents = new Map(current.earningsEvents);
+  for (const symbol of symbols) {
+    earningsEvents.set(symbol, eventsBySymbol.get(symbol) ?? null);
+  }
+  return { ...current, earningsEvents, version: current.version + 1 };
+}
+
+function useAnalystSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(new Set<string>());
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getAnalystResearch) {
+      setState((current) => {
+        const missing = markMissing(targets, current.analystResearch);
+        return missing ? { ...current, analystResearch: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const batch = pickMissingBatch(targets, state.analystResearch, inFlightRef.current);
+    if (batch.length === 0) return;
+    for (const target of batch) inFlightRef.current.add(target.symbol);
+
+    let cancelled = false;
+    Promise.all(batch.map(async (target) => {
+      try {
+        const data = await provider.getAnalystResearch!(target.symbol, target.exchange);
+        return [target.symbol, data] as const;
+      } catch {
+        return [target.symbol, null] as const;
+      } finally {
+        inFlightRef.current.delete(target.symbol);
+      }
+    })).then((entries) => {
+      if (cancelled) return;
+      setState((current) => setAnalystValues(current, entries));
+    }).catch(() => {});
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.analystResearch, targetsKey]);
+}
+
+function useCorporateSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(new Set<string>());
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getCorporateActions) {
+      setState((current) => {
+        const missing = markMissing(targets, current.corporateActions);
+        return missing ? { ...current, corporateActions: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const batch = pickMissingBatch(targets, state.corporateActions, inFlightRef.current);
+    if (batch.length === 0) return;
+    for (const target of batch) inFlightRef.current.add(target.symbol);
+
+    let cancelled = false;
+    Promise.all(batch.map(async (target) => {
+      try {
+        const data = await provider.getCorporateActions!(target.symbol, target.exchange);
+        return [target.symbol, data] as const;
+      } catch {
+        return [target.symbol, null] as const;
+      } finally {
+        inFlightRef.current.delete(target.symbol);
+      }
+    })).then((entries) => {
+      if (cancelled) return;
+      setState((current) => setCorporateValues(current, entries));
+    }).catch(() => {});
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.corporateActions, targetsKey]);
+}
+
+function useEarningsSupplemental(
+  provider: DataProvider | null | undefined,
+  targets: SupplementalTarget[],
+  enabled: boolean,
+  state: SupplementalState,
+  setState: Dispatch<SetStateAction<SupplementalState>>,
+) {
+  const inFlightRef = useRef(false);
+  const targetsKey = targetKey(targets);
+
+  useEffect(() => {
+    if (!enabled || targets.length === 0) return;
+    if (!provider?.getEarningsCalendar) {
+      setState((current) => {
+        const missing = markMissing(targets, current.earningsEvents);
+        return missing ? { ...current, earningsEvents: missing, version: current.version + 1 } : current;
+      });
+      return;
+    }
+
+    const missingSymbols = targets
+      .map((target) => target.symbol)
+      .filter((symbol) => !state.earningsEvents.has(symbol));
+    if (missingSymbols.length === 0 || inFlightRef.current) return;
+
+    inFlightRef.current = true;
+    let cancelled = false;
+    loadEarningsCalendar(provider, missingSymbols)
+      .then((events) => {
+        if (cancelled) return;
+        setState((current) => setEarningsValues(current, missingSymbols, events));
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setState((current) => ({
+          ...current,
+          earningsEvents: markMissing(
+            missingSymbols.map((symbol) => ({ symbol, exchange: "" })),
+            current.earningsEvents,
+          ) ?? current.earningsEvents,
+          version: current.version + 1,
+        }));
+      })
+      .finally(() => {
+        inFlightRef.current = false;
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, setState, state.earningsEvents, targetsKey]);
+}
+
+export function usePortfolioSupplementalData(
+  tickers: TickerRecord[],
+  columns: ColumnConfig[],
+  appActive: boolean,
+): PortfolioSupplementalData {
+  const provider = useAssetData();
+  const targets = useMemo(() => targetsFromTickers(tickers), [tickers]);
+  const [state, setState] = useState<SupplementalState>(() => ({
+    analystResearch: new Map(),
+    corporateActions: new Map(),
+    earningsEvents: new Map(),
+    version: 0,
+  }));
+  const needsAnalyst = appActive && needsAnyColumn(columns, ANALYST_COLUMN_IDS);
+  const needsCorporate = appActive && needsAnyColumn(columns, CORPORATE_COLUMN_IDS);
+  const needsEarnings = appActive && needsAnyColumn(columns, EARNINGS_COLUMN_IDS);
+
+  useAnalystSupplemental(provider, targets, needsAnalyst, state, setState);
+  useCorporateSupplemental(provider, targets, needsCorporate, state, setState);
+  useEarningsSupplemental(provider, targets, needsEarnings, state, setState);
+
+  return state;
+}

package/src/plugins/builtin/portfolio-list/settings.ts

@@ -21,30 +21,57 @@ export interface CollectionEntry {
 const PORTFOLIO_COLUMN_DEFS: ColumnConfig[] = [
   ...DEFAULT_COLUMNS,
   { id: PRICE_SPARKLINE_COLUMN_ID, label: PRICE_SPARKLINE_PERIOD_LABEL, width: 6, align: "left" },
+  { id: "name", label: "NAME", width: 16, align: "left" },
+  { id: "asset_type", label: "TYPE", width: 5, align: "left" },
+  { id: "exchange", label: "EXCH", width: 8, align: "left" },
+  { id: "currency", label: "CCY", width: 4, align: "left" },
+  { id: "sector", label: "SECTOR", width: 14, align: "left" },
+  { id: "industry", label: "INDUSTRY", width: 16, align: "left" },
+  { id: "tags", label: "TAGS", width: 14, align: "left" },
+  { id: "volume", label: "VOL", width: 8, align: "right", format: "compact" },
+  { id: "dollar_volume", label: "$VOL", width: 9, align: "right", format: "compact" },
+  { id: "range_52w", label: "52W%", width: 7, align: "right", format: "percent" },
   { id: "bid", label: "BID", width: 10, align: "right", format: "currency" },
   { id: "ask", label: "ASK", width: 10, align: "right", format: "currency" },
   { id: "spread", label: "SPREAD", width: 10, align: "right", format: "currency" },
+  { id: "spread_pct", label: "SPR%", width: 7, align: "right", format: "percent" },
+  { id: "bid_ask_size", label: "B/A SZ", width: 9, align: "right", format: "compact" },
   { id: "change", label: "CHG", width: 9, align: "right", format: "currency" },
   { id: "ext_hours", label: "EXT%", width: 8, align: "right", format: "percent" },
   { id: "dividend_yield", label: "DIV%", width: 7, align: "right", format: "percent" },
+  { id: "target", label: "TARGET", width: 10, align: "right", format: "currency" },
+  { id: "target_pct", label: "TARGET%", width: 8, align: "right", format: "percent" },
+  { id: "rating", label: "RATING", width: 7, align: "right", format: "number" },
+  { id: "ex_div", label: "EX-DIV", width: 7, align: "right" },
+  { id: "next_earn", label: "ERN", width: 7, align: "right" },
+  { id: "side", label: "SIDE", width: 5, align: "left" },
   { id: "shares", label: "SHARES", width: 9, align: "right", format: "number" },
   { id: "avg_cost", label: "AVG COST", width: 10, align: "right", format: "currency" },
   { id: "cost_basis", label: "COST", width: 10, align: "right", format: "compact" },
   { id: "mkt_value", label: "MKT VAL", width: 10, align: "right", format: "compact" },
+  { id: "weight", label: "WEIGHT", width: 8, align: "right", format: "percent" },
   { id: "day_pnl", label: "DAY", width: 10, align: "right", format: "compact" },
   { id: "pnl", label: "P&L", width: 10, align: "right", format: "compact" },
   { id: "pnl_pct", label: "P&L%", width: 8, align: "right", format: "percent" },
+  { id: "mark_delta", label: "MARK%", width: 8, align: "right", format: "percent" },
+  { id: "acq_date", label: "ACQ", width: 7, align: "right" },
+  { id: "held", label: "HELD", width: 6, align: "right" },
 ];
 
 const PORTFOLIO_COLUMNS_BY_ID = new Map(PORTFOLIO_COLUMN_DEFS.map((column) => [column.id, column]));
 const PORTFOLIO_ONLY_COLUMN_IDS = new Set([
+  "side",
   "shares",
   "avg_cost",
   "cost_basis",
   "mkt_value",
+  "weight",
   "day_pnl",
   "pnl",
   "pnl_pct",
+  "mark_delta",
+  "acq_date",
+  "held",
 ]);
 const COLLECTION_SCOPE_OPTIONS: PaneSettingOption[] = [
   {

package/src/plugins/builtin/portfolio-list/table.tsx

@@ -32,7 +32,7 @@ function buildCellVersion(
   financials: TickerFinancials | undefined,
   context: ColumnContext,
 ): string {
-  const latencyNow = column.id === "latency" ? context.now : 0;
+  const timeSensitiveNow = column.id === "latency" || column.id === "held" ? context.now : 0;
   return [
     column.id,
     objectVersion(ticker),
@@ -40,7 +40,9 @@ function buildCellVersion(
     objectVersion(context.exchangeRates),
     context.activeTab ?? "",
     context.baseCurrency,
-    latencyNow,
+    context.portfolioTotalMarketValue ?? 0,
+    context.supplementalVersion ?? 0,
+    timeSensitiveNow,
   ].join("|");
 }
 

package/src/plugins/builtin/portfolio-list/use-throttled-cursor-symbol.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useThrottledCommitValue } from "../../../react/use-throttled-commit-value";
 
 const FOLLOW_CURSOR_THROTTLE_MS = 150;
 
@@ -7,75 +7,17 @@ export function useThrottledCursorSymbol(
   setCommittedCursorSymbol: (symbol: string | null) => void,
   throttleMs = FOLLOW_CURSOR_THROTTLE_MS,
 ) {
-  const [cursorSymbol, setCursorSymbolState] = useState<string | null>(committedCursorSymbol);
-  const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const hasPendingCommitRef = useRef(false);
-  const pendingCursorSymbolRef = useRef<string | null>(committedCursorSymbol);
-  const appliedCursorSymbolRef = useRef<string | null>(committedCursorSymbol);
-
-  const clearPendingCursorCommit = useCallback(() => {
-    if (commitTimerRef.current) {
-      clearTimeout(commitTimerRef.current);
-      commitTimerRef.current = null;
-    }
-    hasPendingCommitRef.current = false;
-  }, []);
-
-  const commitCursorSymbol = useCallback((nextCursorSymbol?: string | null) => {
-    const targetCursorSymbol = nextCursorSymbol ?? pendingCursorSymbolRef.current;
-    clearPendingCursorCommit();
-    pendingCursorSymbolRef.current = targetCursorSymbol;
-
-    if (Object.is(appliedCursorSymbolRef.current, targetCursorSymbol)) {
-      return;
-    }
-
-    appliedCursorSymbolRef.current = targetCursorSymbol;
-    setCommittedCursorSymbol(targetCursorSymbol);
-  }, [clearPendingCursorCommit, setCommittedCursorSymbol]);
-
-  const scheduleCursorSymbol = useCallback((nextCursorSymbol: string | null, options?: { immediate?: boolean }) => {
-    setCursorSymbolState((current) => (Object.is(current, nextCursorSymbol) ? current : nextCursorSymbol));
-    pendingCursorSymbolRef.current = nextCursorSymbol;
-
-    if (options?.immediate) {
-      commitCursorSymbol(nextCursorSymbol);
-      return;
-    }
-
-    clearPendingCursorCommit();
-
-    if (Object.is(appliedCursorSymbolRef.current, nextCursorSymbol)) {
-      return;
-    }
-
-    hasPendingCommitRef.current = true;
-    commitTimerRef.current = setTimeout(() => {
-      commitCursorSymbol();
-    }, throttleMs);
-  }, [clearPendingCursorCommit, commitCursorSymbol, throttleMs]);
-
-  useEffect(() => {
-    if (hasPendingCommitRef.current && Object.is(committedCursorSymbol, pendingCursorSymbolRef.current)) {
-      clearPendingCursorCommit();
-    }
-
-    if (!hasPendingCommitRef.current) {
-      appliedCursorSymbolRef.current = committedCursorSymbol;
-      setCursorSymbolState((current) => (Object.is(current, committedCursorSymbol) ? current : committedCursorSymbol));
-    }
-  }, [clearPendingCursorCommit, committedCursorSymbol]);
-
-  useEffect(() => () => {
-    if (commitTimerRef.current) {
-      clearTimeout(commitTimerRef.current);
-    }
-  }, []);
+  const {
+    value: cursorSymbol,
+    setValue,
+    flushValue,
+    cancelPendingValue,
+  } = useThrottledCommitValue(committedCursorSymbol, setCommittedCursorSymbol, throttleMs);
 
   return {
     cursorSymbol,
-    setCursorSymbol: scheduleCursorSymbol,
-    flushCursorSymbol: commitCursorSymbol,
-    cancelPendingCursorSymbol: clearPendingCursorCommit,
+    setCursorSymbol: setValue,
+    flushCursorSymbol: flushValue,
+    cancelPendingCursorSymbol: cancelPendingValue,
   };
 }

package/src/plugins/builtin/research/analyst-pane.tsx

@@ -364,6 +364,7 @@ export function AnalystResearchView({ focused, width, height }: { focused: boole
   return (
     <DataTableView<AnalystResearchData["ratings"][number], RatingColumn>
       focused={focused}
+      selection={{ kind: "none" }}
       rootWidth={width}
       rootHeight={height}
       rootBefore={<AnalystSummary data={data} />}
@@ -374,8 +375,6 @@ export function AnalystResearchView({ focused, width, height }: { focused: boole
       sortDirection={sortPreference.direction}
       onHeaderClick={handleHeaderClick}
       getItemKey={(row, index) => `${row.date}:${row.firm}:${index}`}
-      isSelected={() => false}
-      onSelect={() => {}}
       renderCell={renderCell}
       emptyStateTitle={loading ? "Loading analyst data..." : error ?? "No analyst data"}
     />