gloomberb 0.5.1 → 0.6.1

package/src/plugins/builtin/options-availability.test.tsx

@@ -1,179 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { testRender } from "@opentui/react/test-utils";
-import type { DataProvider } from "../../types/data-provider";
-import type { OptionsChain } from "../../types/financials";
-import type { TickerRecord } from "../../types/ticker";
-import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
-import { createTestDataProvider } from "../../test-support/data-provider";
-import {
-  fetchOptionsAvailability,
-  readOptionsAvailability,
-  resetOptionsAvailabilityCache,
-  useOptionsAvailability,
-} from "./options-availability";
-import { resolveOptionsTarget } from "../../utils/options";
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-let setHarnessTicker: ((ticker: TickerRecord | null) => void) | null = null;
-let sharedCoordinator: MarketDataCoordinator | null = null;
-
-function makeTicker(symbol: string, assetCategory = "STK"): TickerRecord {
-  return {
-    metadata: {
-      ticker: symbol,
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: symbol,
-      assetCategory,
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-    },
-  };
-}
-
-function createProvider(
-  getOptionsChain: NonNullable<DataProvider["getOptionsChain"]>,
-): DataProvider {
-  return createTestDataProvider({
-    getOptionsChain,
-  });
-}
-
-function createChain(underlyingSymbol: string, expirationDates: number[]): OptionsChain {
-  return {
-    underlyingSymbol,
-    expirationDates,
-    calls: [],
-    puts: [],
-  };
-}
-
-function createDeferred<T>() {
-  let resolve!: (value: T) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-
-function AvailabilityHarness({ initialTicker }: { initialTicker: TickerRecord | null }) {
-  const [ticker, setTicker] = useState(initialTicker);
-  setHarnessTicker = setTicker;
-  const available = useOptionsAvailability(ticker);
-  return <text>{`${ticker?.metadata.ticker ?? "none"}:${available}`}</text>;
-}
-
-async function renderFrame() {
-  await act(async () => {
-    await testSetup!.renderOnce();
-  });
-}
-
-afterEach(() => {
-  if (testSetup) {
-    testSetup.renderer.destroy();
-    testSetup = undefined;
-  }
-  setHarnessTicker = null;
-  resetOptionsAvailabilityCache();
-  sharedCoordinator = null;
-  setSharedMarketDataCoordinator(null);
-});
-
-beforeEach(() => {
-  resetOptionsAvailabilityCache();
-  setSharedMarketDataCoordinator(null);
-});
-
-describe("options availability", () => {
-  test("marks a stock with expirations as available", async () => {
-    const target = resolveOptionsTarget(makeTicker("AAPL"));
-    const provider = createProvider(async () => createChain("AAPL", [1_717_113_600]));
-
-    expect(target).not.toBeNull();
-    expect(await fetchOptionsAvailability(target!, provider)).toBe(true);
-    expect(readOptionsAvailability(target!)).toBe(true);
-  });
-
-  test("marks an empty chain as unavailable", async () => {
-    const target = resolveOptionsTarget(makeTicker("AAPL"));
-    const provider = createProvider(async () => createChain("AAPL", []));
-
-    expect(target).not.toBeNull();
-    expect(await fetchOptionsAvailability(target!, provider)).toBe(false);
-    expect(readOptionsAvailability(target!)).toBe(false);
-  });
-
-  test("resolves option positions to the underlying before checking", async () => {
-    const ticker = makeTicker("SPY  260619C00500000", "OPT");
-    const calls: Array<{ symbol: string; exchange: string }> = [];
-    const provider = createProvider(async (symbol, exchange = "") => {
-      calls.push({ symbol, exchange });
-      return createChain(symbol, [1_717_113_600]);
-    });
-    const target = resolveOptionsTarget(ticker);
-
-    expect(target).not.toBeNull();
-    await fetchOptionsAvailability(target!, provider);
-
-    expect(calls).toEqual([{ symbol: "SPY", exchange: "" }]);
-  });
-
-  test("ignores stale async results when the selected ticker changes", async () => {
-    const aapl = createDeferred<OptionsChain>();
-    const tsla = createDeferred<OptionsChain>();
-    sharedCoordinator = new MarketDataCoordinator(createProvider(async (symbol) => (
-      symbol === "AAPL" ? aapl.promise : tsla.promise
-    )));
-    setSharedMarketDataCoordinator(sharedCoordinator);
-
-    testSetup = await testRender(<AvailabilityHarness initialTicker={makeTicker("AAPL")} />, {
-      width: 40,
-      height: 4,
-    });
-
-    await renderFrame();
-
-    await act(async () => {
-      setHarnessTicker!(makeTicker("TSLA"));
-      await Promise.resolve();
-    });
-    await renderFrame();
-
-    await act(async () => {
-      tsla.resolve(createChain("TSLA", []));
-      await Promise.resolve();
-    });
-    await renderFrame();
-
-    await act(async () => {
-      aapl.resolve(createChain("AAPL", [1_717_113_600]));
-      await Promise.resolve();
-    });
-    await renderFrame();
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("TSLA:false");
-    expect(frame).not.toContain("TSLA:true");
-  });
-
-  test("suppresses duplicate preflight calls while the cache is fresh", async () => {
-    const target = resolveOptionsTarget(makeTicker("AAPL"));
-    let calls = 0;
-    const provider = createProvider(async () => {
-      calls += 1;
-      return createChain("AAPL", [1_717_113_600]);
-    });
-
-    expect(target).not.toBeNull();
-    expect(await fetchOptionsAvailability(target!, provider)).toBe(true);
-    expect(await fetchOptionsAvailability(target!, provider)).toBe(true);
-    expect(calls).toBe(1);
-  });
-});

package/src/plugins/builtin/options-availability.ts

@@ -1,158 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { getSharedMarketDataCoordinator } from "../../market-data/coordinator";
-import type { DataProvider } from "../../types/data-provider";
-import type { TickerRecord } from "../../types/ticker";
-import type { ResolvedOptionsTarget } from "../../utils/options";
-import { resolveOptionsTarget } from "../../utils/options";
-
-export const OPTIONS_AVAILABILITY_TTL_MS = 5 * 60_000;
-
-const EXPECTED_OPTIONS_MISS = /no data found|symbol may be delisted|not found|no options|no provider available/i;
-
-type OptionsAvailabilityRecord = {
-  available: boolean;
-  checkedAt: number;
-};
-
-const optionsAvailabilityCache = new Map<string, OptionsAvailabilityRecord>();
-const optionsAvailabilityInFlight = new Map<string, Promise<boolean>>();
-
-function getRequestContext(target: ResolvedOptionsTarget) {
-  return {
-    brokerId: target.instrument?.brokerId,
-    brokerInstanceId: target.instrument?.brokerInstanceId,
-    instrument: target.instrument,
-  };
-}
-
-function isCacheFresh(record: OptionsAvailabilityRecord | undefined, now: number): record is OptionsAvailabilityRecord {
-  return !!record && (now - record.checkedAt) < OPTIONS_AVAILABILITY_TTL_MS;
-}
-
-export function readOptionsAvailability(
-  targetOrKey: ResolvedOptionsTarget | string,
-  now = Date.now(),
-): boolean | null {
-  const key = typeof targetOrKey === "string" ? targetOrKey : targetOrKey.cacheKey;
-  const record = optionsAvailabilityCache.get(key);
-  return isCacheFresh(record, now) ? record.available : null;
-}
-
-export function setOptionsAvailability(
-  targetOrKey: ResolvedOptionsTarget | string,
-  available: boolean,
-  checkedAt = Date.now(),
-): void {
-  const key = typeof targetOrKey === "string" ? targetOrKey : targetOrKey.cacheKey;
-  optionsAvailabilityCache.set(key, { available, checkedAt });
-}
-
-export function resetOptionsAvailabilityCache(): void {
-  optionsAvailabilityCache.clear();
-  optionsAvailabilityInFlight.clear();
-}
-
-export async function fetchOptionsAvailability(
-  target: ResolvedOptionsTarget,
-  provider?: DataProvider,
-): Promise<boolean> {
-  const cached = readOptionsAvailability(target);
-  if (cached != null) return cached;
-
-  if (!target.effectiveTicker) {
-    setOptionsAvailability(target, false);
-    return false;
-  }
-
-  const existing = optionsAvailabilityInFlight.get(target.cacheKey);
-  if (existing) return existing;
-
-  const request = (async () => {
-    try {
-      if (provider?.getOptionsChain) {
-        const chain = await provider.getOptionsChain(
-          target.effectiveTicker,
-          target.effectiveExchange,
-          undefined,
-          getRequestContext(target),
-        );
-        const available = chain.expirationDates.length > 0;
-        setOptionsAvailability(target, available);
-        return available;
-      }
-
-      const coordinator = getSharedMarketDataCoordinator();
-      if (!coordinator) {
-        setOptionsAvailability(target, false);
-        return false;
-      }
-      const entry = await coordinator.loadOptions({
-        instrument: {
-          symbol: target.effectiveTicker,
-          exchange: target.effectiveExchange,
-          brokerId: target.instrument?.brokerId,
-          brokerInstanceId: target.instrument?.brokerInstanceId,
-          instrument: target.instrument,
-        },
-      });
-      const chain = entry.data ?? entry.lastGoodData;
-      if (!chain) {
-        setOptionsAvailability(target, false);
-        return false;
-      }
-      const available = chain.expirationDates.length > 0;
-      setOptionsAvailability(target, available);
-      return available;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error ?? "");
-      if (!EXPECTED_OPTIONS_MISS.test(message)) {
-        setOptionsAvailability(target, false);
-        return false;
-      }
-      setOptionsAvailability(target, false);
-      return false;
-    }
-  })().finally(() => {
-    optionsAvailabilityInFlight.delete(target.cacheKey);
-  });
-
-  optionsAvailabilityInFlight.set(target.cacheKey, request);
-  return request;
-}
-
-export function useOptionsAvailability(ticker: TickerRecord | null | undefined): boolean {
-  const target = useMemo(() => resolveOptionsTarget(ticker), [
-    ticker?.metadata.ticker,
-    ticker?.metadata.exchange,
-    ticker?.metadata.assetCategory,
-    ticker?.metadata.broker_contracts?.[0]?.brokerInstanceId,
-    ticker?.metadata.broker_contracts?.[0]?.conId,
-  ]);
-  const [available, setAvailable] = useState(() => (target ? readOptionsAvailability(target) ?? false : false));
-  const requestRef = useRef(0);
-
-  useEffect(() => {
-    if (!target) {
-      requestRef.current += 1;
-      setAvailable(false);
-      return;
-    }
-
-    const cached = readOptionsAvailability(target);
-    if (cached != null) {
-      requestRef.current += 1;
-      setAvailable(cached);
-      return;
-    }
-
-    setAvailable(false);
-    const requestId = ++requestRef.current;
-    void fetchOptionsAvailability(target).then((result) => {
-      if (requestRef.current === requestId) {
-        setAvailable(result);
-      }
-    });
-  }, [target?.cacheKey]);
-
-  return available;
-}

