gloomberb 0.2.0 → 0.3.2

package/src/state/selectors.ts

@@ -0,0 +1,67 @@
+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));
+}
+
+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 [];
+}
+
+export function getCollectionName(state: AppState, collectionId: string | null): string {
+  if (!collectionId) return "";
+  const portfolio = state.config.portfolios.find((entry) => entry.id === collectionId);
+  if (portfolio) return portfolio.name;
+  const watchlist = state.config.watchlists.find((entry) => entry.id === collectionId);
+  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

@@ -0,0 +1,128 @@
+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";
+
+function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange,
+      currency: "USD",
+      name: symbol,
+      portfolios: ["main"],
+      watchlists: [],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+describe("session persistence", () => {
+  test("builds a working-set snapshot from runtime state", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const tickers = new Map<string, TickerRecord>([["AAPL", createTicker("AAPL")]]);
+    const financials = new Map<string, TickerFinancials>([["AAPL", {
+      annualStatements: [],
+      quarterlyStatements: [],
+      priceHistory: [],
+      quote: {
+        symbol: "AAPL",
+        price: 100,
+        currency: "USD",
+        change: 0,
+        changePercent: 0,
+        lastUpdated: Date.now(),
+      },
+    }]]);
+
+    const snapshot = buildAppSessionSnapshot({
+      config,
+      paneState: {
+        "portfolio-list:main": {
+          cursorSymbol: "AAPL",
+          collectionId: "main",
+          collectionSorts: {
+            main: { columnId: "mkt_value", direction: "desc" },
+          },
+        },
+        "ticker-detail:main": { activeTabId: "financials" },
+      },
+      focusedPaneId: "ticker-detail:main",
+      activePanel: "right",
+      statusBarVisible: true,
+      recentTickers: ["AAPL"],
+      tickers,
+      financials,
+      exchangeRates: new Map([["USD", 1], ["JPY", 0.0067]]),
+    });
+
+    expect(snapshot.focusedPaneId).toBe("ticker-detail:main");
+    expect(snapshot.hydrationTargets).toHaveLength(1);
+    expect(snapshot.hydrationTargets[0]?.symbol).toBe("AAPL");
+    expect(snapshot.exchangeCurrencies).toContain("JPY");
+    expect(snapshot.paneState["portfolio-list:main"]).toEqual({
+      cursorSymbol: "AAPL",
+      collectionId: "main",
+      collectionSorts: {
+        main: { columnId: "mkt_value", direction: "desc" },
+      },
+    });
+    expect(snapshot.paneState["ticker-detail:main"]).toEqual({ activeTabId: "financials" });
+  });
+
+  test("reconciles pane state and broker references against the current config", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    config.brokerInstances.push({
+      id: "ibkr-live",
+      brokerType: "ibkr",
+      label: "IBKR",
+      config: {},
+      enabled: true,
+    });
+    const orphanPane = createPaneInstance("ticker-detail", {
+      instanceId: "ticker-detail:orphan",
+      binding: { kind: "follow", sourceInstanceId: "missing" },
+    });
+    config.layout.instances.push(orphanPane);
+
+    const reconciled = reconcileAppSessionSnapshot(config, {
+      paneState: {
+        "portfolio-list:main": {
+          cursorSymbol: "AAPL",
+          collectionId: "main",
+          collectionSorts: {
+            main: { columnId: "mkt_value", direction: "desc" },
+          },
+        },
+        "ticker-detail:main": { activeTabId: "chart" },
+        "missing:pane": { cursorSymbol: "MSFT" },
+      },
+      focusedPaneId: "missing:pane",
+      activePanel: "right",
+      statusBarVisible: false,
+      openPaneIds: ["portfolio-list:main", "missing:pane"],
+      hydrationTargets: [
+        { symbol: "AAPL", brokerInstanceId: "ibkr-live", brokerId: "ibkr" },
+        { symbol: "MSFT", brokerInstanceId: "ibkr-missing", brokerId: "ibkr" },
+      ],
+      exchangeCurrencies: ["USD", "JPY"],
+      savedAt: Date.now(),
+    });
+
+    expect(reconciled?.paneState["portfolio-list:main"]).toEqual({
+      cursorSymbol: "AAPL",
+      collectionId: "main",
+      collectionSorts: {
+        main: { columnId: "mkt_value", direction: "desc" },
+      },
+    });
+    expect(reconciled?.paneState["ticker-detail:main"]).toEqual({ activeTabId: "chart" });
+    expect(reconciled?.paneState["missing:pane"]).toBeUndefined();
+    expect(reconciled?.focusedPaneId).toBe("portfolio-list:main");
+    expect(reconciled?.hydrationTargets).toEqual([{ symbol: "AAPL", brokerInstanceId: "ibkr-live", brokerId: "ibkr", exchange: undefined, instrument: null }]);
+  });
+});

