gloomberb 0.5.0 → 0.6.0

package/src/state/config-save-scheduler.ts

@@ -0,0 +1,35 @@
+import { saveConfig } from "../data/config-store";
+import type { AppConfig } from "../types/config";
+import { debugLog } from "../utils/debug-log";
+import { measurePerfAsync } from "../utils/perf-marks";
+import {
+  CONFIG_SAVE_DEBOUNCE_MS,
+  createPersistScheduler,
+} from "./persist-scheduler";
+
+const log = debugLog.createLogger("persist");
+
+const configSaveScheduler = createPersistScheduler<AppConfig>({
+  delayMs: CONFIG_SAVE_DEBOUNCE_MS,
+  save: (config) => measurePerfAsync("persist.config.save", () => saveConfig(config)),
+  onError: (error) => {
+    log.warn("config.save.failed", { error: error instanceof Error ? error.message : String(error) });
+  },
+});
+
+export function scheduleConfigSave(config: AppConfig): void {
+  configSaveScheduler.schedule(config);
+}
+
+export function flushScheduledConfigSave(): Promise<void> {
+  return configSaveScheduler.flush();
+}
+
+export function cancelScheduledConfigSave(): void {
+  configSaveScheduler.cancel();
+}
+
+export async function saveConfigImmediately(config: AppConfig): Promise<void> {
+  cancelScheduledConfigSave();
+  await measurePerfAsync("persist.config.save", () => saveConfig(config));
+}