package/src/plugins/builtin/portfolio-list/metrics.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getColumnValue, type ColumnContext } from "./metrics";
-import type { ColumnConfig } from "../../../types/config";
-import type { TickerFinancials } from "../../../types/financials";
-import type { TickerRecord } from "../../../types/ticker";
-
-const TICKER_COLUMN: ColumnConfig = {
-  id: "ticker",
-  label: "Ticker",
-  width: 12,
-  align: "left",
-};
-
-const TEST_CONTEXT: ColumnContext = {
-  baseCurrency: "USD",
-  exchangeRates: new Map(),
-  now: Date.now(),
-};
-
-function makeTicker(): TickerRecord {
-  return {
-    metadata: {
-      ticker: "AAPL",
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: "Apple",
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-    },
-  };
-}
-
-function makeFinancials(marketState?: TickerFinancials["quote"]["marketState"]): TickerFinancials {
-  return {
-    annualStatements: [],
-    quarterlyStatements: [],
-    priceHistory: [],
-    quote: {
-      symbol: "AAPL",
-      price: 100,
-      currency: "USD",
-      change: 1,
-      changePercent: 1,
-      lastUpdated: Date.now(),
-      marketState,
-    },
-  };
-}
-
-describe("portfolio-list metrics", () => {
-  test("maps session states to the portfolio status glyphs", () => {
-    expect(getColumnValue(TICKER_COLUMN, makeTicker(), makeFinancials("REGULAR"), TEST_CONTEXT).text).toBe("● AAPL");
-    expect(getColumnValue(TICKER_COLUMN, makeTicker(), makeFinancials("PRE"), TEST_CONTEXT).text).toBe("◐ AAPL");
-    expect(getColumnValue(TICKER_COLUMN, makeTicker(), makeFinancials("POST"), TEST_CONTEXT).text).toBe("◐ AAPL");
-    expect(getColumnValue(TICKER_COLUMN, makeTicker(), makeFinancials("CLOSED"), TEST_CONTEXT).text).toBe("○ AAPL");
-    expect(getColumnValue(TICKER_COLUMN, makeTicker(), makeFinancials(undefined), TEST_CONTEXT).text).toBe("◌ AAPL");
-  });
-});

