gloomberb 0.17.4 → 0.17.5

package/src/market-data/hooks.tsx

@@ -135,6 +135,125 @@ function buildTickerFinancialsKeys(tickers: TickerRecord[], options: TickerInstr
   return keys;
 }
 
+/**
+ * A new object so memo dependencies move, over the map that already holds
+ * every unchanged entry. Copying that map would visit every instrument.
+ */
+class RetainedMapView<K, V> extends Map<K, V> {
+  constructor(private readonly backing: Map<K, V>) {
+    super();
+  }
+
+  override get size(): number {
+    return this.backing.size;
+  }
+
+  override get(key: K): V | undefined {
+    return this.backing.get(key);
+  }
+
+  override has(key: K): boolean {
+    return this.backing.has(key);
+  }
+
+  override forEach(callback: (value: V, key: K, map: Map<K, V>) => void, thisArg?: unknown): void {
+    this.backing.forEach((value, key) => {
+      callback.call(thisArg, value, key, this);
+    });
+  }
+
+  override keys(): MapIterator<K> {
+    return this.backing.keys();
+  }
+
+  override values(): MapIterator<V> {
+    return this.backing.values();
+  }
+
+  override entries(): MapIterator<[K, V]> {
+    return this.backing.entries();
+  }
+
+  override [Symbol.iterator](): MapIterator<[K, V]> {
+    return this.backing[Symbol.iterator]();
+  }
+}
+
+interface PatchedMapSlot<K, V> {
+  key: K;
+  versionKeys: readonly string[];
+  read: () => V | null | undefined;
+}
+
+interface PatchedMapState<K, V> {
+  signature: string;
+  coordinator: SharedCoordinator | null;
+  slots: Array<PatchedMapSlot<K, V>>;
+  versions: number[];
+  backing: Map<K, V>;
+  view: Map<K, V>;
+}
+
+function slotVersion(
+  slot: PatchedMapSlot<unknown, unknown>,
+  versionOf: ((key: string) => number) | null,
+  aggregate: number,
+): number {
+  if (!versionOf) return aggregate;
+  let version = 0;
+  for (const key of slot.versionKeys) version += versionOf(key);
+  return version;
+}
+
+function usePatchedMap<K, V>(
+  signature: string,
+  coordinator: SharedCoordinator | null,
+  aggregateVersion: number,
+  versionOf: ((key: string) => number) | null,
+  createSlots: () => Array<PatchedMapSlot<K, V>>,
+): Map<K, V> {
+  const stateRef = useRef<PatchedMapState<K, V> | null>(null);
+  let state = stateRef.current;
+  if (!state || state.signature !== signature || state.coordinator !== coordinator) {
+    const slots = createSlots();
+    const backing = new Map<K, V>();
+    const versions: number[] = [];
+    for (const slot of slots) {
+      const value = slot.read();
+      if (value != null) backing.set(slot.key, value);
+      versions.push(slotVersion(slot, versionOf, aggregateVersion));
+    }
+    const view = new RetainedMapView(backing);
+    state = { signature, coordinator, slots, versions, backing, view };
+    stateRef.current = state;
+    return view;
+  }
+
+  let changed = false;
+  for (let index = 0; index < state.slots.length; index += 1) {
+    const slot = state.slots[index]!;
+    const version = slotVersion(slot, versionOf, aggregateVersion);
+    if (version === state.versions[index]) continue;
+    state.versions[index] = version;
+    const value = slot.read();
+    if (value == null) {
+      if (state.backing.delete(slot.key)) changed = true;
+    } else if (state.backing.get(slot.key) !== value) {
+      state.backing.set(slot.key, value);
+      changed = true;
+    }
+  }
+  if (!changed) return state.view;
+  const view = new RetainedMapView(state.backing);
+  state.view = view;
+  return view;
+}
+
+function versionOfCoordinator(coordinator: SharedCoordinator | null): ((key: string) => number) | null {
+  if (!coordinator || typeof coordinator.getKeyVersion !== "function") return null;
+  return (key) => coordinator.getKeyVersion(key);
+}
+
 export function useTickerFinancialsMap(
   tickers: TickerRecord[],
   options: TickerInstrumentOptions = {},
@@ -145,19 +264,30 @@ export function useTickerFinancialsMap(
   const subscriptionKeys = useMemo(() => buildTickerFinancialsKeys(tickers, options), [optionsKey, tickerKey]);
   const keysVersion = useCoordinatorKeysVersion(subscriptionKeys);
 
-  return useMemo(() => {
-    if (!coordinator) return new Map<string, TickerFinancials>();
-    const result = new Map<string, TickerFinancials>();
-    for (const ticker of tickers) {
-      const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
-      if (!instrument) continue;
-      const financials = coordinator.getTickerFinancialsSync(instrument);
-      if (financials) {
-        result.set(ticker.metadata.ticker, financials);
+  return usePatchedMap(
+    `${tickerKey}\0${optionsKey}`,
+    coordinator,
+    keysVersion,
+    versionOfCoordinator(coordinator),
+    () => {
+      if (!coordinator) return [];
+      const slots: Array<PatchedMapSlot<string, TickerFinancials>> = [];
+      for (const ticker of tickers) {
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
+        if (!instrument) continue;
+        slots.push({
+          key: ticker.metadata.ticker,
+          versionKeys: [
+            buildSnapshotKey(instrument),
+            buildQuoteKey(instrument),
+            buildChartKey(createBaselineChartRequest(instrument)),
+          ],
+          read: () => coordinator.getTickerFinancialsSync(instrument),
+        });
       }
-    }
-    return result;
-  }, [coordinator, keysVersion, optionsKey, tickerKey, subscriptionKeys]);
+      return slots;
+    },
+  );
 }
 
 export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {
@@ -197,15 +327,23 @@ export function useQuoteEntries(
   const keysVersion = useCoordinatorKeysVersion(keys);
   const coordinator = getSharedMarketDataCoordinator();
 
-  return useMemo(() => {
-    if (!coordinator) return new Map<string, QueryEntry<Quote>>();
-    return new Map(
-      instruments.map((instrument) => [
-        buildQuoteKey(instrument),
-        coordinator.getQuoteEntry(instrument),
-      ]),
-    );
-  }, [coordinator, instrumentKey, keysVersion]);
+  return usePatchedMap(
+    instrumentKey,
+    coordinator,
+    keysVersion,
+    versionOfCoordinator(coordinator),
+    () => {
+      if (!coordinator) return [];
+      return instruments.map((instrument) => {
+        const key = buildQuoteKey(instrument);
+        return {
+          key,
+          versionKeys: [key],
+          read: () => coordinator.getQuoteEntry(instrument),
+        };
+      });
+    },
+  );
 }
 
 export function useChartQueries(
@@ -219,7 +357,8 @@ export function useChartQueries(
   const keysVersion = useCoordinatorKeysVersion(keys);
   const coordinator = getSharedMarketDataCoordinator();
   const appActive = useAppVisible();
-  const wasActiveRef = useRef(appActive);
+  const paneVisible = usePaneVisible();
+  const wasPaneVisibleRef = useRef(paneVisible);
   const entries = useMemo(() => (
     coordinator
       ? requests.map((request) => [buildChartKey(request), coordinator.getChartEntry(request)] as const)
@@ -229,15 +368,15 @@ export function useChartQueries(
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator) {
-      wasActiveRef.current = appActive;
+      wasPaneVisibleRef.current = paneVisible;
       return;
     }
     if (!appActive) {
-      wasActiveRef.current = false;
+      wasPaneVisibleRef.current = false;
       return;
     }
-    const forceRefresh = refreshIntervalMs > 0 && !wasActiveRef.current;
-    wasActiveRef.current = true;
+    const forceRefresh = refreshIntervalMs > 0 && paneVisible && !wasPaneVisibleRef.current;
+    wasPaneVisibleRef.current = paneVisible;
     const loadRequests = () => {
       loadChartRequests(coordinator, requests, { forceRefresh });
     };
@@ -247,17 +386,17 @@ export function useChartQueries(
     }
     const timeout = setTimeout(loadRequests, debounceMs);
     return () => clearTimeout(timeout);
-  }, [appActive, debounceMs, refreshIntervalMs, requestKey]);
+  }, [appActive, debounceMs, paneVisible, refreshIntervalMs, requestKey]);
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
-    if (!coordinator || !appActive || refreshIntervalMs <= 0 || requests.length === 0) return;
+    if (!coordinator || !paneVisible || refreshIntervalMs <= 0 || requests.length === 0) return;
 
     const interval = setInterval(() => {
       loadChartRequests(coordinator, requests, { forceRefresh: true });
     }, refreshIntervalMs);
     return () => clearInterval(interval);
-  }, [appActive, refreshIntervalMs, requestKey]);
+  }, [paneVisible, refreshIntervalMs, requestKey]);
 
   return useMemo(() => new Map(entries), [entries]);
 }

