gloomberb 0.12.0 → 0.13.2

package/src/plugins/builtin/credit-conditions/headless.ts

@@ -0,0 +1,55 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import {
+  loadCreditConditions,
+  type CreditConditionsLoadResult,
+  type CreditSeriesLoader,
+} from "./client";
+
+const COLUMNS = [
+  { key: "label", header: "Index" },
+  { key: "seriesId", header: "FRED series" },
+  { key: "oasBp", header: "OAS", align: "right" as const, format: (value: unknown) => `${Number(value).toFixed(1)}bp` },
+  {
+    key: "dailyChangeBp",
+    header: "1D",
+    align: "right" as const,
+    format: (value: unknown) => value == null ? "-" : `${Number(value) > 0 ? "+" : ""}${Number(value).toFixed(1)}bp`,
+  },
+  { key: "date", header: "As of" },
+];
+
+export interface CreditConditionsHeadlessDependencies {
+  load(args: HeadlessPaneLoadArgs, loader: CreditSeriesLoader): Promise<CreditConditionsLoadResult>;
+}
+
+const defaultDependencies: CreditConditionsHeadlessDependencies = {
+  load: (_args, loader) => loadCreditConditions(false, loader),
+};
+
+export function createCreditConditionsHeadless(
+  dependencies: CreditConditionsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: { kind: "none" },
+    options: [],
+    columns: COLUMNS,
+    describe: "Credit Spreads",
+    async load(args, ctx) {
+      const result = await dependencies.load(
+        args,
+        (seriesId, options) => ctx.apiClient.getCloudFredSeries(seriesId, options),
+      );
+      return {
+        rows: result.rows.map((row) => ({ ...row })),
+        errors: result.errors,
+        metadata: { stale: result.stale },
+      };
+    },
+  };
+}
+
+export const creditConditionsHeadless = createCreditConditionsHeadless();

package/src/plugins/builtin/credit-conditions/index.tsx

@@ -16,12 +16,15 @@ import type { PaneProps } from "../../../types/plugin";
 import { colors } from "../../../theme/colors";
 import type { PluginModule } from "../plugin-module";
 import { getCachedCreditConditions, loadCreditConditions } from "./client";
+import { creditConditionsHeadless } from "./headless";
 import {
   CREDIT_SERIES,
   type CreditConditionRow,
   type CreditSeriesId,
 } from "./model";
 
+export { creditConditionsHeadless } from "./headless";
+
 type SortId = "label" | "oas" | "change";
 interface Column extends DataTableColumn { id: SortId }
 
@@ -204,5 +207,6 @@ export const creditConditionsModule: PluginModule = {
     description: "ICE BofA US corporate option-adjusted spreads from FRED.",
     keywords: ["credit", "spread", "oas", "corporate", "high yield", "investment grade", "macro"],
     shortcut: { prefix: "CRD" },
+    headless: creditConditionsHeadless,
   }],
 };

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 });
+  });
+});

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

