gloomberb 0.15.2 → 0.15.3

package/src/plugins/builtin/market-movers/session-table.ts

@@ -0,0 +1,96 @@
+import type { CloudSessionMoversCategory } from "../../../api-client/market-movers";
+import type { DataTableCell, DataTableColumn } from "../../../components";
+import { getTableWidth } from "../../../components/ui/table-layout";
+import { colors, priceColor } from "../../../theme/colors";
+import { TextAttributes } from "../../../ui";
+import { formatCompact, formatPercentRaw } from "../../../utils/format";
+import { formatMoverPrice, moverReferencePrice } from "./model";
+import { leadCatalyst, type SessionMoverColumnId, type SessionMoverRow } from "./session";
+import { formatVolRatio, volRatioColor } from "./table";
+
+export type SessionMoverColumn = DataTableColumn & { id: SessionMoverColumnId };
+
+const VOLUME_LABEL: Record<CloudSessionMoversCategory, string> = {
+  premarket: "PRE VOL",
+  afterhours: "AH VOL",
+  gaps: "VOL",
+};
+
+/**
+ * Pre-market and after hours: last, change from the reference close, session
+ * volume, relative volume, float and the catalyst. Gaps add the gap and the
+ * distance from VWAP. The name gives way first, then the columns a narrow pane
+ * can do without (the day's volume, then the float).
+ */
+export function buildSessionMoverColumns(view: CloudSessionMoversCategory, width: number): SessionMoverColumn[] {
+  const columns: SessionMoverColumn[] = [
+    { id: "rank", label: "#", width: 3, align: "left" },
+    { id: "symbol", label: "TICKER", width: 8, align: "left" },
+    { id: "name", label: "NAME", width: 6, align: "left" },
+    { id: "price", label: "LAST", width: 10, align: "right" },
+    ...(view === "gaps" ? [{ id: "gapPercent" as const, label: "GAP%", width: 8, align: "right" as const }] : []),
+    { id: "changePercent", label: "CHG%", width: 8, align: "right" },
+    { id: "volume", label: VOLUME_LABEL[view], width: 8, align: "right" },
+    { id: "relativeVolume", label: "RVOL", width: 6, align: "right" },
+    ...(view === "gaps" ? [{ id: "vwapPercent" as const, label: "VWAP%", width: 7, align: "right" as const }] : []),
+    { id: "floatShares", label: "FLOAT", width: 7, align: "right" },
+    { id: "catalyst", label: "EVENT", width: 6, align: "left" },
+  ];
+  const optional: SessionMoverColumnId[] = view === "gaps" ? ["volume", "floatShares"] : ["floatShares"];
+  // Measured the way the table draws it: a header widens its column, and a
+  // left-aligned column after a right-aligned one gets a lead gap. The name
+  // sits between left-aligned columns, so it adds only its width and a gutter.
+  const nameRoom = () => width - getTableWidth(columns.filter((column) => column.id !== "name")) - 1;
+  const minName = 12;
+  for (const id of optional) {
+    if (nameRoom() >= minName) break;
+    columns.splice(columns.findIndex((column) => column.id === id), 1);
+  }
+  columns.find((column) => column.id === "name")!.width = Math.max(6, nameRoom());
+  return columns;
+}
+
+const CATALYST_LABEL = { halt: "Halt", filing: "8-K", news: "News" } as const;
+
+function signedPercent(value: number | null): DataTableCell {
+  return {
+    text: value == null ? "—" : formatPercentRaw(value),
+    value,
+    color: value == null ? colors.textDim : priceColor(value),
+  };
+}
+
+export function renderSessionMoverCell(row: SessionMoverRow, column: SessionMoverColumn): DataTableCell {
+  switch (column.id) {
+    case "rank":
+      return { text: String(row.rank), color: colors.textDim };
+    case "symbol":
+      return { text: row.symbol, color: colors.textBright, attributes: TextAttributes.BOLD };
+    case "name":
+      return { text: row.name };
+    case "price":
+      return { text: formatMoverPrice(row.price, row.currency, moverReferencePrice({ ...row, previousClose: row.referenceClose })), value: row.price };
+    case "gapPercent":
+      return signedPercent(row.gapPercent);
+    case "changePercent":
+      return signedPercent(row.changePercent);
+    case "vwapPercent":
+      return signedPercent(row.vwapPercent);
+    case "volume":
+      return { text: formatCompact(row.volume, { fixedDecimals: true }), value: row.volume, color: colors.textDim };
+    case "relativeVolume":
+      return { text: formatVolRatio(row.relativeVolume), value: row.relativeVolume, color: volRatioColor(row.relativeVolume) };
+    case "floatShares":
+      return {
+        text: row.floatShares == null ? "—" : formatCompact(row.floatShares, { fixedDecimals: true }),
+        value: row.floatShares,
+        color: colors.textDim,
+      };
+    case "catalyst": {
+      const lead = leadCatalyst(row);
+      if (!lead) return { text: "", value: null };
+      // A halt is the one marker that changes what can be traded right now.
+      return { text: CATALYST_LABEL[lead], value: CATALYST_LABEL[lead], color: lead === "halt" ? colors.warning : colors.text };
+    }
+  }
+}