package/src/state/session-persistence.ts

@@ -0,0 +1,161 @@
+import { findPaneInstance, type AppConfig } from "../types/config";
+import type { BrokerContractRef } from "../types/instrument";
+import type { TickerRecord } from "../types/ticker";
+import { getDockedPaneIds } from "../plugins/pane-manager";
+
+export const APP_SESSION_SCHEMA_VERSION = 1;
+export const APP_SESSION_ID = "app";
+
+export interface HydrationTarget {
+  symbol: string;
+  exchange?: string;
+  brokerId?: string;
+  brokerInstanceId?: string;
+  instrument?: BrokerContractRef | null;
+}
+
+export interface AppSessionSnapshot {
+  paneState: Record<string, Record<string, unknown>>;
+  focusedPaneId: string | null;
+  activePanel: "left" | "right";
+  statusBarVisible: boolean;
+  openPaneIds: string[];
+  hydrationTargets: HydrationTarget[];
+  exchangeCurrencies: string[];
+  savedAt: number;
+}
+
+interface SessionStateInput {
+  config: AppConfig;
+  paneState: Record<string, Record<string, unknown>>;
+  focusedPaneId: string | null;
+  activePanel: "left" | "right";
+  statusBarVisible: boolean;
+  recentTickers: string[];
+  tickers: Map<string, TickerRecord>;
+  exchangeRates: Map<string, number>;
+}
+
+function normalizeHydrationTarget(target: HydrationTarget): HydrationTarget {
+  return {
+    symbol: target.symbol.toUpperCase(),
+    exchange: target.exchange?.toUpperCase(),
+    brokerId: target.brokerId,
+    brokerInstanceId: target.brokerInstanceId,
+    instrument: target.instrument ?? null,
+  };
+}
+
+function hydrationTargetKey(target: HydrationTarget): string {
+  const normalized = normalizeHydrationTarget(target);
+  const contractKey = normalized.instrument?.conId
+    ?? normalized.instrument?.localSymbol
+    ?? normalized.instrument?.symbol
+    ?? "";
+  return [
+    normalized.symbol,
+    normalized.exchange ?? "",
+    normalized.brokerId ?? "",
+    normalized.brokerInstanceId ?? "",
+    contractKey,
+  ].join("|");
+}
+
+function targetFromTicker(ticker: TickerRecord): HydrationTarget {
+  const instrument = ticker.metadata.broker_contracts?.[0] ?? null;
+  return normalizeHydrationTarget({
+    symbol: ticker.metadata.ticker,
+    exchange: ticker.metadata.exchange,
+    brokerId: instrument?.brokerId,
+    brokerInstanceId: instrument?.brokerInstanceId,
+    instrument,
+  });
+}
+
+export function buildAppSessionSnapshot(state: SessionStateInput): AppSessionSnapshot {
+  const seen = new Set<string>();
+  const hydrationTargets: HydrationTarget[] = [];
+  const exchangeCurrencies = [...new Set(
+    [...state.exchangeRates.keys()]
+      .map((currency) => currency.trim().toUpperCase())
+      .filter(Boolean),
+  )];
+
+  const pushTarget = (ticker: TickerRecord | null | undefined) => {
+    if (!ticker) return;
+    const target = targetFromTicker(ticker);
+    const key = hydrationTargetKey(target);
+    if (seen.has(key)) return;
+    seen.add(key);
+    hydrationTargets.push(target);
+  };
+
+  for (const symbol of state.recentTickers) {
+    pushTarget(state.tickers.get(symbol));
+  }
+
+  for (const instance of state.config.layout.instances) {
+    const paneState = state.paneState[instance.instanceId];
+    const cursorSymbol = typeof paneState?.cursorSymbol === "string" ? paneState.cursorSymbol : null;
+    if (cursorSymbol) {
+      pushTarget(state.tickers.get(cursorSymbol));
+    }
+    if (instance.binding?.kind === "fixed") {
+      pushTarget(state.tickers.get(instance.binding.symbol));
+    }
+  }
+
+  return {
+    paneState: Object.fromEntries(
+      Object.entries(state.paneState)
+        .filter(([paneId]) => !!findPaneInstance(state.config.layout, paneId))
+        .map(([paneId, value]) => [paneId, { ...value }]),
+    ),
+    focusedPaneId: state.focusedPaneId,
+    activePanel: state.activePanel,
+    statusBarVisible: state.statusBarVisible,
+    openPaneIds: [
+      ...getDockedPaneIds(state.config.layout),
+      ...state.config.layout.floating.map((entry) => entry.instanceId),
+    ],
+    hydrationTargets,
+    exchangeCurrencies,
+    savedAt: Date.now(),
+  };
+}
+
+export function reconcileAppSessionSnapshot(
+  config: AppConfig,
+  snapshot: AppSessionSnapshot | null | undefined,
+): AppSessionSnapshot | null {
+  if (!snapshot) return null;
+
+  const validPaneIds = new Set(config.layout.instances.map((instance) => instance.instanceId));
+  const validBrokerInstanceIds = new Set(config.brokerInstances.map((instance) => instance.id));
+  const paneState = Object.fromEntries(
+    Object.entries(snapshot.paneState ?? {}).filter(([paneId]) => validPaneIds.has(paneId)),
+  );
+  const openPaneIds = (snapshot.openPaneIds ?? []).filter((paneId) => validPaneIds.has(paneId));
+  const defaultOpenPaneId = getDockedPaneIds(config.layout)[0] ?? config.layout.floating[0]?.instanceId ?? null;
+  const focusedPaneId = snapshot.focusedPaneId && validPaneIds.has(snapshot.focusedPaneId)
+    ? snapshot.focusedPaneId
+    : openPaneIds[0] ?? defaultOpenPaneId;
+  const hydrationTargets = (snapshot.hydrationTargets ?? [])
+    .map(normalizeHydrationTarget)
+    .filter((target) => !target.brokerInstanceId || validBrokerInstanceIds.has(target.brokerInstanceId));
+
+  return {
+    paneState,
+    focusedPaneId,
+    activePanel: snapshot.activePanel === "right" ? "right" : "left",
+    statusBarVisible: snapshot.statusBarVisible !== false,
+    openPaneIds,
+    hydrationTargets,
+    exchangeCurrencies: [...new Set(
+      (snapshot.exchangeCurrencies ?? [])
+        .map((currency) => currency.trim().toUpperCase())
+        .filter(Boolean),
+    )],
+    savedAt: typeof snapshot.savedAt === "number" ? snapshot.savedAt : Date.now(),
+  };
+}

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

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { TickerRefreshQueue } from "./ticker-refresh-queue";
+
+function nextTick(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+describe("TickerRefreshQueue", () => {
+  test("holds pending work while paused", async () => {
+    const queue = new TickerRefreshQueue(1);
+    const started: string[] = [];
+    let releaseFirst: (() => void) | undefined;
+
+    queue.enqueue({
+      key: "first",
+      priority: 0,
+      run: async () => {
+        started.push("first");
+        await new Promise<void>((resolve) => {
+          releaseFirst = resolve;
+        });
+      },
+    });
+
+    queue.enqueue({
+      key: "second",
+      priority: 1,
+      run: async () => {
+        started.push("second");
+      },
+    });
+
+    await nextTick();
+    expect(started).toEqual(["first"]);
+
+    queue.setPaused(true);
+    if (!releaseFirst) throw new Error("expected first task to be running");
+    releaseFirst();
+    await nextTick();
+    expect(started).toEqual(["first"]);
+
+    queue.setPaused(false);
+    await nextTick();
+    expect(started).toEqual(["first", "second"]);
+  });
+});

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

@@ -0,0 +1,40 @@
+export interface TickerRefreshTask {
+  key: string;
+  priority: number;
+  run: () => Promise<void>;
+}
+
+export class TickerRefreshQueue {
+  private active = 0;
+  private paused = false;
+  private readonly pendingKeys = new Set<string>();
+  private readonly queue: TickerRefreshTask[] = [];
+
+  constructor(private readonly concurrency = 3) {}
+
+  setPaused(paused: boolean): void {
+    this.paused = paused;
+    if (!paused) this.pump();
+  }
+
+  enqueue(task: TickerRefreshTask): void {
+    if (this.pendingKeys.has(task.key)) return;
+    this.pendingKeys.add(task.key);
+    this.queue.push(task);
+    this.queue.sort((a, b) => a.priority - b.priority);
+    this.pump();
+  }
+
+  private pump(): void {
+    if (this.paused) return;
+    while (this.active < this.concurrency && this.queue.length > 0) {
+      const next = this.queue.shift()!;
+      this.active += 1;
+      void next.run().finally(() => {
+        this.active -= 1;
+        this.pendingKeys.delete(next.key);
+        this.pump();
+      });
+    }
+  }
+}

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

@@ -0,0 +1,174 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { getSharedRegistry } from "../plugins/registry";
+import { useAppState } from "./app-context";
+import { resolveTickerSearch, upsertTickerFromSearchResult } from "../utils/ticker-search";
+import { collectUniqueTickerSymbols } from "../utils/ticker-tokenizer";
+import { useQuoteStreaming } from "./use-quote-streaming";
+import type { Quote } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+
+export type InlineTickerStatus = "loading" | "ready" | "missing";
+
+export interface InlineTickerCatalogEntry {
+  status: InlineTickerStatus;
+  ticker: TickerRecord | null;
+  quote: Quote | null;
+}
+
+const resolutionInFlight = new Map<string, Promise<void>>();
+const quoteInFlight = new Map<string, Promise<void>>();
+const missingSymbols = new Set<string>();
+const initialQuoteRequested = new Set<string>();
+
+function normalizeSymbols(texts: readonly string[]): string[] {
+  return collectUniqueTickerSymbols(texts);
+}
+
+export function useInlineTickers(texts: readonly string[]): {
+  catalog: Record<string, InlineTickerCatalogEntry>;
+  openTicker: (symbol: string) => void;
+} {
+  const { state, dispatch } = useAppState();
+  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 });
+
+  latestRef.current = { state, dispatch, registry };
+
+  useEffect(() => {
+    let mounted = true;
+    const notify = () => {
+      if (!mounted) return;
+      setRefreshVersion((value) => value + 1);
+    };
+
+    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;
+
+      if (currentTicker && currentQuote) {
+        missingSymbols.delete(symbol);
+        initialQuoteRequested.delete(symbol);
+        continue;
+      }
+
+      if (!currentTicker && !missingSymbols.has(symbol)) {
+        let resolution = resolutionInFlight.get(symbol);
+        if (!resolution) {
+          resolution = (async () => {
+            const current = latestRef.current;
+            const activeRegistry = current.registry;
+            if (!activeRegistry) return;
+            const resolved = await resolveTickerSearch({
+              query: symbol,
+              activeTicker: null,
+              tickers: current.state.tickers,
+              dataProvider: activeRegistry.dataProvider,
+            });
+
+            if (!resolved) {
+              missingSymbols.add(symbol);
+              return;
+            }
+
+            if (resolved.kind === "local") return;
+
+            const { ticker, created } = await upsertTickerFromSearchResult(activeRegistry.tickerRepository, resolved.result);
+            current.dispatch({ type: "UPDATE_TICKER", ticker });
+            if (created) {
+              activeRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
+            }
+            missingSymbols.delete(symbol);
+          })()
+            .catch(() => {
+              missingSymbols.add(symbol);
+            })
+            .finally(() => {
+              resolutionInFlight.delete(symbol);
+            });
+          resolutionInFlight.set(symbol, resolution);
+        }
+        void resolution.finally(notify);
+        continue;
+      }
+
+      if (!currentTicker || currentQuote || initialQuoteRequested.has(symbol)) continue;
+
+      let quoteRequest = quoteInFlight.get(symbol);
+      if (!quoteRequest) {
+        initialQuoteRequested.add(symbol);
+        quoteRequest = (async () => {
+          const current = latestRef.current;
+          const activeRegistry = current.registry;
+          if (!activeRegistry) return;
+
+          const latestTicker = current.state.tickers.get(symbol);
+          if (!latestTicker) return;
+
+          const instrument = latestTicker.metadata.broker_contracts?.[0] ?? null;
+          const quote = await activeRegistry.dataProvider.getQuote(
+            symbol,
+            latestTicker.metadata.exchange,
+            instrument
+              ? {
+                brokerId: instrument.brokerId,
+                brokerInstanceId: instrument.brokerInstanceId,
+                instrument,
+              }
+              : undefined,
+          );
+          current.dispatch({ type: "MERGE_QUOTE", symbol, quote });
+        })()
+          .finally(() => {
+            quoteInFlight.delete(symbol);
+          });
+        quoteInFlight.set(symbol, quoteRequest);
+      }
+      void quoteRequest.finally(notify);
+    }
+
+    return () => {
+      mounted = false;
+    };
+  }, [dispatch, registry, state.financials, state.tickers, symbols, symbolsKey]);
+
+  const streamingTargets = symbols
+    .map((symbol) => state.tickers.get(symbol))
+    .filter((ticker): ticker is TickerRecord => ticker != null)
+    .map((ticker) => {
+      const instrument = ticker.metadata.broker_contracts?.[0] ?? null;
+      return {
+        symbol: ticker.metadata.ticker,
+        exchange: ticker.metadata.exchange,
+        context: instrument
+          ? {
+            brokerId: instrument.brokerId,
+            brokerInstanceId: instrument.brokerInstanceId,
+            instrument,
+          }
+          : undefined,
+      };
+    });
+
+  useQuoteStreaming(streamingTargets);
+
+  const openTicker = useCallback((symbol: string) => {
+    registry?.pinTickerFn(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 status: InlineTickerStatus = ticker
+      ? (quote ? "ready" : "loading")
+      : (missingSymbols.has(symbol) ? "missing" : "loading");
+    catalog[symbol] = { status, ticker, quote };
+  }
+
+  return { catalog, openTicker };
+}

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

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { buildQuoteStreamSubscriptionKey } from "./use-quote-streaming";
+
+describe("buildQuoteStreamSubscriptionKey", () => {
+  test("includes broker context so identical symbols can stream independently", () => {
+    const base = {
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+    };
+
+    const workKey = buildQuoteStreamSubscriptionKey({
+      ...base,
+      context: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: { brokerId: "ibkr", brokerInstanceId: "ibkr-work", conId: 1001, symbol: "AAPL" },
+      },
+    });
+    const personalKey = buildQuoteStreamSubscriptionKey({
+      ...base,
+      context: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-personal",
+        instrument: { brokerId: "ibkr", brokerInstanceId: "ibkr-personal", conId: 2002, symbol: "AAPL" },
+      },
+    });
+
+    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);
+  });
+});