package/src/state/persist-scheduler.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+import { createPersistScheduler } from "./persist-scheduler";
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("createPersistScheduler", () => {
+  test("coalesces scheduled saves and writes the latest value", async () => {
+    const saved: number[] = [];
+    const scheduler = createPersistScheduler<number>({
+      delayMs: 5,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule(1);
+    scheduler.schedule(2);
+    scheduler.schedule(3);
+    await delay(15);
+
+    expect(saved).toEqual([3]);
+  });
+
+  test("flush saves immediately", async () => {
+    const saved: string[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 1000,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule("pending");
+    await scheduler.flush();
+
+    expect(saved).toEqual(["pending"]);
+  });
+
+  test("cancel drops pending value", async () => {
+    const saved: string[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 5,
+      save: (value) => saved.push(value),
+    });
+
+    scheduler.schedule("pending");
+    scheduler.cancel();
+    await delay(15);
+
+    expect(saved).toEqual([]);
+  });
+
+  test("save errors are reported without escaping timer", async () => {
+    const errors: unknown[] = [];
+    const scheduler = createPersistScheduler<string>({
+      delayMs: 5,
+      save: () => {
+        throw new Error("boom");
+      },
+      onError: (error) => errors.push(error),
+    });
+
+    scheduler.schedule("pending");
+    await delay(15);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toBeInstanceOf(Error);
+  });
+});

package/src/state/persist-scheduler.ts

@@ -0,0 +1,69 @@
+export const CONFIG_SAVE_DEBOUNCE_MS = 500;
+export const SESSION_SAVE_DEBOUNCE_MS = 1000;
+export const PLUGIN_STATE_SAVE_DEBOUNCE_MS = 500;
+
+export interface PersistSchedulerOptions<T> {
+  delayMs: number;
+  save: (value: T) => Promise<void> | void;
+  onError?: (error: unknown) => void;
+}
+
+export interface PersistScheduler<T> {
+  schedule(value: T): void;
+  flush(): Promise<void>;
+  cancel(): void;
+}
+
+export function createPersistScheduler<T>({
+  delayMs,
+  save,
+  onError,
+}: PersistSchedulerOptions<T>): PersistScheduler<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let pendingValue: T | undefined;
+  let hasPendingValue = false;
+  let inFlight: Promise<void> = Promise.resolve();
+
+  const clearTimer = () => {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = null;
+  };
+
+  const runSave = async (value: T) => {
+    try {
+      await save(value);
+    } catch (error) {
+      onError?.(error);
+    }
+  };
+
+  const drain = async () => {
+    clearTimer();
+    if (!hasPendingValue) return inFlight;
+    const value = pendingValue as T;
+    pendingValue = undefined;
+    hasPendingValue = false;
+    inFlight = inFlight.then(() => runSave(value));
+    return inFlight;
+  };
+
+  return {
+    schedule(value: T): void {
+      pendingValue = value;
+      hasPendingValue = true;
+      clearTimer();
+      timer = setTimeout(() => {
+        void drain();
+      }, Math.max(0, delayMs));
+    },
+    flush(): Promise<void> {
+      return drain();
+    },
+    cancel(): void {
+      clearTimer();
+      pendingValue = undefined;
+      hasPendingValue = false;
+    },
+  };
+}

package/src/state/selectors-ui.ts

@@ -0,0 +1,55 @@
+import type { AppState } from "../core/state/app-state";
+import type { LayoutConfig, SavedLayout } from "../types/config";
+import type { ReleaseInfo, UpdateProgress } from "../updater";
+
+export function selectLayout(state: AppState): LayoutConfig {
+  return state.config.layout;
+}
+
+export function selectFocusedPaneId(state: AppState): string | null {
+  return state.focusedPaneId;
+}
+
+export function selectCommandBarOpen(state: AppState): boolean {
+  return state.commandBarOpen;
+}
+
+export function selectStatusBarVisible(state: AppState): boolean {
+  return state.statusBarVisible;
+}
+
+export function selectBaseCurrency(state: AppState): string {
+  return state.config.baseCurrency;
+}
+
+export function selectSavedLayouts(state: AppState): SavedLayout[] {
+  return state.config.layouts;
+}
+
+export function selectActiveLayoutIndex(state: AppState): number {
+  return state.config.activeLayoutIndex;
+}
+
+export function selectGridlockTipVisible(state: AppState): boolean {
+  return state.gridlockTipVisible;
+}
+
+export function selectGridlockTipSequence(state: AppState): number {
+  return state.gridlockTipSequence;
+}
+
+export function selectUpdateAvailable(state: AppState): ReleaseInfo | null {
+  return state.updateAvailable;
+}
+
+export function selectUpdateProgress(state: AppState): UpdateProgress | null {
+  return state.updateProgress;
+}
+
+export function selectUpdateCheckInProgress(state: AppState): boolean {
+  return state.updateCheckInProgress;
+}
+
+export function selectUpdateNotice(state: AppState): string | null {
+  return state.updateNotice;
+}

package/src/state/selectors.ts

@@ -1,63 +1,29 @@
 import type { AppState } from "./app-context";
-import { resolveCollectionForPane } from "./app-context";
 import type { TickerRecord } from "../types/ticker";
 
-/** Get tickers belonging to a specific portfolio */
-export function getPortfolioTickers(state: AppState, portfolioId: string): TickerRecord[] {
-  const result: TickerRecord[] = [];
-  for (const ticker of state.tickers.values()) {
-    if (ticker.metadata.portfolios.includes(portfolioId)) {
-      result.push(ticker);
-    }
-  }
-  return result.sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
-}
-
-/** Get tickers belonging to a specific watchlist */
-export function getWatchlistTickers(state: AppState, watchlistId: string): TickerRecord[] {
-  const result: TickerRecord[] = [];
-  for (const ticker of state.tickers.values()) {
-    if (ticker.metadata.watchlists.includes(watchlistId)) {
-      result.push(ticker);
-    }
-  }
-  return result.sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
+function getCollectionMembershipKey(state: AppState, collectionId: string | null): "portfolios" | "watchlists" | null {
+  if (!collectionId) return null;
+  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) return "portfolios";
+  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) return "watchlists";
+  return null;
 }
 
 export function getCollectionTickers(state: AppState, collectionId: string | null): TickerRecord[] {
-  if (!collectionId) return [];
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) {
-    return getPortfolioTickers(state, collectionId);
-  }
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) {
-    return getWatchlistTickers(state, collectionId);
-  }
-  return [];
+  const membershipKey = getCollectionMembershipKey(state, collectionId);
+  if (!collectionId || !membershipKey) return [];
+  return [...state.tickers.values()]
+    .filter((ticker) => ticker.metadata[membershipKey].includes(collectionId))
+    .sort((a, b) => a.metadata.ticker.localeCompare(b.metadata.ticker));
 }
 
 export function getCollectionTickerCount(state: AppState, collectionId: string | null): number {
-  if (!collectionId) return 0;
-
+  const membershipKey = getCollectionMembershipKey(state, collectionId);
+  if (!collectionId || !membershipKey) return 0;
   let count = 0;
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) {
-    for (const ticker of state.tickers.values()) {
-      if (ticker.metadata.portfolios.includes(collectionId)) {
-        count += 1;
-      }
-    }
-    return count;
-  }
-
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) {
-    for (const ticker of state.tickers.values()) {
-      if (ticker.metadata.watchlists.includes(collectionId)) {
-        count += 1;
-      }
-    }
-    return count;
+  for (const ticker of state.tickers.values()) {
+    if (ticker.metadata[membershipKey].includes(collectionId)) count += 1;
   }
-
-  return 0;
+  return count;
 }
 
 export function getCollectionName(state: AppState, collectionId: string | null): string {
@@ -68,25 +34,3 @@ export function getCollectionName(state: AppState, collectionId: string | null):
   if (watchlist) return watchlist.name;
   return collectionId;
 }
