gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/earnings/board.tsx

@@ -1,27 +1,35 @@
-import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   DataTableStackView,
+  PageStackView,
   PaneStatusBody,
   QueryBar,
   usePaneFooter,
   usePaneMenuItems,
   usePaneStatusFooter,
   type DataTableKeyEvent,
+  type QueryBarFilter,
+  type QueryBarView,
 } from "../../../components";
-import { handleRefreshKey } from "../../../components/data-table/table-pane";
+import { handleRefreshKey, usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { openFormModal } from "../../../components/form-modal";
+import { FILL_REST } from "../../../components/ui/fill";
 import type { EarningsCalendarQuery } from "../../../api-client/earnings";
-import { useAppSelector, usePaneSettingValue } from "../../../state/app/context";
+import { useAppSelector, usePaneAppConfig, usePaneSettingValue } from "../../../state/app/context";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { useAsyncResource, useAutoRefresh, usePluginPaneState, useUpdatedAgo } from "../../../public/react";
 import type { EarningsEvent } from "../../../types/data-provider";
+import { getSharedRegistry } from "../../registry/shared";
+import { Box, useUiCapabilities } from "../../../ui";
 import { useAssetData, usePluginAppActions, usePluginTickerActions } from "../../runtime";
+import { earningsResultsAlertValues } from "../alerts/research-builder";
+import { cachedMembers, loadMembers } from "../members/client";
 import { isBoardRowLoading, useQuoteBoard } from "../shared/use-quote-board";
 import {
   addDays,
   boardReport,
   boardRows,
   fallbackReport,
-  marketDays,
   newYorkToday,
   ownershipBySymbol,
   relativeDays,
@@ -31,9 +39,36 @@ import {
   type BoardSort,
 } from "./board-model";
 import { boardColumns, boardHasActuals, renderBoardCell, renderBoardSection, SORTABLE, type BoardCellContext, type BoardColumn } from "./board-table";
-import { cachedEarningsCalendar, loadEarningsBoard } from "./client";
+import { EarningsCalendarView, CALENDAR_GROUP_ROWS, calendarSlotsPerRow } from "./calendar";
+import {
+  boardRangeDays,
+  boardRangeLabel,
+  boardRangeWeek,
+  boardRangeWords,
+  CALENDAR_WEEK_OFFSETS,
+  calendarDays,
+  calendarGroupKey,
+  calendarWeekDates,
+  calendarWeekLabel,
+  isBoardRangeDay,
+  requestedBoardRange,
+  type BoardRange,
+} from "./calendar-model";
+import { cachedEarningsCalendar, earningsCalendarKey, loadEarningsBoard } from "./client";
 import { loadEarningsCalendar } from "./data/cache";
 import { EarningsHistoryView } from "./history";
+import {
+  ALL_SCOPE,
+  earningsScopeOptions,
+  MINE_SCOPE,
+  readEarningsScope,
+  SECTOR_HOLDINGS_FUND,
+  sectorSymbols,
+  type EarningsScope,
+} from "./scope";
+
+const NO_SYMBOLS: string[] = [];
+const NONE_EXPANDED: ReadonlySet<string> = new Set();
 
 /** The stored calendar reaches about three months ahead. */
 const HORIZON_DAYS = 90;
@@ -42,9 +77,21 @@ const MARKET_PER_DAY = 200;
 /** The server reads at most this many named companies. */
 const MAX_SYMBOLS = 200;
 
+const MARKET_SCOPE: EarningsScope = { kind: "all" };
+const loadSectorHoldings = (force: boolean) => loadMembers(SECTOR_HOLDINGS_FUND, force);
+/** A sector fund's companies the board reads, its largest first. */
+const sectorNames = (...args: Parameters<typeof sectorSymbols>) => sectorSymbols(...args).slice(0, MAX_SYMBOLS);
+
 type Order = "cap" | "mine";
+type BoardView = "table" | "calendar";
+
+const ORDER_OPTIONS: ReadonlyArray<{ value: Order; label: string }> = [{ value: "cap", label: "Size" }, { value: "mine", label: "Mine first" }];
+/** The week as logos is for the desktop and the web; the terminal draws no logos and keeps the table. */
+const ERN_VIEWS: ReadonlyArray<{ value: BoardView; label: string }> = [{ value: "table", label: "Table" }, { value: "calendar", label: "Calendar" }];
 
 interface BoardData {
+  /** The query read, by `earningsCalendarKey`: kept data from another week is not this week's. */
+  queryKey: string;
   reports: BoardReport[];
   stale: boolean;
   refreshError: string | null;
@@ -53,7 +100,8 @@ interface BoardData {
 /**
  * ERN without a ticker: the market's report days, largest companies first,
  * with the implied move and each company's average move. With tickers, or the
- * Mine filter, the upcoming reports of those companies instead.
+ * Names filter (Mine, a portfolio, a watchlist or a sector fund's holdings),
+ * the upcoming reports of those companies instead.
  */
 export function EarningsBoard({ focused, width, height, scopedSymbols, highlight = null }: {
   focused: boolean;
@@ -66,7 +114,7 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
 }) {
   const dataProvider = useAssetData();
   const { navigateTicker } = usePluginTickerActions();
-  const { createPaneFromTemplate } = usePluginAppActions();
+  const { createPaneFromTemplate, notify } = usePluginAppActions();
   usePaneMenuItems("earnings:catalysts", () => [{ id: "catalysts", label: "Catalyst calendar", onSelect: () => createPaneFromTemplate("catalysts-pane") }], [createPaneFromTemplate]);
   const tickers = useAppSelector((state) => state.tickers);
   // Ticker records change for many reasons; the board reloads only when the held and watched names do.
@@ -78,60 +126,128 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
     () => new Map(ownedKey ? ownedKey.split(",").map((entry) => entry.split(":") as [string, "held" | "watched"]) : []),
     [ownedKey],
   );
-  const [mineOnly, setMineOnly] = usePluginPaneState<boolean>("mineOnly", false);
+  // Before the Names filter, a Mine toggle; a layout saved with it on opens on Mine.
+  const [mineOnly] = usePluginPaneState<boolean>("mineOnly", false);
+  const [savedScope, setScope] = usePluginPaneState<string | null>("scope", null);
   const [order, setOrder] = usePluginPaneState<Order>("order", "cap");
   const [sort, setSort] = usePluginPaneState<BoardSort>("sort", { column: "cap", direction: "desc" });
   // Keyed by symbol and date, so a reload or a shared layout keeps the row.
   const [selectedKey, setSelectedKey] = usePluginPaneState<string | null>("selectedKey", null);
   const [openKey, setOpenKey] = usePluginPaneState<string | null>("openEvent", null);
-  // A layout or `gloomberb shot ERN NVDA,AMD --open NVDA` lands on that company's history.
+  // A layout or `gloom shot ERN NVDA,AMD --open NVDA` lands on that company's history.
   const [openSymbol] = usePaneSettingValue<string>("open", "");
+  // A layout's `view` setting opens on the week; a choice made in the pane wins.
+  const [requestedView] = usePaneSettingValue<string>("view", "");
+  const [chosenView, setView] = usePluginPaneState<BoardView | null>("view", null);
+  // `EVTS --week last` or `--date 2026-10-15` opens on those days; a choice in the bar's Range wins. One
+  // range for both views: the table draws its days, the calendar its week (this week for the days ahead).
+  const [requestedDate] = usePaneSettingValue<string>("date", "");
+  const [requestedWeek] = usePaneSettingValue<string>("week", "");
+  const [range, setRange] = usePluginPaneState<BoardRange>("range", requestedBoardRange(requestedDate, requestedWeek));
+  // The calendar's groups opened past their "+N more" slot, by `calendarGroupKey`.
+  const [expanded, setExpanded] = useState(NONE_EXPANDED);
+  const desktop = useUiCapabilities().nativePaneChrome === true;
+  const config = usePaneAppConfig();
+  const scopeOptions = useMemo(
+    () => earningsScopeOptions({ portfolios: config.portfolios, watchlists: config.watchlists }),
+    [config.portfolios, config.watchlists],
+  );
+  const chosenScope = readEarningsScope(savedScope ?? (mineOnly ? MINE_SCOPE : ALL_SCOPE), scopeOptions);
+  // The terminal keeps its Mine toggle, so a choice only the desktop offers reads as the market there.
+  const scopeOption = desktop || chosenScope.value === MINE_SCOPE ? chosenScope : scopeOptions[0]!;
+  const scoped = scopedSymbols.length > 0;
+  const scope = scoped ? MARKET_SCOPE : scopeOption.scope;
+  const view: BoardView = !desktop ? "table"
+    : chosenView ?? (ERN_VIEWS.some((option) => option.value === requestedView) ? requestedView as BoardView : "table");
+  const calendar = view === "calendar";
   const openedSymbol = useRef<string | null>(null);
   const highlighted = useRef<string | null>(null);
 
   const today = newYorkToday();
-  const market = scopedSymbols.length === 0 && !mineOnly;
-  const named = useMemo(
-    () => (scopedSymbols.length > 0 ? [...scopedSymbols] : [...owned.keys()]).slice(0, MAX_SYMBOLS),
-    [owned, scopedSymbols],
-  );
-  const days = useMemo(() => (market ? marketDays(today) : relativeDays(today)), [market, today]);
-  const query = useMemo<EarningsCalendarQuery>(() => market
-    ? { from: days[0]!.from, to: days.at(-1)!.to, perDay: MARKET_PER_DAY, symbols: named }
-    : { from: today, to: addDays(today, HORIZON_DAYS), perDay: 0, symbols: named },
-  [days, market, named, today]);
+  const market = !scoped && scope.kind === "all";
+  // Keyed by content: ticker records change for many reasons, the board reloads only when the list's names do.
+  const collectionKey = useMemo(() => {
+    if (scope.kind !== "portfolio" && scope.kind !== "watchlist") return "";
+    return [...tickers.values()]
+      .filter(({ metadata }) => (scope.kind === "portfolio" ? metadata.portfolios : metadata.watchlists).includes(scope.id))
+      .map(({ metadata }) => metadata.ticker.trim().toUpperCase())
+      .sort()
+      .join(",");
+  }, [scope, tickers]);
+  const sector = scope.kind === "sector" ? scope : null;
+  // A sector fund's companies come with its holdings, which the loader reads; the others are known here.
+  const named = useMemo(() => {
+    const names = scoped ? [...scopedSymbols]
+      : scope.kind === "portfolio" || scope.kind === "watchlist" ? (collectionKey ? collectionKey.split(",") : [])
+        : scope.kind === "sector" ? [] : [...owned.keys()];
+    return names.slice(0, MAX_SYMBOLS);
+  }, [collectionKey, owned, scope.kind, scoped, scopedSymbols]);
+  // Named companies also go to the per-ticker calendar, which covers listings the stored one does not;
+  // a sector fund's are S&P 500 companies, all in the stored one.
+  const perTicker = !market && !sector;
+  // The days ahead by default; a chosen week or day, past or ahead, for the market and for named companies alike.
+  const days = useMemo(() => (market || range ? boardRangeDays(range, today) : relativeDays(today)), [market, range, today]);
+  const weekOffset = boardRangeWeek(range, today);
+  const week = useMemo(() => calendarWeekDates(today, weekOffset), [today, weekOffset]);
+  // The calendar reads its week, reported days included; the table its days.
+  const query = useMemo<EarningsCalendarQuery>(() => calendar
+    ? { from: week[0]!, to: week.at(-1)!, perDay: market ? MARKET_PER_DAY : 0, symbols: named }
+    : market || range
+      ? { from: days[0]!.from, to: days.at(-1)!.to, perDay: market ? MARKET_PER_DAY : 0, symbols: named }
+      : { from: today, to: addDays(today, HORIZON_DAYS), perDay: 0, symbols: named },
+  [calendar, days, market, named, range, today, week]);
+  // A sector fund's read is named by the fund: its companies are known once its holdings are.
+  const queryKey = sector ? `${sector.etf}|${earningsCalendarKey(query)}` : earningsCalendarKey(query);
 
   const loader = useCallback(async (force: boolean): Promise<BoardData> => {
-    if (!market && named.length === 0) return { reports: [], stale: false, refreshError: null };
-    // Named companies also go to the per-ticker calendar, which covers listings the stored one does not.
+    const names = sector ? sectorNames((await loadSectorHoldings(force)).payload.members, sector.sectors) : named;
+    if (!market && names.length === 0) return { queryKey, reports: [], stale: false, refreshError: null };
+    const read = sector ? { ...query, symbols: names } : query;
     const [cloud, fallback] = await Promise.allSettled([
-      loadEarningsBoard(query, force),
-      market ? Promise.resolve([] as EarningsEvent[]) : loadEarningsCalendar(dataProvider, named, { force }).then((result) => result.events),
+      loadEarningsBoard(read, force),
+      !perTicker ? Promise.resolve([] as EarningsEvent[]) : loadEarningsCalendar(dataProvider, names, { force }).then((result) => result.events
+        // The per-ticker calendar is upcoming reports; a week or a chosen range keeps those in it.
+        .filter((event) => (!calendar && !range) || (event.earningsDate.toISOString().slice(0, 10) >= read.from && event.earningsDate.toISOString().slice(0, 10) <= read.to))),
     ]);
-    if (cloud.status === "rejected" && (market || fallback.status === "rejected")) throw cloud.reason;
+    if (cloud.status === "rejected" && (!perTicker || fallback.status === "rejected")) throw cloud.reason;
     const reports = cloud.status === "fulfilled" ? cloud.value.payload.reports.map((report) => boardReport(report, owned)) : [];
     const covered = new Set(reports.map((report) => report.symbol));
     const extra = fallback.status === "fulfilled"
-      ? fallback.value.filter((event) => !covered.has(event.symbol)).map((event) => fallbackReport(event, owned))
+      ? fallback.value.filter((event) => !covered.has(event.symbol)).map((event) => fallbackReport(event, owned, today))
       : [];
     return {
+      queryKey,
       reports: [...reports, ...extra],
       stale: cloud.status === "fulfilled" && cloud.value.stale,
       refreshError: cloud.status === "rejected"
         ? (cloud.reason instanceof Error ? cloud.reason.message : String(cloud.reason))
         : cloud.value.refreshError,
     };
-  }, [dataProvider, market, named, owned, query]);
+  }, [calendar, dataProvider, market, named, owned, perTicker, query, queryKey, range, sector, today]);
   const resource = useAsyncResource(loader, {
     keepPreviousData: true,
     initialData: () => {
-      const cached = cachedEarningsCalendar(query);
-      return cached ? { reports: cached.payload.reports.map((report) => boardReport(report, owned)), stale: false, refreshError: null } : null;
+      const holdings = sector ? cachedMembers(SECTOR_HOLDINGS_FUND) : null;
+      if (sector && !holdings) return null;
+      const cached = cachedEarningsCalendar(sector && holdings ? { ...query, symbols: sectorNames(holdings.payload.members, sector.sectors) } : query);
+      return cached ? { queryKey, reports: cached.payload.reports.map((report) => boardReport(report, owned)), stale: false, refreshError: null } : null;
     },
   });
   const data = resource.data;
+  // The week on screen is only the one read for it, never the last week's kept while this one loads or after it failed.
+  const weekData = data?.queryKey === queryKey ? data : null;
   const rows = useMemo(() => boardRows(data?.reports ?? [], days, sort, order === "mine"), [data, days, order, sort]);
   const reportRows = useMemo(() => rows.filter((row): row is BoardRow & { kind: "report" } => row.kind === "report"), [rows]);
+  const slotsPerRow = calendarSlotsPerRow(width);
+  const weekDays = useMemo(
+    () => (calendar
+      ? calendarDays(weekData?.reports ?? [], week, { today, mineFirst: order === "mine", limit: slotsPerRow * CALENDAR_GROUP_ROWS, expanded })
+      : []),
+    [calendar, expanded, order, slotsPerRow, today, week, weekData],
+  );
+  const selectedReport = calendar
+    ? weekData?.reports.find((report) => report.key === selectedKey) ?? null
+    : (reportRows.find((row) => row.key === selectedKey) ?? reportRows[0] ?? null)?.report ?? null;
   const selected = reportRows.find((row) => row.key === selectedKey) ?? reportRows[0] ?? null;
   const open = reportRows.find((row) => row.key === openKey)?.report
     ?? (openKey ? data?.reports.find((report) => report.key === openKey) : undefined) ?? null;
@@ -144,14 +260,16 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
     .map((row) => row.report.symbol))].join(",");
   const reportedSymbols = useMemo(() => (reportedKey ? reportedKey.split(",") : []), [reportedKey]);
   const liveStreaming = useLiveStreamingSetting();
