gloomberb 0.11.3 → 0.12.0

package/src/plugins/builtin/market-valuation/detail.tsx

@@ -0,0 +1,159 @@
+import { useMemo, useState } from "react";
+import { CompositeChart } from "../../../components/chart/composite";
+import { ExternalLinkText } from "../../../components/ui";
+import { blendHex, colors } from "../../../theme/colors";
+import { Box, Text } from "../../../ui";
+import { formatNumber } from "../../../utils/format";
+import { markerSeries, zoneSeriesFor } from "./chart-projection";
+import type { IndicatorViewModel } from "./view";
+import { ZoneColorScale } from "./zone-scale";
+
+function formatTrillions(billions: number): string {
+  return `${formatNumber(billions / 1000, 1)}T`;
+}
+
+export function IndicatorDetail({
+  view,
+  width,
+  height,
+  focused = false,
+}: {
+  view: IndicatorViewModel;
+  width: number;
+  height: number;
+  focused?: boolean;
+}) {
+  const PANELS = [{ id: "main" }];
+  const indicator = view.indicator;
+  const levels = indicator.input.kind === "ratio" ? indicator.input.levels : undefined;
+  const [userViewport, setUserViewport] = useState<{ start: Date; end: Date } | null>(null);
+  const chartWidth = Math.max(24, width - 2);
+  const AXIS_WIDTH = 8;
+  // Give a tall pane a taller plot instead of leaving the space empty below.
+  const chartHeight = Math.max(8, Math.min(26, height - 16));
+
+  const visible = view.chart.sourcePoints;
+  const series = useMemo(() => {
+    const zones = zoneSeriesFor(indicator, visible);
+    const markers = [
+      indicator.reference
+        ? markerSeries(
+          indicator,
+          "reference",
+          indicator.reference.label,
+          indicator.reference.value,
+          colors.textDim,
+          visible,
+        )
+        : null,
+      markerSeries(
+        indicator,
+        "mean",
+        "mean",
+        view.mean,
+        blendHex(colors.textDim, colors.bg, 0.35),
+        visible,
+      ),
+    ].filter((entry) => entry != null);
+    return [...markers, ...zones];
+  }, [indicator, view.mean, visible]);
+
+  // One clean entry instead of a row per valuation band.
+  const legendSeries = useMemo(
+    () => series.filter((entry) => entry.id === "reference" || entry.id === "mean"),
+    [series],
+  );
+
+  const viewport = useMemo(() => {
+    if (userViewport) return userViewport;
+    if (visible.length < 2) return undefined;
+    return { start: new Date(visible[0]!.date), end: new Date(visible.at(-1)!.date) };
+  }, [userViewport, visible]);
+
+
+  return (
+    <Box flexDirection="column" width={width} paddingX={1} gap={1}>
+      {view.chart.points.length >= 2 ? (
+        <Box flexDirection="column" gap={0}>
+          <Box flexDirection="row" width={chartWidth} overflow="hidden">
+            <Text>{" ".repeat(AXIS_WIDTH)}</Text>
+            <ZoneColorScale
+              indicator={indicator}
+              value={view.current.ratio}
+              width={Math.max(1, chartWidth - AXIS_WIDTH)}
+              markerColor={view.zone.color}
+            />
+          </Box>
+          <CompositeChart
+            series={series}
+            legendSeries={legendSeries}
+            panels={PANELS}
+            width={chartWidth}
+            height={chartHeight}
+            focused={focused}
+            interactive
+            axisWidth={AXIS_WIDTH}
+            showLegend
+            viewport={viewport}
+            viewportResetKey={`${indicator.id}:${view.range}`}
+            onViewportChange={setUserViewport}
+            formatValue={(value) => indicator.formatValue(value)}
+            emptyMessage="Not enough chart data"
+          />
+        </Box>
+      ) : (
+        <Box height={chartHeight} justifyContent="center" alignItems="center">
+          <Text fg={colors.textMuted}>Not enough chart data</Text>
+        </Box>
+      )}
+
+      <Box flexDirection="column" gap={0}>
+        {levels && view.current.numeratorBillions != null
+          && view.current.denominatorBillions != null ? (
+          <Box flexDirection="row" height={1} overflow="hidden">
+            <Text fg={colors.textDim}>{`${levels.numeratorLabel} `}</Text>
+            <Text fg={colors.textBright}>{formatTrillions(view.current.numeratorBillions)}</Text>
+            <Text fg={colors.textDim}>{`  ${levels.denominatorLabel} `}</Text>
+            <Text fg={colors.textBright}>{formatTrillions(view.current.denominatorBillions)}</Text>
+            {view.vintageLabel ? (
+              <Text fg={colors.textDim}>{`  ${view.vintageLabel}`}</Text>
+            ) : null}
+          </Box>
+        ) : null}
+        <Box flexDirection="row" height={1} overflow="hidden">
+          <Text fg={colors.textDim}>1Y ago </Text>
+          <Text fg={colors.text}>
+            {view.ratioOneYearAgo == null ? "--" : indicator.formatValue(view.ratioOneYearAgo)}
+          </Text>
+          <Text fg={colors.textDim}>{"  mean "}</Text>
+          <Text fg={colors.text}>{indicator.formatValue(view.mean)}</Text>
+          <Text fg={colors.textDim}>{"  ATH "}</Text>
+          <Text fg={colors.text}>
+            {`${indicator.formatValue(view.allTimeHigh.ratio)} ${view.allTimeHigh.date}`}
+          </Text>
+          <Text fg={colors.textDim}>{"  ATL "}</Text>
+          <Text fg={colors.text}>
+            {`${indicator.formatValue(view.allTimeLow.ratio)} ${view.allTimeLow.date}`}
+          </Text>
+        </Box>
+      </Box>
+
+      <Box flexDirection="column" gap={1} width={Math.max(1, width - 2)}>
+        {indicator.notes.map((note) => (
+          <Text key={note.slice(0, 24)} fg={colors.textDim} wrapMode="word" wrapText>
+            {note}
+          </Text>
+        ))}
+        {indicator.link ? (
+          <Box flexDirection="row" height={1} overflow="hidden">
+            <ExternalLinkText
+              url={indicator.link.url}
+              label={indicator.link.label}
+              color={colors.text}
+            />
+          </Box>
+        ) : null}
+      </Box>
+    </Box>
+  );
+}

