gloomberb 0.13.1 → 0.13.2

package/src/plugins/builtin/research/analyst-pane.tsx

@@ -4,43 +4,36 @@ import {
   DataTableView,
   usePaneFooter,
   type DataTableCell,
-  type DataTableColumn,
   type DataTableKeyEvent,
 } from "../../../components";
-import type { AnalystRatingRecord, AnalystResearchData } from "../../../types/financials";
+import type { AnalystResearchData } from "../../../types/financials";
 import { blendHex, colors, priceColor } from "../../../theme/colors";
-import { formatCurrency, formatNumber, formatPercent } from "../../../utils/format";
-import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
+import { formatCurrency, formatPercent } from "../../../utils/format";
 import { useAssetData } from "../../runtime";
 import { handleRefreshKey, loadingErrorFooterInfo } from "../shared/table-pane";
 import { useBoundTicker as useSymbolBinding, useTickerRequest } from "../shared/ticker-request";
-
-function compactPeriod(period: string): string {
-  return period
-    .replace("current ", "")
-    .replace("previous ", "prev ")
-    .replace("next_", "next ")
-    .replace(/_/g, " ");
-}
-
-function targetUpside(target: AnalystResearchData["priceTarget"]): number | undefined {
-  if (!target?.average || !target.current) return undefined;
-  return (target.average - target.current) / target.current;
-}
-
-function latestRecommendation(data: AnalystResearchData | null) {
-  return data?.recommendations[0] ?? null;
-}
-
-function recommendationTotal(data: AnalystResearchData | null): number {
-  const rec = latestRecommendation(data);
-  if (!rec) return 0;
-  return (rec.strongBuy ?? 0) + (rec.buy ?? 0) + (rec.hold ?? 0) + (rec.sell ?? 0) + (rec.strongSell ?? 0);
-}
-
-function formatRatingLabel(value: number | undefined): string {
-  return value == null ? "-" : `${formatNumber(value, 1)}/10`;
-}
+import { loadAnalystResearch } from "./client";
+import {
+  DEFAULT_RATING_SORT,
+  buildAnalystSummaryLines,
+  buildRatingColumns,
+  formatRatingTarget,
+  nextRatingSortPreference,
+  ratingTargetDelta,
+  sortRatingRows,
+  targetUpside,
+  type RatingColumn,
+  type RatingSortPreference,
+} from "./analyst-model";
+
+export {
+  buildAnalystSummaryLines,
+  buildRatingColumns,
+  formatRatingTarget,
+  nextRatingSortPreference,
+  sortRatingRows,
+  type RatingSortPreference,
+} from "./analyst-model";
 
 function ratingActionColor(action: string | undefined): string {
   const normalized = action?.toLowerCase() ?? "";
@@ -49,41 +42,6 @@ function ratingActionColor(action: string | undefined): string {
   return colors.textDim;
 }
 
-function formatPriceTarget(value: number | undefined, currency: string): string {
-  if (value == null) return "-";
-  return formatCurrency(value, currency)
-    .replace(/\.00\b/, "")
-    .replace(/(\.\d)0\b/, "$1");
-}
-
-const TARGET_SEPARATOR = " → ";
-
-interface RatingTargetColumnSizing {
-  targetPriorWidth: number;
-  targetCurrentWidth: number;
-}
-
-export function formatRatingTarget(
-  row: AnalystResearchData["ratings"][number],
-  currency: string,
-  sizing?: Partial<RatingTargetColumnSizing>,
-): string {
-  const current = row.currentPriceTarget;
-  const prior = row.priorPriceTarget;
-  if (current == null && prior == null) return "-";
-  if (current == null) return ` ${formatPriceTarget(prior, currency)}`;
-  if (prior == null) return ` ${formatPriceTarget(current, currency)}`;
-
-  const priorText = formatPriceTarget(prior, currency).padStart(sizing?.targetPriorWidth ?? 0);
-  const currentText = formatPriceTarget(current, currency).padEnd(sizing?.targetCurrentWidth ?? 0);
-  return ` ${priorText}${TARGET_SEPARATOR}${currentText}`;
-}
-
-function ratingTargetDelta(row: AnalystResearchData["ratings"][number]): number | null {
-  if (row.currentPriceTarget == null || row.priorPriceTarget == null) return null;
-  return row.currentPriceTarget - row.priorPriceTarget;
-}
-
 function ratingTargetBackground(delta: number | null): string | undefined {
   if (delta == null || delta === 0) return undefined;
   return blendHex(colors.bg, delta > 0 ? colors.positive : colors.negative, 0.42);
@@ -93,30 +51,6 @@ function ratingTargetBackground(delta: number | null): string | undefined {
  * Price targets and the recommendation mix are pane content, not status, so the
  * summary block owns them and the footer stays empty unless something changed.
  */
-export function buildAnalystSummaryLines(data: AnalystResearchData | null): string[] {
-  if (!data) return [];
-
-  const target = data.priceTarget;
-  const currency = target?.currency ?? data.currency ?? "USD";
-  const price = (value: number | undefined) => value != null ? formatCurrency(value, currency) : "-";
-  const rec = latestRecommendation(data);
-  const total = recommendationTotal(data);
-  const lines: string[] = [];
-
-  if (target) {
-    lines.push(`low ${price(target.low)}   med ${price(target.median)}   high ${price(target.high)}`);
-  }
-  if (data.recommendationRating != null || rec || total > 0) {
-    lines.push([
-      data.recommendationRating != null ? `rating ${formatRatingLabel(data.recommendationRating)}` : null,
-      rec ? `SB ${rec.strongBuy ?? 0}  B ${rec.buy ?? 0}  H ${rec.hold ?? 0}  S ${(rec.sell ?? 0) + (rec.strongSell ?? 0)}` : null,
-      total > 0 ? `${total} analysts${rec?.period ? ` (${compactPeriod(rec.period)})` : ""}` : null,
-    ].filter(Boolean).join("   "));
-  }
-
-  return lines;
-}
-
 function AnalystSummary({ data }: { data: AnalystResearchData | null }) {
   const target = data?.priceTarget;
   const upside = targetUpside(target);
@@ -147,142 +81,18 @@ function AnalystSummary({ data }: { data: AnalystResearchData | null }) {
   );
 }
 
-type RatingColumnId = "date" | "firm" | "action" | "current" | "target" | "prior";
-type RatingColumn = DataTableColumn & { id: RatingColumnId } & Partial<RatingTargetColumnSizing>;
-
-export interface RatingSortPreference {
-  columnId: RatingColumnId;
-  direction: SortDirection;
-}
-
-const DEFAULT_RATING_SORT: RatingSortPreference = {
-  columnId: "date",
-  direction: "desc",
-};
-
-const DEFAULT_RATING_SORT_DIRECTIONS: Record<RatingColumnId, SortDirection> = {
-  date: "desc",
-  firm: "asc",
-  action: "asc",
-  current: "asc",
-  target: "desc",
-  prior: "asc",
-};
-
-const BASE_RATING_COLUMNS: RatingColumn[] = [
-  { id: "date", label: "DATE", width: 10, align: "left" },
-  { id: "firm", label: "FIRM", width: 20, align: "left" },
-  { id: "action", label: "ACTION", width: 10, align: "left" },
-  { id: "current", label: "RATING", width: 13, align: "left" },
-  { id: "target", label: "TARGET", width: 13, align: "left" },
-  { id: "prior", label: "PRIOR", width: 13, align: "left" },
-];
-
-export function buildRatingColumns(
-  rows: readonly AnalystRatingRecord[],
-  currency: string,
-): RatingColumn[] {
-  const targetSizing = rows.reduce<RatingTargetColumnSizing>(
-    (sizing, row) => ({
-      targetPriorWidth: Math.max(
-        sizing.targetPriorWidth,
-        row.priorPriceTarget == null ? 0 : formatPriceTarget(row.priorPriceTarget, currency).length,
-      ),
-      targetCurrentWidth: Math.max(
-        sizing.targetCurrentWidth,
-        row.currentPriceTarget == null ? 0 : formatPriceTarget(row.currentPriceTarget, currency).length,
-      ),
-    }),
-    { targetPriorWidth: 0, targetCurrentWidth: 0 },
-  );
-  const targetWidth = rows.reduce(
-    (width, row) => Math.max(width, formatRatingTarget(row, currency, targetSizing).length),
-    BASE_RATING_COLUMNS.find((column) => column.id === "target")?.width ?? 13,
-  );
-
-  return BASE_RATING_COLUMNS.map((column) => {
-    return column.id === "target" ? { ...column, ...targetSizing, width: targetWidth } : column;
-  });
-}
-
-function normalizedText(value: string | undefined): string | null {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed.toLocaleLowerCase() : null;
-}
-
-function ratingTargetSortValue(row: AnalystRatingRecord): number | null {
-  return row.currentPriceTarget ?? row.priorPriceTarget ?? null;
-}
-
-function ratingSortValue(row: AnalystRatingRecord, columnId: RatingColumnId): string | number | null {
-  switch (columnId) {
-    case "date":
-      return normalizedText(row.date);
-    case "firm":
-      return normalizedText(row.firm);
-    case "action":
-      return normalizedText(row.action);
-    case "current":
-      return normalizedText(row.current);
-    case "target":
-      return ratingTargetSortValue(row);
-    case "prior":
-      return normalizedText(row.prior);
-  }
-}
-
-export function sortRatingRows<T extends AnalystRatingRecord>(
-  rows: readonly T[],
-  preference: RatingSortPreference,
-): T[] {
-  return rows
-    .map((row, index) => ({ row, index }))
-    .sort((left, right) => {
-      const primary = compareSortValues(
-        ratingSortValue(left.row, preference.columnId),
-        ratingSortValue(right.row, preference.columnId),
-        preference.direction,
-      );
-      if (primary !== 0) return primary;
-
-      const dateTieBreak = preference.columnId === "date"
-        ? 0
-        : compareSortValues(
-          ratingSortValue(left.row, "date"),
-          ratingSortValue(right.row, "date"),
-          "desc",
-        );
-      if (dateTieBreak !== 0) return dateTieBreak;
-
-      return left.index - right.index;
-    })
-    .map((entry) => entry.row);
-}
-
-export function nextRatingSortPreference(
-  current: RatingSortPreference,
-  columnId: string,
-): RatingSortPreference {
-  const typedColumnId = columnId as RatingColumnId;
-  if (current.columnId !== typedColumnId) {
-    return {
-      columnId: typedColumnId,
-      direction: DEFAULT_RATING_SORT_DIRECTIONS[typedColumnId] ?? "asc",
-    };
-  }
-  return {
-    columnId: typedColumnId,
-    direction: current.direction === "asc" ? "desc" : "asc",
-  };
-}
-
 export function AnalystResearchView({ focused, width, height }: { focused: boolean; width: number; height: number }) {
   const dataProvider = useAssetData();
   const { symbol, exchange } = useSymbolBinding();
   const [sortPreference, setSortPreference] = useState<RatingSortPreference>(DEFAULT_RATING_SORT);
   const loader = useCallback((nextSymbol: string, nextExchange: string, forceRefresh: boolean) => {
-    if (!dataProvider?.getAnalystResearch) throw new Error("Analyst data unavailable");
-    return dataProvider.getAnalystResearch(nextSymbol, nextExchange, forceRefresh ? { cacheMode: "refresh" } : undefined);
+    if (!dataProvider) throw new Error("Analyst data unavailable");
+    return loadAnalystResearch(
+      dataProvider,
+      nextSymbol,
+      nextExchange,
+      forceRefresh ? { cacheMode: "refresh" } : undefined,
+    );
   }, [dataProvider]);
   const { data, loading, error, reload } = useTickerRequest<AnalystResearchData>(loader, symbol, exchange);
   const rows = useMemo(() => sortRatingRows(data?.ratings ?? [], sortPreference), [data?.ratings, sortPreference]);

package/src/plugins/builtin/research/client.ts

@@ -0,0 +1,12 @@
+import type { DataProvider, MarketDataRequestContext } from "../../../types/data-provider";
+import type { AnalystResearchData } from "../../../types/financials";
+
+export async function loadAnalystResearch(
+  provider: DataProvider,
+  symbol: string,
+  exchange = "",
+  context?: MarketDataRequestContext,
+): Promise<AnalystResearchData> {
+  if (!provider.getAnalystResearch) throw new Error("Analyst data unavailable");
+  return provider.getAnalystResearch(symbol, exchange, context);
+}

package/src/plugins/builtin/research/headless.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import {
+  createEarningsEstimatesHeadless,
+  type EarningsEstimateSources,
+} from "./headless";
+
+const sources: EarningsEstimateSources = {
+  currency: "USD",
+  actions: {
+    symbol: "AMD",
+    currency: "USD",
+    dividends: [],
+    splits: [],
+    earnings: [{
+      date: "2026-07-28",
+      epsEstimate: 0.45,
+      epsActual: 0.48,
+      difference: 0.03,
+      surprisePercent: 6.67,
+    }],
+  },
+  estimates: {
+    symbol: "AMD",
+    currency: "USD",
+    recommendations: [],
+    ratings: [],
+    earningsEstimates: [
+      { date: "2026-09-30", period: "next_quarter", average: 1.2, analysts: 30 },
+      { date: "2026-12-31", period: "current_year", average: 4.8, analysts: 32 },
+    ],
+    revenueEstimates: [
+      { date: "2026-09-30", period: "next_quarter", average: 9_000_000_000, analysts: 28 },
+      { date: "2026-12-31", period: "current_year", average: 35_000_000_000, analysts: 29 },
+    ],
+  },
+  financials: {
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+  },
+};
+
+function args(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("earnings estimates headless", () => {
+  test("maps the shared event model into estimate rows", async () => {
+    const definition = createEarningsEstimatesHeadless({
+      loadSources: async () => sources,
+    });
+
+    const result = await definition.load(args({ kind: "all", limit: 50 }), context);
+
+    expect(result.rows).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        status: "Q Est",
+        period: "next qtr",
+        qEps: 1.2,
+        qRevenue: 9_000_000_000,
+        detail: "30E/28R",
+      }),
+      expect.objectContaining({
+        status: "FY Est",
+        annualEps: 4.8,
+        annualRevenue: 35_000_000_000,
+      }),
+      expect.objectContaining({
+        status: "Earnings",
+        qEps: 0.48,
+        value: "+6.67%",
+      }),
+    ]));
+  });
+
+  test("applies kind and limit options", async () => {
+    const definition = createEarningsEstimatesHeadless({ loadSources: async () => sources });
+
+    const result = await definition.load(args({ kind: "estimates", limit: 1 }), context);
+
+    expect(result.rows).toHaveLength(1);
+    expect(["Q Est", "FY Est"]).toContain(result.rows[0]?.status);
+    expect(result.metadata).toMatchObject({ kind: "estimates", total: 2, truncated: true });
+  });
+});