-  const { quotes } = useQuoteBoard(reportedSymbols, { liveStreaming, selectedSymbol: selected?.report.symbol ?? null });
+  const { quotes } = useQuoteBoard(calendar ? NO_SYMBOLS : reportedSymbols, { liveStreaming, selectedSymbol: calendar ? null : selected?.report.symbol ?? null });
   const quotesRef = useRef(quotes);
   quotesRef.current = quotes;
   const statusShown = columns.some((column) => column.id === "status");
+  const logos = desktop;
   // Stable while the quotes tick: each row redraws by its own quote's version.
   const renderCell = useCallback((row: BoardRow, column: BoardColumn) => {
     const context: BoardCellContext = {
       statusShown,
+      logos,
       move: (report) => {
         const state = quotesRef.current.get(report.symbol);
         const move = reportMove(report, state?.quote, today);
@@ -159,7 +277,7 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
       },
     };
     return renderBoardCell(row, column, context);
-  }, [statusShown, today]);
+  }, [logos, statusShown, today]);
   const rowVersion = useCallback((row: BoardRow) => {
     if (row.kind !== "report") return row.key;
     const state = quotes.get(row.report.symbol);
@@ -193,7 +311,9 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
     stale: !!data?.stale,
     info: data && updatedAgo ? [{ id: "updated", parts: [{ text: updatedAgo, tone: "muted" as const }] }] : [],
   });
