gloomberb 0.18.3 → 0.18.4

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

@@ -1,16 +1,15 @@
 import { useCompanyDisclosureLinks } from "../company-kpis/related";
 import { useCallback, useMemo } from "react";
-import { usePaneFooter } from "../../../components";
+import { PaneStatusBody, usePaneFooter } from "../../../components";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
 import { usePaneInstance } from "../../../state/app/context";
-import { parseTickerListInput, formatTickerListInput } from "../../../tickers/list";
+import { formatTickerListInput } from "../../../tickers/list";
 import { usePluginAppActions, usePluginTickerActions } from "../../runtime";
 import { useUiCapabilities } from "../../../ui";
 import type {
   PaneSettingsContext,
   PaneSettingsDef,
-  PaneTemplateCreateOptions,
 } from "../../../types/plugin";
 import { attachEarningsCalendarPersistence, resetEarningsCalendarPersistence } from "./data/cache";
 import { attachEarningsCloudCaches, resetEarningsCloudCaches } from "./client";
@@ -41,34 +40,24 @@ function TickerEarnings({ symbol, focused, width, height }: { symbol: string; fo
 function EarningsPane({ focused, width, height }: PaneProps) {
   const pane = usePaneInstance();
   const { nativePaneChrome } = useUiCapabilities();
-  const symbols = useMemo(() => scopedSymbolsFromSettings(pane?.settings), [pane?.settings]);
+  const scope = useMemo(() => scopedSymbolsFromSettings(pane?.settings), [pane?.settings]);
   // EVTS is always the market board; its ticker only picks the row.
   const board = pane?.settings?.board === true;
   const highlight = typeof pane?.settings?.highlight === "string" ? pane.settings.highlight : null;
   const bodyHeight = Math.max(3, height - (nativePaneChrome ? 1 : 0));
+  if (!board && scope.error) return <PaneStatusBody error={scope.error} subject="Earnings scope" />;
+  const symbols = scope.symbols ?? [];
   return !board && symbols.length === 1
     ? <TickerEarnings symbol={symbols[0]!} focused={focused} width={width} height={bodyHeight} />
     : <EarningsBoard scopedSymbols={board ? [] : symbols} highlight={highlight} focused={focused} width={width} height={bodyHeight} />;
 }
 
-/** Tickers named on the command bar or the CLI. */
-function earningsScopeSymbols(options: PaneTemplateCreateOptions | undefined): string[] {
-  if (options?.symbols && options.symbols.length > 0) return options.symbols;
-  const raw = options?.arg?.trim() ?? "";
-  if (!raw) return [];
-  try {
-    return parseTickerListInput(raw);
-  } catch {
-    return [];
-  }
-}
-
 /** The pane's tickers live in its settings, so they are editable there too. */
 function earningsSettings(context: PaneSettingsContext): PaneSettingsDef {
-  const symbols = scopedSymbolsFromSettings(context.settings);
+  const scope = scopedSymbolsFromSettings(context.settings);
   return {
     title: "Earnings Scope",
-    values: { symbolsText: symbols.length > 0 ? formatTickerListInput(symbols) : "" },
+    values: { symbolsText: scope.text },
     fields: [
       {
         key: "symbolsText",
@@ -102,7 +91,8 @@ export const earningsModule: PluginModule = {
       // ERN and EVTS open this pane: EVTS sets `board`, a scoped ERN sets the tickers.
       identitySettings: ["board", "symbols", "symbolsText"],
       personalData: ({ settings, tickers }) => {
-        const symbols = settings.board === true ? [] : scopedSymbolsFromSettings(settings);
+        const symbols = settings.board === true ? [] : scopedSymbolsFromSettings(settings).symbols;
+        if (!symbols) return null;
         // Single-ticker report history is public. The board marks owned names.
         if (symbols.length === 1) return null;
         return [...tickers.values()].some(({ metadata }) => (
@@ -134,11 +124,14 @@ export const earningsModule: PluginModule = {
       canCreate: () => true,
       // Tickers named on the command bar scope the pane; without them it is the market board.
       createInstance: (_context, options) => {
-        const symbols = earningsScopeSymbols(options);
+        const scope = scopedSymbolsFromSettings(options?.symbols?.length
+          ? { symbols: options.symbols } : { symbolsText: options?.arg });
+        const symbols = scope.symbols;
         return {
-          title: symbols.length > 0 ? `ERN ${formatTickerListInput(symbols)}` : "Earnings Calendar",
+          title: symbols?.length ? `ERN ${formatTickerListInput(symbols)}` : "Earnings Calendar",
           placement: "floating",
-          settings: symbols.length > 0 ? { symbols, symbolsText: formatTickerListInput(symbols) } : undefined,
+          settings: scope.error ? { symbolsText: scope.text }
+            : symbols?.length ? { symbols, symbolsText: scope.text } : undefined,
         };
       },
     },

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

@@ -1,17 +1,22 @@
-import { parseTickerListInput } from "../../../tickers/list";
+import { formatTickerListInput, parseTickerListInput } from "../../../tickers/list";
 
-export function scopedSymbolsFromSettings(settings: Record<string, unknown> | undefined): string[] {
+type EarningsSymbols = { text: string } & (
+  | { symbols: string[]; error: null }
+  | { symbols: null; error: string }
+);
+
+/** Invalid input stays editable and can never stand for the unscoped market board. */
+export function scopedSymbolsFromSettings(settings: Record<string, unknown> | undefined): EarningsSymbols {
   const symbols = settings?.symbols;
-  if (Array.isArray(symbols)) {
-    return symbols
-      .filter((symbol): symbol is string => typeof symbol === "string" && symbol.trim().length > 0)
-      .map((symbol) => symbol.trim().toUpperCase());
-  }
-  const symbolsText = settings?.symbolsText;
-  if (typeof symbolsText !== "string" || !symbolsText.trim()) return [];
+  const text = Array.isArray(symbols)
+    ? formatTickerListInput(symbols.filter((symbol): symbol is string => typeof symbol === "string" && symbol.trim().length > 0))
+    : typeof settings?.symbolsText === "string" ? settings.symbolsText : "";
+  if (!text.trim()) return { symbols: [], error: null, text: "" };
   try {
-    return parseTickerListInput(symbolsText);
-  } catch {
-    return [];
+    const parsed = parseTickerListInput(text);
+    return { symbols: parsed, error: null, text: formatTickerListInput(parsed) };
+  } catch (error) {
+    // Intentional ignore: user input validation becomes a visible, editable error state.
+    return { symbols: null, error: error instanceof Error ? error.message : "Invalid ticker list.", text };
   }
 }

package/src/plugins/builtin/earnings/scope.ts

@@ -0,0 +1,89 @@
+import type { FundMember } from "../../../api-client/members";
+import type { Portfolio, Watchlist } from "../../../types/ticker";
+import { getSectorCollection } from "../sectors/sector-data";
+
+/**
+ * The fund whose holdings name each company's GICS sector: the S&P 500's, as
+ * MEMB reads it. A Select Sector SPDR holds the S&P 500's companies of one
+ * sector, so its members are these holdings in that sector.
+ */
+export const SECTOR_HOLDINGS_FUND = "IVV";
+
+/** The GICS sector each of SECT's sector funds holds, as the S&P 500's holdings name it. */
+const SECTOR_OF_FUND: Readonly<Record<string, readonly string[]>> = {
+  XLK: ["Information Technology"],
+  XLV: ["Health Care"],
+  XLF: ["Financials"],
+  XLY: ["Consumer Discretionary"],
+  // The holdings file says "Communication"; GICS's own name is the longer one.
+  XLC: ["Communication", "Communication Services"],
+  XLI: ["Industrials"],
+  XLP: ["Consumer Staples"],
+  XLE: ["Energy"],
+  XLU: ["Utilities"],
+  XLRE: ["Real Estate"],
+  XLB: ["Materials"],
+};
+
+/** Which companies ERN lists: the market's, the user's, one portfolio or watchlist, or one sector fund's. */
+export type EarningsScope =
+  | { kind: "all" }
+  | { kind: "mine" }
+  | { kind: "portfolio" | "watchlist"; id: string; name: string }
+  | { kind: "sector"; etf: string; name: string; sectors: readonly string[] };
+
+export interface EarningsScopeOption {
+  value: string;
+  label: string;
+  description?: string;
+  scope: EarningsScope;
+}
+
+/** The value that lists the market; also what an unknown or removed choice reads as. */
+export const ALL_SCOPE = "all";
+export const MINE_SCOPE = "mine";
+
+/** "Portfolio" under a portfolio's name, unless the name already says so ("Main Portfolio"). */
+const kindNote = (name: string, kind: "Portfolio" | "Watchlist") =>
+  name.toLowerCase().includes(kind.toLowerCase()) ? undefined : kind;
+
+/**
+ * The choices of ERN's Names filter, in menu order: the market, every held or
+ * watched name, each portfolio and watchlist, then SECT's sector funds, each
+ * named with its fund ("Technology (XLK)").
+ */
+export function earningsScopeOptions(collections: { portfolios: readonly Portfolio[]; watchlists: readonly Watchlist[] }): EarningsScopeOption[] {
+  return [
+    { value: ALL_SCOPE, label: "All", scope: { kind: "all" } },
+    { value: MINE_SCOPE, label: "Mine", description: "Portfolios and watchlists", scope: { kind: "mine" } },
+    ...collections.portfolios.map((portfolio): EarningsScopeOption => ({
+      value: `portfolio:${portfolio.id}`, label: portfolio.name, description: kindNote(portfolio.name, "Portfolio"),
+      scope: { kind: "portfolio", id: portfolio.id, name: portfolio.name },
+    })),
+    ...collections.watchlists.map((watchlist): EarningsScopeOption => ({
+      value: `watchlist:${watchlist.id}`, label: watchlist.name, description: kindNote(watchlist.name, "Watchlist"),
+      scope: { kind: "watchlist", id: watchlist.id, name: watchlist.name },
+    })),
+    ...getSectorCollection("sectors").items.flatMap((sector): EarningsScopeOption[] => {
+      const sectors = SECTOR_OF_FUND[sector.etf];
+      return sectors ? [{
+        value: `sector:${sector.etf}`, label: `${sector.name} (${sector.etf})`,
+        scope: { kind: "sector", etf: sector.etf, name: sector.name, sectors },
+      }] : [];
+    }),
+  ];
+}
+
+/** The scope a saved value names among `options`; the market when it names none. */
+export function readEarningsScope(value: string, options: readonly EarningsScopeOption[]): EarningsScopeOption {
+  return options.find((option) => option.value === value) ?? options[0]!;
+}
+
+/** A sector fund's companies: the S&P 500's holdings in its sector, largest weight first. */
+export function sectorSymbols(members: readonly FundMember[], sectors: readonly string[]): string[] {
+  const symbols = members
+    .filter((member) => member.symbol && member.sector && sectors.includes(member.sector))
+    .sort((left, right) => (right.weight ?? 0) - (left.weight ?? 0))
+    .map((member) => member.symbol!.trim().toUpperCase());
+  return [...new Set(symbols)];
+}

package/src/plugins/builtin/earnings-calls/calendar.tsx

@@ -0,0 +1,310 @@
+import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import type { CloudEarningsCallPayload } from "../../../api-client";
+import { usePlanAccess } from "../../../api-client/plan-access";
+import {
+  buildSectionedRows,
+  DataTableStackView,
+  isSectionedItemRow,
+  QueryBar,
+  renderSectionedRowHeader,
+  usePaneNoticeFooter,
+  usePaneStatusFooter,
+  useQueryBarSearch,
+  type DataTableCell,
+  type DataTableColumn,
+  type DataTableKeyEvent,
+  type DataTableRootKeyContext,
+  type PaneHint,
+  type QueryBarView,
+  type SectionedRow,
+} from "../../../components";
+import { handleRefreshKey } from "../../../components/data-table/table-pane";
+import { TABLE_COLUMN_GAP, tableColumnWidth } from "../../../components/ui/table-layout";
+import { useAsyncResource } from "../../../react/async-resource";
+import { useAgeClock, useAutoRefresh } from "../../../react/auto-refresh";
+import { colors } from "../../../theme/colors";
+import { TextAttributes } from "../../../ui";
+import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
+import { usePluginPaneState } from "../../runtime";
+import { newYorkToday } from "../earnings/board-model";
+import { ProWall, SignInWall } from "../cloud/auth-actions";
+import { cachedUpcomingCalls, calendarAway, loadUpcomingCalls, statusOf, upcomingCutNotice, type UpcomingCallsResult } from "./data";
+import { formatPeriod } from "./format";
+import {
+  calendarDays,
+  calendarSections,
+  callLocalClock,
+  callNewYorkClock,
+  clockIsNewYork,
+  DEFAULT_CALENDAR_SORT,
+  isUpcomingCall,
+  type CalendarSort,
+} from "./upcoming";
+
+export type CallsView = "upcoming" | "transcripts";
+
+/** CALLS alone: the calendar of every company's calls, or the shelf of transcripts. */
+export const CALLS_VIEWS: ReadonlyArray<{ value: CallsView; label: string }> = [
+  { value: "upcoming", label: "Upcoming" },
+  { value: "transcripts", label: "Transcripts" },
+];
+
+type CalendarColumnId = "ticker" | "company" | "local" | "newYork" | "period" | "away";
+type CalendarColumn = DataTableColumn & { id: CalendarColumnId };
+type CalendarRow = SectionedRow<CloudEarningsCallPayload>;
+
+const COMPANY_MIN_WIDTH = 12;
+const MISSING = "\u2014";
+
+const ALL_COLUMNS: CalendarColumn[] = [
+  { id: "ticker", label: "TICKER", width: 6, align: "left" },
+  { id: "company", label: "COMPANY", width: COMPANY_MIN_WIDTH, align: "left" },
+  { id: "local", label: "LOCAL", width: 5, align: "left" },
+  { id: "newYork", label: "ET", width: 5, align: "left" },
+  { id: "period", label: "PERIOD", width: 7, align: "left" },
+  // "in 23h 59m" and "in progress" are the longest.
+  { id: "away", label: "IN", width: 11, align: "right" },
+];
+
+/** Dropped first when narrow: the period, then the local clock (New York's stays). */
+const DROP_ORDER: CalendarColumnId[] = ["period", "local"];
+
+/** Header clicks sort these within each day; the rest keep start order. */
+const SORTABLE: Partial<Record<CalendarColumnId, CalendarSort["column"]>> = {
+  ticker: "ticker", company: "company", local: "time", newYork: "time",
+};
+
+function calendarColumns(width: number, { localClock }: { localClock: boolean }): CalendarColumn[] {
+  const fixed = (list: CalendarColumn[]) =>
+    list.reduce((sum, column) => sum + (column.id === "company" ? 0 : tableColumnWidth(column)) + TABLE_COLUMN_GAP, 2);
+  let columns = localClock ? ALL_COLUMNS : ALL_COLUMNS.filter((column) => column.id !== "local");
+  for (const id of DROP_ORDER) {
+    if (fixed(columns) + COMPANY_MIN_WIDTH <= width) break;
+    columns = columns.filter((column) => column.id !== id);
+  }
+  const companyWidth = Math.max(COMPANY_MIN_WIDTH, width - fixed(columns));
+  return columns.map((column) => (column.id === "company" ? { ...column, width: companyWidth } : column));
+}
+
+function renderCalendarCell(row: CalendarRow, column: CalendarColumn, now: number): DataTableCell {
+  if (!isSectionedItemRow(row)) return { text: "" };
+  const call = row.item;
+  // A call already over is shown and quieter, as a row that no longer applies is.
+  const over = !isUpcomingCall(call, now);
+  const tone = (color: string) => (over ? colors.textMuted : color);
+  switch (column.id) {
+    case "ticker":
+      return { text: call.ticker, color: tone(colors.text), attributes: over ? undefined : TextAttributes.BOLD };
+    case "company":
+      return { text: call.companyName ?? call.ticker, color: tone(colors.text) };
+    case "local": {
+      const clock = callLocalClock(call);
+      return clock ? { text: clock, color: tone(colors.text) } : { text: MISSING, color: colors.textMuted };
+    }
+    case "newYork": {
+      const clock = callNewYorkClock(call);
+      return clock ? { text: clock, color: tone(colors.textDim) } : { text: MISSING, color: colors.textMuted };
+    }
+    case "period":
+      return { text: formatPeriod(call.fiscalYear, call.fiscalQuarter), color: tone(colors.textDim) };
+    case "away":
+      return { text: calendarAway(call, now), color: over ? colors.textMuted : colors.textBright };
+  }
+}
+
+function matches(call: CloudEarningsCallPayload, query: string): boolean {
+  return `${call.ticker} ${call.companyName ?? ""}`.toLowerCase().includes(query);
+}
+
+interface CompanyCallsProps {
+  ticker: string;
+  focused: boolean;
+  height: number;
+  /** The company's view says when it holds Back, Esc and Backspace (a call open, its search focused). */
+  onHoldsKeys: (holds: boolean) => void;
+}
+
+interface UpcomingCallsViewProps {
+  focused: boolean;
+  width: number;
+  height: number;
+  view: QueryBarView<CallsView>;
+  /** A company's calls, opened from the calendar in its place. */
+  renderCompany: (props: CompanyCallsProps) => ReactNode;
+}
+
+const NO_CALLS: CloudEarningsCallPayload[] = [];
+
+/**
+ * CALLS alone: every company's calls today, the next session and the rest of
+ * that week, as ERN's board lays out its days. Enter opens the company's calls.
+ */
+export function UpcomingCallsView({ focused, width, height, view, renderCompany }: UpcomingCallsViewProps) {
+  const access = usePlanAccess();
+  const entitled = access.signedIn && access.emailVerified && access.hasProAccess;
+  // The days move at New York's midnight; the countdowns on a coarse clock.
+  const [loadedAt, setLoadedAt] = useState<number | null>(null);
+  const now = useAgeClock(loadedAt);
+  const today = newYorkToday(new Date(now));
+  const days = useMemo(() => calendarDays(Date.parse(`${today}T12:00:00-05:00`)), [today]);
+  const range = useMemo(() => ({ from: days[0]!.from, to: days.at(-1)!.to }), [days]);
+
+  const refusal = useRef<number | undefined>(undefined);
+  const loader = useCallback(async (force: boolean): Promise<UpcomingCallsResult> => {
+    try {
+      const result = await loadUpcomingCalls(range, { force });
+      refusal.current = result.errorStatus;
+      return result;
+    } catch (error) {
+      refusal.current = statusOf(error);
+      throw error;
+    }
+  }, [range]);
+  const resource = useAsyncResource(entitled ? loader : null, {
+    keepPreviousData: true,
+    initialData: () => cachedUpcomingCalls(range),
+  });
+  const data = resource.data;
+  useEffect(() => {
+    if (data) setLoadedAt(data.fetchedAt);
+  }, [data]);
+  useAutoRefresh(resource.updatedAt, resource.load);
+
+  const [openTicker, setOpenTicker] = usePluginPaneState<string | null>("calendar:open", null);
+  const [selectedKey, setSelectedKey] = usePluginPaneState<string | null>("calendar:selected", null);
+  const [sort, setSort] = useState<CalendarSort>(DEFAULT_CALENDAR_SORT);
+  const [query, setQuery] = useState("");
+  const { active: searchFocused, focus: focusSearch, blur: blurSearch, searchProps } = useQueryBarSearch();
+  // The company's own view takes Back while a call is open in it or its search has the keys.
+  const [companyHoldsKeys, setCompanyHoldsKeys] = useState(false);
+
+  const calls = data?.calls ?? NO_CALLS;
+  const rows = useMemo(() => {
+    const needle = query.trim().toLowerCase();
+    const shown = needle ? calls.filter((call) => matches(call, needle)) : calls;
+    return buildSectionedRows(calendarSections(shown, days, sort), (call) => call.id);
+  }, [calls, days, query, sort]);
+  const callRows = useMemo(() => rows.filter(isSectionedItemRow), [rows]);
+  // The cursor starts on the next call, so the day's calls already over sit above it.
+  const selected = callRows.find((row) => row.key === selectedKey)
+    ?? callRows.find((row) => isUpcomingCall(row.item, now))
+    ?? callRows[0]
+    ?? null;
+  const localClock = useMemo(() => !clockIsNewYork(calls, now), [calls, now]);
+  const columns = useMemo(() => calendarColumns(width, { localClock }), [localClock, width]);
+  const renderCell = useCallback((row: CalendarRow, column: CalendarColumn) => renderCalendarCell(row, column, now), [now]);
+
+  const openCall = openTicker ? calls.find((call) => call.ticker === openTicker) ?? null : null;
+  const detailOpen = !!openTicker && entitled;
+  const reload = useCallback(() => void resource.reload(), [resource.reload]);
+
+  const refused = refusal.current;
+  const signInRequired = !access.signedIn || (!data && refused === 401);
+  const verificationRequired = !signInRequired && (!access.emailVerified || (!data && refused === 403));
+  const proRequired = !signInRequired && !verificationRequired && (!access.hasProAccess || (!data && refused === 402));
+
+  const hints = useMemo<PaneHint[]>(() => [{ id: "search", key: "/", label: "search", onPress: focusSearch }], [focusSearch]);
+  usePaneStatusFooter({
+    registrationId: "earnings-calls:calendar",
+    enabled: !detailOpen && entitled,
+    loading: resource.loading && !!data,
+    error: data ? data.refreshError ?? resource.error : null,
+    stale: !!data && (data.stale || !!resource.error),
+    hints,
+  });
+  // A calendar cut at the server's limit says so, rather than end the week early.
+  usePaneNoticeFooter({
+    registrationId: "earnings-calls:calendar-notices",
+    focused,
+    enabled: !detailOpen && entitled,
+    notices: data?.truncated ? [upcomingCutNotice(data.calls)] : [],
+  });
+
+  const handleRootKey = useCallback((event: DataTableKeyEvent, context: DataTableRootKeyContext) => {
+    if (context.selectedIndex <= 0 && isPlainArrowUp(event)) {
+      stopSearchFocusNavigation(event);
+      focusSearch();
+      return true;
+    }
+    return handleRefreshKey(event, reload, { stopPropagation: true });
+  }, [focusSearch, reload]);
+
+  if (signInRequired || verificationRequired) {
+    return (
+      <SignInWall
+        placement="calls-signin" width={width} height={height} symbol={null}
+        action="browse earnings call transcripts" needsVerification={verificationRequired}
+      />
+    );
+  }
+  if (proRequired) {
+    return (
+      <ProWall
+        placement="calls-wall" width={width} height={height} symbol={null}
+        title="Earnings call transcripts are part of Gloom Cloud Pro."
+        message="Every company's earnings calls this week with their start times, then each call's full transcript with speaker attribution, analyst Q&A, and extracted guidance, risks and tone."
+      />
+    );
+  }
+
+  const sortColumn = (Object.entries(SORTABLE).find(([id, value]) => value === sort.column && (id !== "local" || localClock))?.[0]) ?? null;
+  return (
+    <DataTableStackView<CalendarRow, CalendarColumn>
+      focused={focused && !searchFocused && !companyHoldsKeys}
+      detailOpen={detailOpen}
+      onBack={() => setOpenTicker(null)}
+      detailTitle={openTicker ? (openCall?.companyName ? `${openTicker} · ${openCall.companyName}` : openTicker) : undefined}
+      detailContent={detailOpen && openTicker
+        ? renderCompany({ ticker: openTicker, focused, height: Math.max(4, height - 1), onHoldsKeys: setCompanyHoldsKeys })
+        : null}
+      rootBefore={
+        <QueryBar
+          width={width}
+          search={{
+            value: query,
+            onChange: setQuery,
+            placeholder: "ticker or company",
+            focused: focused && !detailOpen,
+            ...searchProps,
+            debounceMs: 80,
+          }}
+          view={view}
+        />
+      }
+      status={data ? undefined : { loading: resource.loading, error: resource.error, subject: "the earnings call calendar" }}
+      onRootKeyDown={handleRootKey}
+      rootWidth={width}
+      rootHeight={Math.max(2, height)}
+      columns={columns}
+      items={rows}
+      getItemKey={(row) => row.key}
+      isNavigable={isSectionedItemRow}
+      renderSectionHeader={renderSectionedRowHeader}
+      renderCell={renderCell}
+      selectedTextOverridesCellColor
+      sortColumnId={sortColumn}
+      sortDirection={sort.direction}
+      onHeaderClick={(columnId) => {
+        const column = SORTABLE[columnId as CalendarColumnId];
+        if (!column) return;
+        setSort((current) => current.column === column
+          ? { column, direction: current.direction === "asc" ? "desc" : "asc" }
+          : { column, direction: "asc" });
+      }}
+      selection={{
+        kind: "index",
+        selectedIndex: selected ? rows.indexOf(selected) : -1,
+        onChange: (_index, row) => { if (isSectionedItemRow(row)) setSelectedKey(row.key); },
+      }}
+      onActivate={(row) => {
+        if (!isSectionedItemRow(row)) return;
+        blurSearch();
+        setSelectedKey(row.key);
+        setOpenTicker(row.item.ticker);
+      }}
+      resetScrollKey={`${range.from}:${query}`}
+      emptyStateTitle={query.trim() ? "No matching calls." : "No calls on the calendar these days."}
+      emptyStateHint={query.trim() ? "Clear the search to see every call." : undefined}
+    />
+  );
+}