package/src/plugins/builtin/yield-curve/treasury-data.test.ts

@@ -1,212 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import type { PersistedResourceValue } from "../../../types/persistence";
-import type { PluginPersistence } from "../../../types/plugin";
-import {
-  attachYieldCurvePersistence,
-  isInverted,
-  loadYieldCurve,
-  parseYieldPoints,
-  resetYieldCurvePersistence,
-  TREASURY_MATURITIES,
-  YIELD_CURVE_CACHE_POLICY,
-  type YieldPoint,
-} from "./treasury-data";
-
-class MemoryPluginPersistence implements PluginPersistence {
-  private readonly resources = new Map<string, PersistedResourceValue<unknown>>();
-  private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
-
-  getState<T = unknown>(key: string, options?: { schemaVersion?: number }): T | null {
-    const record = this.state.get(key);
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
-    return record.value as T;
-  }
-
-  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
-    this.state.set(key, { schemaVersion: options?.schemaVersion ?? 1, value });
-  }
-
-  deleteState(key: string): void {
-    this.state.delete(key);
-  }
-
-  getResource<T = unknown>(
-    kind: string,
-    key: string,
-    options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
-  ): PersistedResourceValue<T> | null {
-    const record = this.resources.get(this.resourceKey(kind, key, options?.sourceKey));
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
-    const next = this.withFreshness(record);
-    if (!options?.allowExpired && next.expired) return null;
-    return next as PersistedResourceValue<T>;
-  }
-
-  setResource<T = unknown>(
-    kind: string,
-    key: string,
-    value: T,
-    options: {
-      cachePolicy: { staleMs: number; expireMs: number };
-      sourceKey?: string;
-      schemaVersion?: number;
-      provenance?: unknown;
-    },
-  ): PersistedResourceValue<T> {
-    const now = Date.now();
-    const record: PersistedResourceValue<T> = {
-      value,
-      fetchedAt: now,
-      staleAt: now + options.cachePolicy.staleMs,
-      expiresAt: now + options.cachePolicy.expireMs,
-      sourceKey: options.sourceKey ?? "",
-      schemaVersion: options.schemaVersion ?? 1,
-      provenance: options.provenance,
-      stale: false,
-      expired: false,
-    };
-    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
-    return record;
-  }
-
-  deleteResource(kind: string, key: string, options?: { sourceKey?: string }): void {
-    this.resources.delete(this.resourceKey(kind, key, options?.sourceKey));
-  }
-
-  seedResource<T>(
-    kind: string,
-    key: string,
-    value: T,
-    options: { sourceKey?: string; stale?: boolean; expired?: boolean } = {},
-  ): void {
-    const now = Date.now();
-    const record: PersistedResourceValue<T> = {
-      value,
-      fetchedAt: now - 60_000,
-      staleAt: options.stale ? now - 1 : now + YIELD_CURVE_CACHE_POLICY.staleMs,
-      expiresAt: options.expired ? now - 1 : now + YIELD_CURVE_CACHE_POLICY.expireMs,
-      sourceKey: options.sourceKey ?? "",
-      schemaVersion: 1,
-      stale: !!options.stale,
-      expired: !!options.expired,
-    };
-    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
-  }
-
-  private resourceKey(kind: string, key: string, sourceKey = ""): string {
-    return `${kind}:${key}:${sourceKey}`;
-  }
-
-  private withFreshness<T>(record: PersistedResourceValue<T>): PersistedResourceValue<T> {
-    const now = Date.now();
-    return {
-      ...record,
-      stale: now >= record.staleAt,
-      expired: now >= record.expiresAt,
-    };
-  }
-}
-
-const SAMPLE_POINTS: YieldPoint[] = [
-  { maturity: "2Y", maturityYears: 2, yield: 4.5 },
-  { maturity: "10Y", maturityYears: 10, yield: 4.3 },
-];
-
-afterEach(() => {
-  resetYieldCurvePersistence();
-});
-
-describe("parseYieldPoints", () => {
-  test("filters out null yields", () => {
-    const points: YieldPoint[] = [
-      { maturity: "2Y", maturityYears: 2, yield: 4.5 },
-      { maturity: "5Y", maturityYears: 5, yield: null },
-      { maturity: "10Y", maturityYears: 10, yield: 4.3 },
-    ];
-    const result = parseYieldPoints(points);
-    expect(result).toHaveLength(2);
-    expect(result[0]!.maturity).toBe("2Y");
-    expect(result[1]!.maturity).toBe("10Y");
-  });
-
-  test("returns empty for all nulls", () => {
-    expect(parseYieldPoints([{ maturity: "2Y", maturityYears: 2, yield: null }])).toEqual([]);
-  });
-});
-
-describe("isInverted", () => {
-  test("detects inverted curve (2Y > 10Y)", () => {
-    const points: YieldPoint[] = [
-      { maturity: "2Y", maturityYears: 2, yield: 5.0 },
-      { maturity: "10Y", maturityYears: 10, yield: 4.3 },
-    ];
-    expect(isInverted(points)).toBe(true);
-  });
-
-  test("normal curve is not inverted", () => {
-    const points: YieldPoint[] = [
-      { maturity: "2Y", maturityYears: 2, yield: 4.0 },
-      { maturity: "10Y", maturityYears: 10, yield: 4.5 },
-    ];
-    expect(isInverted(points)).toBe(false);
-  });
-
-  test("returns false when data is missing", () => {
-    expect(isInverted([])).toBe(false);
-    expect(isInverted([{ maturity: "2Y", maturityYears: 2, yield: 4.0 }])).toBe(false);
-  });
-});
-
-describe("TREASURY_MATURITIES", () => {
-  test("has 10 maturities in ascending order", () => {
-    expect(TREASURY_MATURITIES).toHaveLength(10);
-    for (let i = 1; i < TREASURY_MATURITIES.length; i++) {
-      expect(TREASURY_MATURITIES[i]!.years).toBeGreaterThan(TREASURY_MATURITIES[i - 1]!.years);
-    }
-  });
-});
-
-describe("loadYieldCurve cache", () => {
-  test("uses a fresh plugin resource cache without fetching", async () => {
-    const persistence = new MemoryPluginPersistence();
-    attachYieldCurvePersistence(persistence);
-    persistence.setResource("treasury-yield-curve", "latest", SAMPLE_POINTS, {
-      sourceKey: "fred",
-      cachePolicy: YIELD_CURVE_CACHE_POLICY,
-    });
-    let fetchCalls = 0;
-
-    const points = await loadYieldCurve("key", {
-      fetcher: async () => {
-        fetchCalls += 1;
-        throw new Error("unexpected fetch");
-      },
-    });
-
-    expect(points).toEqual(SAMPLE_POINTS);
-    expect(fetchCalls).toBe(0);
-  });
-
-  test("falls back to stale plugin resource cache when refresh fails", async () => {
-    const persistence = new MemoryPluginPersistence();
-    attachYieldCurvePersistence(persistence);
-    persistence.seedResource("treasury-yield-curve", "latest", SAMPLE_POINTS, {
-      sourceKey: "fred",
-      stale: true,
-    });
-    let fetchCalls = 0;
-
-    const points = await loadYieldCurve("key", {
-      force: true,
-      fetcher: async () => {
-        fetchCalls += 1;
-        throw new Error("offline");
-      },
-    });
-
-    expect(points).toEqual(SAMPLE_POINTS);
-    expect(fetchCalls).toBe(1);
-  });
-});

package/src/plugins/prediction-markets/status.ts

@@ -1,24 +0,0 @@
-import { colors } from "../../theme/colors";
-import type { PredictionTransportState } from "./types";
-
-export function formatPredictionTransportBadge(
-  transport: PredictionTransportState,
-): {
-  label: string;
-  color: string;
-} {
-  switch (transport) {
-    case "live":
-      return { label: "Live WS", color: colors.positive };
-    case "polling":
-      return { label: "Polling", color: colors.text };
-    case "stale":
-      return { label: "Stale", color: colors.textDim };
-    case "error":
-      return { label: "Error", color: colors.negative };
-    case "loading":
-      return { label: "Loading", color: colors.text };
-    default:
-      return { label: "Idle", color: colors.textDim };
-  }
-}