package/src/plugins/builtin/market-valuation/headless.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { resetValuationPersistence } from "./cache";
+import { marketValuationHeadless } from "./headless";
+
+beforeEach(resetValuationPersistence);
+afterEach(resetValuationPersistence);
+
+function loadArgs(): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "cape",
+    argument: "cape",
+    symbols: [],
+    options: { range: "10Y" },
+  };
+}
+
+describe("market valuation headless model", () => {
+  test("loads through the injected cloud client and produces bundle sections", async () => {
+    let shillerCalls = 0;
+    const apiClient = {
+      getCloudFredSeries: async () => { throw new Error("unexpected FRED request"); },
+      getCloudHistory: async () => { throw new Error("unexpected history request"); },
+      getCloudShiller: async () => {
+        shillerCalls += 1;
+        return {
+          observations: [
+            { date: "2024-01-01", price: 4800, dividend: 70, earnings: 180, cpi: 310, longRate: 4, cape: 32, excessCapeYield: 0.02 },
+            { date: "2025-01-01", price: 5900, dividend: 76, earnings: 200, cpi: 320, longRate: 4.2, cape: 36, excessCapeYield: 0.015 },
+            { date: "2026-01-01", price: 6300, dividend: 80, earnings: 220, cpi: 330, longRate: 4.4, cape: 39, excessCapeYield: 0.01 },
+          ],
+          sourceUrl: "https://example.test/shiller.xls",
+          fetchedAt: "2026-01-02T00:00:00Z",
+        };
+      },
+    } as unknown as HeadlessPaneContext["apiClient"];
+    const context: HeadlessPaneContext = {
+      marketData: createTestDataProvider(),
+      apiClient,
+      config: createDefaultConfig("/tmp/gloomberb-headless-valuation"),
+      signal: new AbortController().signal,
+    };
+
+    const result = await marketValuationHeadless.load(loadArgs(), context);
+
+    expect(shillerCalls).toBe(1);
+    expect(result.sections.map(({ title }) => title)).toEqual([
+      "Market valuation",
+      "Shiller CAPE",
+    ]);
+    expect(result.sections[0]).toMatchObject({
+      rows: [{ id: "shiller-cape", value: 39, formattedValue: "39.0" }],
+    });
+    expect(result.metadata).toMatchObject({ range: "10Y", selected: "shiller-cape" });
+  });
+});

