gloomberb 0.7.4 → 0.8.0

package/src/market-data/market/freshness.ts

@@ -0,0 +1,140 @@
+import type { MarketState } from "../../types/financials";
+import { canonicalExchange, EXCHANGE_TIME_ZONES } from "../../utils/exchanges";
+
+const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
+const ALWAYS_OPEN_EXCHANGES = new Set(["CCC"]);
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
+const exchangeLocalDateFormatters = new Map<string, Intl.DateTimeFormat>();
+const usSessionFormatter = new Intl.DateTimeFormat("en-US", {
+  timeZone: "America/New_York",
+  weekday: "short",
+  hour: "2-digit",
+  minute: "2-digit",
+  hourCycle: "h23",
+});
+
+type UsSessionState = Exclude<MarketState, never>;
+
+function isUsExtendedHoursExchange(exchange?: string): boolean {
+  return US_EXTENDED_HOURS_EXCHANGES.has(canonicalExchange(exchange));
+}
+
+function getExchangeLocalDateFormatter(timeZone: string): Intl.DateTimeFormat {
+  let formatter = exchangeLocalDateFormatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    });
+    exchangeLocalDateFormatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+
+function exchangeLocalDate(exchange: string, timestampMs: number): string | null {
+  const timeZone = EXCHANGE_TIME_ZONES[canonicalExchange(exchange)];
+  if (!timeZone) return null;
+
+  const parts = getExchangeLocalDateFormatter(timeZone).formatToParts(new Date(timestampMs));
+  const year = parts.find((part) => part.type === "year")?.value;
+  const month = parts.find((part) => part.type === "month")?.value;
+  const day = parts.find((part) => part.type === "day")?.value;
+  if (!year || !month || !day) return null;
+  return `${year}-${month}-${day}`;
+}
+
+function isoLocalDateToUtcDay(date: string): number | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  if (!match) return null;
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+
+  return Math.floor(Date.UTC(year, month - 1, day) / MS_PER_DAY);
+}
+
+function localWeekdaysBetween(earlierDate: string, laterDate: string): number {
+  const earlierDay = isoLocalDateToUtcDay(earlierDate);
+  const laterDay = isoLocalDateToUtcDay(laterDate);
+  if (earlierDay == null || laterDay == null || laterDay <= earlierDay) return 0;
+
+  let weekdays = 0;
+  for (let day = earlierDay + 1; day <= laterDay; day += 1) {
+    const weekday = new Date(day * MS_PER_DAY).getUTCDay();
+    if (weekday !== 0 && weekday !== 6) {
+      weekdays += 1;
+    }
+  }
+  return weekdays;
+}
+
+function localWeekday(date: string): number | null {
+  const day = isoLocalDateToUtcDay(date);
+  return day == null ? null : new Date(day * MS_PER_DAY).getUTCDay();
+}
+
+function usSessionState(timestampMs: number): UsSessionState {
+  const parts = usSessionFormatter.formatToParts(new Date(timestampMs));
+
+  const weekday = parts.find((part) => part.type === "weekday")?.value ?? "";
+  if (weekday === "Sat" || weekday === "Sun") return "CLOSED";
+
+  const hour = Number(parts.find((part) => part.type === "hour")?.value ?? "0");
+  const minute = Number(parts.find((part) => part.type === "minute")?.value ?? "0");
+  const totalMinutes = hour * 60 + minute;
+
+  if (totalMinutes < 4 * 60) return "PREPRE";
+  if (totalMinutes < 9 * 60 + 30) return "PRE";
+  if (totalMinutes < 16 * 60) return "REGULAR";
+  if (totalMinutes < 20 * 60) return "POST";
+  return "POSTPOST";
+}
+
+export function isTimestampStaleForExchangeSession(
+  timestampMs: number,
+  exchange?: string,
+  now = Date.now(),
+  marketState?: MarketState,
+): boolean {
+  try {
+    return isTimestampStaleForExchangeSessionUnsafe(timestampMs, exchange, now, marketState);
+  } catch {
+    return true;
+  }
+}
+
+function isTimestampStaleForExchangeSessionUnsafe(
+  timestampMs: number,
+  exchange?: string,
+  now = Date.now(),
+  marketState?: MarketState,
+): boolean {
+  const canonical = canonicalExchange(exchange);
+  if (!canonical || !Number.isFinite(timestampMs) || !Number.isFinite(now)) return false;
+
+  const timestampDate = exchangeLocalDate(canonical, timestampMs);
+  const currentDate = exchangeLocalDate(canonical, now);
+  if (!timestampDate || !currentDate || timestampDate === currentDate) return false;
+
+  if (ALWAYS_OPEN_EXCHANGES.has(canonical)) return true;
+  if (marketState === "REGULAR") return true;
+
+  if (isUsExtendedHoursExchange(canonical)) {
+    const session = usSessionState(now);
+    if (session === "PRE" || session === "REGULAR" || session === "POST") {
+      return true;
+    }
+  }
+
+  const weekdaysBehind = localWeekdaysBetween(timestampDate, currentDate);
+  if (weekdaysBehind > 1) return true;
+  if (weekdaysBehind === 1 && now - timestampMs > OVERNIGHT_CLOSE_MAX_AGE_MS) {
+    return localWeekday(currentDate) !== 1;
+  }
+  return false;
+}

