gloomberb 0.13.1 → 0.13.3

package/src/plugins/builtin/congress-trades/headless.ts

@@ -0,0 +1,145 @@
+import type {
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import type { CloudCongressHousePayload } from "../../../api-client";
+import { loadCongressHouse } from "./client";
+import {
+  CONGRESS_FILING_LIMIT,
+  CONGRESS_TRADE_LIMIT,
+  formatAmountRange,
+  formatLag,
+  formatShortDate,
+  sortedMembers,
+  sortedTrades,
+} from "./model";
+
+const TRADE_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "filingDate", header: "Filed", format: (value) => formatShortDate(typeof value === "string" ? value : null) },
+  { key: "transactionDate", header: "Tx", format: (value) => formatShortDate(typeof value === "string" ? value : null) },
+  { key: "lagDays", header: "Lag", align: "right", format: (value) => formatLag(typeof value === "number" ? value : null) },
+  { key: "memberName", header: "Member" },
+  { key: "side", header: "Side" },
+  { key: "ticker", header: "Ticker" },
+  {
+    key: "amountLow",
+    header: "Amount",
+    align: "right",
+    format: (value, row) => formatAmountRange(
+      typeof value === "number" ? value : null,
+      typeof row.amountHigh === "number" ? row.amountHigh : null,
+      typeof row.amount === "string" ? row.amount : undefined,
+    ),
+  },
+  { key: "owner", header: "Owner" },
+];
+
+const MEMBER_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "memberName", header: "Member" },
+  { key: "stateDistrict", header: "Dist" },
+  { key: "tradeCount", header: "Trades", align: "right" },
+  { key: "buyCount", header: "Buy", align: "right" },
+  { key: "sellCount", header: "Sell", align: "right" },
+  {
+    key: "estimatedLow",
+    header: "Est Range",
+    align: "right",
+    format: (value, row) => formatAmountRange(
+      typeof value === "number" ? value : null,
+      typeof row.estimatedHigh === "number" ? row.estimatedHigh : null,
+    ),
+  },
+  { key: "lastFilingDate", header: "Last", format: (value) => formatShortDate(typeof value === "string" ? value : null) },
+  { key: "avgLagDays", header: "Avg", align: "right", format: (value) => formatLag(typeof value === "number" ? value : null) },
+];
+
+export interface CongressHeadlessDependencies {
+  loadHouse(
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<CloudCongressHousePayload>;
+}
+
+const defaultDependencies: CongressHeadlessDependencies = {
+  loadHouse: (args, ctx) => loadCongressHouse({
+    year: Number(args.options.year),
+    limit: CONGRESS_TRADE_LIMIT,
+    filingLimit: CONGRESS_FILING_LIMIT,
+  }, ctx.apiClient),
+};
+
+export function createCongressHeadless(
+  dependencies: CongressHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "none",
+      description: "The House PTR feed does not require an argument.",
+    },
+    options: [
+      {
+        key: "tab",
+        description: "Congress pane tab.",
+        type: "enum",
+        values: [{ value: "trades" }, { value: "members" }],
+        defaultValue: "trades",
+        pluginState: { pluginId: "gloomberb-cloud", key: "activeTab" },
+      },
+      {
+        key: "year",
+        description: "House disclosure year.",
+        type: "integer",
+        defaultValue: new Date().getUTCFullYear(),
+        minimum: 2008,
+        maximum: 2100,
+      },
+      {
+        key: "limit",
+        aliases: ["count", "rows"],
+        description: "Maximum rows.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    describe: (args) => `Congress Trades | ${args.options.tab === "members" ? "Members" : "Trades"}`,
+    async load(args, ctx) {
+      const payload = await dependencies.loadHouse(args, ctx);
+      const limit = Number(args.options.limit);
+      if (args.options.tab === "members") {
+        const rows = sortedMembers(payload.members, { columnId: "trades", direction: "desc" })
+          .slice(0, limit)
+          .map((member) => ({ ...member }));
+        return {
+          columns: MEMBER_COLUMNS,
+          rows,
+          metadata: {
+            asOf: payload.asOf,
+            chamber: payload.chamber,
+            source: payload.source,
+            year: payload.year,
+          },
+        };
+      }
+      const rows = sortedTrades(payload.trades, { columnId: "filed", direction: "desc" })
+        .slice(0, limit)
+        .map((trade) => ({ ...trade }));
+      return {
+        columns: TRADE_COLUMNS,
+        rows,
+        metadata: {
+          asOf: payload.asOf,
+          chamber: payload.chamber,
+          source: payload.source,
+          year: payload.year,
+        },
+      };
+    },
+  };
+}
+
+export const congressHeadless = createCongressHeadless();

package/src/plugins/builtin/congress-trades/pane.tsx

@@ -10,7 +10,6 @@ import { useDebouncedPluginPaneState, usePluginPaneState } from "../../runtime";
 import { useAutoRefresh } from "../shared/auto-refresh";
 import { useInlineTickerOpener } from "../../../state/hooks/inline-tickers";
 import {
-  apiClient,
   type CloudCongressHousePayload,
   type CloudCongressMemberPayload,
   type CloudCongressTradePayload,
@@ -46,6 +45,7 @@ import {
   renderCongressMemberCell,
   renderCongressTradeCell,
 } from "./table";
+import { loadCongressHouse } from "./client";
 
 export { CONGRESS_TRADES_PANE_ID } from "./model";
 
@@ -77,7 +77,7 @@ export function CongressTradesPane({ focused, width, height }: PaneProps) {
     setStatus((current) => (current === "loaded" && !refresh ? "loaded" : "loading"));
     setError(null);
     setLoadingMore(false);
-    apiClient.getCloudCongressHouse({
+    loadCongressHouse({
       limit: CONGRESS_TRADE_LIMIT,
       filingLimit: CONGRESS_FILING_LIMIT,
       refresh,
@@ -103,7 +103,7 @@ export function CongressTradesPane({ focused, width, height }: PaneProps) {
     if (!nextRequest) return;
     const gen = fetchGenRef.current;
     setLoadingMore(true);
-    apiClient.getCloudCongressHouse({
+    loadCongressHouse({
       ...nextRequest,
       limit: CONGRESS_TRADE_LIMIT,
       filingLimit: CONGRESS_FILING_LIMIT,

package/src/plugins/builtin/dividend-yield/headless.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import type { DividendData } from "./client";
+import { createDividendYieldHeadless } from "./headless";
+
+const fixture: DividendData = {
+  price: 200,
+  metrics: {
+    trailingYield: 0.005,
+    forwardYield: 0.0052,
+    trailingRate: 1,
+    forwardRate: 1.04,
+    payoutRatio: 0.14,
+    growth1Y: 0.04,
+    growth3Y: 0.03,
+    paymentFrequency: "quarterly",
+    exDividendDate: new Date("2026-08-10T00:00:00.000Z"),
+    nextPayDate: new Date("2026-08-17T00:00:00.000Z"),
+  },
+  payments: [
+    {
+      exDate: new Date("2026-08-10T00:00:00.000Z"),
+      recordDate: null,
+      paymentDate: null,
+      declarationDate: null,
+      amount: 0.26,
+      currency: "USD",
+      type: "cash",
+    },
+    {
+      exDate: new Date("2026-05-11T00:00:00.000Z"),
+      recordDate: null,
+      paymentDate: null,
+      declarationDate: null,
+      amount: 0.24,
+      currency: "USD",
+      type: "special",
+    },
+  ],
+};
+
+function args(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AAPL",
+    argument: "AAPL",
+    symbols: ["AAPL"],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("dividend yield headless", () => {
+  test("maps metrics and payment rows", async () => {
+    const definition = createDividendYieldHeadless({
+      loadData: async () => fixture,
+    });
+
+    const result = await definition.load(args({ type: "all", limit: 40 }), context);
+
+    expect(result.sections[0]).toMatchObject({
+      title: "Dividend metrics",
+      entries: expect.arrayContaining([
+        { label: "Trailing yield", value: 0.005 },
+        { label: "Frequency", value: "quarterly" },
+      ]),
+    });
+    expect(result.sections[1]).toMatchObject({
+      title: "Dividend history",
+      rows: [
+        expect.objectContaining({ exDate: "2026-08-10", amount: 0.26, type: "cash" }),
+        expect.objectContaining({ exDate: "2026-05-11", amount: 0.24, type: "special" }),
+      ],
+    });
+  });
+
+  test("applies type and limit options", async () => {
+    const definition = createDividendYieldHeadless({ loadData: async () => fixture });
+
+    const result = await definition.load(args({ type: "cash", limit: 1 }), context);
+    const history = result.sections[1];
+
+    expect(history).toMatchObject({
+      rows: [expect.objectContaining({ type: "cash" })],
+    });
+    expect(result.metadata).toMatchObject({ totalPayments: 1, returnedPayments: 1 });
+  });
+});

package/src/plugins/builtin/dividend-yield/headless.ts

@@ -0,0 +1,135 @@
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { fetchDividendData, type DividendData } from "./client";
+import type { DividendPayment } from "./types";
+import { toDividendRows } from "./view";
+
+const PAYMENT_COLUMNS = [
+  { key: "exDate", header: "Ex-date" },
+  { key: "amount", header: "Amount", align: "right" as const },
+  { key: "currency", header: "CCY" },
+  { key: "type", header: "Type" },
+];
+
+export interface DividendYieldHeadlessDependencies {
+  loadData(symbol: string, context: HeadlessPaneContext): Promise<DividendData>;
+}
+
+const defaultDependencies: DividendYieldHeadlessDependencies = {
+  async loadData(symbol, context) {
+    let currentPrice: number | null = null;
+    try {
+      currentPrice = (await context.marketData.getQuote(symbol, "")).price ?? null;
+    } catch {
+      currentPrice = null;
+    }
+    return fetchDividendData(symbol, currentPrice);
+  },
+};
+
+function matchesType(payment: DividendPayment, type: string): boolean {
+  return type === "all" || payment.type === type;
+}
+
+export function projectDividendYieldHeadless(
+  data: DividendData,
+  args: HeadlessPaneLoadArgs,
+): HeadlessBundleResult {
+  const type = String(args.options.type ?? "all");
+  const limit = Number(args.options.limit ?? 40);
+  const matching = data.payments.filter((payment) => matchesType(payment, type));
+  const selectedPayments = matching.slice(0, limit);
+  const rows = toDividendRows(selectedPayments).map((row, index) => {
+    const payment = selectedPayments[index];
+    return {
+      ...row,
+      recordDate: payment?.recordDate?.toISOString() ?? null,
+      paymentDate: payment?.paymentDate?.toISOString() ?? null,
+      declarationDate: payment?.declarationDate?.toISOString() ?? null,
+      type: payment?.type ?? null,
+    };
+  });
+  const metrics = data.metrics;
+
+  return {
+    sections: [
+      {
+        title: "Dividend metrics",
+        entries: [
+          { label: "Price", value: data.price },
+          { label: "Trailing yield", value: metrics.trailingYield },
+          { label: "Forward yield", value: metrics.forwardYield },
+          { label: "Trailing rate", value: metrics.trailingRate },
+          { label: "Forward rate", value: metrics.forwardRate },
+          { label: "Payout ratio", value: metrics.payoutRatio },
+          { label: "1Y growth", value: metrics.growth1Y },
+          { label: "3Y growth", value: metrics.growth3Y },
+          { label: "Frequency", value: metrics.paymentFrequency },
+          { label: "Ex-dividend", value: metrics.exDividendDate },
+          { label: "Next pay", value: metrics.nextPayDate },
+        ],
+      },
+      {
+        title: "Dividend history",
+        columns: PAYMENT_COLUMNS,
+        rows,
+      },
+    ],
+    metadata: {
+      totalPayments: matching.length,
+      returnedPayments: rows.length,
+      truncated: rows.length < matching.length,
+      type,
+    },
+  };
+}
+
+export function createDividendYieldHeadless(
+  dependencies: DividendYieldHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Company symbol.",
+    },
+    options: [
+      {
+        key: "type",
+        description: "Dividend payment type to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "cash" },
+          { value: "special" },
+          { value: "stock" },
+          { value: "unknown" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum historical payments to return.",
+        type: "integer",
+        defaultValue: 40,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    describe: (args) => `Dividend Yield | ${String(args.argument)}`,
+    async load(args, context) {
+      const symbol = String(args.argument);
+      return projectDividendYieldHeadless(
+        await dependencies.loadData(symbol, context),
+        args,
+      );
+    },
+  };
+}
+
+export const dividendYieldHeadless = createDividendYieldHeadless();

package/src/plugins/builtin/dividend-yield/index.tsx

@@ -6,6 +6,7 @@ import {
   YAHOO_DIVIDENDS_CONNECTION_ID,
 } from "./client";
 import { DividendYieldPane } from "./pane";
+import { dividendYieldHeadless } from "./headless";
 
 let disposeConnection: (() => void) | null = null;
 
@@ -50,13 +51,16 @@ export const dividendYieldModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "dividend-yield-pane",
-      paneId: "dividend-yield",
-      label: "Dividend Yield",
-      description: "Dividend history, trailing/forward yield, growth rates, and payment schedule.",
-      keywords: ["dividend", "yield", "dvd", "income", "payout", "ex-date", "distribution"],
-      shortcut: "DVD",
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "dividend-yield-pane",
+        paneId: "dividend-yield",
+        label: "Dividend Yield",
+        description: "Dividend history, trailing/forward yield, growth rates, and payment schedule.",
+        keywords: ["dividend", "yield", "dvd", "income", "payout", "ex-date", "distribution"],
+        shortcut: "DVD",
+      }),
+      headless: dividendYieldHeadless,
+    },
   ],
 };

package/src/plugins/builtin/dividend-yield/model.ts

@@ -1,17 +1,13 @@
 import type { DataTableColumn } from "../../../components";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
-import type { DividendPayment } from "./types";
+import type { DividendRow } from "./view";
+
+export { toDividendRows } from "./view";
+export type { DividendRow } from "./view";
 
 export type DividendColumnId = "exDate" | "amount" | "currency";
 export type DividendColumn = DataTableColumn & { id: DividendColumnId };
 
-export interface DividendRow {
-  key: string;
-  exDate: string;
-  amount: number;
-  currency: string;
-}
-
 export interface DividendSortPreference {
   columnId: DividendColumnId | null;
   direction: SortDirection;
@@ -67,17 +63,3 @@ export function nextSortPreference(
   }
   return DEFAULT_SORT_PREFERENCE;
 }
-
-export function toDividendRows(payments: DividendPayment[]): DividendRow[] {
-  return payments.map((p, i) => ({
-    key: `${p.exDate.toISOString()}:${i}`,
-    exDate: formatDate(p.exDate),
-    amount: p.amount,
-    currency: p.currency,
-  }));
-}
-
-function formatDate(date: Date): string {
-  const iso = date.toISOString();
-  return iso.slice(0, 10);
-}

package/src/plugins/builtin/dividend-yield/view.ts

@@ -0,0 +1,17 @@
+import type { DividendPayment } from "./types";
+
+export interface DividendRow {
+  key: string;
+  exDate: string;
+  amount: number;
+  currency: string;
+}
+
+export function toDividendRows(payments: DividendPayment[]): DividendRow[] {
+  return payments.map((payment, index) => ({
+    key: `${payment.exDate.toISOString()}:${index}`,
+    exDate: payment.exDate.toISOString().slice(0, 10),
+    amount: payment.amount,
+    currency: payment.currency,
+  }));
+}

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

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import type { EarningsEvent } from "../../../types/data-provider";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createEarningsCalendarHeadless } from "./headless";
+
+const events: EarningsEvent[] = [
+  {
+    symbol: "MSFT",
+    name: "Microsoft",
+    earningsDate: new Date("2026-09-08T20:00:00.000Z"),
+    earningsCallDate: new Date("2026-09-08T21:00:00.000Z"),
+    isDateEstimate: false,
+    epsEstimate: 3.67,
+    epsLow: 3.5,
+    epsHigh: 3.8,
+    epsGrowth: 0.12,
+    epsTrend30dAgo: 3.55,
+    epsRevisionUp30d: 8,
+    epsRevisionDown30d: 2,
+    epsActual: null,
+    revenueEstimate: 74_000_000_000,
+    revenueLow: 72_000_000_000,
+    revenueHigh: 76_000_000_000,
+    revenueGrowth: 0.16,
+    revenueActual: null,
+    surprise: null,
+    timing: "AMC",
+  },
+  {
+    symbol: "AAPL",
+    name: "Apple",
+    earningsDate: new Date("2026-09-07T12:00:00.000Z"),
+    epsEstimate: 1.5,
+    epsActual: null,
+    revenueEstimate: 95_000_000_000,
+    revenueActual: null,
+    surprise: null,
+    timing: "BMO",
+  },
+];
+
+function args(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AAPL,MSFT",
+    argument: ["AAPL", "MSFT"],
+    symbols: ["AAPL", "MSFT"],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("earnings calendar headless", () => {
+  test("maps provider events into date-ordered rows", async () => {
+    const definition = createEarningsCalendarHeadless({
+      loadCalendar: async () => ({ events, fetchedAt: 123, stale: false }),
+    });
+
+    const result = await definition.load(args({ timing: "all", limit: 50 }), context);
+
+    expect(result.rows.map((row) => row.symbol)).toEqual(["AAPL", "MSFT"]);
+    expect(result.rows[1]).toMatchObject({
+      date: "2026-09-08T20:00:00.000Z",
+      timing: "AMC",
+      dateStatus: "confirmed",
+      epsEstimate: 3.67,
+      revenueEstimate: 74_000_000_000,
+    });
+  });
+
+  test("applies timing and limit options", async () => {
+    const definition = createEarningsCalendarHeadless({
+      loadCalendar: async () => ({ events, fetchedAt: 123, stale: false }),
+    });
+
+    const result = await definition.load(args({ timing: "AMC", limit: 1 }), context);
+
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]?.symbol).toBe("MSFT");
+    expect(result.metadata).toMatchObject({ timing: "AMC", returned: 1 });
+  });
+});