package/src/plugins/builtin/market-valuation/headless.ts

@@ -0,0 +1,170 @@
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneDefinition,
+  HeadlessPaneEntry,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { formatNumber } from "../../../utils/format";
+import {
+  createValuationSeriesLoader,
+  loadValuationBundle,
+  type ValuationSeriesLoader,
+} from "./client";
+import type { ValuationRangeId } from "./defs";
+import { DEFAULT_INDICATOR_ID, INDICATORS, resolveIndicatorArg } from "./indicators";
+import { createCloudSourceDeps } from "./sources";
+import {
+  formatSigma,
+  selectValuationViews,
+  type IndicatorViewModel,
+  type ValuationBundle,
+} from "./view";
+
+function detailEntries(view: IndicatorViewModel): HeadlessPaneEntry[] {
+  const format = view.indicator.formatValue;
+  return [
+    { label: "Current", value: view.current.ratio, formatted: format(view.current.ratio) },
+    {
+      label: "1Y ago",
+      value: view.ratioOneYearAgo,
+      formatted: view.ratioOneYearAgo == null ? "-" : format(view.ratioOneYearAgo),
+    },
+    { label: "Mean", value: view.mean, formatted: format(view.mean) },
+    {
+      label: "Rich percentile",
+      value: view.richPercentile,
+      formatted: formatNumber(view.richPercentile, 0),
+    },
+    {
+      label: "Trend deviation",
+      value: view.richSigma,
+      formatted: formatSigma(view.richSigma),
+    },
+    {
+      label: "All-time high",
+      value: { value: view.allTimeHigh.ratio, date: view.allTimeHigh.date },
+      formatted: `${format(view.allTimeHigh.ratio)} ${view.allTimeHigh.date}`,
+    },
+    {
+      label: "All-time low",
+      value: { value: view.allTimeLow.ratio, date: view.allTimeLow.date },
+      formatted: `${format(view.allTimeLow.ratio)} ${view.allTimeLow.date}`,
+    },
+    { label: "As of", value: view.asOf },
+  ];
+}
+
+export function projectValuationHeadlessBundle(
+  bundle: ValuationBundle,
+  range: ValuationRangeId,
+  selectedId: string,
+): HeadlessBundleResult {
+  const views = selectValuationViews(bundle, range);
+  const selected = views.find((view) => view.indicator.id === selectedId) ?? views[0] ?? null;
+  const rows = views.map((view) => ({
+    id: view.indicator.id,
+    indicator: view.indicator.label,
+    value: view.current.ratio,
+    formattedValue: view.indicator.formatValue(view.current.ratio),
+    zone: view.zone.label,
+    richPercentile: view.richPercentile,
+    richSigma: view.richSigma,
+    asOf: view.asOf,
+    stale: view.observationStale,
+  }));
+
+  return {
+    sections: [
+      {
+        title: "Market valuation",
+        columns: [
+          { key: "indicator", header: "Indicator" },
+          {
+            key: "value",
+            header: "Value",
+            align: "right",
+            format: (_value, row) => String(row.formattedValue),
+          },
+          { key: "zone", header: "Zone" },
+          {
+            key: "richPercentile",
+            header: "Rich %ile",
+            align: "right",
+            format: (value) => formatNumber(Number(value), 0),
+          },
+          {
+            key: "richSigma",
+            header: "Trend",
+            align: "right",
+            format: (value) => formatSigma(Number(value)),
+          },
+          { key: "asOf", header: "As of" },
+        ],
+        rows,
+      },
+      ...(selected
+        ? [{ title: selected.indicator.label, entries: detailEntries(selected) }]
+        : []),
+    ],
+    errors: bundle.errors,
+    metadata: {
+      fetchedAt: bundle.fetchedAt,
+      range,
+      selected: selected?.indicator.id ?? null,
+    },
+  };
+}
+
+export interface MarketValuationHeadlessDependencies {
+  loadBundle(args: HeadlessPaneLoadArgs, loader: ValuationSeriesLoader): Promise<ValuationBundle>;
+}
+
+const defaultDependencies: MarketValuationHeadlessDependencies = {
+  loadBundle: (args, loader) => {
+    const requested = typeof args.argument === "string" ? resolveIndicatorArg(args.argument) : null;
+    return loadValuationBundle({
+      loader,
+      ...(requested ? { indicators: [requested] } : {}),
+    });
+  },
+};
+
+export function createMarketValuationHeadless(
+  dependencies: MarketValuationHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: {
+      kind: "free-text",
+      placeholder: "indicator",
+      description: "Optional valuation indicator id, label, or prefix.",
+      optional: true,
+    },
+    options: [{
+      key: "range",
+      description: "History window used by the selected indicator view.",
+      type: "enum",
+      values: [{ value: "10Y" }, { value: "25Y" }, { value: "ALL", aliases: ["all"] }],
+      defaultValue: "25Y",
+    }],
+    describe: (args) => `Market Valuation | ${String(args.options.range)}`,
+    async load(args, ctx) {
+      const requested = typeof args.argument === "string" ? resolveIndicatorArg(args.argument) : null;
+      if (args.argument && !requested) {
+        throw new Error(
+          `Unknown valuation indicator "${String(args.argument)}". Use one of: ${INDICATORS.map(({ id }) => id).join(", ")}.`,
+        );
+      }
+      const range = args.options.range as ValuationRangeId;
+      const loader = createValuationSeriesLoader(createCloudSourceDeps(ctx.apiClient));
+      const bundle = await dependencies.loadBundle(args, loader);
+      return projectValuationHeadlessBundle(
+        bundle,
+        range,
+        requested?.id ?? DEFAULT_INDICATOR_ID,
+      );
+    },
+  };
+}
+
+export const marketValuationHeadless = createMarketValuationHeadless();