@@ -0,0 +1,162 @@
+import type { EarningsEvent } from "../../../types/data-provider";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import {
+  loadEarningsCalendar,
+  type EarningsCalendarResult,
+} from "./data/cache";
+
+const EARNINGS_COLUMNS = [
+  { key: "date", header: "Date" },
+  { key: "timing", header: "When" },
+  { key: "dateStatus", header: "Status" },
+  { key: "symbol", header: "Ticker" },
+  { key: "name", header: "Name" },
+  { key: "epsEstimate", header: "EPS est", align: "right" as const },
+  { key: "epsLow", header: "EPS low", align: "right" as const },
+  { key: "epsHigh", header: "EPS high", align: "right" as const },
+  { key: "epsGrowth", header: "EPS growth", align: "right" as const },
+  { key: "epsTrend30dAgo", header: "EPS 30D ago", align: "right" as const },
+  { key: "epsRevisionUp30d", header: "Rev up", align: "right" as const },
+  { key: "epsRevisionDown30d", header: "Rev down", align: "right" as const },
+  { key: "revenueEstimate", header: "Sales est", align: "right" as const },
+  { key: "revenueLow", header: "Sales low", align: "right" as const },
+  { key: "revenueHigh", header: "Sales high", align: "right" as const },
+  { key: "revenueGrowth", header: "Sales growth", align: "right" as const },
+  { key: "epsAnalysts", header: "EPS analysts", align: "right" as const },
+  { key: "revenueAnalysts", header: "Sales analysts", align: "right" as const },
+];
+
+export interface EarningsCalendarHeadlessDependencies {
+  loadCalendar(
+    symbols: string[],
+    context: HeadlessPaneContext,
+  ): Promise<EarningsCalendarResult>;
+}
+
+const defaultDependencies: EarningsCalendarHeadlessDependencies = {
+  loadCalendar: (symbols, context) => loadEarningsCalendar(context.marketData, symbols),
+};
+
+function timingMatches(event: EarningsEvent, timing: string): boolean {
+  if (timing === "all") return true;
+  if (timing === "unknown") return !event.timing;
+  return event.timing?.toUpperCase() === timing;
+}
+
+function eventRow(event: EarningsEvent) {
+  return {
+    date: event.earningsDate.toISOString(),
+    earningsCallDate: event.earningsCallDate?.toISOString() ?? null,
+    timing: event.timing || null,
+    dateStatus: event.isDateEstimate == null
+      ? null
+      : event.isDateEstimate
+        ? "estimated"
+        : "confirmed",
+    symbol: event.symbol,
+    name: event.name,
+    epsEstimate: event.epsEstimate ?? null,
+    epsLow: event.epsLow ?? null,
+    epsHigh: event.epsHigh ?? null,
+    epsYearAgo: event.epsYearAgo ?? null,
+    epsGrowth: event.epsGrowth ?? null,
+    epsAnalysts: event.epsAnalysts ?? null,
+    epsTrend7dAgo: event.epsTrend7dAgo ?? null,
+    epsTrend30dAgo: event.epsTrend30dAgo ?? null,
+    epsRevisionUp7d: event.epsRevisionUp7d ?? null,
+    epsRevisionUp30d: event.epsRevisionUp30d ?? null,
+    epsRevisionDown7d: event.epsRevisionDown7d ?? null,
+    epsRevisionDown30d: event.epsRevisionDown30d ?? null,
+    epsActual: event.epsActual ?? null,
+    revenueEstimate: event.revenueEstimate ?? null,
+    revenueLow: event.revenueLow ?? null,
+    revenueHigh: event.revenueHigh ?? null,
+    revenueYearAgo: event.revenueYearAgo ?? null,
+    revenueGrowth: event.revenueGrowth ?? null,
+    revenueAnalysts: event.revenueAnalysts ?? null,
+    revenueActual: event.revenueActual ?? null,
+    surprise: event.surprise ?? null,
+  };
+}
+
+export function projectEarningsCalendarHeadless(
+  result: EarningsCalendarResult,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const timing = String(args.options.timing ?? "all").toUpperCase();
+  const normalizedTiming = timing === "ALL" || timing === "UNKNOWN"
+    ? timing.toLowerCase()
+    : timing;
+  const limit = Number(args.options.limit ?? 50);
+  const matching = result.events
+    .filter((event) => timingMatches(event, normalizedTiming))
+    .sort((left, right) => left.earningsDate.getTime() - right.earningsDate.getTime());
+  const rows = matching.slice(0, limit).map(eventRow);
+
+  return {
+    columns: EARNINGS_COLUMNS,
+    rows,
+    errors: result.refreshError ? [result.refreshError] : undefined,
+    metadata: {
+      fetchedAt: result.fetchedAt,
+      stale: result.stale,
+      timing: normalizedTiming,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+    },
+  };
+}
+
+export function createEarningsCalendarHeadless(
+  dependencies: EarningsCalendarHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "symbol-list",
+      placeholder: "tickers",
+      description: "Comma-separated company symbols.",
+      minimum: 1,
+      maximum: 100,
+    },
+    options: [
+      {
+        key: "timing",
+        description: "Release timing to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "BMO" },
+          { value: "AMC" },
+          { value: "TNS" },
+          { value: "unknown" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum earnings rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: EARNINGS_COLUMNS,
+    describe: (args) => `Earnings Calendar | ${args.symbols.join(", ")}`,
+    async load(args, context) {
+      return projectEarningsCalendarHeadless(
+        await dependencies.loadCalendar(args.symbols, context),
+        args,
+      );
+    },
+  };
+}
+
+export const earningsCalendarHeadless = createEarningsCalendarHeadless();

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

@@ -23,6 +23,7 @@ import {
   type EarningsDisplayRow,
   type EarningsEventDisplayRow,
 } from "./model";
+import { earningsCalendarHeadless } from "./headless";
 import {
   buildEarningsColumns,
   renderEarningsCell,
@@ -266,6 +267,7 @@ export const earningsModule: PluginModule = {
       description: "Upcoming earnings dates and estimates for your tickers.",
       keywords: ["earn", "earnings", "calendar", "eps", "revenue", "quarterly"],
       shortcut: { prefix: "ERN" },
+      headless: earningsCalendarHeadless,
       createInstance: (context) => ({
         settings: context.activeCollectionId
           ? { collectionId: context.activeCollectionId }