package/src/market-data/market/status.ts

@@ -0,0 +1,112 @@
+import type { MarketState, Quote, QuoteFieldProvenance } from "../../types/financials";
+import { colors } from "../../theme/colors";
+
+export interface ActiveQuoteDisplay {
+  price: number;
+  change: number;
+  changePercent: number;
+}
+
+export function marketStateLabel(state: MarketState): string {
+  switch (state) {
+    case "PRE": return "PRE-MKT";
+    case "REGULAR": return "OPEN";
+    case "POST": return "AFTER-HRS";
+    case "PREPRE":
+    case "POSTPOST":
+    case "CLOSED": return "CLOSED";
+  }
+}
+
+export function marketStateColor(state: MarketState): string {
+  switch (state) {
+    case "REGULAR": return colors.positive;
+    case "PRE":
+    case "POST": return colors.textBright;
+    case "PREPRE":
+    case "POSTPOST":
+    case "CLOSED": return colors.textDim;
+  }
+}
+
+export function marketStateDot(state?: MarketState): string {
+  switch (state) {
+    case "REGULAR":
+      return "\u25CF";
+    case "PRE":
+    case "POST":
+      return "\u25D0";
+    case "CLOSED":
+    case "PREPRE":
+    case "POSTPOST":
+      return "\u25CB";
+    default:
+      return "\u25CC";
+  }
+}
+
+/** Short exchange display name */
+export function exchangeShortName(exchangeName?: string, fullExchangeName?: string): string {
+  if (!exchangeName && !fullExchangeName) return "";
+  const name = exchangeName || fullExchangeName || "";
+  // Common Yahoo Finance exchange abbreviations
+  const map: Record<string, string> = {
+    NMS: "NASDAQ", NGM: "NASDAQ", NCM: "NASDAQ", NAS: "NASDAQ",
+    NYQ: "NYSE", NYS: "NYSE",
+    PCX: "AMEX", ASE: "AMEX",
+    HKG: "HKEX",
+    TYO: "TYO",
+    LSE: "LSE",
+    ASX: "ASX",
+    SGX: "SGX",
+    KSC: "KRX", KOE: "KOSDAQ",
+    TAI: "TWSE",
+    SHH: "SSE", SHZ: "SZSE",
+    PAR: "EURONEXT", AMS: "EURONEXT", BRU: "EURONEXT",
+    GER: "XETRA",
+    OSL: "OSE",
+    BOM: "BSE", NSI: "NSE",
+    SAO: "B3",
+    JPX: "TYO",
+  };
+  return map[name] || name;
+}
+
+export function quoteSourceLabel(
+  provenance?: QuoteFieldProvenance,
+  kind: "price" | "session" = "price",
+): string {
+  if (!provenance?.providerId) return "Unknown";
+  if (provenance.providerId === "ibkr") {
+    if (kind === "session") return "Broker";
+    if (provenance.dataSource === "live") return "IBKR live";
+    if (provenance.dataSource === "delayed") return "IBKR delayed";
+    return "IBKR";
+  }
+  if (provenance.providerId === "gloomberb-cloud") return "Cloud";
+  if (provenance.providerId === "yahoo") return "Yahoo";
+  return provenance.providerId;
+}
+
+export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  if (!quote) return null;
+  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
+    return {
+      price: quote.preMarketPrice,
+      change: quote.preMarketChange ?? 0,
+      changePercent: quote.preMarketChangePercent ?? 0,
+    };
+  }
+  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
+    return {
+      price: quote.postMarketPrice,
+      change: quote.postMarketChange ?? 0,
+      changePercent: quote.postMarketChangePercent ?? 0,
+    };
+  }
+  return {
+    price: quote.price,
+    change: quote.change,
+    changePercent: quote.changePercent,
+  };
+}

