gloomberb 0.9.9 → 0.10.0

package/src/ui/context-menu.tsx

@@ -1,4 +1,5 @@
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, type ReactNode } from "react";
+import { t, tf } from "../i18n";
 import { getSharedRegistry, type PluginRegistry } from "../plugins/registry";
 import type { TickerFinancials } from "../types/financials";
 import { TICKER_RESEARCH_PANE_ID } from "../types/config";
@@ -225,12 +226,12 @@ export function tickerContextMenuItems({
   const items: ContextMenuItem[] = [
     {
       id: "ticker:open",
-      label: `Open ${symbol} Ticker Research`,
+      label: tf("Open {symbol} Ticker Research", { symbol }),
       onSelect: () => (openTicker ? openTicker(symbol) : registry?.navigateTicker(symbol)),
     },
     {
       id: "ticker:pin-floating",
-      label: `Open ${symbol} in New Floating Ticker Research`,
+      label: tf("Open {symbol} in New Floating Ticker Research", { symbol }),
       onSelect: () => registry?.pinTicker(symbol, { floating: true, paneType: TICKER_RESEARCH_PANE_ID, forceNewPane: true }),
     },
     {
@@ -283,6 +284,17 @@ export function tickerContextMenuItems({
   return items;
 }
 
+function translateContextMenuItems(items: ContextMenuItem[]): ContextMenuItem[] {
+  return items.map((item) => {
+    if (item.type === "divider" || item.type === "role") return item;
+    return {
+      ...item,
+      label: t(item.label),
+      submenu: item.submenu ? translateContextMenuItems(item.submenu) : item.submenu,
+    };
+  });
+}
+
 export function ContextMenuProvider({
   pluginRegistry,
   children,
@@ -314,7 +326,7 @@ export function ContextMenuProvider({
 
     event?.preventDefault?.();
     event?.stopPropagation?.();
-    return renderer.showContextMenu(withSafeActions(items, handleActionError));
+    return renderer.showContextMenu(withSafeActions(translateContextMenuItems(items), handleActionError));
   }, [handleActionError, nativeSupported, registry, renderer]);
 
   useEffect(() => {

package/src/ui/dialog.tsx

@@ -18,6 +18,8 @@ export interface DialogApi {
 interface DialogContextValue {
   dialog: DialogApi;
   isOpen: boolean;
+  dialogId?: string;
+  keyboardEnabled: boolean;
 }
 
 const DialogContext = createContext<DialogContextValue | null>(null);
@@ -25,14 +27,18 @@ const DialogContext = createContext<DialogContextValue | null>(null);
 export function DialogHostProvider({
   dialog,
   isOpen,
+  dialogId,
+  keyboardEnabled = true,
   children,
 }: {
   dialog: DialogApi;
   isOpen: boolean;
+  dialogId?: string;
+  keyboardEnabled?: boolean;
   children: ReactNode;
 }) {
   return (
-    <DialogContext value={{ dialog, isOpen }}>
+    <DialogContext value={{ dialog, isOpen, dialogId, keyboardEnabled }}>
       {children}
     </DialogContext>
   );
@@ -54,5 +60,11 @@ export function useDialogKeyboard(
   handler: (event: KeyEventLike) => void,
   options?: ShortcutOptions | string,
 ): void {
-  useShortcut(handler, typeof options === "string" ? { scope: options } : options);
+  const context = useContext(DialogContext);
+  const resolved = typeof options === "string" ? { scope: options } : options;
+  useShortcut(handler, {
+    ...resolved,
+    enabled: (resolved?.enabled ?? true) && (context?.keyboardEnabled ?? true),
+    scope: resolved?.scope ?? context?.dialogId,
+  });
 }

package/src/ui/host.tsx

@@ -1,6 +1,7 @@
-import { createContext, useContext, type ComponentType, type ReactNode } from "react";
+import { createContext, useContext, type ComponentType, type ReactNode, type Ref } from "react";
 import type { ContextMenuItem } from "../types/context-menu";
 import type { AppNotificationRequest } from "../types/plugin";
+import type { LiveStreamResolveRequest, ResolvedLiveStream } from "../types/media";
 import type { AsciiFontName } from "./ascii-font";
 
 export const TextAttributes = {
@@ -56,6 +57,8 @@ export interface ChartCrosshairOverlay {
   pixelX: number;
   pixelY: number;
   color: string;
+  /** Per-series dots on the cursor column, in bitmap pixels. */
+  markers?: readonly { pixelY: number; color: string }[];
 }
 
 interface TextEditBuffer {
@@ -105,6 +108,7 @@ export interface ScrollBoxRenderable {
   scrollTop: number;
   scrollLeft?: number;
   scrollHeight: number;
+  scrollWidth?: number;
   scrollTopPx?: number;
   scrollLeftPx?: number;
   scrollHeightPx?: number;
@@ -125,6 +129,7 @@ export interface InputRenderable {
   cursorOffset?: number;
   setCursorOffset?(offset: number): void;
   focus?(): void;
+  blur?(): void;
 }
 
 export interface TextareaRenderable extends InputRenderable {
@@ -214,6 +219,23 @@ export interface ImageSurfaceProps extends BoxProps {
   alt?: string;
   objectFit?: "contain" | "cover";
 }
+export interface MediaSurfaceProps extends BoxProps {
+  src?: string;
+  title?: string;
+  poster?: string;
+  autoPlay?: boolean;
+  muted?: boolean;
+  mediaHandleRef?: Ref<MediaSurfaceHandle>;
+  onPlaybackStateChange?: (state: "idle" | "loading" | "playing" | "paused" | "error") => void;
+  onMutedChange?: (muted: boolean) => void;
+  onError?: (message: string) => void;
+}
+export interface MediaSurfaceHandle {
+  play(): Promise<void>;
+  pause(): void;
+  toggle(): Promise<void>;
+  toggleMuted(): boolean;
+}
 interface SpinnerMarkProps extends BoxProps {
   name?: string;
   color?: string;
@@ -257,6 +279,7 @@ export interface HostTabsProps {
   activeValue: string | null;
   onSelect: (value: string) => void;
   compact?: boolean;
+  dense?: boolean;
   variant?: "underline" | "pill" | "bare";
   closeMode?: "active" | "always";
   addLabel?: string;
@@ -277,6 +300,18 @@ export interface HostCheckboxProps {
   variant?: "default" | "desktop";
 }
 
+export interface HostPopoverProps {
+  open: boolean;
+  onOpenChange(open: boolean): void;
+  trigger: ReactNode;
+  children: ReactNode;
+  anchorPoint?: { x: number; y: number } | null;
+  placement?: "bottom-start" | "bottom-end";
+  minWidth?: number | string;
+  maxWidth?: number | string;
+  label?: string;
+}
+
 export interface UiHost {
   kind?: "opentui" | "desktop-web";
   capabilities?: {
@@ -302,6 +337,7 @@ export interface UiHost {
   Textarea: ComponentType<TextareaProps>;
   ChartSurface: ComponentType<ChartSurfaceProps>;
   ImageSurface: ComponentType<ImageSurfaceProps>;
+  MediaSurface: ComponentType<MediaSurfaceProps>;
   SpinnerMark: ComponentType<SpinnerMarkProps>;
   AsciiText: ComponentType<AsciiTextProps>;
   Button?: ComponentType<any>;
@@ -313,6 +349,7 @@ export interface UiHost {
   PageStackView?: ComponentType<any>;
   Tabs?: ComponentType<HostTabsProps>;
   Checkbox?: ComponentType<HostCheckboxProps>;
+  Popover?: ComponentType<HostPopoverProps>;
   DataTable?: ComponentType<any>;
   createSyntaxStyle?(): SyntaxStyleLike;
   colorFromHex?(hex: string): unknown;
@@ -329,6 +366,8 @@ export interface RendererHost {
   supportsNativeDesktopNotifications?: boolean;
   notify(notification: AppNotificationRequest): void;
   showContextMenu?(items: ContextMenuItem[]): Promise<boolean>;
+  playTerminalMedia?(url: string, title?: string, options?: { muted?: boolean }): Promise<void>;
+  resolveLiveStream?(request: LiveStreamResolveRequest): Promise<ResolvedLiveStream>;
 }
 
 interface UiHostContextValue {

package/src/ui/index.tsx

@@ -37,8 +37,11 @@ export type {
   BoxRenderable,
   ChartSurfaceProps,
   HostCheckboxProps,
+  HostPopoverProps,
   Highlight,
   ImageSurfaceProps,
+  MediaSurfaceHandle,
+  MediaSurfaceProps,
   InputRenderable,
   NativeCursorState,
   NativeRendererHost,
@@ -283,6 +286,12 @@ export const ImageSurface = forwardRef<any, ComponentProps<UiHost["ImageSurface"
 });
 ImageSurface.displayName = "ImageSurface";
 
+export const MediaSurface = forwardRef<any, ComponentProps<UiHost["MediaSurface"]>>((props, ref) => {
+  const { MediaSurface: HostMediaSurface } = useUiHost();
+  return createElement(HostMediaSurface as any, { ...props, ref });
+});
+MediaSurface.displayName = "MediaSurface";
+
 export const SpinnerMark = forwardRef<any, ComponentProps<UiHost["SpinnerMark"]>>((props, ref) => {
   const { SpinnerMark: HostSpinnerMark } = useUiHost();
   return createElement(HostSpinnerMark as any, { ...props, ref });

package/src/utils/exchanges.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { canonicalExchange, CANONICAL_EXCHANGE_ALIASES, EXCHANGE_TIME_ZONES, resolveExchangeTimeZone } from "./exchanges";
+import {
+  canonicalExchange,
+  CANONICAL_EXCHANGE_ALIASES,
+  EXCHANGE_TIME_ZONES,
+  parsePublicTickerKey,
+  publicTickerKey,
+  resolveExchangeTimeZone,
+} from "./exchanges";
 
 describe("exchange metadata", () => {
   test("has a valid timezone for every canonical exchange", () => {
@@ -23,4 +30,9 @@ describe("exchange metadata", () => {
     expect(resolveExchangeTimeZone("TSE")).toBe("America/Toronto");
     expect(resolveExchangeTimeZone("AEB")).toBe("Europe/Amsterdam");
   });
+
+  test("round-trips public exchange-qualified ticker keys", () => {
+    expect(publicTickerKey("3hnx", "LSE")).toBe("3HNX:XLON");
+    expect(parsePublicTickerKey("3hnx:xlon")).toEqual({ symbol: "3HNX", exchange: "LSE" });
+  });
 });

package/src/utils/exchanges.ts

@@ -238,6 +238,16 @@ export function publicExchange(value?: string): string {
   return PUBLIC_EXCHANGE_ALIASES[canonical] ?? canonical;
 }
 
+export function parsePublicTickerKey(value: string): { symbol: string; exchange?: string } {
+  const normalized = normalizeSymbol(value);
+  const separator = normalized.lastIndexOf(":");
+  if (separator <= 0 || separator === normalized.length - 1) return { symbol: normalized };
+  return {
+    symbol: normalized.slice(0, separator),
+    exchange: canonicalExchange(normalized.slice(separator + 1)),
+  };
+}
+
 export function canonicalTickerKey(symbol: string, exchange?: string): string {
   const normalizedSymbol = normalizeSymbol(symbol);
   const canonical = canonicalExchange(exchange);

package/src/utils/financial-statements.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import { mergeFinancialStatementRows } from "./financial-statements";
+
+describe("mergeFinancialStatementRows", () => {
+  test("preserves per-field availability across providers", () => {
+    const [merged] = mergeFinancialStatementRows(
+      [{
+        date: "2025-12-31",
+        totalRevenue: 120,
+        availableAt: "2026-02-10",
+        fieldAvailability: { totalRevenue: "2026-02-10" },
+      }],
+      [{
+        date: "2025-12-31",
+        grossProfit: 72,
+        availableAt: "2026-02-12",
+        fieldAvailability: { grossProfit: "2026-02-12" },
+      }],
+    );
+
+    expect(merged).toMatchObject({
+      availableAt: "2026-02-12",
+      totalRevenue: 120,
+      grossProfit: 72,
+      fieldAvailability: {
+        totalRevenue: "2026-02-10",
+        grossProfit: "2026-02-12",
+      },
+    });
+  });
+
+  test("never attaches fallback provenance to a different primary value", () => {
+    const [merged] = mergeFinancialStatementRows(
+      [{
+        date: "2025-12-31",
+        totalRevenue: 120,
+        availableAt: "2026-03-15",
+      }],
+      [{
+        date: "2025-12-31",
+        totalRevenue: 100,
+        fieldAvailability: { totalRevenue: "2026-02-01" },
+      }],
+    );
+
+    expect(merged).toMatchObject({
+      totalRevenue: 120,
+      availableAt: "2026-03-15",
+      fieldAvailability: { totalRevenue: "2026-03-15" },
+    });
+  });
+
+  test("copies fallback availability only when the retained value matches", () => {
+    const [matching] = mergeFinancialStatementRows(
+      [{ date: "2025-12-31", totalRevenue: 100 }],
+      [{
+        date: "2025-12-31",
+        totalRevenue: 100,
+        fieldAvailability: { totalRevenue: "2026-02-01" },
+      }],
+    );
+    const [different] = mergeFinancialStatementRows(
+      [{ date: "2025-12-31", totalRevenue: 120 }],
+      [{
+        date: "2025-12-31",
+        totalRevenue: 100,
+        fieldAvailability: { totalRevenue: "2026-02-01" },
+      }],
+    );
+
+    expect(matching?.fieldAvailability?.totalRevenue).toBe("2026-02-01");
+    expect(different?.fieldAvailability?.totalRevenue).toBeUndefined();
+    expect(different?.availableAt).toBeUndefined();
+  });
+
+  test("coalesces calendar-normalized and issuer fiscal period ends", () => {
+    const merged = mergeFinancialStatementRows(
+      [
+        { date: "2025-06-30", totalRevenue: 94_036 },
+        { date: "2025-09-30", totalRevenue: 102_466 },
+      ],
+      [
+        {
+          date: "2025-06-28",
+          totalRevenue: 94_036,
+          fieldAvailability: { totalRevenue: "2025-08-01" },
+        },
+        {
+          date: "2025-09-27",
+          totalRevenue: 102_466,
+          fieldAvailability: { totalRevenue: "2025-10-31" },
+        },
+      ],
+    );
+
+    expect(merged).toEqual([
+      {
+        date: "2025-06-28",
+        availableAt: "2025-08-01",
+        totalRevenue: 94_036,
+        fieldAvailability: { totalRevenue: "2025-08-01" },
+      },
+      {
+        date: "2025-09-27",
+        availableAt: "2025-10-31",
+        totalRevenue: 102_466,
+        fieldAvailability: { totalRevenue: "2025-10-31" },
+      },
+    ]);
+  });
+
+  test("does not coalesce statement rows outside the fiscal-close tolerance", () => {
+    const merged = mergeFinancialStatementRows(
+      [{ date: "2025-06-30", totalRevenue: 94_036 }],
+      [{
+        date: "2025-07-15",
+        totalRevenue: 94_036,
+        fieldAvailability: { totalRevenue: "2025-08-01" },
+      }],
+    );
+
+    expect(merged.map((row) => row.date)).toEqual(["2025-06-30", "2025-07-15"]);
+  });
+
+  test("retains a primary fiscal close when only the fallback is calendar-normalized", () => {
+    const merged = mergeFinancialStatementRows(
+      [{
+        date: "2025-06-28",
+        totalRevenue: 94_036,
+        fieldAvailability: { totalRevenue: "2025-08-01" },
+      }],
+      [{ date: "2025-06-30", totalRevenue: 94_036 }],
+    );
+
+    expect(merged).toHaveLength(1);
+    expect(merged[0]?.date).toBe("2025-06-28");
+  });
+});

package/src/utils/financial-statements.ts

@@ -1,5 +1,71 @@
 import type { FinancialStatement } from "../types/financials";
 
+const STATEMENT_METADATA_KEYS = new Set(["date", "availableAt", "fieldAvailability"]);
+const NEARBY_PERIOD_END_MS = 7 * 24 * 60 * 60 * 1_000;
+
+function metricKeys(...rows: Array<FinancialStatement | undefined>): string[] {
+  return [...new Set(rows.flatMap((row) => Object.keys(row ?? {})))]
+    .filter((key) => !STATEMENT_METADATA_KEYS.has(key));
+}
+
+function metricValue(row: FinancialStatement | undefined, key: string): unknown {
+  return (row as unknown as Record<string, unknown> | undefined)?.[key];
+}
+
+function hasMetricValue(row: FinancialStatement | undefined, key: string): boolean {
+  return typeof metricValue(row, key) === "number";
+}
+
+function hasAvailabilityEvidence(row: FinancialStatement | undefined): boolean {
+  return !!row?.availableAt || Object.keys(row?.fieldAvailability ?? {}).length > 0;
+}
+
+function canonicalStatementDate(
+  primary: FinancialStatement,
+  fallback: FinancialStatement | undefined,
+): string {
+  if (!fallback) return primary.date;
+  return hasAvailabilityEvidence(fallback) && !hasAvailabilityEvidence(primary)
+    ? fallback.date
+    : primary.date;
+}
+
+function statementDateTime(row: FinancialStatement): number | null {
+  const time = Date.parse(`${row.date}T00:00:00Z`);
+  return Number.isFinite(time) ? time : null;
+}
+
+export function areNearbyFinancialPeriodEnds(
+  left: string | Date,
+  right: string | Date,
+): boolean {
+  const leftTime = left instanceof Date ? left.getTime() : Date.parse(`${left}T00:00:00Z`);
+  const rightTime = right instanceof Date ? right.getTime() : Date.parse(`${right}T00:00:00Z`);
+  return Number.isFinite(leftTime)
+    && Number.isFinite(rightTime)
+    && Math.abs(leftTime - rightTime) <= NEARBY_PERIOD_END_MS;
+}
+
+function matchFallbackRow(
+  primary: FinancialStatement,
+  fallbackRows: FinancialStatement[],
+  usedFallbackRows: Set<FinancialStatement>,
+): FinancialStatement | undefined {
+  const exact = fallbackRows.find((row) => row.date === primary.date && !usedFallbackRows.has(row));
+  if (exact) return exact;
+  const primaryTime = statementDateTime(primary);
+  if (primaryTime === null) return undefined;
+  return fallbackRows
+    .flatMap((row) => {
+      if (usedFallbackRows.has(row)) return [];
+      const fallbackTime = statementDateTime(row);
+      if (fallbackTime === null) return [];
+      const distance = Math.abs(fallbackTime - primaryTime);
+      return areNearbyFinancialPeriodEnds(primary.date, row.date) ? [{ row, distance }] : [];
+    })
+    .sort((left, right) => left.distance - right.distance || left.row.date.localeCompare(right.row.date))[0]?.row;
+}
+
 export function mergeFinancialStatementRows(
   primaryRows: FinancialStatement[],
   fallbackRows: FinancialStatement[],
@@ -7,16 +73,57 @@ export function mergeFinancialStatementRows(
   if (primaryRows.length === 0) return fallbackRows;
   if (fallbackRows.length === 0) return primaryRows;
 
-  const fallbackByDate = new Map(fallbackRows.map((row) => [row.date, row]));
-  const primaryDates = new Set(primaryRows.map((row) => row.date));
-  const mergedRows = primaryRows.map((row) => ({
-    ...fallbackByDate.get(row.date),
-    ...row,
-    date: row.date,
-  }));
+  const usedFallbackRows = new Set<FinancialStatement>();
+  const mergedRows = primaryRows.map((row) => {
+    const fallback = matchFallbackRow(row, fallbackRows, usedFallbackRows);
+    if (fallback) usedFallbackRows.add(fallback);
+    const merged = {
+      ...fallback,
+      ...row,
+      // Prefer the date backed by filing provenance. Generic provider merges
+      // otherwise retain their primary provider's period identity.
+      date: canonicalStatementDate(row, fallback),
+    } as FinancialStatement;
+    const fieldAvailability: Record<string, string> = {};
+    const keys = metricKeys(row, fallback);
+
+    for (const key of keys) {
+      const primaryHasValue = hasMetricValue(row, key);
+      const fallbackHasValue = hasMetricValue(fallback, key);
+      if (!primaryHasValue && fallbackHasValue) {
+        (merged as unknown as Record<string, unknown>)[key] = metricValue(fallback, key);
+      }
+
+      if (primaryHasValue) {
+        const primaryAvailability = row.fieldAvailability?.[key] ?? row.availableAt;
+        const valuesMatch = fallbackHasValue && Object.is(metricValue(row, key), metricValue(fallback, key));
+        const availability = primaryAvailability
+          ?? (valuesMatch ? fallback?.fieldAvailability?.[key] ?? fallback?.availableAt : undefined);
+        if (availability) fieldAvailability[key] = availability;
+      } else if (fallbackHasValue) {
+        const availability = fallback?.fieldAvailability?.[key] ?? fallback?.availableAt;
+        if (availability) fieldAvailability[key] = availability;
+      }
+    }
+
+    // A fallback row-level date cannot safely date a different primary value.
+    // Retained fallback fields still carry their own per-field provenance.
+    const primaryHasMetrics = keys.some((key) => hasMetricValue(row, key));
+    const retainedMetricKeys = keys.filter((key) => hasMetricValue(merged, key));
+    const completeFieldAvailability = retainedMetricKeys.length > 0
+      && retainedMetricKeys.every((key) => !!fieldAvailability[key]);
+    const availableAt = completeFieldAvailability
+      ? Object.values(fieldAvailability).sort().at(-1)
+      : row.availableAt ?? (!primaryHasMetrics ? fallback?.availableAt : undefined);
+    if (availableAt) merged.availableAt = availableAt;
+    else delete merged.availableAt;
+    if (Object.keys(fieldAvailability).length > 0) merged.fieldAvailability = fieldAvailability;
+    else delete merged.fieldAvailability;
+    return merged;
+  });
 
   for (const row of fallbackRows) {
-    if (!primaryDates.has(row.date)) mergedRows.push(row);
+    if (!usedFallbackRows.has(row)) mergedRows.push(row);
   }
 
   return mergedRows.sort((left, right) => left.date.localeCompare(right.date));

package/src/utils/format.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { displayWidth, formatTimeAgo, padTo } from "./format";
+import { displayWidth, formatTimeAgo, padTo, truncateToDisplayWidth } from "./format";
 import { normalizeTimestamp } from "./timestamp";
 
 describe("formatTimeAgo", () => {
@@ -29,3 +29,13 @@ describe("padTo", () => {
     expect(padTo("🇺🇸 CPI", 6)).toBe("🇺🇸 CPI");
   });
 });
+
+describe("truncateToDisplayWidth", () => {
+  test("preserves grapheme clusters and stays within the terminal cell budget", () => {
+    expect(displayWidth("📈")).toBe(2);
+    expect(displayWidth("e\u0301")).toBe(1);
+    expect(displayWidth("👨‍👩‍👧‍👦")).toBe(2);
+    expect(truncateToDisplayWidth("投资组合分析面板", 9)).toBe("投资组...");
+    expect(displayWidth(truncateToDisplayWidth("👨‍👩‍👧‍👦 family", 7))).toBeLessThanOrEqual(7);
+  });
+});

package/src/utils/format.ts

@@ -186,6 +186,13 @@ function truncateToWidth(value: string, width: number): string {
   return output;
 }
 
+export function truncateToDisplayWidth(value: string, width: number): string {
+  if (width <= 0) return "";
+  if (displayWidth(value) <= width) return value;
+  if (width <= 3) return ".".repeat(width);
+  return `${truncateToWidth(value, width - 3)}...`;
+}
+
 /** Pad/truncate a string to a fixed display width */
 export function padTo(str: string, width: number, align: "left" | "right" | "center" = "left"): string {
   const clipped = displayWidth(str) > width ? truncateToWidth(str, width) : str;

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.9.9";
+export const VERSION = "0.10.0";