gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/portfolio-list/summary/totals.ts

@@ -3,6 +3,7 @@ import type { Portfolio, TickerRecord } from "../../../../types/ticker";
 import { convertCurrency, formatCompactAmount } from "../../../../utils/format";
 import { getCurrencySymbol } from "../../../../market-data/market/format";
 import { getActiveQuoteDisplay } from "../../../../market-data/market/status";
+import { combinedChangeBasisLabel, quoteChangeBasis, type QuoteChangeBasis } from "../../../../market-data/market/change-basis";
 import { isQuoteStaleForCurrentSession } from "../../../../market-data/quotes/freshness";
 import { headlineQuoteDisplay } from "../../../../portfolio/column-values";
 import { isManualPortfolio } from "../../../../portfolio/mutations";
@@ -45,6 +46,13 @@ export interface PortfolioSummaryTotals {
   unrealizedPnlBasis?: PortfolioPositionPnl["basis"];
   dailyPnl: number;
   dailyPnlPct: number;
+  /**
+   * What Day (or a watchlist's Avg Day) is measured from, as each holding's
+   * change line says it: "vs Fri 16 Oct close" when they agree, "vs mixed
+   * closes" when they do not (an HKEX listing beside a US one). Absent
+   * without a move.
+   */
+  dayChangeBasis?: string;
   totalCostBasis: number;
   hasPositions: boolean;
   unrealizedPnl: number;
@@ -131,6 +139,7 @@ export function calculatePortfolioSummaryTotals(
   let hasPositions = false;
   let watchlistChangeSum = 0;
   let watchlistCount = 0;
+  const dayBases: Array<QuoteChangeBasis | null> = [];
   const unavailableConversions = new Set<string>();
   let livePriced = true;
   const pricedLots: PricedPortfolioLot[] = [];
@@ -150,11 +159,12 @@ export function calculatePortfolioSummaryTotals(
     const quoteCurrency = quote?.currency || ticker.metadata.currency || "USD";
 
     if (!isPortfolio) {
-      // The CHG% column's value, so Avg Day is the mean of that column.
-      const changePercent = headlineQuoteDisplay(activeQuote, quote)?.changePercent;
+      // The CHG% column's value, so Avg Day is the mean of that column; a listing that no longer trades has none.
+      const changePercent = quote?.delisting ? undefined : headlineQuoteDisplay(activeQuote, quote)?.changePercent;
       if (changePercent != null) {
         watchlistChangeSum += changePercent;
         watchlistCount++;
+        dayBases.push(quoteChangeBasis(quote));
       }
       continue;
     }
@@ -220,9 +230,18 @@ export function calculatePortfolioSummaryTotals(
       totalMktValue += marketValue.gross;
       netMktValue += marketValue.net;
       if (activeQuote && Number.isFinite(grossPriceUnits)) {
-        const previousClose = activeQuote.change != null ? activeQuote.price - activeQuote.change : Number.NaN;
+        // A listing that no longer trades does not move: its last session's change is not today's.
+        const previousClose = quote?.delisting ? activeQuote.price
+          : activeQuote.change != null ? activeQuote.price - activeQuote.change : Number.NaN;
         totalPrevValue += toBaseQuote(grossPriceUnits * previousClose);
         signedDailyPnl += toBaseQuote(totalPriceUnits * (activeQuote.price - previousClose));
+        // The move valued: the latest print's from the daily reference, the regular close's from the session before it.
+        if (!quote?.delisting) {
+          dayBases.push(quoteChangeBasis(quote, {
+            session: valuationBasis === "regular-close" ? "regular" : "active",
+            terms: futuresTerms?.get(ticker.metadata.ticker),
+          }));
+        }
       } else {
         // A broker mark is not evidence of an unchanged day.
         signedDailyPnl = Number.NaN;
@@ -242,6 +261,7 @@ export function calculatePortfolioSummaryTotals(
   const unrealizedPnl = signedUnrealizedPnl;
   const unrealizedPnlPct = portfolioPnlPercent(unrealizedPnl, totalCostBasis) ?? Number.NaN;
   const avgWatchlistChange = watchlistCount > 0 ? watchlistChangeSum / watchlistCount : 0;
+  const dayChangeBasis = combinedChangeBasisLabel(dayBases, now);
 
   return {
     totalMktValue,
@@ -258,6 +278,7 @@ export function calculatePortfolioSummaryTotals(
       : pnlBases.size > 1 ? "mixed" : [...pnlBases][0],
     dailyPnl,
     dailyPnlPct,
+    ...(dayChangeBasis ? { dayChangeBasis } : {}),
     totalCostBasis,
     hasPositions,
     unrealizedPnl,

package/src/plugins/builtin/primary-dealers/client.ts

@@ -2,26 +2,17 @@ import { httpFetch } from "../../../utils/http-transport";
 import { isoDateOrNull, numericOrNull, recordOrNull, textOrNull } from "../../../utils/guards";
 import {
   boardAsOf,
-  selectSeries,
-  toDealerRow,
-  type CatalogEntry,
+  buildDealerRows,
+  newestSeriesBreak,
+  sumSeries,
   type DealerRow,
-  type DealerTab,
+  type SeriesPoint,
 } from "./model";
 
-const LIST_URL = "https://markets.newyorkfed.org/api/pd/list/timeseries.json";
+const API = "https://markets.newyorkfed.org/api/pd";
 const FETCH_TIMEOUT_MS = 15_000;
-
-interface SeriesPoint {
-  asOf: string;
-  value: number;
-}
-
-interface ParsedSeries {
-  keyid: string;
-  latest: SeriesPoint | null;
-  previous: SeriesPoint | null;
-}
+/** The release is weekly; a series read is kept this long so moving through the board never asks twice. */
+const HISTORY_TTL_MS = 30 * 60_000;
 
 export interface DealerBoard {
   seriesBreak: string;
@@ -30,52 +21,57 @@ export interface DealerBoard {
   asOf: string | null;
 }
 
-function parseCatalog(payload: unknown): CatalogEntry[] {
+/** A row's weekly history: the sum of the series behind it, oldest first. */
+export interface DealerHistory {
+  rowId: string;
+  points: SeriesPoint[];
+}
+
+function timeseriesRows(payload: unknown): unknown[] {
   const root = recordOrNull(payload);
   const pd = recordOrNull(root?.pd);
-  const rows = Array.isArray(pd?.timeseries) ? pd.timeseries : Array.isArray(root?.timeseries) ? root.timeseries : [];
-  const entries: CatalogEntry[] = [];
-  for (const raw of rows) {
-    const row = recordOrNull(raw);
-    if (!row) continue;
-    const seriesBreak = textOrNull(row.seriesbreak) ?? textOrNull(row.seriesBreak);
-    const keyid = textOrNull(row.keyid) ?? textOrNull(row.keyId);
-    if (!seriesBreak || !keyid) continue;
-    entries.push({ seriesBreak, keyid, description: textOrNull(row.description) ?? "" });
-  }
-  return entries;
+  return Array.isArray(pd?.timeseries) ? pd.timeseries : Array.isArray(root?.timeseries) ? root.timeseries : [];
 }
 
-/** Latest two observations. Points may arrive oldest-last or newest-last. */
-function parseSeriesObservations(payload: unknown, fallbackKeyid = ""): ParsedSeries {
+function parseSeriesBreaks(payload: unknown): Array<{ seriesBreak: string; startDate: string }> {
   const root = recordOrNull(payload);
   const pd = recordOrNull(root?.pd);
-  const rows = Array.isArray(pd?.timeseries) ? pd.timeseries : Array.isArray(root?.timeseries) ? root.timeseries : [];
-  const points: Array<SeriesPoint & { keyid: string }> = [];
+  const rows = Array.isArray(pd?.seriesbreaks) ? pd.seriesbreaks : [];
+  const breaks: Array<{ seriesBreak: string; startDate: string }> = [];
   for (const raw of rows) {
     const row = recordOrNull(raw);
-    if (!row) continue;
-    const asOf = isoDateOrNull(row.asofdate) ?? isoDateOrNull(row.asOfDate) ?? isoDateOrNull(row.date);
-    const value = numericOrNull(row.value);
-    if (!asOf || value == null) continue;
-    points.push({
-      asOf,
-      value,
-      keyid: textOrNull(row.keyid) ?? fallbackKeyid,
-    });
+    const seriesBreak = textOrNull(row?.seriesbreak) ?? textOrNull(row?.seriesBreak);
+    const startDate = isoDateOrNull(row?.startdate) ?? isoDateOrNull(row?.startDate);
+    if (seriesBreak && startDate) breaks.push({ seriesBreak, startDate });
   }
-  points.sort((a, b) => a.asOf < b.asOf ? -1 : a.asOf > b.asOf ? 1 : 0);
-  const latest = points.length > 0 ? points[points.length - 1] ?? null : null;
-  const previous = points.length >= 2 ? points[points.length - 2] ?? null : null;
-  return {
-    keyid: latest?.keyid || fallbackKeyid,
-    latest: latest ? { asOf: latest.asOf, value: latest.value } : null,
-    previous: previous ? { asOf: previous.asOf, value: previous.value } : null,
-  };
+  return breaks;
+}
+
+/** The newest observation of every series that has a figure (the release writes `*` for a suppressed one). */
+function parseLatest(payload: unknown): Map<string, SeriesPoint> {
+  const latest = new Map<string, SeriesPoint>();
+  for (const raw of timeseriesRows(payload)) {
+    const row = recordOrNull(raw);
+    const keyid = textOrNull(row?.keyid) ?? textOrNull(row?.keyId);
+    const asOf = isoDateOrNull(row?.asofdate) ?? isoDateOrNull(row?.asOfDate);
+    const value = numericOrNull(row?.value);
+    if (!keyid || !asOf || value == null) continue;
+    const known = latest.get(keyid);
+    if (!known || asOf > known.asOf) latest.set(keyid, { asOf, value });
+  }
+  return latest;
 }
 
-function seriesUrl(seriesBreak: string, keyid: string): string {
-  return `https://markets.newyorkfed.org/api/pd/get/${encodeURIComponent(seriesBreak)}/timeseries/${encodeURIComponent(keyid)}.json`;
+/** Every observation of one series, oldest first. */
+function parseSeriesPoints(payload: unknown): SeriesPoint[] {
+  const points: SeriesPoint[] = [];
+  for (const raw of timeseriesRows(payload)) {
+    const row = recordOrNull(raw);
+    const asOf = isoDateOrNull(row?.asofdate) ?? isoDateOrNull(row?.asOfDate);
+    const value = numericOrNull(row?.value);
+    if (asOf && value != null) points.push({ asOf, value });
+  }
+  return points.sort((a, b) => (a.asOf < b.asOf ? -1 : a.asOf > b.asOf ? 1 : 0));
 }
 
 async function readJson(url: string): Promise<unknown> {
@@ -87,22 +83,101 @@ async function readJson(url: string): Promise<unknown> {
   return response.json() as Promise<unknown>;
 }
 
+/** The series break changes about every two years; one read serves the session. */
+let seriesBreakRead: Promise<string> | null = null;
+
+function currentSeriesBreak(force: boolean): Promise<string> {
+  if (!seriesBreakRead || force) {
+    const read = readJson(`${API}/list/seriesbreaks.json`).then((payload) => {
+      const seriesBreak = newestSeriesBreak(parseSeriesBreaks(payload));
+      if (!seriesBreak) throw new Error("No series break was listed.");
+      return seriesBreak;
+    });
+    seriesBreakRead = read;
+    // A failed read is not kept, so the next one asks again.
+    read.catch(() => { if (seriesBreakRead === read) seriesBreakRead = null; });
+  }
+  return seriesBreakRead;
+}
+
+/**
+ * The board in two reads: the break the release is in now, and the latest
+ * figure of every series in it together with each one's change from the week
+ * before. History is not read here; see `loadDealerHistory`.
+ */
 export async function fetchPrimaryDealers(): Promise<DealerBoard> {
-  const selected = selectSeries(parseCatalog(await readJson(LIST_URL)));
-  const jobs: Array<{ entry: CatalogEntry; tab: DealerTab }> = [
-    ...selected.positions.map((entry) => ({ entry, tab: "positions" as const })),
-    ...selected.fails.map((entry) => ({ entry, tab: "fails" as const })),
-  ];
-  if (jobs.length === 0) throw new Error("No position series were listed.");
-  const rows = (await Promise.all(jobs.map(async ({ entry, tab }) => {
-    const parsed = parseSeriesObservations(await readJson(seriesUrl(entry.seriesBreak, entry.keyid)), entry.keyid);
-    return toDealerRow(entry, parsed, tab);
-  }))).filter((row) => row.latest != null);
+  const seriesBreak = await currentSeriesBreak(false);
+  const rows = buildDealerRows(parseLatest(await readJson(`${API}/latest/${encodeURIComponent(seriesBreak)}.json`)));
   if (rows.length === 0) throw new Error("No positions were recognized.");
   return {
-    seriesBreak: selected.seriesBreak,
+    seriesBreak,
     positions: rows.filter((row) => row.tab === "positions"),
     fails: rows.filter((row) => row.tab === "fails"),
     asOf: boardAsOf(rows),
   };
 }
+
+interface SeriesRead {
+  at: number;
+  read: Promise<SeriesPoint[]>;
+  points: SeriesPoint[] | null;
+}
+
+const seriesReads = new Map<string, SeriesRead>();
+
+function seriesRead(seriesBreak: string, key: string, force: boolean): Promise<SeriesPoint[]> {
+  const id = `${seriesBreak}:${key}`;
+  const known = seriesReads.get(id);
+  if (known && !force && Date.now() - known.at < HISTORY_TTL_MS) return known.read;
+  const url = `${API}/get/${encodeURIComponent(seriesBreak)}/timeseries/${encodeURIComponent(key)}.json`;
+  const entry: SeriesRead = {
+    at: Date.now(),
+    points: null,
+    read: readJson(url).then((payload) => {
+      entry.points = parseSeriesPoints(payload);
+      return entry.points;
+    }),
+  };
+  seriesReads.set(id, entry);
+  // A failed read is not kept, so the next one asks again.
+  entry.read.catch(() => { if (seriesReads.get(id) === entry) seriesReads.delete(id); });
+  return entry.read;
+}
+
+/** A row's history, one read per series behind it, each kept for the session. */
+export async function loadDealerHistory(
+  seriesBreak: string,
+  row: Pick<DealerRow, "id" | "keys">,
+  force = false,
+): Promise<DealerHistory> {
+  const series = await Promise.all(row.keys.map((key) => seriesRead(seriesBreak, key, force)));
+  return { rowId: row.id, points: sumSeries(series) };
+}
+
+/** The points of every series behind the row when they are all in hand and fresh. */
+function heldSeries(seriesBreak: string, row: Pick<DealerRow, "keys">): SeriesPoint[][] | null {
+  const series: SeriesPoint[][] = [];
+  for (const key of row.keys) {
+    const known = seriesReads.get(`${seriesBreak}:${key}`);
+    if (!known?.points || Date.now() - known.at >= HISTORY_TTL_MS) return null;
+    series.push(known.points);
+  }
+  return series;
+}
+
+/** Whether the row's history is in hand, so a chart can follow the selection at once. */
+export function hasDealerHistory(seriesBreak: string, row: Pick<DealerRow, "keys">): boolean {
+  return heldSeries(seriesBreak, row) != null;
+}
+
+/** The history when every series behind the row is already in hand, so a chart can draw before any read. */
+export function cachedDealerHistory(seriesBreak: string, row: Pick<DealerRow, "id" | "keys">): DealerHistory | null {
+  const series = heldSeries(seriesBreak, row);
+  return series ? { rowId: row.id, points: sumSeries(series) } : null;
+}
+
+/** Forgets what was read, for a test or a refresh that must see the release again. */
+export function resetPrimaryDealersCache(): void {
+  seriesBreakRead = null;
+  seriesReads.clear();
+}

package/src/plugins/builtin/primary-dealers/headless.ts

@@ -5,19 +5,26 @@ import { formatChange, formatLevel, type DealerRow } from "./model";
 const level = (value: unknown) => typeof value === "number" ? formatLevel(value) : "—";
 const change = (value: unknown) => typeof value === "number" ? formatChange(value) : "—";
 const text = (value: unknown) => typeof value === "string" && value ? value : "—";
+const group = (value: unknown) => typeof value === "string" ? value : "";
 
 const COLUMNS: HeadlessPaneColumn[] = [
   { key: "position", header: "Position" },
+  { key: "group", header: "Group", format: group },
   { key: "asOf", header: "As of", format: text },
   { key: "latest", header: "Latest $mn", align: "right", format: level },
   { key: "previous", header: "Previous $mn", align: "right", format: level },
   { key: "change", header: "Change $mn", align: "right", format: change },
 ];
 
+/** The report's table sets a breakdown in under its total, as the pane does; the export names the total in `group` instead. */
+const TEXT_COLUMNS: HeadlessPaneColumn[] = COLUMNS.filter((column) => column.key !== "group");
+
 function reportRow(row: DealerRow) {
   return {
-    id: row.keyid,
+    id: row.id,
     position: row.label,
+    group: row.parent,
+    series: row.keys.join("+"),
     asOf: row.asOf,
     latest: row.latest,
     previous: row.previous,
@@ -25,6 +32,24 @@ function reportRow(row: DealerRow) {
   };
 }
 
+function textRow(row: DealerRow) {
+  return { ...reportRow(row), position: `${"  ".repeat(row.depth)}${row.label}` };
+}
+
+function section(title: string, rows: readonly DealerRow[]) {
+  return {
+    title,
+    columns: COLUMNS,
+    rows: rows.map(reportRow),
+    textColumns: TEXT_COLUMNS,
+    textRows: rows.map(textRow),
+    unit: "USD millions",
+    rowSymbolKey: "series",
+    rowAsOfKey: "asOf",
+    interval: "weekly",
+  };
+}
+
 export const primaryDealersHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
   argument: { kind: "none" },
@@ -35,8 +60,8 @@ export const primaryDealersHeadless: HeadlessPaneDefinition<"bundle"> = {
     aliases: ["PDLR"],
     dataRequirements: ["Weekly primary dealer positions and settlement fails"],
     limitations: [
-      "Treasury and mortgage-backed aggregate totals, not tenor or CUSIP buckets",
-      "Latest observation and the one before it",
+      "Net positions in Treasuries (bills, coupons by tenor, TIPS, FRN), agencies, MBS, corporates, munis and ABS; settlement fails in Treasuries, TIPS and MBS",
+      "Latest observation and the change from the week before; the weekly history is in the pane",
     ],
   },
   async load() {
@@ -44,8 +69,8 @@ export const primaryDealersHeadless: HeadlessPaneDefinition<"bundle"> = {
     return {
       complete: board.positions.length > 0,
       sections: [
-        { title: "Positions", columns: COLUMNS, rows: board.positions.map(reportRow) },
-        { title: "Fails", columns: COLUMNS, rows: board.fails.map(reportRow) },
+        section("Positions", board.positions),
+        section("Fails", board.fails),
       ],
       metadata: { asOf: board.asOf, seriesBreak: board.seriesBreak },
     };

package/src/plugins/builtin/primary-dealers/index.tsx

@@ -8,8 +8,9 @@ export const primaryDealersModule: PluginModule = {
     id: "primary-dealers-pane",
     paneId: PRIMARY_DEALERS_PANE_ID,
     label: "Primary Dealer Positions",
-    description: "Weekly net positions and settlement fails in Treasuries and mortgage-backed securities.",
-    keywords: ["primary", "dealer", "dealers", "positions", "fails", "treasury", "tips", "mbs", "pdlr"],
+    description: "Weekly net positions with history, by sector and Treasury tenor, and settlement fails.",
+    // No "muni": a muni search lands on DVD's muni funds alone (known-gaps.test.ts), not on a table of two functions.
+    keywords: ["primary", "dealer", "dealers", "positions", "fails", "treasury", "bills", "coupons", "tips", "frn", "mbs", "pdlr"],
     shortcut: { prefix: "PDLR" },
     headless: primaryDealersHeadless,
     createInstance: () => ({ placement: "floating" }),