gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/econ-statistics/trend.ts

@@ -0,0 +1,57 @@
+import type { StatPoint } from "./transform";
+
+const MS_PER_DAY = 86_400_000;
+
+export interface TrendFit {
+  alpha: number;
+  beta: number;
+  sigma: number;
+  originMs: number;
+}
+
+/**
+ * Plain least squares against time. These series go negative routinely, so unlike
+ * the valuation ratios there is no log variant to choose.
+ */
+export function fitTrend(points: readonly StatPoint[]): TrendFit {
+  const usable = points.filter((point) => Number.isFinite(point.value));
+  const empty: TrendFit = { alpha: 0, beta: 0, sigma: 0, originMs: 0 };
+  if (usable.length === 0) return empty;
+
+  const originMs = Date.parse(usable[0]!.date);
+  if (usable.length < 2) return { alpha: usable[0]!.value, beta: 0, sigma: 0, originMs };
+
+  const xs = usable.map((point) => (Date.parse(point.date) - originMs) / MS_PER_DAY);
+  const ys = usable.map((point) => point.value);
+  const n = xs.length;
+  let sumX = 0;
+  let sumY = 0;
+  let sumXX = 0;
+  let sumXY = 0;
+  for (let i = 0; i < n; i += 1) {
+    sumX += xs[i]!;
+    sumY += ys[i]!;
+    sumXX += xs[i]! * xs[i]!;
+    sumXY += xs[i]! * ys[i]!;
+  }
+  const denom = n * sumXX - sumX * sumX;
+  const beta = denom === 0 ? 0 : (n * sumXY - sumX * sumY) / denom;
+  const alpha = (sumY - beta * sumX) / n;
+  if (n < 3) return { alpha, beta, sigma: 0, originMs };
+
+  let residualSq = 0;
+  for (let i = 0; i < n; i += 1) {
+    const residual = ys[i]! - (alpha + beta * xs[i]!);
+    residualSq += residual * residual;
+  }
+  return { alpha, beta, sigma: Math.sqrt(residualSq / (n - 2)), originMs };
+}
+
+export function trendAt(fit: TrendFit, date: string): number {
+  return fit.alpha + fit.beta * ((Date.parse(date) - fit.originMs) / MS_PER_DAY);
+}
+
+export function sigmaVsTrend(fit: TrendFit, value: number, date: string): number {
+  if (!(fit.sigma > 0)) return 0;
+  return (value - trendAt(fit, date)) / fit.sigma;
+}

package/src/plugins/builtin/econ-statistics/view.ts

@@ -0,0 +1,90 @@
+import type { StatBuild } from "./client";
+import type { StatDef } from "./defs";
+import { periodsPerYear, type StatPoint } from "./transform";
+import { sigmaVsTrend, trendAt } from "./trend";
+
+export type StatRangeId = "5Y" | "20Y" | "ALL";
+
+const MS_PER_YEAR = 365.25 * 24 * 60 * 60 * 1000;
+
+export const STAT_RANGE_WINDOWS_MS: { readonly [K in StatRangeId]: number | null } = {
+  "5Y": 5 * MS_PER_YEAR,
+  "20Y": 20 * MS_PER_YEAR,
+  ALL: null,
+};
+
+export interface StatViewModel {
+  stat: StatDef;
+  range: StatRangeId;
+  latest: StatPoint;
+  /** The print before this one, for the direction of the last move. */
+  previous: StatPoint | null;
+  yearAgo: StatPoint | null;
+  changeOnPrevious: number | null;
+  /** Where the current reading sits in the series' own history. */
+  percentile: number;
+  sigmaVsTrend: number;
+  mean: number;
+  high: StatPoint;
+  low: StatPoint;
+  visible: StatPoint[];
+  observationStale: boolean;
+}
+
+export function sliceByRange(
+  points: readonly StatPoint[],
+  range: StatRangeId,
+): StatPoint[] {
+  const window = STAT_RANGE_WINDOWS_MS[range];
+  if (window == null || points.length === 0) return [...points];
+  const cutoff = Date.parse(points.at(-1)!.date) - window;
+  const sliced = points.filter((point) => Date.parse(point.date) >= cutoff);
+  return sliced.length >= 2 ? sliced : [...points];
+}
+
+function extreme(points: readonly StatPoint[], pick: "high" | "low"): StatPoint {
+  let best = points[0]!;
+  for (const point of points) {
+    if (pick === "high" ? point.value > best.value : point.value < best.value) best = point;
+  }
+  return best;
+}
+
+export function projectStat(
+  build: StatBuild,
+  range: StatRangeId,
+  opts: { nowMs?: number } = {},
+): StatViewModel {
+  const { stat, points, trend } = build;
+  const latest = points[points.length - 1]!;
+  const nowMs = opts.nowMs ?? Date.now();
+  const perYear = periodsPerYear(points.map((point) => ({ date: point.date, value: point.value })));
+  const yearAgo = points[points.length - 1 - perYear] ?? null;
+  const previous = points[points.length - 2] ?? null;
+  const atOrBelow = points.filter((point) => point.value <= latest.value).length;
+
+  return {
+    stat,
+    range,
+    latest,
+    previous,
+    yearAgo,
+    changeOnPrevious: previous ? latest.value - previous.value : null,
+    percentile: points.length === 0 ? 0 : (100 * atOrBelow) / points.length,
+    sigmaVsTrend: sigmaVsTrend(trend, latest.value, latest.date),
+    mean: points.reduce((total, point) => total + point.value, 0) / points.length,
+    high: extreme(points, "high"),
+    low: extreme(points, "low"),
+    visible: sliceByRange(points, range),
+    observationStale: nowMs - Date.parse(latest.date) > stat.staleAfterMs,
+  };
+}
+
+export function selectStatViews(
+  builds: readonly StatBuild[],
+  range: StatRangeId,
+): StatViewModel[] {
+  return builds.map((build) => projectStat(build, range));
+}
+
+export { trendAt };