package/src/market-data/quotes/contributions.ts

@@ -0,0 +1,194 @@
+import type {
+  Quote,
+  QuoteContribution,
+  QuoteContributionMap,
+  SessionConfidence,
+  TickerFinancials,
+} from "../../types/financials";
+
+function inferQuoteProviderId(quote: Quote | QuoteContribution): string {
+  if (quote.providerId?.trim()) return quote.providerId;
+  return "quote";
+}
+
+function inferSessionConfidence(
+  quote: Quote | QuoteContribution,
+  providerId: string,
+): SessionConfidence {
+  if (quote.sessionConfidence) return quote.sessionConfidence;
+  if (providerId === "ibkr") return "unknown";
+  if (quote.marketState) return providerId === "gloomberb-cloud" ? "derived" : "derived";
+  return "unknown";
+}
+
+function normalizeListingExchange(
+  quote: Quote | QuoteContribution,
+  providerId: string,
+): { listingExchangeName?: string; listingExchangeFullName?: string } {
+  const listingExchangeName = quote.listingExchangeName ?? quote.exchangeName;
+  const listingExchangeFullName = quote.listingExchangeFullName ?? quote.fullExchangeName ?? listingExchangeName;
+  if (providerId === "ibkr" && listingExchangeName === "SMART") {
+    return {
+      listingExchangeName: undefined,
+      listingExchangeFullName: undefined,
+    };
+  }
+  return { listingExchangeName, listingExchangeFullName };
+}
+
+function shouldProjectSessionPrice(quote: Quote | QuoteContribution): boolean {
+  return quote.sessionConfidence === "explicit" || quote.dataSource === "live";
+}
+
+export function finalizeSessionFields(
+  quote: QuoteContribution,
+  options: { allowPriceProjection?: boolean } = {},
+): QuoteContribution {
+  const allowPriceProjection = options.allowPriceProjection !== false;
+  const canProjectSessionPrice = allowPriceProjection && shouldProjectSessionPrice(quote);
+
+  if (quote.marketState === "PRE") {
+    return {
+      ...quote,
+      preMarketPrice: quote.preMarketPrice ?? (canProjectSessionPrice ? quote.price : undefined),
+      preMarketChange: quote.preMarketChange ?? (canProjectSessionPrice ? quote.change : undefined),
+      preMarketChangePercent: quote.preMarketChangePercent ?? (canProjectSessionPrice ? quote.changePercent : undefined),
+      postMarketPrice: undefined,
+      postMarketChange: undefined,
+      postMarketChangePercent: undefined,
+    };
+  }
+
+  if (quote.marketState === "POST") {
+    return {
+      ...quote,
+      preMarketPrice: undefined,
+      preMarketChange: undefined,
+      preMarketChangePercent: undefined,
+      postMarketPrice: quote.postMarketPrice ?? (canProjectSessionPrice ? quote.price : undefined),
+      postMarketChange: quote.postMarketChange ?? (canProjectSessionPrice ? quote.change : undefined),
+      postMarketChangePercent: quote.postMarketChangePercent ?? (canProjectSessionPrice ? quote.changePercent : undefined),
+    };
+  }
+
+  if (quote.marketState != null) {
+    return {
+      ...quote,
+      preMarketPrice: undefined,
+      preMarketChange: undefined,
+      preMarketChangePercent: undefined,
+      postMarketPrice: undefined,
+      postMarketChange: undefined,
+      postMarketChangePercent: undefined,
+    };
+  }
+
+  return quote;
+}
+
+export function getQuoteContributionKey(quote: Quote | QuoteContribution): string {
+  return inferQuoteProviderId(quote);
+}
+
+export function normalizeQuoteContribution(
+  quote: Quote | QuoteContribution | null | undefined,
+): QuoteContribution | undefined {
+  if (!quote) return undefined;
+  const providerId = inferQuoteProviderId(quote);
+  const { listingExchangeName, listingExchangeFullName } = normalizeListingExchange(quote, providerId);
+  const routingExchangeName = quote.routingExchangeName;
+  const routingExchangeFullName = quote.routingExchangeFullName ?? routingExchangeName;
+
+  return finalizeSessionFields({
+    ...quote,
+    providerId,
+    listingExchangeName,
+    listingExchangeFullName,
+    routingExchangeName,
+    routingExchangeFullName,
+    exchangeName: listingExchangeName ?? quote.exchangeName,
+    fullExchangeName: listingExchangeFullName ?? quote.fullExchangeName,
+    sessionConfidence: inferSessionConfidence(quote, providerId),
+  });
+}
+
+export function mergeQuoteContribution(
+  current: QuoteContribution | undefined,
+  nextQuote: Quote | QuoteContribution,
+): QuoteContribution {
+  const next = normalizeQuoteContribution(nextQuote);
+  if (!next) {
+    throw new Error("Cannot merge an empty quote contribution");
+  }
+  if (!current) return next;
+
+  const merged: QuoteContribution = {
+    ...current,
+    ...next,
+  };
+
+  if (next.marketState == null && current.marketState != null) {
+    merged.marketState = current.marketState;
+  }
+  if (next.sessionConfidence == null && current.sessionConfidence != null) {
+    merged.sessionConfidence = current.sessionConfidence;
+  }
+
+  if ((current.marketState === "PRE" || current.marketState === "POST") && next.marketState == null) {
+    const canProjectNextSessionPrice = shouldProjectSessionPrice(next);
+    merged.marketState = current.marketState;
+    if (current.marketState === "PRE") {
+      merged.preMarketPrice = next.preMarketPrice ?? (canProjectNextSessionPrice ? next.price : current.preMarketPrice);
+      merged.preMarketChange = next.preMarketChange ?? (canProjectNextSessionPrice ? next.change : current.preMarketChange);
+      merged.preMarketChangePercent = next.preMarketChangePercent ?? (canProjectNextSessionPrice ? next.changePercent : current.preMarketChangePercent);
+    } else {
+      merged.postMarketPrice = next.postMarketPrice ?? (canProjectNextSessionPrice ? next.price : current.postMarketPrice);
+      merged.postMarketChange = next.postMarketChange ?? (canProjectNextSessionPrice ? next.change : current.postMarketChange);
+      merged.postMarketChangePercent = next.postMarketChangePercent ?? (canProjectNextSessionPrice ? next.changePercent : current.postMarketChangePercent);
+    }
+  }
+
+  return finalizeSessionFields(merged);
+}
+
+export function mergeQuoteContributionMaps(
+  preferred: QuoteContributionMap | undefined,
+  fallback: QuoteContributionMap | undefined,
+): QuoteContributionMap | undefined {
+  const entries = new Map<string, QuoteContribution>();
+
+  for (const source of [fallback, preferred]) {
+    if (!source) continue;
+    for (const [key, quote] of Object.entries(source)) {
+      const normalized = normalizeQuoteContribution(quote);
+      if (!normalized) continue;
+      const contributionKey = key || getQuoteContributionKey(normalized);
+      entries.set(
+        contributionKey,
+        mergeQuoteContribution(entries.get(contributionKey), normalized),
+      );
+    }
+  }
+
+  if (entries.size === 0) return undefined;
+  return Object.fromEntries(entries.entries());
+}
+
+function cloneQuoteContributionMap(map: QuoteContributionMap | undefined): QuoteContributionMap | undefined {
+  return mergeQuoteContributionMaps(map, undefined);
+}
+
+export function quoteContributionValues(map: QuoteContributionMap | undefined): QuoteContribution[] {
+  return Object.values(map ?? {});
+}
+
+export function seedQuoteContributions(financials: TickerFinancials | null | undefined): QuoteContributionMap | undefined {
+  if (!financials) return undefined;
+  if (financials.quoteContributions && Object.keys(financials.quoteContributions).length > 0) {
+    return cloneQuoteContributionMap(financials.quoteContributions);
+  }
+  const normalizedQuote = normalizeQuoteContribution(financials.quote);
+  if (!normalizedQuote) return undefined;
+  const key = getQuoteContributionKey(normalizedQuote);
+  return { [key]: normalizedQuote };
+}