-
-export function getCollectionType(state: AppState, collectionId: string | null): "portfolio" | "watchlist" | null {
-  if (!collectionId) return null;
-  if (state.config.portfolios.some((portfolio) => portfolio.id === collectionId)) return "portfolio";
-  if (state.config.watchlists.some((watchlist) => watchlist.id === collectionId)) return "watchlist";
-  return null;
-}
-
-export function getPaneCollectionTickers(state: AppState, paneId: string): TickerRecord[] {
-  return getCollectionTickers(state, resolveCollectionForPane(state, paneId));
-}
-
-export function getAllCollections(state: AppState): Array<{ id: string; name: string; type: "portfolio" | "watchlist" }> {
-  const collections: Array<{ id: string; name: string; type: "portfolio" | "watchlist" }> = [];
-  for (const portfolio of state.config.portfolios) {
-    collections.push({ id: portfolio.id, name: portfolio.name, type: "portfolio" });
-  }
-  for (const watchlist of state.config.watchlists) {
-    collections.push({ id: watchlist.id, name: watchlist.name, type: "watchlist" });
-  }
-  return collections;
-}

package/src/state/session-persistence.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { createDefaultConfig, createPaneInstance } from "../types/config";
 import type { TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
-import { buildAppSessionSnapshot, reconcileAppSessionSnapshot } from "./session-persistence";
+import { buildAppSessionSnapshot, reconcileAppSessionSnapshot } from "../core/state/session-persistence";
 
 function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
   return {

package/src/state/ticker-refresh-queue.ts

@@ -1,14 +1,26 @@
+
+import { debugLog } from "../utils/debug-log";
+import { measurePerfAsync } from "../utils/perf-marks";
+
 export interface TickerRefreshTask {
   key: string;
   priority: number;
   run: () => Promise<void>;
 }
 
+interface QueuedTickerRefreshTask extends TickerRefreshTask {
+  enqueuedAt: number;
+}
+
+const TASK_WARN_MS = 500;
+const WAIT_WARN_MS = 1000;
+const refreshQueueLog = debugLog.createLogger("refresh-queue");
+
 export class TickerRefreshQueue {
   private active = 0;
   private paused = false;
   private readonly pendingKeys = new Set<string>();
-  private readonly queue: TickerRefreshTask[] = [];
+  private readonly queue: QueuedTickerRefreshTask[] = [];
 
   constructor(private readonly concurrency = 3) {}
 
@@ -20,8 +32,15 @@ export class TickerRefreshQueue {
   enqueue(task: TickerRefreshTask): void {
     if (this.pendingKeys.has(task.key)) return;
     this.pendingKeys.add(task.key);
-    this.queue.push(task);
+    this.queue.push({ ...task, enqueuedAt: Date.now() });
     this.queue.sort((a, b) => a.priority - b.priority);
+    refreshQueueLog.info("task queued", {
+      key: task.key,
+      priority: task.priority,
+      active: this.active,
+      pending: this.queue.length,
+      paused: this.paused,
+    });
     this.pump();
   }
 
@@ -30,7 +49,37 @@ export class TickerRefreshQueue {
     while (this.active < this.concurrency && this.queue.length > 0) {
       const next = this.queue.shift()!;
       this.active += 1;
-      void next.run().finally(() => {
+      const waitMs = Date.now() - next.enqueuedAt;
+      refreshQueueLog.info("task started", {
+        key: next.key,
+        priority: next.priority,
+        waitMs,
+        active: this.active,
+        pending: this.queue.length,
+      });
+      void measurePerfAsync(
+        `refresh-queue.${next.key}`,
+        next.run,
+        {
+          key: next.key,
+          priority: next.priority,
+          waitMs,
+        },
+      ).finally(() => {
+        const durationMs = Date.now() - next.enqueuedAt - waitMs;
+        const payload = {
+          key: next.key,
+          priority: next.priority,
+          waitMs,
+          durationMs,
+          active: this.active - 1,
+          pending: this.queue.length,
+        };
+        if (durationMs >= TASK_WARN_MS || waitMs >= WAIT_WARN_MS) {
+          refreshQueueLog.warn("task finished slowly", payload);
+        } else {
+          refreshQueueLog.info("task finished", payload);
+        }
         this.active -= 1;
         this.pendingKeys.delete(next.key);
         this.pump();

package/src/state/use-inline-tickers.ts

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { getSharedRegistry } from "../plugins/registry";
-import { useAppState } from "./app-context";
+import { useAppDispatch, useAppSelector } from "./app-context";
 import { resolveTickerSearch, upsertTickerFromSearchResult } from "../utils/ticker-search";
 import { collectUniqueTickerSymbols } from "../utils/ticker-tokenizer";
 import { useQuoteStreaming } from "./use-quote-streaming";
@@ -28,15 +28,17 @@ export function useInlineTickers(texts: readonly string[]): {
   catalog: Record<string, InlineTickerCatalogEntry>;
   openTicker: (symbol: string) => void;
 } {
-  const { state, dispatch } = useAppState();
+  const dispatch = useAppDispatch();
+  const tickers = useAppSelector((state) => state.tickers);
+  const financials = useAppSelector((state) => state.financials);
   const registry = getSharedRegistry();
   const [, setRefreshVersion] = useState(0);
   const textsKey = texts.join("\u0000");
   const symbols = useMemo(() => normalizeSymbols(texts), [textsKey]);
   const symbolsKey = symbols.join("|");
-  const latestRef = useRef({ state, dispatch, registry });
+  const latestRef = useRef({ tickers, financials, dispatch, registry });
 
-  latestRef.current = { state, dispatch, registry };
+  latestRef.current = { tickers, financials, dispatch, registry };
 
   useEffect(() => {
     let mounted = true;
@@ -46,9 +48,9 @@ export function useInlineTickers(texts: readonly string[]): {
     };
 
     for (const symbol of symbols) {
-      const currentState = latestRef.current.state;
-      const currentTicker = currentState.tickers.get(symbol) ?? null;
-      const currentQuote = currentState.financials.get(symbol)?.quote ?? null;
+      const current = latestRef.current;
+      const currentTicker = current.tickers.get(symbol) ?? null;
+      const currentQuote = current.financials.get(symbol)?.quote ?? null;
 
       if (currentTicker && currentQuote) {
         missingSymbols.delete(symbol);
@@ -66,8 +68,8 @@ export function useInlineTickers(texts: readonly string[]): {
             const resolved = await resolveTickerSearch({
               query: symbol,
               activeTicker: null,
-              tickers: current.state.tickers,
-              dataProvider: activeRegistry.dataProvider,
+              tickers: current.tickers,
+              dataProvider: activeRegistry.marketData,
             });
 
             if (!resolved) {
@@ -106,11 +108,11 @@ export function useInlineTickers(texts: readonly string[]): {
           const activeRegistry = current.registry;
           if (!activeRegistry) return;
 
-          const latestTicker = current.state.tickers.get(symbol);
+          const latestTicker = current.tickers.get(symbol);
           if (!latestTicker) return;
 
           const instrument = latestTicker.metadata.broker_contracts?.[0] ?? null;
-          const quote = await activeRegistry.dataProvider.getQuote(
+          const quote = await activeRegistry.marketData.getQuote(
             symbol,
             latestTicker.metadata.exchange,
             instrument
@@ -134,10 +136,10 @@ export function useInlineTickers(texts: readonly string[]): {
     return () => {
       mounted = false;
     };
-  }, [dispatch, registry, state.financials, state.tickers, symbols, symbolsKey]);
+  }, [dispatch, financials, registry, symbols, symbolsKey, tickers]);
 
   const streamingTargets = symbols
-    .map((symbol) => state.tickers.get(symbol))
+    .map((symbol) => tickers.get(symbol))
     .filter((ticker): ticker is TickerRecord => ticker != null)
     .map((ticker) => {
       const instrument = ticker.metadata.broker_contracts?.[0] ?? null;
@@ -157,13 +159,13 @@ export function useInlineTickers(texts: readonly string[]): {
   useQuoteStreaming(streamingTargets);
 
   const openTicker = useCallback((symbol: string) => {
-    registry?.pinTickerFn(symbol, { floating: true, paneType: "ticker-detail" });
+    registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail" });
   }, [registry]);
 
   const catalog: Record<string, InlineTickerCatalogEntry> = {};
   for (const symbol of symbols) {
-    const ticker = state.tickers.get(symbol) ?? null;
-    const quote = state.financials.get(symbol)?.quote ?? null;
+    const ticker = tickers.get(symbol) ?? null;
+    const quote = financials.get(symbol)?.quote ?? null;
     const status: InlineTickerStatus = ticker
       ? (quote ? "ready" : "loading")
       : (missingSymbols.has(symbol) ? "missing" : "loading");

package/src/state/use-quote-streaming.test.ts

@@ -28,10 +28,4 @@ describe("buildQuoteStreamSubscriptionKey", () => {
     expect(workKey).not.toBe(personalKey);
   });
 
-  test("uses the same key for equivalent plain provider targets", () => {
-    const first = buildQuoteStreamSubscriptionKey({ symbol: "MSFT", exchange: "NASDAQ" });
-    const second = buildQuoteStreamSubscriptionKey({ symbol: "MSFT", exchange: "NASDAQ" });
-
-    expect(first).toBe(second);
-  });
 });

package/src/state/use-quote-streaming.test.tsx

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useState } from "react";
-import { testRender } from "@opentui/react/test-utils";
+import { testRender } from "../renderers/opentui/test-utils";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
 import { useQuoteStreaming } from "./use-quote-streaming";
 

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

@@ -2,17 +2,18 @@ import { useEffect } from "react";
 import { useAppActive } from "./app-activity";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import { debugLog } from "../utils/debug-log";
+import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
 import { getSharedMarketDataCoordinator } from "../market-data/coordinator";
 
 const quoteStreamLog = debugLog.createLogger("quote-stream");
 
 function normalizeTarget(target: QuoteSubscriptionTarget): QuoteSubscriptionTarget | null {
-  const symbol = target.symbol.trim().toUpperCase();
+  const symbol = normalizeSymbol(target.symbol);
   if (!symbol) return null;
   return {
     ...target,
     symbol,
-    exchange: target.exchange?.trim().toUpperCase() ?? "",
+    exchange: canonicalExchange(target.exchange),
   };
 }
 

package/src/state/use-session-snapshot.ts

@@ -3,8 +3,13 @@ import type { SessionStore } from "../data/session-store";
 import {
   buildAppSessionSnapshot,
   type AppSessionSnapshot,
-} from "./session-persistence";
+} from "../core/state/session-persistence";
 import type { AppState } from "./app-context";
+import { measurePerf } from "../utils/perf-marks";
+import {
+  createPersistScheduler,
+  SESSION_SAVE_DEBOUNCE_MS,
+} from "./persist-scheduler";
 
 export function usePersistSessionSnapshot(
   sessionStore: SessionStore | undefined,
@@ -25,20 +30,33 @@ export function usePersistSessionSnapshot(
     schemaVersion,
   };
 
-  const saveSnapshotRef = useRef<() => void>(() => {});
-  saveSnapshotRef.current = () => {
+  const schedulerRef = useRef<ReturnType<typeof createPersistScheduler<AppSessionSnapshot>> | null>(null);
+  if (!schedulerRef.current) {
+    schedulerRef.current = createPersistScheduler<AppSessionSnapshot>({
+      delayMs: SESSION_SAVE_DEBOUNCE_MS,
+      save: (snapshot) => {
+        const {
+          sessionStore: currentStore,
+          sessionId: currentSessionId,
+          schemaVersion: currentSchemaVersion,
+        } = latestRef.current;
+        if (!currentStore) return;
+        measurePerf("persist.session.save", () => {
+          currentStore.set(currentSessionId, snapshot, currentSchemaVersion);
+        }, { sessionId: currentSessionId });
+      },
+    });
+  }
+
+  const buildSnapshot = (): AppSessionSnapshot | null => {
     const {
-      sessionStore: currentStore,
       state: currentState,
-      sessionId: currentSessionId,
-      schemaVersion: currentSchemaVersion,
     } = latestRef.current;
 
-    if (!currentStore) return;
-    if (!currentState.initialized && currentState.tickers.size === 0) return;
+    if (!currentState.initialized && currentState.tickers.size === 0) return null;
 
     try {
-      currentStore.set(currentSessionId, buildAppSessionSnapshot({
+      return buildAppSessionSnapshot({
         config: currentState.config,
         paneState: currentState.paneState,
         focusedPaneId: currentState.focusedPaneId,
@@ -47,21 +65,18 @@ export function usePersistSessionSnapshot(
         recentTickers: currentState.recentTickers,
         tickers: currentState.tickers,
         exchangeRates: currentState.exchangeRates,
-      }) satisfies AppSessionSnapshot, currentSchemaVersion);
+      }) satisfies AppSessionSnapshot;
     } catch {
       // Snapshot persistence is best-effort during teardown.
+      return null;
     }
   };
 
   useEffect(() => {
     if (!sessionStore) return;
     if (!state.initialized && state.tickers.size === 0) return;
-    const timer = setTimeout(() => {
-      saveSnapshotRef.current();
-    }, 250);
-    return () => {
-      clearTimeout(timer);
-    };
+    const snapshot = buildSnapshot();
+    if (snapshot) schedulerRef.current?.schedule(snapshot);
   }, [
     sessionStore,
     sessionId,
@@ -78,7 +93,7 @@ export function usePersistSessionSnapshot(
 
   useEffect(() => {
     return () => {
-      saveSnapshotRef.current();
+      void schedulerRef.current?.flush();
     };
   }, []);
 }