package/src/plugins/builtin/fear-greed/charts.tsx

@@ -1,9 +1,8 @@
 import { useMemo } from "react";
 import { Box, Text, TextAttributes, useUiHost } from "../../../ui";
-import { StaticChartSurface } from "../../../components";
+import { StaticChartSurface, type StaticChartOverlay } from "../../../components/chart/static";
 import { colors, blendHex } from "../../../theme/colors";
-import { resolveChartPalette } from "../../../components/chart/core/renderer";
-import type { ChartIndicatorOverlays } from "../../../components/chart/core/types";
+import { resolveChartPalette } from "../../../components/chart/core/palette";
 import type {
   FearGreedData,
   FearGreedIndicator,
@@ -82,19 +81,9 @@ export function PreviousScoreGrid({ data, width, layout = "grid" }: { data: Fear
   );
 }
 
-function chartOverlay(indicator: FearGreedIndicator): ChartIndicatorOverlays | null {
-  if (indicator.secondaryPoints.length === 0) return null;
-  return {
-    smaLines: [{
-      period: 0,
-      points: indicator.secondaryPoints,
-      color: colors.warning,
-    }],
-    emaLines: [],
-    bollinger: null,
-    rsi: null,
-    macd: null,
-  };
+function chartOverlay(indicator: FearGreedIndicator): StaticChartOverlay[] | undefined {
+  if (indicator.secondaryPoints.length === 0) return undefined;
+  return [{ id: "secondary", color: colors.warning, points: indicator.secondaryPoints }];
 }
 
 function SentimentChart({
@@ -120,7 +109,7 @@ function SentimentChart({
   primaryLabel: string;
   secondaryLabel?: string;
   secondaryValue?: number | null;
-  overlays?: ChartIndicatorOverlays | null;
+  overlays?: StaticChartOverlay[];
 }) {
   const isDesktopWeb = useUiHost().kind === "desktop-web";
   const stackMeta = width < CHART_META_STACK_WIDTH;
@@ -183,7 +172,7 @@ function SentimentChart({
             height={chartHeight}
             mode="line"
             colors={palette}
-            indicators={overlays}
+            overlays={overlays}
             showTimeAxis
             timeAxisColor={colors.textDim}
             yAxisColor={colors.textDim}

package/src/plugins/builtin/fear-greed/data.ts

@@ -1,5 +1,4 @@
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
-import type { OverlayPoint } from "../../../components/chart/indicators/types";
 
 const CNN_FEAR_GREED_GRAPH_URL = "https://production.dataviz.cnn.io/index/fearandgreed/graphdata";
 const CNN_REFERER = "https://www.cnn.com/markets/fear-and-greed";
@@ -69,6 +68,12 @@ interface FearGreedIndicatorDefinition {
   valueFormat: FearGreedValueFormat;
 }
 
+/** A secondary reading aligned to the primary series by observation index. */
+interface OverlayPoint {
+  index: number;
+  value: number;
+}
+
 export interface FearGreedIndicator {
   definition: FearGreedIndicatorDefinition;
   score: number | null;

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

@@ -250,6 +250,7 @@ export const futuresModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 76, height: 34 },
+      tableExport: true,
       // Resolved per open so the dialog shows the full default set until the
       // user saves a narrower selection.
       settings: (context) => ({

package/src/plugins/builtin/fx-matrix/index.tsx

@@ -169,6 +169,7 @@ export const fxMatrixModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 105, height: 14 },
+      tableExport: true,
       settings: (context) => ({
         title: "FX Cross Rates Settings",
         values: {

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

@@ -239,6 +239,10 @@ function HelpPane({ focused, width, height }: PaneProps) {
                   description="Copy a screenshot of the focused pane."
                 />
               )}
+              <ShortcutRow
+                badges={[platformShortcut(["Shift", "E"])]}
+                description="Export the focused pane's table as CSV."
+              />
               <ShortcutRow
                 badges={[platformShortcut(["Shift", "L"])]}
                 description="Open layout actions."

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

@@ -22,6 +22,7 @@ export const holdersModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 105, height: 34 },
+      tableExport: true,
     },
   ],
 

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

@@ -266,6 +266,7 @@ export const insiderModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 30 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/ipo-calendar/index.tsx

@@ -40,6 +40,7 @@ export const ipoCalendarModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 110, height: 28 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/kelly-sizer/pane.tsx

@@ -54,7 +54,7 @@ import {
   buildModeFields,
   type InlineField,
 } from "./fields";
-import type { StaticChartXMarker } from "../../../components/chart/static/chart/surface";
+import type { StaticChartXMarker } from "../../../components/chart/static";
 import {
   KellyCurveSection,
   KellyResultMetrics,

package/src/plugins/builtin/kelly-sizer/sections.tsx

@@ -1,7 +1,7 @@
 import { Box, Text, TextAttributes } from "../../../ui";
 import { StaticChartSurface } from "../../../components";
-import { resolveChartPalette } from "../../../components/chart/core/renderer";
-import type { StaticChartXMarker } from "../../../components/chart/static/chart/surface";
+import { resolveChartPalette } from "../../../components/chart/core/palette";
+import type { StaticChartXMarker } from "../../../components/chart/static";
 import { colors, priceColor } from "../../../theme/colors";
 import { formatCompact, formatCurrency, formatNumber } from "../../../utils/format";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
@@ -97,7 +97,6 @@ export function KellyCurveSection({
           width={Math.max(10, width - 2)}
           height={height}
           mode="line"
-          axisMode="percent"
           colors={resolveChartPalette(colors, "positive")}
           yAxisLabel="Expected log growth"
           yAxisColor={colors.textDim}

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

@@ -12,6 +12,7 @@ export const marketHaltsModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 124, height: 26 },
+      tableExport: true,
     },
   ],
 

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

@@ -324,6 +324,7 @@ export const marketMoversModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 100, height: 36 },
+      tableExport: true,
       quickSettings: [LIVE_STREAMING_QUICK_SETTING],
       settings: (context) => withLiveStreamingSetting({
         title: "Market Movers Settings",

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

@@ -0,0 +1,122 @@
+import type { IndicatorDef, SeriesDef } from "./defs";
+import type { DatedSeries } from "./series";
+
+export interface ScaledObs {
+  date: string;
+  value: number;
+}
+
+export interface RatioPoint {
+  date: string;
+  ratio: number;
+  /** Present only when both legs are dollar amounts worth showing. */
+  numeratorBillions?: number;
+  denominatorBillions?: number;
+}
+
+export interface ValuationSeries {
+  indicatorId: string;
+  points: RatioPoint[];
+  /** Observation date of the slowest leg, which usually lags the headline value. */
+  vintageDate: string;
+}
+
+function parseDateMs(date: string): number {
+  return Date.parse(date);
+}
+
+/** "2026Q1" style label for the low-frequency leg behind a faster-moving value. */
+export function vintageLabel(prefix: string, vintageDate: string): string {
+  const d = new Date(parseDateMs(vintageDate));
+  const quarter = Math.floor(d.getUTCMonth() / 3) + 1;
+  return `${prefix} as of ${d.getUTCFullYear()}Q${quarter}`;
+}
+
+export function scaleObservations(def: SeriesDef, data: DatedSeries): ScaledObs[] {
+  const points: ScaledObs[] = [];
+  for (const obs of data.observations) {
+    if (obs.value == null || !Number.isFinite(obs.value)) continue;
+    points.push({ date: obs.date, value: obs.value * def.scaleToBillions });
+  }
+  points.sort((a, b) => a.date.localeCompare(b.date));
+  return points;
+}
+
+/**
+ * Carries a low-frequency denominator across the numerator's dates, interpolating
+ * between prints and holding the last one flat past the final release.
+ */
+export function alignToDenominator(
+  indicator: IndicatorDef,
+  numerator: readonly ScaledObs[],
+  denominator: readonly ScaledObs[],
+  withLevels: boolean,
+): RatioPoint[] {
+  if (denominator.length === 0 || numerator.length === 0) return [];
+  const firstMs = parseDateMs(denominator[0]!.date);
+  const last = denominator[denominator.length - 1]!;
+  const lastMs = parseDateMs(last.date);
+  const out: RatioPoint[] = [];
+
+  for (const point of numerator) {
+    const t = parseDateMs(point.date);
+    if (t < firstMs) continue;
+
+    let value: number;
+    if (t >= lastMs) {
+      value = last.value;
+    } else {
+      let i = 0;
+      while (i + 1 < denominator.length && parseDateMs(denominator[i + 1]!.date) <= t) i += 1;
+      const left = denominator[i]!;
+      const right = denominator[i + 1];
+      if (!right || parseDateMs(left.date) === t) {
+        value = left.value;
+      } else {
+        const t0 = parseDateMs(left.date);
+        const t1 = parseDateMs(right.date);
+        value = left.value + ((t - t0) / (t1 - t0)) * (right.value - left.value);
+      }
+    }
+    if (!(value > 0)) continue;
+    out.push({
+      date: point.date,
+      ratio: (point.value / value) * indicator.ratioScale,
+      ...(withLevels
+        ? { numeratorBillions: point.value, denominatorBillions: value }
+        : {}),
+    });
+  }
+  return out;
+}
+
+export function buildValuationSeries(
+  indicator: IndicatorDef,
+  legs: ReadonlyMap<string, DatedSeries>,
+): ValuationSeries {
+  if (indicator.input.kind === "direct") {
+    const def = indicator.input.series;
+    const data = legs.get(def.key);
+    if (!data) throw new Error(`missing ${def.key}`);
+    const points = scaleObservations(def, data).map((obs) => ({
+      date: obs.date,
+      ratio: obs.value * indicator.ratioScale,
+    }));
+    if (points.length === 0) throw new Error("no observations");
+    return { indicatorId: indicator.id, points, vintageDate: points.at(-1)!.date };
+  }
+
+  const { numerator, denominator, levels } = indicator.input;
+  const top = legs.get(numerator.key);
+  const bottom = legs.get(denominator.key);
+  if (!top || !bottom) throw new Error(`missing ${!top ? numerator.key : denominator.key}`);
+  const scaledTop = scaleObservations(numerator, top);
+  const scaledBottom = scaleObservations(denominator, bottom);
+  const points = alignToDenominator(indicator, scaledTop, scaledBottom, levels != null);
+  if (points.length === 0) throw new Error("no overlapping observations");
+  return {
+    indicatorId: indicator.id,
+    points,
+    vintageDate: scaledBottom.at(-1)!.date,
+  };
+}

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

@@ -0,0 +1,32 @@
+import { createSeriesCache } from "../shared/series-cache";
+import type { DatedObservation } from "./series";
+import type { PluginPersistence } from "../../../types/plugin";
+
+const cache = createSeriesCache("market-valuation-series", 6 * 60 * 60 * 1000);
+
+export type { SeriesCacheEntry } from "../shared/series-cache";
+
+export function attachValuationPersistence(next: PluginPersistence): void {
+  cache.attach(next);
+}
+
+export function resetValuationPersistence(): void {
+  cache.reset();
+}
+
+export function hydrateValuationSeries(
+  entries: readonly (readonly [string, DatedObservation[]])[],
+): void {
+  cache.hydrate(entries);
+}
+
+export function getCachedSeries(key: string, options?: { allowExpired?: boolean }) {
+  return cache.get(key, options);
+}
+
+export function loadCachedSeries(
+  key: string,
+  loader: () => Promise<DatedObservation[]>,
+): Promise<DatedObservation[]> {
+  return cache.load(key, loader);
+}