-  const symbol = open?.symbol ?? selected?.report.symbol ?? null;
+  const symbol = open?.symbol ?? selectedReport?.symbol ?? null;
+  // The desktop and the web only: the terminal's footer stays as it was.
+  const alerts = desktop && getSharedRegistry()?.commands.has("set-event-alert") === true;
   usePaneFooter("earnings-actions", () => ({
     order: 10,
     hints: symbol
@@ -203,27 +323,112 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
           { id: "estimates", key: "e", label: "stimates", onPress: () => createPaneFromTemplate("earnings-estimates-pane", { symbol }) },
           { id: "calls", key: "c", label: "alls", onPress: () => createPaneFromTemplate("earnings-calls-pane", { symbol }) },
           { id: "analysts", key: "a", label: "nalysts", onPress: () => createPaneFromTemplate("analyst-research-pane", { symbol }) },
+          // ALRT's earnings alert, set to go off when the results are out.
+          ...(alerts ? [{ id: "alert", key: "n", label: "otify", title: "Earnings alert", onPress: () => {
+            if (!openEarningsAlert(symbol)) notify({ body: "Open this from the main window.", type: "info" });
+          } }] : []),
         ]
       : [],
-  }), [createPaneFromTemplate, navigateTicker, symbol]);
+  }), [alerts, createPaneFromTemplate, navigateTicker, notify, symbol]);
 
