gloomberb 0.17.2 → 0.17.3

package/src/cli/pane-functions/market-session.ts

@@ -10,6 +10,7 @@ import {
 import { currentFxClosureStart } from "../../utils/fx-market-hours";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import type { ReportTime } from "../../utils/utc-time";
+import type { QuoteIndexSession } from "../../types/financials";
 
 /** Where the venues behind a quote report stand, as a report says it after the delay. */
 type ReportMarketState = "open" | "pre-market" | "after-hours" | "closed";
@@ -27,6 +28,8 @@ export interface SessionObservation {
   exchange: string;
   marketState?: string;
   time: ReportTime | null;
+  /** The regular sessions an index quote carries, for a publisher the app has no calendar for. */
+  calendar?: QuoteIndexSession;
 }
 
 interface VenueSession {
@@ -35,16 +38,19 @@ interface VenueSession {
   /** The latest regular session that has closed: its local date and open. */
   last?: { date: string; open: number | null };
   timeZone?: string;
+  /** The sessions are the quote's own, not a calendar of the venue. */
+  quoted?: true;
 }
 
 const CLOSED_STATES = new Set(["CLOSED", "PREPRE", "POSTPOST"]);
+const US_EXCHANGE_TIME_ZONE = "America/New_York";
 
 /**
  * A venue's session now, from its calendar (weekends and published holidays),
  * or from the state its source reports when the app has no calendar for it,
  * such as an index publisher or a futures exchange. Null when neither says.
  */
-function venueSession(exchange: string, marketState: string | undefined, now: number): VenueSession | null {
+function venueSession(exchange: string, marketState: string | undefined, now: number, calendar?: QuoteIndexSession): VenueSession | null {
   if (isAlwaysOpenExchange(exchange)) return { state: "always" };
   const next = nextRegularSessionOpen(exchange, now);
   if (next) {
@@ -61,10 +67,24 @@ function venueSession(exchange: string, marketState: string | undefined, now: nu
     return { state: "closed", next, last, timeZone };
   }
   if (marketState === "REGULAR") return { state: "open" };
-  if (marketState === "PRE") return { state: "pre-market" };
-  if (marketState === "POST") return { state: "after-hours" };
-  if (marketState && CLOSED_STATES.has(marketState)) return { state: "closed" };
-  return null;
+  const stated = marketState === "PRE" ? "pre-market" : marketState === "POST" ? "after-hours" : marketState && CLOSED_STATES.has(marketState) ? "closed" : null;
+  if (!stated) return null;
+  return calendar ? { state: stated, ...quotedSessions(calendar, now) } : { state: stated };
+}
+
+/**
+ * An index publisher's sessions (SNP, DJI, NASDAQ GIDS) as its quote dates
+ * them, read like a venue's calendar: the open still to come, and the latest
+ * regular session that has closed.
+ */
+function quotedSessions({ timeZone, current, regular }: QuoteIndexSession, now: number): Pick<VenueSession, "next" | "last" | "timeZone" | "quoted"> {
+  const closed = [...regular, current].filter((window) => window.end <= now).sort((left, right) => right.end - left.end)[0];
+  return {
+    timeZone,
+    quoted: true,
+    ...(current.start > now ? { next: { date: zonedDateKey(current.start, timeZone), open: current.start } } : {}),
+    ...(closed ? { last: { date: zonedDateKey(closed.start, timeZone), open: closed.start } } : {}),
+  };
 }
 
 /** The venue spot FX pairs trade on. It has no session calendar here; its week is in `fx-market-hours`. */
@@ -101,9 +121,52 @@ function closeDateOf(observation: SessionObservation, session: VenueSession, now
 function closeMarketOf(exchange: string, session: VenueSession): string | null {
   if (exchange === FX_VENUE) return "FX";
   if (!session.last || !session.timeZone) return null;
+  // An index publisher's name is no market: a session dated in New York is the US's, any other is a bare date.
+  if (session.quoted) return session.timeZone === US_EXCHANGE_TIME_ZONE ? "US" : null;
   return isUsListingExchange(exchange) ? "US" : exchange;
 }
 
+/** One market's session behind a report that mixes markets: its local date, and whether that session has closed. */
+export interface VenueSessionDate {
+  /** `US` for the US listing venues, which share one calendar, the venue's code elsewhere (`XETRA`, `EPA`). */
+  market: string;
+  /** The session's local date, `YYYY-MM-DD`. */
+  date: string;
+  /** The newest row on that market is its latest close. */
+  close: boolean;
+}
+
+/**
+ * Each market's session, for a report whose rows trade on more than one
+ * (a US line beside Xetra and Paris ones): the newest row of each, dated in
+ * its venue's own day, in the order the markets first appear. Empty when the
+ * rows share one market, or fewer than two can be placed.
+ */
+export function reportVenueSessionDates(observations: readonly SessionObservation[], now: number): VenueSessionDate[] {
+  const newestByMarket = new Map<string, { observation: SessionObservation & { time: ReportTime }; session: VenueSession }>();
+  for (const observation of observations) {
+    const exchange = canonicalExchange(observation.exchange);
+    const time = observation.time;
+    if (!exchange || !time) continue;
+    const session = venueSession(exchange, observation.marketState, now);
+    if (!session || session.state === "always") continue;
+    const market = exchange === FX_VENUE ? "FX" : isUsListingExchange(exchange) ? "US" : exchange;
+    const current = newestByMarket.get(market);
+    if (!current || time.time > current.observation.time.time) newestByMarket.set(market, { observation: { ...observation, time }, session });
+  }
+  if (newestByMarket.size < 2) return [];
+  return [...newestByMarket].map(([market, { observation, session }]) => {
+    // A venue in its session whose newest row is from an earlier day has not printed today: that row is its last close.
+    const exchange = canonicalExchange(observation.exchange);
+    const latestClose = session.state === "open" && session.timeZone ? latestRegularSessionClose(exchange, now) : null;
+    const last = latestClose ? { date: latestClose.date, open: latestRegularSessionOpen(exchange, latestClose.close) } : session.last;
+    const closeDate = closeDateOf(observation, { ...session, last }, now);
+    const date = closeDate
+      ?? (session.timeZone ? zonedDateKey(observation.time.time, session.timeZone) : new Date(observation.time.time).toISOString().slice(0, 10));
+    return { market, date, close: closeDate != null };
+  });
+}
+
 /**
  * Where the markets behind a quote report stand now, and whether the newest
  * observation is a close, and whose. Null market when the venues disagree
@@ -120,7 +183,7 @@ export function reportMarketSession(
     const exchange = canonicalExchange(observation.exchange);
     if (!exchange) continue;
     const key = `${exchange}:${observation.marketState ?? ""}`;
-    const session = sessions.get(key) ?? venueSession(exchange, observation.marketState, now);
+    const session = sessions.get(key) ?? venueSession(exchange, observation.marketState, now, observation.calendar);
     if (!session) continue;
     sessions.set(key, session);
     if (observation.time && (!newest || observation.time.time > (newest.observation.time?.time ?? -Infinity))) {

package/src/cli/pane-functions/resolver.ts

@@ -12,6 +12,7 @@ import { normalizeTickerInput } from "../../tickers/search";
 import { slugifyName } from "../../utils/slugify";
 import { ListingArgError, listingReadNotes, resolveCliListing, usListingsOnlyMessage } from "../listing-arg";
 import { listingAbroadVenue } from "../../utils/sec";
+import { splitSymbolArgs, stripStrayEdges } from "../symbol-args";
 import type { MarketContext } from "../types";
 import {
   buildPaneFunctionLookup,
@@ -135,10 +136,11 @@ export async function applyListingArgument(
   }
   const exchange = typeof args.options.exchange === "string" ? args.options.exchange : undefined;
   const { exchange: _exchange, ...options } = args.options;
-  const typed = takesOneTicker ? [args.arg] : args.arg.split(/[,\s]+/).filter(Boolean);
+  const typed = takesOneTicker ? [args.arg] : splitSymbolArgs([args.arg]);
   if (typed.length === 0) return args;
   let listings = await Promise.all(typed.map((raw) => resolveCliListing(raw, exchange, context, { ownExchangeWins: typed.length > 1 })));
-  const notes: string[] = [];
+  // A separator stuck to the end of a pasted list (`UPST;`) is not part of a symbol; it is named.
+  const notes: string[] = takesOneTicker ? [] : stripStrayEdges(args.arg).notes;
   const usOnly = headless?.usListingsOnly;
   const abroad = usOnly ? listings.filter((listing) => listingAbroadVenue(listing.key) != null) : [];
   if (usOnly && abroad.length > 0) {

package/src/cli/pane-functions/screenshot.ts

@@ -936,6 +936,8 @@ export async function renderDesktopShot({
   watermark,
   statusLine = false,
   fitRows = false,
+  fitReader = false,
+  maxHeightCells,
   options,
   captureImage = true,
   onStalledReport,
@@ -953,6 +955,10 @@ export async function renderDesktopShot({
   statusLine?: boolean;
   /** No `--height` was asked for: a pane that fits its rows (FUT) grows to show them all. */
   fitRows?: boolean;
+  /** A pane whose reader has a page open grows to show all of its text (a report's, which saves no image). */
+  fitReader?: boolean;
+  /** How tall a pane that fits its rows or its reader may grow, in cells, where the height limit of a saved image does not apply. */
+  maxHeightCells?: number;
   options: Record<string, string | true>;
   captureImage?: boolean;
   /**
@@ -999,7 +1005,14 @@ export async function renderDesktopShot({
       loadModel,
     );
     if (statusLine && captureImage) payload.statusLine = true;
-    if (fitRows && resolved.pane.shotFitsRows) payload.maxHeightCells = shotMaxHeightCells(scale ?? 1);
+    const fitRoles = [
+      ...(fitRows && resolved.pane.shotFitsRows ? ["data-table-body-scroll"] : []),
+      ...(fitReader && resolved.pane.shotFitsReader ? ["detail-scroll-body"] : []),
+    ];
+    if (fitRoles.length > 0) {
+      payload.maxHeightCells = maxHeightCells ?? shotMaxHeightCells(scale ?? 1);
+      payload.fitRoles = fitRoles;
+    }
     // Loads while the page renders.
     const report = payload.statusLine ? reportShotFreshness(resolved, loadModel) : undefined;
     // The same load says whether the report is complete, with or without a status line.

package/src/cli/scroll-truncation.ts

@@ -6,7 +6,11 @@ export interface ScrollBoxMetrics {
   scrollLeft: number;
   scrollWidth: number;
   clientWidth: number;
-  /** The box draws a scrollbar on that axis, which says it overflows even when the measures cannot. */
+  /**
+   * The box draws a scrollbar on that axis, which says it overflows even when the measures cannot:
+   * a table's body, which draws only the rows near the viewport. A plain scroll box draws one by
+   * default and holds all its content, so its measures say it.
+   */
   scrollbarY: boolean;
   scrollbarX: boolean;
 }

package/src/cli/symbol-args.ts

@@ -1,11 +1,49 @@
+/** The quote marks a pasted list wraps its entries in: "AAPL", 'MSFT', “NVDA”. */
+const QUOTE_MARKS = "\"'`\u2018\u2019\u201C\u201D";
+const QUOTE_EDGES = new RegExp(`^[${QUOTE_MARKS}]+|[${QUOTE_MARKS}]+$`, "g");
+
 /**
  * Symbols given as command arguments, each of which may hold several split by
  * commas, semicolons, spaces, tabs or newlines (a pasted list), with the blanks
- * dropped and the typed case kept. Every command that takes a symbol list splits
- * its arguments here, and `not-a-ticker` reads the typed spelling back from them.
+ * dropped, the quote marks around each entry removed and the typed case kept.
+ * Every command that takes a symbol list splits its arguments here, and
+ * `not-a-ticker` reads the typed spelling back from them.
  */
 export function splitSymbolArgs(args: readonly string[]): string[] {
-  return args.flatMap((arg) => arg.replace(/^\uFEFF/, "").split(/[\s,;]+/)).filter(Boolean);
+  return args
+    .flatMap((arg) => arg.replace(/^\uFEFF/, "").split(/[\s,;]+/))
+    .map((entry) => entry.replace(QUOTE_EDGES, ""))
+    .filter(Boolean);
+}
+
+/** The list separators in `text`, each once: `,;` for a stray `;,;`. */
+function separatorsIn(text: string): string {
+  return [...new Set([...text].filter((char) => char === "," || char === ";"))].join("");
+}
+
+/**
+ * A pasted list, or one cell of a file, without the separators and quote marks
+ * stuck to its ends (`UPST;`, `"GME",`). The separators it dropped are named
+ * (`Ignored the stray ";" after UPST.`) rather than swallowed, and never reach
+ * a listing search as part of a symbol, which would ask for `UPST;`.
+ */
+export function stripStrayEdges(text: string): { text: string; notes: string[] } {
+  const junk = `[\\s,;${QUOTE_MARKS}]`;
+  const leading = text.match(new RegExp(`^${junk}+`))?.[0] ?? "";
+  const rest = text.slice(leading.length);
+  const trailing = rest.match(new RegExp(`${junk}+$`))?.[0] ?? "";
+  const inner = rest.slice(0, rest.length - trailing.length);
+  const entries = splitSymbolArgs([inner]);
+  const [first, last] = [entries[0], entries.at(-1)];
+  const before = separatorsIn(leading);
+  const after = separatorsIn(trailing);
+  const notes = !first
+    ? (before || after ? [`Ignored the stray "${separatorsIn(leading + trailing)}".`] : [])
+    : [
+      ...before ? [`Ignored the stray "${before}" before ${first}.`] : [],
+      ...after ? [`Ignored the stray "${after}" after ${last}.`] : [],
+    ];
+  return { text: inner, notes };
 }
 
 /** How a symbol is compared for repeats: AAPL, aapl and $AAPL are one. */

package/src/cli/symbol-list.ts

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
 import { fstatSync } from "fs";
-import { splitSymbolArgs, uniqueSymbols } from "./symbol-args";
+import { splitSymbolArgs, stripStrayEdges, uniqueSymbols } from "./symbol-args";
 
 /** Header cells that name a spreadsheet's symbol column, compared without case, spaces or punctuation. */
 const SYMBOL_HEADERS = new Set(["symbol", "symbols", "ticker", "tickers", "code", "stockcode", "securitycode", "instrument"]);
@@ -129,13 +129,25 @@ export class SymbolListError extends Error {
 /**
  * The symbols a command was given: as arguments, from `--file`, and from
  * standard input when an argument is `-` or nothing else was given and input
- * is piped in. Repeats are dropped.
+ * is piped in. Repeats are dropped. A separator stuck to a symbol in a file, or
+ * left on the end of what was typed (`UPST;`), is dropped with the quote marks
+ * around it, and each is named in `strays` so the command can say so.
  */
-export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number }> {
+export async function readSymbolList(source: SymbolListSource): Promise<{ symbols: string[]; repeated: number; strays: string[] }> {
   const readStdin = source.readStdin ?? (() => Bun.stdin.text());
   const wantsStdin = source.args.includes("-") || source.file === "-";
-  const typed = splitSymbolArgs(source.args.filter((arg) => arg !== "-"));
+  const typedArgs = source.args.filter((arg) => arg !== "-");
+  const typed = splitSymbolArgs(typedArgs);
   const collected = [...typed];
+  // A separator left on the end of what was typed: `UPST;`, or a list that ends in a comma.
+  const strays = new Set<string>(stripStrayEdges(typedArgs.join(" ")).notes);
+  const addCells = (cells: readonly string[]) => {
+    for (const cell of cells) {
+      const cleaned = stripStrayEdges(cell);
+      cleaned.notes.forEach((note) => strays.add(note));
+      collected.push(cleaned.text);
+    }
+  };
   if (source.file != null && source.file !== "-") {
     if (!source.file.trim() || source.file.startsWith("--")) throw new SymbolListError("--file needs a path, such as --file symbols.csv.");
     let text: string;
@@ -145,10 +157,10 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
       const code = (error as NodeJS.ErrnoException).code;
       throw new SymbolListError(code === "ENOENT" ? `No file at ${source.file}.` : `Could not read ${source.file}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    collected.push(...parseSymbolText(text));
+    addCells(parseSymbolText(text));
   }
   if (wantsStdin || (typed.length === 0 && source.file == null && (source.stdinPiped ?? stdinIsPiped()))) {
-    collected.push(...parseSymbolText(await readStdin()));
+    addCells(parseSymbolText(await readStdin()));
   }
-  return uniqueSymbols(collected);
+  return { ...uniqueSymbols(collected), strays: [...strays] };
 }

package/src/cli/unknown-command.ts

@@ -0,0 +1,70 @@
+/** A function the catalog finds for a word typed as a command (`comps`, `peers`). */
+export interface CatalogCommandHit {
+  code: string;
+  label: string;
+  /** What the function takes after its code: `ticker`, `tickers`, `free-text`, `none`... */
+  argKind: string | null;
+  argPlaceholder: string | null;
+  /** It has a `--peers` switch that adds a symbol's competitors (RV). */
+  peers: boolean;
+}
+
+const TICKER_ARGUMENTS = new Set(["ticker", "tickers", "symbol-list", "ticker-list"]);
+
+/** A company name typed where a ticker goes (`duolingo`, `"coca cola"`): lowercase and longer than a ticker, or several words. */
+function nameLike(arg: string): boolean {
+  return /\s/.test(arg.trim()) || /^[a-z]{6,}$/.test(arg.trim());
+}
+
+function shellWord(arg: string): string {
+  return /^[\w.:,=%+@/$^-]+$/.test(arg) ? arg : JSON.stringify(arg);
+}
+
+/**
+ * The command that runs `hit` with what the reader typed after the unknown
+ * word: their tickers (`gloomberb fn RV DUOL --peers`, the switch added when
+ * one symbol meets a function that picks its peers), or the function's
+ * placeholder and a search when they typed a company's name.
+ */
+function catalogHitCommand(hit: CatalogCommandHit, args: readonly string[]): { command: string; search: string | null } {
+  const typed = args.filter((arg) => arg.trim() && !arg.startsWith("-"));
+  const base = `gloomberb fn ${hit.code}`;
+  if (hit.argKind === "none") return { command: base, search: null };
+  const placeholder = hit.argPlaceholder ?? hit.argKind;
+  if (!hit.argKind || !TICKER_ARGUMENTS.has(hit.argKind)) {
+    const argument = typed.length > 0 ? typed.map(shellWord).join(" ") : placeholder ? `<${placeholder}>` : "";
+    return { command: [base, argument].filter(Boolean).join(" "), search: null };
+  }
+  const names = typed.filter(nameLike);
+  const single = typed.length === 1;
+  const peers = hit.peers && single ? " --peers" : "";
+  if (names.length > 0) {
+    return { command: `${base} <${single ? "ticker" : placeholder ?? "tickers"}>${peers}`, search: `gloomberb search ${names.map(shellWord).join(" ")}` };
+  }
+  return { command: `${base} ${typed.length > 0 ? typed.map(shellWord).join(" ") : `<${placeholder ?? "ticker"}>`}${peers}`, search: null };
+}
+
+/**
+ * What an unknown command word is answered with when it names something the
+ * catalog has (`peers`, `comps`): one function as a command to run, several
+ * as a list, with the catalog search for more. Null when the catalog has
+ * nothing for it.
+ */
+export function catalogPointer(token: string, hits: readonly CatalogCommandHit[], args: readonly string[]): string | null {
+  if (hits.length === 0) return null;
+  const word = /^[\w.:-]+$/.test(token) ? token : JSON.stringify(token);
+  const more = `gloomberb catalog ${word}`;
+  if (hits.length === 1) {
+    const { command, search } = catalogHitCommand(hits[0]!, args);
+    return `Try \`${command}\` (${hits[0]!.label})${search ? `; \`${search}\` finds the ticker` : ""}. \`${more}\` lists more.`;
+  }
+  const commands = hits.map((hit) => catalogHitCommand(hit, args));
+  const width = Math.max(...commands.map(({ command }) => command.length));
+  const searches = [...new Set(commands.flatMap(({ search }) => search ?? []))];
+  return [
+    "Closest functions:",
+    ...commands.map(({ command }, index) => `  ${command.padEnd(width)}  ${hits[index]!.label}`),
+    ...searches.map((search) => `Find the ticker: ${search}`),
+    `Search the catalog: ${more}`,
+  ].join("\n");
+}

package/src/components/chart/native/surface/visibility.ts

@@ -29,27 +29,57 @@ export function resolveNativeSurfaceVisibleRect(
 ): CellRect | null {
   if (!renderable) return null;
 
+  const cached = visibleRectCache.get(renderable);
+  if (cached && cached.terminalWidth === terminalWidth && cached.terminalHeight === terminalHeight && ancestorChainUnchanged(renderable, cached.chain)) {
+    return cached.visible;
+  }
+  const chain: Array<CellRect & { visible: boolean }> = [];
+  let current: NativeSurfaceRenderableNode | null = renderable;
+  const seen = new Set<NativeSurfaceRenderableNode>();
+  let depth = 0;
   let visible: CellRect = {
     x: 0,
     y: 0,
     width: terminalWidth,
     height: terminalHeight,
   };
-  let current: NativeSurfaceRenderableNode | null = renderable;
-  const seen = new Set<NativeSurfaceRenderableNode>();
-  let depth = 0;
-
   while (current && !seen.has(current)) {
     if (depth >= MAX_RENDERABLE_ANCESTOR_DEPTH) return null;
     seen.add(current);
     depth += 1;
     if (current.visible === false) return null;
-
-    const nextVisible = intersectCellRects(visible, getRenderableCellRect(current));
+    const rect = getRenderableCellRect(current);
+    const nextVisible = intersectCellRects(visible, rect);
     if (!nextVisible) return null;
+    chain.push({ ...rect, visible: true });
     visible = nextVisible;
     current = current.parent;
   }
-
+  visibleRectCache.set(renderable, { terminalWidth, terminalHeight, chain, visible });
   return visible;
 }
+
+function ancestorChainUnchanged(
+  renderable: NativeSurfaceRenderableNode,
+  chain: ReadonlyArray<CellRect & { visible: boolean }>,
+): boolean {
+  let current: NativeSurfaceRenderableNode | null = renderable;
+  let index = 0;
+  const seen = new Set<NativeSurfaceRenderableNode>();
+  while (current && !seen.has(current)) {
+    if (index >= chain.length || index >= MAX_RENDERABLE_ANCESTOR_DEPTH) return false;
+    seen.add(current);
+    const cached = chain[index]!;
+    if (current.visible === false || current.x !== cached.x || current.y !== cached.y || current.width !== cached.width || current.height !== cached.height) return false;
+    current = current.parent;
+    index += 1;
+  }
+  return index === chain.length;
+}
+
+const visibleRectCache = new WeakMap<NativeSurfaceRenderableNode, {
+  terminalWidth: number;
+  terminalHeight: number;
+  chain: Array<CellRect & { visible: boolean }>;
+  visible: CellRect;
+}>();