package/src/plugins/builtin/market-valuation/index.tsx

@@ -0,0 +1,64 @@
+import type { PluginModule } from "../plugin-module";
+import { createValuationChartSeriesCapability } from "./chart-series";
+import { INDICATORS, resolveIndicatorArg } from "./indicators";
+import { marketValuationHeadless } from "./headless";
+import { MarketValuationPane } from "./pane";
+import { buildValuationSettingsDef, VALUATION_DEFAULTS } from "./settings";
+
+export { marketValuationHeadless } from "./headless";
+
+const MARKET_VALUATION_PANE_ID = "market-valuation";
+
+const INDICATOR_KEYWORDS = INDICATORS.flatMap((indicator) => [
+  indicator.id,
+  ...indicator.shortLabel.toLowerCase().split(" "),
+  ...indicator.label.toLowerCase().split(" "),
+]);
+
+export const marketValuationModule: PluginModule = {
+  // Exposes each ratio as a chartable series, so G can overlay them on anything else.
+  capabilities: [createValuationChartSeriesCapability()],
+  panes: [{
+    id: MARKET_VALUATION_PANE_ID,
+    name: "Market Valuation",
+    icon: "V",
+    component: MarketValuationPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 88, height: 34 },
+    settings: buildValuationSettingsDef(),
+  }],
+  paneTemplates: [{
+    id: "market-valuation-pane",
+    paneId: MARKET_VALUATION_PANE_ID,
+    label: "Market Valuation",
+    description: "Whole-market valuation ratios against their own history, with zones and trend deviation.",
+    keywords: [
+      "valuation",
+      "market cap",
+      "gdp",
+      "wilshire",
+      "macro",
+      "bubble",
+      "overvalued",
+      "undervalued",
+      ...INDICATOR_KEYWORDS,
+    ],
+    shortcut: {
+      prefix: "VAL",
+      argPlaceholder: "indicator",
+      argKind: "text",
+      argOptional: true,
+    },
+    headless: marketValuationHeadless,
+    // No wizard: VAL opens straight into the pane, where the summary rows swap
+    // indicators with the cursor. The argument form stays for deep links.
+    canCreate: () => true,
+    createInstance: (_context, options) => {
+      const indicator = resolveIndicatorArg(options?.arg);
+      return {
+        settings: { indicator: indicator?.id ?? VALUATION_DEFAULTS.indicator },
+      };
+    },
+  }],
+};