package/src/plugins/builtin/research/headless.ts

@@ -0,0 +1,161 @@
+import type {
+  AnalystResearchData,
+  CorporateActionsData,
+  TickerFinancials,
+} from "../../../types/financials";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import { buildEventRows, type EventRow } from "./event-model";
+
+const ESTIMATE_COLUMNS = [
+  { key: "date", header: "Date" },
+  { key: "status", header: "Event" },
+  { key: "period", header: "Period" },
+  { key: "qEps", header: "Q EPS", align: "right" as const },
+  { key: "qRevenue", header: "Q revenue", align: "right" as const },
+  { key: "annualEps", header: "Annual EPS", align: "right" as const },
+  { key: "annualRevenue", header: "Annual revenue", align: "right" as const },
+  { key: "value", header: "Value", align: "right" as const },
+  { key: "detail", header: "Detail" },
+];
+
+export interface EarningsEstimateSources {
+  actions: CorporateActionsData | null;
+  estimates: AnalystResearchData | null;
+  financials: TickerFinancials | null;
+  currency: string;
+  errors?: string[];
+}
+
+export interface EarningsEstimatesHeadlessDependencies {
+  loadSources(
+    symbol: string,
+    context: HeadlessPaneContext,
+  ): Promise<EarningsEstimateSources>;
+}
+
+async function settledValue<T>(
+  promise: Promise<T> | null,
+  errors: string[],
+  label: string,
+): Promise<T | null> {
+  if (!promise) return null;
+  try {
+    return await promise;
+  } catch (error) {
+    errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+
+const defaultDependencies: EarningsEstimatesHeadlessDependencies = {
+  async loadSources(symbol, context) {
+    const errors: string[] = [];
+    const provider = context.marketData;
+    const [actions, estimates, financials] = await Promise.all([
+      settledValue(
+        provider.getCorporateActions?.(symbol, "") ?? null,
+        errors,
+        "corporate actions",
+      ),
+      settledValue(
+        provider.getAnalystResearch?.(symbol, "") ?? null,
+        errors,
+        "analyst estimates",
+      ),
+      settledValue(provider.getTickerFinancials(symbol, ""), errors, "financials"),
+    ]);
+    if (!actions && !estimates && !financials && errors.length > 0) {
+      throw new Error(errors.join("; "));
+    }
+    return {
+      actions,
+      estimates,
+      financials,
+      currency: actions?.currency ?? estimates?.currency ?? financials?.quote?.currency ?? "USD",
+      errors,
+    };
+  },
+};
+
+function matchesKind(row: EventRow, kind: string): boolean {
+  if (kind === "all") return true;
+  if (kind === "estimates") return row.status === "Q Est" || row.status === "FY Est";
+  return row.status === "Earnings" || row.status === "TTM";
+}
+
+export function projectEarningsEstimatesHeadless(
+  sources: EarningsEstimateSources,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const kind = String(args.options.kind ?? "all");
+  const limit = Number(args.options.limit ?? 50);
+  const matching = buildEventRows(
+    sources.actions,
+    sources.estimates,
+    sources.financials,
+    sources.currency,
+  ).filter((row) => matchesKind(row, kind));
+  const rows = matching.slice(0, limit).map((row) => ({ ...row }));
+
+  return {
+    columns: ESTIMATE_COLUMNS,
+    rows,
+    errors: sources.errors?.length ? sources.errors : undefined,
+    metadata: {
+      currency: sources.currency,
+      kind,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+    },
+  };
+}
+
+export function createEarningsEstimatesHeadless(
+  dependencies: EarningsEstimatesHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Company symbol.",
+    },
+    options: [
+      {
+        key: "kind",
+        description: "Estimate or reported rows to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "estimates" },
+          { value: "reported" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: ESTIMATE_COLUMNS,
+    describe: (args) => `Earnings Estimates | ${String(args.argument)}`,
+    async load(args, context) {
+      return projectEarningsEstimatesHeadless(
+        await dependencies.loadSources(String(args.argument), context),
+        args,
+      );
+    },
+  };
+}
+
+export const earningsEstimatesHeadless = createEarningsEstimatesHeadless();

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

@@ -5,9 +5,13 @@ import { AnalystResearchView } from "./analyst-pane";
 import { CorporateActionsView } from "./corporate-actions-pane";
 import { EquityDiagnosticView } from "./equity-diagnostic-pane";
 import { RelativeValuationPane } from "./relative-valuation-pane";
+import { analystResearchHeadless } from "./analyst-headless";
 import { eventsHeadless } from "./events-headless";
+import { earningsEstimatesHeadless } from "./headless";
 
+export { analystResearchHeadless } from "./analyst-headless";
 export { eventsHeadless } from "./events-headless";
+export { earningsEstimatesHeadless } from "./headless";
 
 function EarningsEstimatesPane(props: { focused: boolean; width: number; height: number }) {
   return (
@@ -98,15 +102,18 @@ export const researchModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "analyst-research-pane",
-      paneId: "analyst-research",
-      label: "Analyst Research",
-      description: "Price targets, recommendations, and recent analyst actions.",
-      keywords: ["analyst", "research", "ratings", "target", "anr"],
-      shortcut: "ANR",
-      publicShare: true,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "analyst-research-pane",
+        paneId: "analyst-research",
+        label: "Analyst Research",
+        description: "Price targets, recommendations, and recent analyst actions.",
+        keywords: ["analyst", "research", "ratings", "target", "anr"],
+        shortcut: "ANR",
+        publicShare: true,
+      }),
+      headless: analystResearchHeadless,
+    },
     createTickerSurfacePaneTemplate({
       id: "equity-diagnostic-pane",
       paneId: "equity-diagnostic",
@@ -125,15 +132,18 @@ export const researchModule: PluginModule = {
       shortcut: "EVT",
       publicShare: true,
     }),
-    createTickerSurfacePaneTemplate({
-      id: "earnings-estimates-pane",
-      paneId: "earnings-estimates",
-      label: "Earnings Estimates",
-      description: "EPS and revenue estimates with reported earnings.",
-      keywords: ["earnings", "estimates", "ee", "analyst", "eps", "revenue", "events"],
-      shortcut: "EE",
-      publicShare: true,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "earnings-estimates-pane",
+        paneId: "earnings-estimates",
+        label: "Earnings Estimates",
+        description: "EPS and revenue estimates with reported earnings.",
+        keywords: ["earnings", "estimates", "ee", "analyst", "eps", "revenue", "events"],
+        shortcut: "EE",
+        publicShare: true,
+      }),
+      headless: earningsEstimatesHeadless,
+    },
     {
       id: "relative-valuation-pane",
       paneId: "relative-valuation",

package/src/plugins/builtin/sec/client.ts

@@ -0,0 +1,16 @@
+import type {
+  DataProvider,
+  MarketDataRequestContext,
+  SecFilingItem,
+} from "../../../types/data-provider";
+
+export async function loadSecFilings(
+  provider: DataProvider,
+  symbol: string,
+  count: number,
+  exchange = "",
+  context?: MarketDataRequestContext,
+): Promise<SecFilingItem[]> {
+  if (!provider.getSecFilings) throw new Error("SEC filing data unavailable");
+  return provider.getSecFilings(symbol, count, exchange, context);
+}