package/src/market-data/quotes/freshness.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "bun:test";
+import type { Quote } from "../../types/financials";
+import { isQuoteStaleForCurrentSession } from "./freshness";
+
+function quote(overrides: Partial<Quote>): Quote {
+  return {
+    symbol: "2337",
+    price: 168,
+    currency: "TWD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.parse("2026-05-08T06:00:00Z"),
+    listingExchangeName: "TWSE",
+    exchangeName: "TWSE",
+    marketState: "CLOSED",
+    dataSource: "delayed",
+    ...overrides,
+  };
+}
+
+describe("quote freshness", () => {
+  test("treats multi-business-day-old non-US closed quotes as stale", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({}),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("treats stale Paris and Toronto quotes as refreshable", () => {
+    const now = Date.parse("2026-05-13T21:00:00Z");
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "ALRIB",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-05-08T15:30:00Z"),
+          listingExchangeName: "PAR",
+          exchangeName: "PAR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HPS-A.TO",
+          currency: "CAD",
+          lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
+          listingExchangeName: "TOR",
+          exchangeName: "TOR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+  });
+
+  test("treats old crypto quotes as stale on the 24/7 venue", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "BTC-USD",
+          currency: "USD",
+          lastUpdated: Date.parse("2026-05-09T15:29:00Z"),
+          listingExchangeName: "CCC",
+          exchangeName: "CCC",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("allows the previous local business day before the market reopens", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "1211",
+          currency: "HKD",
+          lastUpdated: Date.parse("2026-05-13T08:00:00Z"),
+          listingExchangeName: "SEHK",
+          exchangeName: "SEHK",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("rejects previous-day weekday quotes that are older than a normal overnight close", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-12T21:00:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-13T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("allows Friday closes before Monday reopen", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-08T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-10T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("treats prior-date regular-session quotes as stale immediately", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HY9H",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-04-07T19:55:00Z"),
+          listingExchangeName: "FWB2",
+          exchangeName: "FWB2",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-04-08T10:49:00Z"),
+      ),
+    ).toBe(true);
+  });
+});

package/src/market-data/quotes/freshness.ts

@@ -0,0 +1,36 @@
+import type { Quote } from "../../types/financials";
+import { isTimestampStaleForExchangeSession } from "../market/freshness";
+
+function isQuoteMissingActiveSessionPrice(quote: Quote): boolean {
+  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice == null) {
+    return true;
+  }
+  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice == null) {
+    return true;
+  }
+  return false;
+}
+
+export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, now = Date.now()): boolean {
+  if (!quote) return false;
+  if (isQuoteMissingActiveSessionPrice(quote)) return true;
+
+  return isTimestampStaleForExchangeSession(
+    quote.lastUpdated,
+    quote.listingExchangeName || quote.exchangeName,
+    now,
+    quote.marketState,
+  );
+}
+
+export function hasFreshQuoteForCurrentSession(
+  quotes: Iterable<Quote | null | undefined>,
+  now = Date.now(),
+): boolean {
+  for (const quote of quotes) {
+    if (quote && !isQuoteStaleForCurrentSession(quote, now)) {
+      return true;
+    }
+  }
+  return false;
+}