package/src/plugins/builtin/market-movers/session.ts

@@ -0,0 +1,233 @@
+import type {
+  CloudSessionMoverItem,
+  CloudSessionMoversCategory,
+  CloudSessionMoversSide,
+  CloudSessionPhase,
+} from "../../../api-client/market-movers";
+import { activeUsMarketSession } from "../../../market-data/market/freshness";
+import { getActiveQuoteDisplay } from "../../../market-data/market/status";
+import { getPublishedUsEquitySession } from "../../../market-data/published-us-sessions";
+import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
+import type { QueryEntry } from "../../../market-data/result-types";
+import type { Quote } from "../../../types/financials";
+import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
+import { zonedDateKey, zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
+import type { SessionTabId } from "./model";
+
+const NEW_YORK = "America/New_York";
+const HOUR_MS = 60 * 60_000;
+const SESSION_TABS = new Set<string>(["premarket", "afterhours", "gaps"]);
+/** Lists that belong to the regular session, where the day's own lists are the default. */
+const REGULAR_TABS = new Set<string>(["gainers", "losers", "actives", "trending", "gaps"]);
+
+export function isSessionTab(tab: string): tab is SessionTabId {
+  return SESSION_TABS.has(tab);
+}
+
+export interface UsSession {
+  /** New York trading date. */
+  date: string;
+  phase: CloudSessionPhase;
+  /** Date and phase, e.g. "2026-09-29:pre": a list picked in one session is not carried into the next. */
+  key: string;
+}
+
+/**
+ * What is trading in New York at `now`: the pre-market from 04:00, the regular
+ * session on the published calendar's hours (13:00 closes included), and four
+ * hours after the close. Holidays and weekends are closed. Past the published
+ * years it falls back to weekday hours.
+ */
+export function usSessionAt(now: number): UsSession {
+  const date = zonedDateKey(now, NEW_YORK);
+  const [year, month, day] = date.split("-").map(Number) as [number, number, number];
+  const at = (hour: number) => zonedWallClockToUtcMs(NEW_YORK, year, month, day, hour, 0, 0);
+  const published = getPublishedUsEquitySession("NYSE", date);
+  let phase: CloudSessionPhase;
+  if (!published) {
+    const active = activeUsMarketSession(now);
+    phase = active === "PRE" ? "pre" : active === "REGULAR" ? "regular" : active === "POST" ? "post" : "closed";
+  } else if (published.kind === "closed" || now < at(4)) {
+    phase = "closed";
+  } else if (now < published.open) {
+    phase = "pre";
+  } else if (now < published.close) {
+    phase = "regular";
+  } else if (now < Math.min(published.close + 4 * HOUR_MS, at(20))) {
+    phase = "post";
+  } else {
+    phase = "closed";
+  }
+  return { date, phase, key: `${date}:${phase}` };
+}
+
+/**
+ * The list MOST opens on. A list asked for with `--list` (the CLI or a
+ * screenshot) is kept until the user picks another. A list the user picked
+ * stays while the session it was picked in lasts; otherwise the pane follows
+ * the session that is trading: Pre-market before 09:30, the day's lists during
+ * the regular session, After hours after the close. Overnight and on closed
+ * days the last pick stands. An account that cannot open the session lists
+ * (signed out, unverified, free) keeps the day's lists instead of being moved
+ * onto a wall.
+ */
+export function resolveActiveTab<T extends string>(args: {
+  tabs: readonly T[];
+  saved: string;
+  pickedIn: string | null | undefined;
+  session: UsSession;
+  requested?: string | null;
+  sessionListsOpen: boolean;
+}): T {
+  const { tabs, session } = args;
+  const requested = tabs.find((tab) => tab === args.requested);
+  if (requested) return requested;
+  const saved = tabs.find((tab) => tab === args.saved) ?? tabs[0]!;
+  if (session.phase === "closed" || args.pickedIn === session.key) return saved;
+  if (session.phase === "regular" || !args.sessionListsOpen) {
+    return REGULAR_TABS.has(saved) ? saved : tabs.find((tab) => REGULAR_TABS.has(tab)) ?? saved;
+  }
+  const sessionTab = session.phase === "pre" ? "premarket" : "afterhours";
+  return tabs.find((tab) => tab === sessionTab) ?? saved;
+}
+
+export interface SideOption {
+  value: CloudSessionMoversSide;
+  label: string;
+}
+
+const MOVER_SIDES: SideOption[] = [
+  { value: "up", label: "Gainers" },
+  { value: "down", label: "Losers" },
+  { value: "active", label: "Active" },
+];
+const GAP_SIDES: SideOption[] = [
+  { value: "up", label: "Up" },
+  { value: "down", label: "Down" },
+];
+
+export function sessionSides(view: CloudSessionMoversCategory): SideOption[] {
+  return view === "gaps" ? GAP_SIDES : MOVER_SIDES;
+}
+
+/** The persisted side, or the first one the view has. */
+export function resolveSide(view: CloudSessionMoversCategory, saved: string | undefined): CloudSessionMoversSide {
+  const sides = sessionSides(view);
+  return sides.find((side) => side.value === saved)?.value ?? sides[0]!.value;
+}
+
+/**
+ * Whether live quotes can update a list: only while its session segment is
+ * trading. A finished pre-market list or last evening's after-hours list keeps
+ * the prices it closed at.
+ */
+export function sessionListIsLive(
+  view: CloudSessionMoversCategory,
+  listSession: string | null,
+  session: UsSession,
+): boolean {
+  if (!listSession || listSession !== session.date) return false;
+  if (view === "premarket") return session.phase === "pre";
+  if (view === "afterhours") return session.phase === "post";
+  return session.phase !== "closed";
+}
+
+export type SessionMoverRow = CloudSessionMoverItem;
+
+function percentFrom(value: number, reference: number | null | undefined): number | null {
+  return reference != null && Number.isFinite(reference) && reference > 0 ? (value / reference - 1) * 100 : null;
+}
+
+const overlays = new WeakMap<CloudSessionMoverItem, { quote: Quote; row: SessionMoverRow }>();
+
+/**
+ * Live prices on a live list. The change is measured from the row's own
+ * reference close (after hours: the day's close, not the prior one) and the
+ * VWAP distance from the session VWAP; volume, relative volume and the gap stay
+ * the list's, which the next list refresh brings forward.
+ */
+export function overlaySessionMovers(
+  rows: readonly CloudSessionMoverItem[],
+  entries: ReadonlyMap<string, QueryEntry<Quote>>,
+): SessionMoverRow[] {
+  return rows.map((row) => {
+    const quote = resolveEntryData(entries.get(buildQuoteKey({ symbol: row.symbol, exchange: row.exchange })));
+    const price = getActiveQuoteDisplay(quote)?.price;
+    if (!quote || price == null || !Number.isFinite(price) || price <= 0 || quote.lastUpdated < row.lastUpdated) {
+      return row;
+    }
+    const cached = overlays.get(row);
+    if (cached?.quote === quote) return cached.row;
+    const changePercent = percentFrom(price, row.referenceClose);
+    const overlaid: SessionMoverRow = {
+      ...row,
+      price,
+      change: price - row.referenceClose,
+      changePercent: changePercent ?? row.changePercent,
+      vwapPercent: row.vwap != null ? percentFrom(price, row.vwap) : row.vwapPercent,
+      lastUpdated: quote.lastUpdated,
+    };
+    overlays.set(row, { quote, row: overlaid });
+    return overlaid;
+  });
+}
+
+export type SessionMoverColumnId =
+  | "rank"
+  | "symbol"
+  | "name"
+  | "price"
+  | "gapPercent"
+  | "changePercent"
+  | "volume"
+  | "relativeVolume"
+  | "vwapPercent"
+  | "floatShares"
+  | "catalyst";
+
+export interface SessionMoverSortPreference {
+  columnId: SessionMoverColumnId | null;
+  direction: SortDirection;
+}
+
+const CATALYST_ORDER = { halt: 3, filing: 2, news: 1 } as const;
+
+/** The strongest catalyst first: a halt, then an 8-K, then news. */
+export function leadCatalyst(row: Pick<CloudSessionMoverItem, "catalysts">): CloudSessionMoverItem["catalysts"][number] | null {
+  return [...row.catalysts].sort((a, b) => CATALYST_ORDER[b] - CATALYST_ORDER[a])[0] ?? null;
+}
+
+function sortValue(columnId: SessionMoverColumnId, row: SessionMoverRow): string | number | null {
+  switch (columnId) {
+    case "catalyst": {
+      const lead = leadCatalyst(row);
+      return lead ? CATALYST_ORDER[lead] : null;
+    }
+    case "rank":
+    case "symbol":
+    case "name":
+    case "price":
+    case "gapPercent":
+    case "changePercent":
+    case "volume":
+    case "relativeVolume":
+    case "vwapPercent":
+    case "floatShares":
+      return row[columnId];
+  }
+}
+
+export function sortSessionRows(rows: SessionMoverRow[], preference: SessionMoverSortPreference): SessionMoverRow[] {
+  const columnId = preference.columnId;
+  if (!columnId) return rows;
+  return [...rows].sort((left, right) => compareSortValues(sortValue(columnId, left), sortValue(columnId, right), preference.direction));
+}
+
+/** The session date when it is not today's, e.g. last evening's after-hours list. */
+export function earlierSessionLabel(listSession: string | null, session: UsSession): string | null {
+  if (!listSession || listSession === session.date) return null;
+  const date = new Date(`${listSession}T12:00:00Z`);
+  return Number.isFinite(date.getTime())
+    ? date.toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" })
+    : null;
+}

package/src/plugins/builtin/market-movers/table.ts

@@ -5,13 +5,13 @@ import { formatCompact, formatPercentRaw } from "../../../utils/format";
 import type { MarketMoverColumn, MarketMoverRow } from "./model";
 import { fiftyTwoWeekPositionPercent, formatMoverPrice, moverReferencePrice } from "./model";
 
-function formatVolRatio(ratio: number | null): string {
+export function formatVolRatio(ratio: number | null): string {
   if (ratio == null || !Number.isFinite(ratio) || ratio < 0) return "—";
   if (ratio >= 10) return `${Math.round(ratio)}x`;
   return `${ratio.toFixed(1)}x`;
 }
 
-function volRatioColor(ratio: number | null): string {
+export function volRatioColor(ratio: number | null): string {
   if (ratio != null && ratio >= 3) return colors.textBright;
   if (ratio != null && ratio >= 1.5) return colors.text;
   return colors.textDim;
@@ -51,45 +51,45 @@ export function buildMarketMoverColumns(width: number): MarketMoverColumn[] {
 export function renderMarketMoverCell(
   row: MarketMoverRow,
   column: MarketMoverColumn,
-  _index: number,
-  rowState: { selected: boolean },
 ): DataTableCell {
-  const selectedColor = rowState.selected ? colors.selectedText : undefined;
-
   switch (column.id) {
     case "rank":
-      return { text: String(row.rank), color: selectedColor ?? colors.textDim };
+      return { text: String(row.rank), color: colors.textDim };
     case "symbol":
       return {
         text: row.symbol,
-        color: selectedColor ?? colors.textBright,
+        color: colors.textBright,
         attributes: TextAttributes.BOLD,
       };
     case "name":
-      return { text: row.name, color: selectedColor };
+      return { text: row.name };
     case "price":
-      return { text: formatMoverPrice(row.price, row.currency, moverReferencePrice(row)), color: selectedColor };
+      return { text: formatMoverPrice(row.price, row.currency, moverReferencePrice(row)) };
     case "changePercent":
       return {
         text: formatPercentRaw(row.changePercent ?? undefined),
-        color: selectedColor ?? priceColor(row.changePercent ?? 0),
+        value: row.changePercent,
+        color: priceColor(row.changePercent ?? 0),
       };
     case "volume":
-      return { text: formatCompact(row.volume ?? undefined, { fixedDecimals: true }), color: selectedColor ?? colors.textDim };
+      return { text: formatCompact(row.volume ?? undefined, { fixedDecimals: true }), value: row.volume, color: colors.textDim };
     case "volumeRatio":
       return {
         text: formatVolRatio(row.volumeRatio),
-        color: selectedColor ?? volRatioColor(row.volumeRatio),
+        value: row.volumeRatio != null && row.volumeRatio >= 0 ? row.volumeRatio : null,
+        color: volRatioColor(row.volumeRatio),
       };
     case "range":
       return {
         text: fiftyTwoWeekPosition(row.price, row.fiftyTwoWeekLow, row.fiftyTwoWeekHigh),
-        color: selectedColor ?? colors.textDim,
+        value: fiftyTwoWeekPositionPercent(row.price, row.fiftyTwoWeekLow, row.fiftyTwoWeekHigh),
+        color: colors.textDim,
       };
     case "marketCap":
       return {
         text: row.marketCap != null ? formatCompact(row.marketCap, { fixedDecimals: true }) : "—",
-        color: selectedColor ?? colors.textDim,
+        value: row.marketCap,
+        color: colors.textDim,
       };
   }
 }

package/src/plugins/builtin/market-valuation/cache.ts

@@ -1,40 +1,3 @@
-import { createSeriesCache, type SeriesCacheLoadOptions, type SeriesCacheInput } from "../shared/series-cache";
-import type { DatedObservation } from "./series";
-import type { PluginPersistence } from "../../../types/plugin";
+import { createSeriesCache } from "../shared/series-cache";
 
-const cache = createSeriesCache("market-valuation-series", 6 * 60 * 60 * 1000);
-
-export type { SeriesCacheEntry } from "../shared/series-cache";
-
-export function attachValuationPersistence(next: PluginPersistence): void {
-  cache.attach(next);
-}
-
-export function resetValuationPersistence(): void {
-  cache.reset();
-}
-
-export function hydrateValuationSeries(
-  entries: readonly (readonly [string, DatedObservation[]])[],
-): void {
-  cache.hydrate(entries);
-}
-
-export function getCachedSeries(key: string, options?: { allowExpired?: boolean }) {
-  return cache.get(key, options);
-}
-
-export function loadCachedSeries(
-  key: string,
-  loader: () => Promise<DatedObservation[]>,
-): Promise<DatedObservation[]> {
-  return cache.load(key, loader);
-}
-
-export function loadCachedSeriesEntry(
-  key: string,
-  loader: () => Promise<DatedObservation[] | SeriesCacheInput>,
-  options?: SeriesCacheLoadOptions,
-) {
-  return cache.loadEntry(key, loader, options);
-}
+export const valuationCache = createSeriesCache("market-valuation-series", 6 * 60 * 60 * 1000);

package/src/plugins/builtin/market-valuation/chart-projection.ts

@@ -2,6 +2,7 @@ import type { ProjectedChartPoint } from "../../../components/chart/core/data";
 import { blendHex, colors } from "../../../theme/colors";
 import { isUsableRatio, type RatioPoint } from "./align";
 import type { ResolvedSeries, TimeSeriesPoint } from "../../../time-series/types";
+import type { SeriesAxis } from "../shared/series-detail-chart";
 import {
   classifyZone,
   shortZoneLabel,
@@ -138,6 +139,15 @@ export function chartYearLabels(points: readonly ProjectedChartPoint[], maxLabel
   return picked;
 }
 
+/** The axis every valuation line shares, the flat mean and reference lines included. */
+export function valuationAxis(indicator: IndicatorDef): SeriesAxis {
+  return {
+    unit: indicator.axisUnit,
+    unitGroup: indicator.axisUnit === "%" ? "valuation-percent" : "valuation",
+    nativeFrequency: "daily",
+  };
+}
+
 /**
  * CompositeChart draws one colour per series, so the zone gradient is carried by
  * one series per zone that holds nulls everywhere the ratio sits in another band.
@@ -172,9 +182,7 @@ export function zoneSeriesFor(
       id: `zone:${zoneId}`,
       label: shortZoneLabel(zoneId),
       color: zoneColor(zoneId),
-      unit: indicator.axisUnit,
-      unitGroup: indicator.axisUnit === "%" ? "valuation-percent" : "valuation",
-      nativeFrequency: "daily",
+      ...valuationAxis(indicator),
       dataShape: "scalar",
       style: "line",
       transform: "raw",
@@ -186,34 +194,3 @@ export function zoneSeriesFor(
   }
   return built;
 }
-
-/** Flat line at a fixed level, for parity, replacement cost, or the sample mean. */
-export function markerSeries(
-  indicator: IndicatorDef,
-  id: string,
-  label: string,
-  value: number,
-  color: string,
-  points: readonly RatioPoint[],
-): ResolvedSeries | null {
-  if (points.length === 0 || !Number.isFinite(value)) return null;
-  const ends = [points[0]!, points[points.length - 1]!].map((point) => {
-    const date = new Date(point.date);
-    return { date, observedAt: date, value };
-  });
-  return {
-    id,
-    label,
-    color,
-    unit: indicator.axisUnit,
-    unitGroup: indicator.axisUnit === "%" ? "valuation-percent" : "valuation",
-    nativeFrequency: "daily",
-    dataShape: "scalar",
-    style: "line",
-    transform: "raw",
-    axis: "left",
-    panelId: "main",
-    interpolation: "none",
-    points: ends,
-  };
-}

package/src/plugins/builtin/market-valuation/client.ts

@@ -1,5 +1,5 @@
 import { buildValuationSeries } from "./align";
-import { getCachedSeries, loadCachedSeriesEntry } from "./cache";
+import { valuationCache } from "./cache";
 import { indicatorUnavailableReason, indicatorSeries, type IndicatorDef, type SeriesDef } from "./defs";
 import { INDICATORS } from "./indicators";
 import { validateObservationDates, type DatedSeries, type ValuationSourceMetadata } from "./series";
@@ -9,8 +9,7 @@ import {
   provenanceFor,
   type ValuationSourceDeps,
 } from "./sources";
-import { fitIndicatorTrend } from "./trend";
-import type { IndicatorBuild, ValuationBundle } from "./view";
+import { fitIndicatorTrend, type IndicatorBuild, type ValuationBundle } from "./view";
 
 export type ValuationSeriesLoader = (def: SeriesDef, options?: { force?: boolean }) => Promise<DatedSeries>;
 
@@ -35,7 +34,7 @@ export function createValuationSeriesLoader(deps: ValuationSourceDeps): Valuatio
     if (def.unavailableReason) throw new Error(def.unavailableReason);
     return {
       seriesId: def.key,
-      ...await loadCachedSeriesEntry(def.key, async () => {
+      ...await valuationCache.loadEntry(def.key, async () => {
         const { observations, provider } = await cloudLoader(def);
         validateObservationDates(observations);
         return { observations, ...(provider ? { provider } : {}) };
@@ -53,7 +52,7 @@ export function getCachedValuationBundle(
 ): ValuationBundle | null {
   const legs = new Map<string, DatedSeries>();
   for (const def of requiredSeries(indicators)) {
-    const cached = getCachedSeries(def.key, { allowExpired: true });
+    const cached = valuationCache.get(def.key, { allowExpired: true });
     if (!cached) continue;
     legs.set(def.key, {
       seriesId: def.key,

package/src/plugins/builtin/market-valuation/defs.ts

@@ -232,15 +232,6 @@ export function zoneScaleValueAt(indicator: IndicatorDef, fraction: number): num
   return lo + (pos - bandIdx) * (hi - lo);
 }
 
-export function zoneScaleMarkerColumn(
-  indicator: IndicatorDef,
-  value: number,
-  width: number,
-): number {
-  if (width <= 1) return 0;
-  return Math.round(zoneScaleFraction(indicator, value) * (width - 1));
-}
-
 export function zoneScaleColumnValue(
   indicator: IndicatorDef,
   column: number,