-  // t, e, c and a are footer hints, which bind their own keys.
+  // t, e, c, a and n are footer hints, which bind their own keys.
   const handleKeyDown = useCallback((event: DataTableKeyEvent) => handleRefreshKey(event, () => void resource.reload()), [resource.reload]);
+  usePaneRefreshKey(() => void resource.reload(), { focused, enabled: calendar && !open });
 
   const sortColumn = (Object.entries(SORTABLE).find(([, value]) => value === sort.column)?.[0]) ?? null;
-  const queryBar = (
+  const mineFilter: QueryBarFilter[] = scoped ? [] : [
+    { id: "mine", kind: "toggle", label: "Mine", value: scope.kind === "mine", defaultValue: false, onChange: (mine: boolean) => setScope(mine ? MINE_SCOPE : ALL_SCOPE) },
+  ];
+  // The desktop's Mine is one choice of the Names filter, beside each portfolio, watchlist and sector fund.
+  const namesFilter: QueryBarFilter[] = scoped ? [] : [{
+    id: "names",
+    label: "Names",
+    value: scopeOption.value,
+    defaultValue: ALL_SCOPE,
+    options: scopeOptions.map(({ value, label, description }) => ({ value, label, description })),
+    onChange: (value: string) => setScope(value),
+  }];
+  const orderView: QueryBarView<Order> = { value: order, options: ORDER_OPTIONS, onChange: setOrder };
+  // The weeks the bar offers, last week to three ahead, and the one on screen when it is another.
+  const weekOptions = (shown: number | null) => [...new Set([...CALENDAR_WEEK_OFFSETS, ...(shown == null ? [] : [shown])])]
+    .sort((left, right) => left - right)
+    .map((offset) => ({ value: String(offset), label: calendarWeekLabel(today, offset) }));
+  // One Range for both views. The table's: the days ahead, a week, or a day asked for (`--date`), which stays a
+  // choice once the bar moves off it. The calendar's: the week it draws, a day's own week.
+  const rangeDates = [...new Set([requestedDate, range].filter(isBoardRangeDay))];
+  const rangeFilter: QueryBarFilter = calendar
+    ? { id: "range", label: "Range", value: String(weekOffset), options: weekOptions(weekOffset), onChange: setRange }
+    : {
+      id: "range",
+      label: "Range",
+      value: range,
+      defaultValue: "",
+      options: [
+        { value: "", label: "Upcoming" },
+        ...weekOptions(range && !isBoardRangeDay(range) ? weekOffset : null),
+        ...rangeDates.map((date) => ({ value: date, label: boardRangeLabel(date, today)! })),
+      ],
+      onChange: (value: string) => { setRange(value); setSelectedKey(null); },
+    };
+  // On the desktop the view picks the table or the week, and the order is a filter beside the names and the Range.
+  const queryBar = !desktop ? <QueryBar width={width} filters={[...mineFilter, rangeFilter]} view={orderView} /> : (
     <QueryBar
       width={width}
-      filters={scopedSymbols.length > 0 ? [] : [
-        { id: "mine", kind: "toggle", label: "Mine", value: mineOnly, defaultValue: false, onChange: setMineOnly },
+      filters={[
+        ...namesFilter,
+        rangeFilter,
+        { id: "order", label: "Order", inline: true, value: order, options: ORDER_OPTIONS, onChange: setOrder },
       ]}
-      view={{
-        value: order,
-        options: [{ value: "cap", label: "Size" }, { value: "mine", label: "Mine first" }],
-        onChange: (value: Order) => setOrder(value),
-      }}
+      view={{ value: view, options: ERN_VIEWS, onChange: setView }}
     />
   );
+  // "last week", "on Thu Oct 15", "in the week of Nov 2": the days the empty board or week is of.
+  const rangeWords = calendar ? boardRangeWords(String(weekOffset), today) : boardRangeWords(range, today);
+  const emptyStateTitle = market ? `No reports on the calendar ${rangeWords ?? "these days"}.`
+    : scope.kind === "mine" && named.length === 0 ? "No portfolio or watchlist names."
+      : (scope.kind === "portfolio" || scope.kind === "watchlist") && named.length === 0 ? `No tickers in ${scope.name}.`
+        : rangeWords ? `No reports from these companies ${rangeWords}.` : "No upcoming reports.";
+  const history = open ? (
+    <EarningsHistoryView key={open.symbol} symbol={open.symbol} width={width} height={Math.max(4, height - 1)}
+      focused={focused} registrationId="earnings-history" />
+  ) : null;
+
+  if (calendar) {
+    // The query bar stays up while a week loads or fails, so another week or the table is a click away.
+    return (
+      <PageStackView
+        focused={focused}
+        detailOpen={!!open}
+        onBack={() => setOpenKey(null)}
+        detailTitle={open ? `${open.symbol} · ${open.name}` : undefined}
+        rootContent={(
+          <Box flexDirection="column" {...FILL_REST}>
+            {queryBar}
+            <EarningsCalendarView
+              days={weekDays}
+              width={width}
+              focused={focused && !open}
+              selectedKey={selectedKey}
+              onSelect={setSelectedKey}
+              onOpen={(report) => setOpenKey(report.key)}
+              onMore={(day, group) => {
+                // The group draws in full, the cursor on the first company its last slot counted.
+                const all = calendarDays(weekData?.reports ?? [], [day.date], { today, mineFirst: order === "mine" })[0]
+                  ?.groups.find((entry) => entry.session === group.session);
+                setExpanded((current) => new Set(current).add(calendarGroupKey(day.date, group.session)));
+                const next = all?.reports[group.reports.length];
+                if (next) setSelectedKey(next.key);
+              }}
+              loading={!weekData && !resource.error}
+              error={weekData ? null : resource.error}
+              emptyTitle={emptyStateTitle}
+            />
+          </Box>
+        )}
+        detailContent={history}
+      />
+    );
+  }
 
   return (
     <PaneStatusBody loading={resource.loading && !data} error={!data ? resource.error : null} subject="the earnings calendar">
@@ -257,16 +462,14 @@ export function EarningsBoard({ focused, width, height, scopedSymbols, highlight
         detailOpen={!!open}
         onBack={() => setOpenKey(null)}
         detailTitle={open ? `${open.symbol} · ${open.name}` : undefined}
-        detailContent={open ? (
-          <EarningsHistoryView key={open.symbol} symbol={open.symbol} width={width} height={Math.max(4, height - 1)}
-            focused={focused} registrationId="earnings-history" />
-        ) : null}
-        emptyStateTitle={
-          market ? "No reports on the calendar these days."
-            : named.length === 0 ? "No portfolio or watchlist names."
-              : "No upcoming reports."
-        }
+        detailContent={history}
+        emptyStateTitle={emptyStateTitle}
       />
     </PaneStatusBody>
   );
 }
+
+/** ALRT's form for an earnings alert on `symbol`, set to go off when the results are out. */
+function openEarningsAlert(symbol: string): boolean {
+  return openFormModal({ kind: "plugin-command", commandId: "set-event-alert", values: earningsResultsAlertValues(symbol) });
+}

package/src/plugins/builtin/earnings/calendar-model.ts

@@ -0,0 +1,188 @@
+import type { EarningsTiming } from "../../../api-client/earnings";
+import { addDays, isSession, marketDays, ownershipRank, type BoardReport, type MarketDay } from "./board-model";
+import { shortDate, weekday } from "./format";
+
+/** The weeks the calendar view offers, from the one before this week to three ahead. */
+export const CALENDAR_WEEK_OFFSETS = [-1, 0, 1, 2, 3] as const;
+type CalendarWeekOffset = (typeof CALENDAR_WEEK_OFFSETS)[number];
+
+/** Within a day, reports before the open come first, then during the session, after the close, and those with no time yet. */
+const SESSIONS: ReadonlyArray<{ session: EarningsTiming | null; label: string }> = [
+  { session: "bmo", label: "Before open" },
+  { session: "dmh", label: "During market" },
+  { session: "amc", label: "After close" },
+  { session: null, label: "Time not set" },
+];
+
+export interface CalendarGroup {
+  session: EarningsTiming | null;
+  label: string;
+  /** The ones drawn, largest first (held, then watched names lead when the board puts mine first). */
+  reports: BoardReport[];
+  /** Reports of this group past its limit, counted in its last slot until the group is expanded. */
+  more: number;
+}
+
+/** Names a day's group, so a "+N more" slot can expand that group alone. */
+export function calendarGroupKey(date: string, session: EarningsTiming | null): string {
+  return `${date}:${session ?? "unset"}`;
+}
+
+export interface CalendarDay {
+  date: string;
+  /** "Mon" */
+  weekday: string;
+  /** "Oct 20" */
+  label: string;
+  today: boolean;
+  /** No NYSE session that day. */
+  closed: boolean;
+  /** Every report that day, drawn or not. */
+  total: number;
+  /** Only the sessions with a report. */
+  groups: CalendarGroup[];
+}
+
+/**
+ * Monday to Friday of the week `offset` weeks from the one `today` falls in;
+ * on a Saturday or Sunday "this week" is the one about to start.
+ */
+export function calendarWeekDates(today: string, offset: number): string[] {
+  const day = new Date(`${today}T00:00:00Z`).getUTCDay();
+  const monday = addDays(today, day === 0 ? 1 : day === 6 ? 2 : 1 - day);
+  const start = addDays(monday, offset * 7);
+  return [0, 1, 2, 3, 4].map((index) => addDays(start, index));
+}
+
+/** "Last week", "This week", "Next week", then "Week of Nov 3". */
+export function calendarWeekLabel(today: string, offset: number): string {
+  if (offset === -1) return "Last week";
+  if (offset === 0) return "This week";
+  if (offset === 1) return "Next week";
+  return `Week of ${shortDate(calendarWeekDates(today, offset)[0]!)}`;
+}
+
+/** The weeks `--week` names, as offsets from this week. */
+export const BOARD_WEEKS = ["last", "this", "next"] as const;
+export type BoardWeek = typeof BOARD_WEEKS[number];
+const BOARD_WEEK_OFFSET: Record<BoardWeek, CalendarWeekOffset> = { last: -1, this: 0, next: 1 };
+
+export function isBoardWeek(value: unknown): value is BoardWeek {
+  return typeof value === "string" && (BOARD_WEEKS as readonly string[]).includes(value);
+}
+
+/**
+ * The days a board shows, as the pane's Range saves them: "" for the days
+ * ahead (the default), a week as its offset from this one ("-1" last week,
+ * "2" the week after next), or one day as YYYY-MM-DD. The table draws a
+ * section per day of it; the calendar draws its week.
+ */
+export type BoardRange = string;
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+const WEEK_OFFSET = /^-?\d+$/;
+
+/** The range `--date` or `--week` asks for; the days ahead without either. */
+export function requestedBoardRange(date: unknown, week: unknown): BoardRange {
+  if (typeof date === "string" && ISO_DAY.test(date)) return date;
+  return isBoardWeek(week) ? String(BOARD_WEEK_OFFSET[week]) : "";
+}
+
+/** A range that is one day (`--date`), not a week or the days ahead. */
+export function isBoardRangeDay(range: BoardRange): boolean {
+  return ISO_DAY.test(range);
+}
+
+function mondayOf(date: string): string {
+  return calendarWeekDates(date, 0)[0]!;
+}
+
+/** The week a range falls in, from this week: a day's own week, and this week for the days ahead. */
+export function boardRangeWeek(range: BoardRange, today: string): number {
+  if (WEEK_OFFSET.test(range)) return Number(range);
+  if (!ISO_DAY.test(range)) return 0;
+  return Math.round((Date.parse(mondayOf(range)) - Date.parse(mondayOf(today))) / (7 * 86_400_000));
+}
+
+/** A day of a week or the day asked for: "Today" for today, otherwise "Thu Oct 15". */
+function dayLabel(date: string, today: string): string {
+  return date === today ? "Today" : `${weekday(date)} ${shortDate(date)}`;
+}
+
+/**
+ * The table's sections for `range`: the market's days ahead by default, one
+ * section per weekday of a week, or the one day asked for. Days without
+ * reports (a holiday) leave no section.
+ */
+export function boardRangeDays(range: BoardRange, today: string): MarketDay[] {
+  if (ISO_DAY.test(range)) return [{ label: dayLabel(range, today), from: range, to: range }];
+  if (!WEEK_OFFSET.test(range)) return marketDays(today);
+  return calendarWeekDates(today, Number(range)).map((date) => ({ label: dayLabel(date, today), from: date, to: date }));
+}
+
+/** What the range reads as: "Last week", "Week of Nov 2", "Thu Oct 15", or null for the days ahead. */
+export function boardRangeLabel(range: BoardRange, today: string): string | null {
+  if (ISO_DAY.test(range)) return dayLabel(range, today);
+  return WEEK_OFFSET.test(range) ? calendarWeekLabel(today, Number(range)) : null;
+}
+
+/** The range in a sentence ("No reports … last week"): "today", "on Thu Oct 15", "in the week of Nov 2"; null for the days ahead. */
+export function boardRangeWords(range: BoardRange, today: string): string | null {
+  if (ISO_DAY.test(range)) return range === today ? "today" : `on ${dayLabel(range, today)}`;
+  if (!WEEK_OFFSET.test(range)) return null;
+  const offset = Number(range);
+  return offset >= -1 && offset <= 1 ? calendarWeekLabel(today, offset).toLowerCase() : `in the week of ${shortDate(calendarWeekDates(today, offset)[0]!)}`;
+}
+
+function bySize(left: BoardReport, right: BoardReport, mineFirst: boolean): number {
+  const rank = ownershipRank(left, mineFirst) - ownershipRank(right, mineFirst);
+  if (rank !== 0) return rank;
+  // Missing caps sink, as they do in the table.
+  if (left.marketCap !== right.marketCap) {
+    if (left.marketCap == null) return 1;
+    if (right.marketCap == null) return -1;
+    return right.marketCap - left.marketCap;
+  }
+  return left.symbol.localeCompare(right.symbol);
+}
+
+/**
+ * The week as the calendar draws it: a column per day, and in each the
+ * reports grouped by when they come out, before the open, during the
+ * session, after the close, and with no time yet. A group takes at most
+ * `limit` slots: past it, its largest companies and a last slot that counts
+ * the rest. A group named in `expanded` (see `calendarGroupKey`) draws all
+ * of its reports.
+ */
+export function calendarDays(
+  reports: readonly BoardReport[],
+  dates: readonly string[],
+  { today, mineFirst = false, limit = Number.POSITIVE_INFINITY, expanded }: {
+    today: string;
+    mineFirst?: boolean;
+    limit?: number;
+    expanded?: ReadonlySet<string>;
+  },
+): CalendarDay[] {
+  return dates.map((date) => {
+    const inDay = reports.filter((report) => report.date === date);
+    const groups = SESSIONS.flatMap(({ session, label }): CalendarGroup[] => {
+      const inGroup = inDay.filter((report) => report.timing === session).sort((left, right) => bySize(left, right, mineFirst));
+      if (inGroup.length === 0) return [];
+      // Past the limit, the last slot counts the rest.
+      const shown = inGroup.length > limit && !expanded?.has(calendarGroupKey(date, session))
+        ? inGroup.slice(0, Math.max(0, limit - 1))
+        : inGroup;
+      return [{ session, label, reports: shown, more: inGroup.length - shown.length }];
+    });
+    return {
+      date,
+      weekday: weekday(date),
+      label: shortDate(date),
+      today: date === today,
+      closed: !isSession(date),
+      total: inDay.length,
+      groups,
+    };
+  });
+}