package/src/plugins/builtin/broker-manager/detail.tsx

@@ -91,8 +91,8 @@ function BrokerConfigFieldEditor({
 function accountDetail(account: BrokerAccount): string {
   const parts = [
     account.accountId,
-    account.netLiquidation != null ? tf("{value} net liq", { value: formatCurrency(account.netLiquidation, account.currency || "USD") }) : null,
-    account.buyingPower != null ? tf("{value} buying power", { value: formatCurrency(account.buyingPower, account.currency || "USD") }) : null,
+    account.netLiquidation != null ? tf("{value} net liq", { value: formatCurrency(account.netLiquidation, account.currency || "") }) : null,
+    account.buyingPower != null ? tf("{value} buying power", { value: formatCurrency(account.buyingPower, account.currency || "") }) : null,
   ];
   return parts.filter(Boolean).join(" · ");
 }

package/src/plugins/builtin/broker-manager/model.ts

@@ -46,10 +46,10 @@ function formatBrokerMode(value: unknown): string {
 
 function summarizeBrokerAccounts(accounts: BrokerAccount[]): string {
   if (accounts.length === 0) return "0 acct";
-  const currencies = new Set(accounts.map((account) => account.currency || "USD"));
+  const currencies = new Set(accounts.map((account) => account.currency || ""));
   const canSum = currencies.size === 1 && accounts.every((account) => typeof account.netLiquidation === "number");
   if (!canSum) return `${accounts.length} acct${accounts.length === 1 ? "" : "s"}`;
-  const currency = currencies.values().next().value ?? "USD";
+  const currency = currencies.values().next().value ?? "";
   const total = accounts.reduce((sum, account) => sum + (account.netLiquidation ?? 0), 0);
   return formatCurrency(total, currency);
 }

package/src/plugins/builtin/chart-composer/headless.ts

@@ -27,6 +27,7 @@ import { parseChartSpec } from "./chart-spec";
 import { paneSchemas } from "./headless-schema";
 import { barHistoryFreshness, REPORTED_DATA } from "../shared/report-freshness";
 import { inferSeriesFrequency } from "../../../series/csv";
+import { isDatasetChart } from "../../../time-series/spec";
 
 export interface ChartPaneModel extends HeadlessSeriesResult {
   /** The renderer consumes the full model; generic reports project series and metadata. */
@@ -285,7 +286,7 @@ function seriesAttribution(series: readonly HeadlessSeries[]): Pick<HeadlessPane
 function chartFreshness(series: readonly HeadlessSeries[], spec: ChartSpec): HeadlessPaneFreshness {
   const order = ["1wk", "1mo"];
   const resolutions = series.map((entry) => (entry as HeadlessSeries & { historyResolution?: string }).historyResolution);
-  const dataset = spec.series.length > 0 && spec.series.every(({ source }) => source.kind === "capability");
+  const dataset = isDatasetChart(spec);
   if (!series.length || resolutions.some((resolution) => !resolution)) {
     return { ...REPORTED_DATA, basis: "reported and published data", ...(dataset ? { dataset } : {}), ...economicChartDates(series, spec), ...seriesAttribution(series) };
   }

package/src/plugins/builtin/chart-composer/pane.tsx

@@ -18,6 +18,7 @@ import {
   type MultiSelectRowAction,
 } from "../../../components/ui";
 import { CompositeChart } from "../../../components/chart/composite";
+import { formatCompositeDatasetDate } from "../../../components/chart/composite/format";
 import type { CompositeChartLevels, CompositeLevelEdit } from "../../../components/chart/composite/levels";
 import type { PaneProps, TickerResearchTabProps } from "../../../types/plugin";
 import type { ChartResolution, TimeRange } from "../../../components/chart/core/types";
@@ -46,6 +47,7 @@ import {
 import { colors } from "../../../theme/colors";
 import { isUsListingExchange, parsePublicTickerKey, publicTickerKey } from "../../../utils/exchanges";
 import { isMarketFieldId } from "../../../time-series/field-catalog";
+import { isDatasetChart } from "../../../time-series/spec";
 import { CHART_COMPOSER_PANE_ID } from "../../../types/config";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { SeriesEditorDialog } from "./editor";
@@ -934,12 +936,28 @@ function ChartComposerSurface({
   }, [anchoredVwapOn]);
   const anchorable = anchoredVwapOn && !pickingAnchor;
   const footerAnchor = useCallback(() => setPickingAnchor(true), []);
+  // A dataset (CHOKE's transits) panned or zoomed back from its newest
+  // observation says how far its data goes, as its legend dates a value.
+  const newestBeyondView = useMemo(() => {
+    const end = viewport?.end.getTime();
+    if (!activeRuntimeViewport || !isDatasetChart(spec) || end === undefined || !Number.isFinite(end)) return null;
+    let newest = Number.NEGATIVE_INFINITY;
+    for (const entry of plottedSeries) {
+      for (const point of entry.points) {
+        const time = point.date.getTime();
+        if (point.value != null && Number.isFinite(time) && time > newest) newest = time;
+      }
+    }
+    return newest > end ? formatCompositeDatasetDate(new Date(newest), end) : null;
+  }, [activeRuntimeViewport, plottedSeries, spec, viewport]);
   usePaneFooter(footerId, () => ({
     info: resolution.loading
       ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }]
       : pickingAnchor
         ? [{ id: "anchor", parts: [{ text: "pick a bar to anchor VWAP", tone: "muted" as const }] }]
-        : [],
+        : newestBeyondView
+          ? [{ id: "newest", asOf: true, parts: [{ text: `newest ${newestBeyondView}`, tone: "muted" as const }] }]
+          : [],
     hints: [
       { id: "series", key: "s", label: "eries", onPress: footerSeries },
       { id: "indicators", key: "i", label: "ndicators", onPress: openIndicators, disabled: indicatorsDisabled },
@@ -947,7 +965,7 @@ function ChartComposerSurface({
       { id: "resolution", key: "t", label: "imeframe", onPress: footerResolution },
       ...(anchorable ? [{ id: "vwap-anchor", key: "v", label: "wap anchor", title: "Anchor VWAP", onPress: footerAnchor }] : []),
     ],
-  }), [resolution.loading, pickingAnchor, footerSeries, openIndicators, indicatorsDisabled, openFormulas, formulasDisabled, footerResolution, anchorable, footerAnchor]);
+  }), [resolution.loading, pickingAnchor, newestBeyondView, footerSeries, openIndicators, indicatorsDisabled, openFormulas, formulasDisabled, footerResolution, anchorable, footerAnchor]);
 
   // A fixed window (a GIP session) highlights no range, so the bar names it.
   const dateWindowLabel = useMemo(() => {

package/src/plugins/builtin/chat/content/footer.tsx

@@ -16,6 +16,8 @@ import { canReactToMessage } from "../reactions";
  * The chat pane's keys, shown in its footer and listed in its pane menu. The
  * hints are the bindings for everything but Enter and `i`, which the chat's
  * own handler owns because they depend on the composer and the selection.
+ * With no message selected both open the composer, as a click on it does, so
+ * the footer leaves that out and only the pane menu lists Compose.
  */
 export function useChatFooter({
   composing,
@@ -240,8 +242,6 @@ export function useChatFooter({
       if (openTargets.length > 0) hints.push({ id: "open", key: "o", label: "pen", title: openTargetTitle, onPress: () => { void latest.current.openSelectedTargets(); } });
       // Every author but a Discord ghost has a card, if only their name and a way to write to them.
       if (author) hints.push({ id: "profile", key: "p", label: "rofile", title: "Show Profile", onPress: () => latest.current.toggleAuthorProfile() });
-    } else if (!composing && canSend) {
-      hints.push({ id: "compose", key: "i", label: " compose", title: "Compose", onPress: () => queueMicrotask(() => latest.current.focusComposer()) });
     }
     if (canSend && notificationChannelId) {
       const channelId = notificationChannelId;
@@ -261,6 +261,9 @@ export function useChatFooter({
     }
 
     const menu: ContextMenuItem[] = [];
+    if (!composing && !selectedMessage && canSend) {
+      menu.push({ id: "compose", label: "Compose", accelerator: "Enter", onSelect: () => queueMicrotask(() => latest.current.focusComposer()) });
+    }
     // No key of its own: a stray press would start a conversation. The pane
     // menu (.) and a right-click on the name reach it.
     if (authorMessageLabel) {

package/src/plugins/builtin/chat/controller/index.ts

@@ -68,6 +68,7 @@ import {
 } from "../edit-window";
 import { ChatControllerRealtime } from "./realtime";
 import { ChatControllerChannels } from "./channels";
+import { ChatControllerUnreadPeople } from "./unread-people";
 import { ChatControllerView } from "./view";
 import { ChatControllerMessageLoading } from "./message-loading";
 import { ChatControllerStorage } from "./storage";
@@ -149,6 +150,13 @@ export class ChatController {
     getListenerSnapshot: (channelId) => this.getSnapshot(channelId),
     getVisibleMessages: (channelId) => this.getVisibleMessages(channelId),
     getUnreadMentionCount: (channelId) => this.getUnreadMentionCount(channelId),
+    getUnreadPeople: () => this.unreadPeople.snapshot(),
+  });
+  private readonly unreadPeople = new ChatControllerUnreadPeople({
+    getChannels: () => this.channelCatalog.getChannels(),
+    getChannelStates: () => this.storage.channelStates.entries(),
+    getUser: () => this.session.user,
+    onChange: () => this.emit(),
   });
   private readonly messageLoading = new ChatControllerMessageLoading({
     ensureChannelState: (channelId) => this.ensureChannelState(channelId),
@@ -247,6 +255,16 @@ export class ChatController {
     return this.view.getSnapshot(channelId);
   }
 
+  /**
+   * Keeps who sent each channel's unread messages (`unreadPeople` in the
+   * snapshot) current until the returned stop is called, reading what the
+   * device does not hold. Nothing is read, and the snapshot leaves it empty,
+   * unless something tracks it: only the app badge needs it.
+   */
+  trackUnreadPeople(): () => void {
+    return this.unreadPeople.track();
+  }
+
   /** Channels with unread messages, from the counts and messages already held; no request. */
   listUnreadInbox() {
     return listUnreadInboxItems({
@@ -786,6 +804,7 @@ export class ChatController {
 
   private emit(channelId?: string): void {
     this.view.emit(channelId);
+    this.unreadPeople.sync();
   }
 
   private applyChannelState(state: ChatChannelState): void {
@@ -803,6 +822,7 @@ export class ChatController {
   private stopRealtime(): void {
     this.realtime.stopAll();
     this.alerts.clear();
+    this.unreadPeople.clear();
   }
 
   private applySignedOutSession(): void {

package/src/plugins/builtin/chat/controller/messages.ts

@@ -39,9 +39,21 @@ export function isSameMessageRevision(current: ChatMessage, incoming: ChatMessag
     && attachmentKey(current) === attachmentKey(incoming);
 }
 
+// Both lists are replaced on edits, reactions, pagination and send transitions.
+// A draft save, upload progress or presence update changes neither. Keep the
+// projection's identity then: subscribers must not redraw the entire transcript.
+const visibleMessages = new WeakMap<ChannelRuntimeState, {
+  messages: ChatMessage[];
+  pending: ChatMessage[];
+  visible: ChatMessage[];
+}>();
+
 export function getVisibleMessages(channel: ChannelRuntimeState): ChatMessage[] {
-  return [...channel.messages, ...channel.pendingMessages]
-    .sort(compareMessages);
+  const cached = visibleMessages.get(channel);
+  if (cached?.messages === channel.messages && cached.pending === channel.pendingMessages) return cached.visible;
+  const visible = [...channel.messages, ...channel.pendingMessages].sort(compareMessages);
+  visibleMessages.set(channel, { messages: channel.messages, pending: channel.pendingMessages, visible });
+  return visible;
 }
 
 function mergeStoredMessages(channel: ChannelRuntimeState, messages: ChatMessage[]): ChatMessage[] {

package/src/plugins/builtin/chat/controller/state.ts

@@ -44,6 +44,14 @@ export interface PersistedTranscript {
   messages: ChatMessage[];
 }
 
+/** Who the unread messages of one channel are from, by account id. */
+export interface ChannelUnreadPeople {
+  /** Everyone who sent an unread message there. */
+  senders: string[];
+  /** The ones among them with an unread message that mentions you. */
+  mentioners: string[];
+}
+
 export interface ChatControllerSnapshot {
   channelId: string;
   channels: ChatChannel[];
@@ -63,6 +71,13 @@ export interface ChatControllerSnapshot {
   draftAttachments: ChatDraftAttachment[];
   replyToId: string | null;
   unreadMentionCount: number;
+  /**
+   * Who sent the unread messages of each channel with any, by channel id: what
+   * the app badge counts people from. Empty unless the badge asked for it
+   * ({@link ChatController.trackUnreadPeople}). A channel whose unread messages
+   * are not on this device yet lists only the ones that are, until they load.
+   */
+  unreadPeople: Record<string, ChannelUnreadPeople>;
 }
 
 type ChatConnection = {