gloomberb 0.16.4 → 0.16.5

package/src/cli/desktop-pane-shot.ts

@@ -60,6 +60,11 @@ export interface DesktopPaneShotPayload {
    * once the pane has loaded. Absent for `--no-status` and for reports.
    */
   statusLine?: boolean;
+  /**
+   * The tallest the capture may grow, in cells, to show every row its tables
+   * scroll past; absent keeps the requested height (`--height`, most panes).
+   */
+  maxHeightCells?: number;
   tickers: TickerRecord[];
   /** Broker accounts as last synced, by profile, so a broker portfolio shows its equity and cash. */
   brokerAccounts?: Record<string, BrokerAccount[]>;
@@ -145,9 +150,15 @@ export interface DesktopPaneShotRenderResult {
 
 /**
  * The status line variants for a capture, longest first, worked out from what
- * the pane rendered; null leaves the footer row empty.
+ * the pane rendered; null leaves the footer row empty. `observed` says the
+ * line dates the data by its newest observation (a dataset's), so the pane's
+ * own `as of` footer text is left out rather than repeat the date.
  */
-type ShotStatusLine = (rendered: DesktopPaneShotRenderResult) => readonly string[] | null | Promise<readonly string[] | null>;
+interface ShotStatusLineVariants {
+  variants: readonly string[];
+  observed?: boolean;
+}
+type ShotStatusLine = (rendered: DesktopPaneShotRenderResult) => ShotStatusLineVariants | null | Promise<ShotStatusLineVariants | null>;
 
 type CdpResponse = {
   id?: number;
@@ -176,7 +187,8 @@ const SHOT_MODE_CSS = [
   + " line-height: var(--cell-h); font-size: 12px; letter-spacing: 0.02em; color: var(--gloom-text-dim, #888);"
   + " pointer-events: none; z-index: 1000; }";
 
-const CHROME_POLL_ATTEMPTS = 80;
+// Chrome gets 30 s (300 polls x 100 ms) to open its DevTools port: 8 s was not enough on a busy machine.
+const CHROME_POLL_ATTEMPTS = 300;
 const SHOT_READY_TIMEOUT_MS = 45_000;
 const CDP_CALL_TIMEOUT_MS = 10_000;
 const DEFAULT_DEVICE_SCALE_FACTOR = 2;
@@ -205,6 +217,7 @@ export async function renderDesktopPaneScreenshot(
       userDataDir: join(tempDir, "chrome-profile"),
       captureImage: options.captureImage !== false,
       statusLine: payload.statusLine ? options.statusLine : undefined,
+      ...(payload.maxHeightCells ? { fitRows: { heightCells: payload.heightCells, maxHeightCells: payload.maxHeightCells } } : {}),
     });
   } finally {
     server?.stop(true);
@@ -426,6 +439,7 @@ async function capturePageScreenshot({
   userDataDir,
   captureImage,
   statusLine,
+  fitRows,
 }: {
   chrome: string;
   url: string;
@@ -436,6 +450,7 @@ async function capturePageScreenshot({
   userDataDir: string;
   captureImage: boolean;
   statusLine?: ShotStatusLine;
+  fitRows?: { heightCells: number; maxHeightCells: number };
 }): Promise<DesktopPaneShotRenderResult> {
   await mkdir(userDataDir, { recursive: true });
   const port = 43000 + Math.floor(Math.random() * 10000);
@@ -481,10 +496,11 @@ async function capturePageScreenshot({
       color: { r: 0, g: 0, b: 0, a: 0 },
     });
     await waitForShotReady(session);
+    if (fitRows) await growToFitRows(session, { widthPx, heightPx, deviceScaleFactor, ...fitRows });
     const rendered = await readRenderedPaneState(session);
     if (captureImage && statusLine) {
-      const variants = await statusLine(rendered);
-      rendered.statusLine = variants?.length ? await fitShotStatusLine(session, variants) : null;
+      const line = await statusLine(rendered);
+      rendered.statusLine = line?.variants.length ? await fitShotStatusLine(session, line) : null;
     }
     if (captureImage) {
       const screenshot = await session.send("Page.captureScreenshot", {
@@ -506,6 +522,42 @@ async function capturePageScreenshot({
   }
 }
 
+/**
+ * Grows the viewport and the pane by the rows their tables scroll past, up to
+ * `maxHeightCells`, then waits for the taller pane to settle: a board a
+ * default capture would cut (FUT's last sectors) shows every row.
+ */
+async function growToFitRows(session: CdpSession, size: {
+  widthPx: number;
+  heightPx: number;
+  deviceScaleFactor: number;
+  heightCells: number;
+  maxHeightCells: number;
+}): Promise<void> {
+  const result = await session.send("Runtime.evaluate", {
+    expression: `Math.max(0, ...[...document.querySelectorAll('[data-gloom-role="data-table-body-scroll"]')]
+      .map((element) => element.scrollHeight - element.clientHeight))`,
+    returnByValue: true,
+  }) as { result?: { value?: unknown } };
+  const overflowPx = Number(result.result?.value);
+  // One pixel is subpixel layout, not a hidden row.
+  if (!Number.isFinite(overflowPx) || overflowPx <= 1) return;
+  const cellPx = size.heightPx / size.heightCells;
+  const heightCells = Math.min(size.maxHeightCells, size.heightCells + Math.ceil(overflowPx / cellPx));
+  if (heightCells <= size.heightCells) return;
+  await session.send("Emulation.setDeviceMetricsOverride", {
+    width: size.widthPx,
+    height: Math.round(heightCells * cellPx),
+    deviceScaleFactor: size.deviceScaleFactor,
+    mobile: false,
+  });
+  await session.send("Runtime.evaluate", {
+    expression: `window.__GLOOM_CLI_SHOT_RESIZE__ && window.__GLOOM_CLI_SHOT_RESIZE__(${heightCells})`,
+    returnByValue: true,
+  });
+  await waitForShotReady(session);
+}
+
 const LOADING_STATE_PATTERNS = [
   /\bLoading(?: [^.]{0,80})?\.{3}/gi,
   /\bRendering pane\.{3}/gi,
@@ -765,11 +817,11 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
 }
 
 /** Draws the first variant that fits the pane footer, and returns what it drew. */
-async function fitShotStatusLine(session: CdpSession, variants: readonly string[]): Promise<string | null> {
+async function fitShotStatusLine(session: CdpSession, { variants, observed }: ShotStatusLineVariants): Promise<string | null> {
   const result = await session.send("Runtime.evaluate", {
     expression: `(() => {
       const fit = window.__GLOOM_CLI_SHOT_FIT_STATUS__;
-      return fit ? fit(${JSON.stringify(variants)}) : null;
+      return fit ? fit(${JSON.stringify(variants)}, ${JSON.stringify({ observed: observed === true })}) : null;
     })()`,
     awaitPromise: true,
     returnByValue: true,

package/src/cli/earnings-calendar.ts

@@ -0,0 +1,71 @@
+import type { EarningsEvent } from "../types/data-provider";
+import { isUsListingExchange } from "../utils/exchanges";
+import { listingChoiceNote, loadListingQuote, usLineOfListing, type CliListing, type ListingDeps, type ListingVenue } from "./listing-arg";
+import { sameCompany } from "../tickers/company-name";
+
+const DAY_MS = 86_400_000;
+
+/** How firm a report date is: "reported" once there is an actual, else "est" or "confirmed" as the calendar flags it. */
+export function earningsDateLabel(event: Pick<EarningsEvent, "isDateEstimate" | "epsActual">): string {
+  if (event.epsActual != null) return "reported";
+  return event.isDateEstimate === true ? "est" : event.isDateEstimate === false ? "confirmed" : "";
+}
+
+/** Whether the listing trades abroad, where the calendar is the listing's own exchange's rather than the US one. */
+export function isListingAbroad(listing: Pick<CliListing, "exchange">): boolean {
+  return !!listing.exchange && !isUsListingExchange(listing.exchange);
+}
+
+const isoDate = (date: Date) => date.toISOString().slice(0, 10);
+
+/**
+ * "SAN:MCE: no calendar for this listing; ADR date 2026-11-04 (estimate)" for
+ * a listing abroad the calendar has no date for. The same company's line in
+ * the US, under the same symbol, lends its date as an estimate; a US line that
+ * is another company (SAN:EPA is Sanofi, SAN in New York is Banco Santander)
+ * lends nothing.
+ */
+export async function noListingCalendarNote(
+  listing: Pick<CliListing, "symbol" | "exchange" | "key" | "request" | "saved">,
+  deps: ListingDeps,
+  now = Date.now(),
+): Promise<string> {
+  const lead = `${listing.key}: no calendar for this listing`;
+  const quote = await loadListingQuote(deps.dataProvider, listing);
+  const company = quote?.name?.trim() || listing.saved?.metadata.name?.trim() || null;
+  const usLine = await usLineOfListing(listing, company, deps);
+  if (!usLine || !deps.dataProvider.getEarningsCalendar) return lead;
+  const events = await deps.dataProvider.getEarningsCalendar([listing.symbol]).catch(() => []);
+  const event = events.find((entry) => entry.symbol.toUpperCase() === listing.symbol.toUpperCase());
+  if (!event || event.earningsDate.getTime() < now - DAY_MS) return lead;
+  return `${lead}; ADR date ${isoDate(event.earningsDate)} (estimate)`;
+}
+
+/**
+ * "SAN = Banco Santander, NYSE (also EPA, LSE)" for a bare symbol whose
+ * calendar date is its US line's, when several companies list the symbol:
+ * the event names the company the date is for.
+ */
+export function earningsChoiceNote(
+  listing: Pick<CliListing, "symbol">,
+  event: Pick<EarningsEvent, "name"> | undefined,
+  venues: readonly ListingVenue[],
+): string | null {
+  const chosen = event && venues.find((venue) => isUsListingExchange(venue.exchange) && sameCompany(venue.name, event.name));
+  return chosen ? listingChoiceNote(listing.symbol, { exchange: chosen.exchange, name: event.name }, venues) : null;
+}
+
+const REASON_CODE = /^[A-Z][A-Z_]+$/;
+
+/**
+ * What to say when the data service refused the calendar with a reason code
+ * (UPSTREAM_ERROR) rather than words: which listings, and that the source
+ * failed. Null for any other error, whose own message stands.
+ */
+export function earningsCalendarFailure(error: unknown, keys: readonly string[]): string | null {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!REASON_CODE.test(message.trim())) return null;
+  const what = `Earnings dates for ${keys.join(", ")}`;
+  if (message === "TIMEOUT") return `${what} did not load: the calendar source timed out. Try again in a few minutes.`;
+  return `${what} did not load: the calendar source failed. Try again in a few minutes.`;
+}

package/src/cli/freshness.ts

@@ -1,7 +1,8 @@
 import type { FinancialStatement, Quote, TickerFinancials } from "../types/financials";
 import type { HeadlessPaneFreshness, HeadlessPaneRow } from "../types/headless";
 import { deriveHeadlessFreshness, type ReportFreshness } from "./pane-functions/freshness";
-import { quoteFreshnessFields, REPORTED_DATA } from "../plugins/builtin/shared/report-freshness";
+import { fxPairObservation, fxRateObservations, type FxRateTiming } from "../plugins/builtin/shared/fx-rate-freshness";
+import { quoteObservation, REPORTED_DATA } from "../plugins/builtin/shared/report-freshness";
 import { latestFinancialPeriod } from "../utils/latest-financial-period";
 
 /**
@@ -24,11 +25,6 @@ export function rowsFreshness(
   );
 }
 
-/** One row per quote shown, as `fn` quote reports carry them: live, delayed or stale for its session. */
-function quoteFreshnessRow(quote: Quote, now: number): HeadlessPaneRow {
-  return { ...quoteFreshnessFields(quote, now), updatedAt: quote.lastUpdated };
-}
-
 /**
  * Worst of across the quotes shown, dated by the newest, with their delay and
  * where their markets stand. Quotes that failed to load say nothing.
@@ -38,10 +34,25 @@ export function quotesFreshness(
   declared?: HeadlessPaneFreshness,
   now = Date.now(),
 ): ReportFreshness | undefined {
-  const rows = [...quotes].filter((quote): quote is Quote => quote != null).map((quote) => quoteFreshnessRow(quote, now));
+  const rows = [...quotes].filter((quote): quote is Quote => quote != null).map((quote) => quoteObservation(quote, now));
   return rows.length > 0 ? rowsFreshness(rows, declared, undefined, now) : undefined;
 }
 
+/**
+ * A currency pair crossed from the loaded USD rates of its legs, dated as the
+ * FX matrix dates its rates (`fn FXC`): as old as its oldest dated leg, as
+ * held back as its most delayed, stale when any leg is, and read against the
+ * FX week. A pair with no loaded leg (a code priced in itself) cites nothing.
+ */
+export function fxPairFreshness(
+  legs: ReadonlyMap<string, { rate: number; timing: FxRateTiming }>,
+  now = Date.now(),
+): ReportFreshness | undefined {
+  const rates = new Map([...legs].map(([currency, leg]) => [currency, leg.rate] as const));
+  const observation = fxPairObservation(fxRateObservations([...legs.keys()], rates, (currency) => ({ entry: legs.get(currency)?.timing }), now));
+  return observation ? rowsFreshness([observation], undefined, undefined, now) : undefined;
+}
+
 /** The newest reported period end in the statements, the period the trailing figures run through. */
 function latestReportedPeriod(financials: Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">): string | null {
   const rows: FinancialStatement[] = [...financials.annualStatements, ...financials.quarterlyStatements];