gloomberb 0.13.1 → 0.13.2

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 }

package/src/plugins/builtin/earnings-calls/data.ts

@@ -4,7 +4,12 @@ import {
   type CloudEarningsTranscriptPayload,
 } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
-import type { PluginPersistence } from "../../../types/plugin";
+import type { HeadlessPaneApiClient, PluginPersistence } from "../../../types/plugin";
+
+type EarningsCallsApiClient = Pick<
+  HeadlessPaneApiClient,
+  "getCloudEarningsCalls" | "getCloudEarningsTranscript"
+>;
 
 const LIST_KIND = "calls";
 const TRANSCRIPT_KIND = "transcript";
@@ -83,7 +88,8 @@ function listKey(ticker: string | null): string {
   return ticker ? ticker.toUpperCase() : "__all__";
 }
 
-export async function loadEarningsCalls(
+export async function loadEarningsCallsWithClient(
+  client: EarningsCallsApiClient,
   ticker: string | null,
   options?: { force?: boolean; limit?: number },
 ): Promise<EarningsCallsResult> {
@@ -101,7 +107,7 @@ export async function loadEarningsCalls(
   const active = activeListFetches.get(key);
   if (active && !force) return active;
 
-  const request = apiClient
+  const request = client
     .getCloudEarningsCalls({
       ticker: ticker ?? undefined,
       limit: options?.limit ?? 50,
@@ -155,6 +161,13 @@ export async function loadEarningsCalls(
   return request;
 }
 
+export function loadEarningsCalls(
+  ticker: string | null,
+  options?: { force?: boolean; limit?: number },
+): Promise<EarningsCallsResult> {
+  return loadEarningsCallsWithClient(apiClient, ticker, options);
+}
+
 /**
  * The server answers 202 with a pending marker when a call is known but not
  * transcribed yet, having just queued it. That is not a transcript and must
@@ -163,12 +176,13 @@ export async function loadEarningsCalls(
 export function isPendingTranscript(
   value: CloudEarningsTranscriptPayload | { status?: string } | null,
 ): boolean {
-  if (!value) return false
-  const record = value as { status?: string; turns?: unknown }
-  return record.status === "pending" || !Array.isArray(record.turns)
+  if (!value) return false;
+  const record = value as { status?: string; turns?: unknown };
+  return record.status === "pending" || !Array.isArray(record.turns);
 }
 
-export async function loadTranscript(
+export async function loadTranscriptWithClient(
+  client: EarningsCallsApiClient,
   callId: string,
   options?: { force?: boolean },
 ): Promise<CloudEarningsTranscriptPayload> {
@@ -184,7 +198,7 @@ export async function loadTranscript(
   const active = activeTranscriptFetches.get(callId);
   if (active && !force) return active;
 
-  const request = apiClient
+  const request = client
     .getCloudEarningsTranscript(callId)
     .then((transcript) => {
       if (isPendingTranscript(transcript)) return transcript;
@@ -221,3 +235,10 @@ export async function loadTranscript(
   activeTranscriptFetches.set(callId, request);
   return request;
 }
+
+export function loadTranscript(
+  callId: string,
+  options?: { force?: boolean },
+): Promise<CloudEarningsTranscriptPayload> {
+  return loadTranscriptWithClient(apiClient, callId, options);
+}

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

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "bun:test";
+import type {
+  CloudEarningsCallPayload,
+  CloudEarningsTranscriptPayload,
+} from "../../../api-client";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import {
+  createEarningsCallsHeadless,
+  createEarningsTranscriptHeadless,
+  type EarningsCallsHeadlessDependencies,
+} from "./headless";
+
+const calls: CloudEarningsCallPayload[] = [
+  {
+    id: "amd-fq2-2026",
+    ticker: "AMD",
+    companyName: "Advanced Micro Devices",
+    fiscalYear: 2026,
+    fiscalQuarter: 2,
+    callAt: "2026-07-29T21:00:00.000Z",
+    status: "published",
+    durationSeconds: 3_600,
+    wordCount: 12_000,
+    hasTranscript: true,
+    sentiment: 0.2,
+  },
+  {
+    id: "amd-fq1-2026",
+    ticker: "AMD",
+    companyName: "Advanced Micro Devices",
+    fiscalYear: 2026,
+    fiscalQuarter: 1,
+    callAt: "2026-04-29T21:00:00.000Z",
+    status: "discovered",
+    durationSeconds: null,
+    wordCount: null,
+    hasTranscript: false,
+    sentiment: null,
+  },
+];
+
+const transcript: CloudEarningsTranscriptPayload = {
+  id: "amd-fq2-2026",
+  ticker: "AMD",
+  companyName: "Advanced Micro Devices",
+  fiscalYear: 2026,
+  fiscalQuarter: 2,
+  callAt: "2026-07-29T21:00:00.000Z",
+  timing: "AMC",
+  webcastUrl: "https://example.com/call",
+  durationSeconds: 3_600,
+  status: "published",
+  fullText: "",
+  turns: [
+    {
+      speaker: "Jean Hu",
+      role: "Chief Financial Officer",
+      company: "AMD",
+      text: `Gross margin expanded. ${"Margin discipline remained strong. ".repeat(80)}`,
+      isQa: false,
+      startSeconds: 120,
+    },
+    {
+      speaker: "Analyst One",
+      role: "Analyst",
+      company: "Research Firm",
+      text: "What should investors expect from the CFO on data center margins?",
+      isQa: true,
+      startSeconds: 2_400,
+    },
+  ],
+  participants: [
+    { name: "Jean Hu", role: "Chief Financial Officer", company: "AMD" },
+  ],
+  summary: "Revenue grew while gross margin expanded.",
+  guidance: "Management expects sequential growth.",
+  riskFactors: "Supply remains constrained.",
+  analystFocus: "Analysts focused on data center margins.",
+  notable: "Management raised its annual outlook.",
+  sentiment: 0.2,
+  sentimentRationale: "Constructive outlook.",
+  qaStartTurn: 1,
+  wordCount: 12_000,
+  asrModel: "test",
+  updatedAt: "2026-07-30T00:00:00.000Z",
+};
+
+function callArgs(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "",
+    argument: null,
+    symbols: [],
+    options,
+  };
+}
+
+function transcriptArgs(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options,
+  };
+}
+
+function dependencies(): EarningsCallsHeadlessDependencies {
+  return {
+    loadCalls: async () => ({
+      calls,
+      fetchedAt: 123,
+      stale: false,
+    }),
+    loadTranscript: async () => transcript,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("earnings calls headless", () => {
+  test("maps call shelf rows and applies availability", async () => {
+    const definition = createEarningsCallsHeadless(dependencies());
+
+    const result = await definition.load(
+      callArgs({ availability: "pending", limit: 1 }),
+      context,
+    );
+
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        id: "amd-fq1-2026",
+        ticker: "AMD",
+        status: "queued",
+        hasTranscript: false,
+      }),
+    ]);
+    expect(result.metadata).toMatchObject({ availability: "pending", returned: 1 });
+  });
+});
+
+describe("earnings transcript headless", () => {
+  test("selects a quarter and filters speakers by role acronym", async () => {
+    const definition = createEarningsTranscriptHeadless(dependencies());
+
+    const result = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "FQ2-2026",
+      speaker: "CFO",
+      search: "margin",
+      offset: 0,
+      limit: 20,
+    }), context);
+
+    expect(result.rows.length).toBeGreaterThan(0);
+    expect(result.rows.every((row) => row.speaker === "Jean Hu")).toBe(true);
+    expect(result.metadata).toMatchObject({
+      fiscalYear: 2026,
+      fiscalQuarter: 2,
+      section: "transcript",
+      speaker: "CFO",
+    });
+  });
+
+  test("pages bounded transcript segments and reports truncation", async () => {
+    const definition = createEarningsTranscriptHeadless(dependencies());
+    const first = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "latest",
+      speaker: "CFO",
+      search: "",
+      offset: 0,
+      limit: 1,
+    }), context);
+    const second = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "latest",
+      speaker: "CFO",
+      search: "",
+      offset: 1,
+      limit: 1,
+    }), context);
+
+    expect(first.rows).toHaveLength(1);
+    expect(first.metadata).toMatchObject({
+      returnedSegments: 1,
+      truncated: true,
+      hasMore: true,
+      nextOffset: 1,
+    });
+    expect(second.rows).toHaveLength(1);
+    expect(second.rows[0]?.index).toBe(1);
+  });
+});