gloomberb 0.9.1 → 0.9.3

package/src/market-data/performance.ts

@@ -0,0 +1,109 @@
+import type { PricePoint, Quote } from "../types/financials";
+
+export interface PriceReturnHorizon {
+  id: string;
+  label: string;
+  amount: number;
+  unit: "month" | "year";
+}
+
+export interface PriceReturnField {
+  id: string;
+  label: string;
+  value: number | null;
+}
+
+export const PRICE_RETURN_HORIZONS: PriceReturnHorizon[] = [
+  { id: "1M", label: "1M", amount: 1, unit: "month" },
+  { id: "3M", label: "3M", amount: 3, unit: "month" },
+  { id: "6M", label: "6M", amount: 6, unit: "month" },
+  { id: "1Y", label: "1Y", amount: 1, unit: "year" },
+  { id: "3Y", label: "3Y", amount: 3, unit: "year" },
+  { id: "5Y", label: "5Y", amount: 5, unit: "year" },
+];
+
+function coercePointDate(value: Date | string | number): Date | null {
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+export function normalizePriceReturnHistory(points: readonly PricePoint[]): PricePoint[] {
+  const byTimestamp = new Map<number, PricePoint>();
+  for (const point of points) {
+    const date = coercePointDate(point.date as Date | string | number);
+    if (!date || !Number.isFinite(point.close)) continue;
+    byTimestamp.set(date.getTime(), { ...point, date });
+  }
+  return [...byTimestamp.entries()]
+    .sort((left, right) => left[0] - right[0])
+    .map(([, point]) => point);
+}
+
+export function appendQuoteToPriceReturnHistory(
+  points: readonly PricePoint[],
+  quote: Pick<Quote, "price" | "lastUpdated"> | null | undefined,
+): PricePoint[] {
+  const history = normalizePriceReturnHistory(points);
+  if (!quote || !Number.isFinite(quote.price) || !Number.isFinite(quote.lastUpdated)) {
+    return history;
+  }
+
+  const quoteDate = new Date(quote.lastUpdated);
+  if (!Number.isFinite(quoteDate.getTime())) return history;
+
+  const latestHistoryTime = history.at(-1)?.date.getTime() ?? Number.NEGATIVE_INFINITY;
+  if (quoteDate.getTime() <= latestHistoryTime) return history;
+
+  return [
+    ...history,
+    {
+      date: quoteDate,
+      close: quote.price,
+    },
+  ];
+}
+
+function subtractHorizon(date: Date, horizon: PriceReturnHorizon): Date {
+  const target = new Date(date);
+  if (horizon.unit === "month") {
+    target.setMonth(target.getMonth() - horizon.amount);
+  } else {
+    target.setFullYear(target.getFullYear() - horizon.amount);
+  }
+  return target;
+}
+
+export function computePriceReturnForHorizon(
+  points: readonly PricePoint[],
+  horizon: PriceReturnHorizon,
+): number | null {
+  const history = normalizePriceReturnHistory(points);
+  if (history.length < 2) return null;
+
+  const latest = history.at(-1)!;
+  const cutoff = subtractHorizon(latest.date, horizon);
+  let baseline: PricePoint | null = null;
+
+  for (const point of history) {
+    if (point.date.getTime() <= cutoff.getTime()) {
+      baseline = point;
+    } else {
+      break;
+    }
+  }
+
+  if (!baseline || !Number.isFinite(baseline.close) || baseline.close === 0) return null;
+  if (!Number.isFinite(latest.close)) return null;
+  return (latest.close - baseline.close) / baseline.close;
+}
+
+export function buildPriceReturnFields(
+  points: readonly PricePoint[],
+  horizons: readonly PriceReturnHorizon[] = PRICE_RETURN_HORIZONS,
+): PriceReturnField[] {
+  return horizons.map((horizon) => ({
+    id: horizon.id,
+    label: horizon.label,
+    value: computePriceReturnForHorizon(points, horizon),
+  }));
+}

package/src/plugins/builtin/cloud-tweets/pane.tsx

@@ -267,6 +267,7 @@ export function TwitterFeedPane({ focused, width, height }: PaneProps) {
       inputRef={searchInputRef}
       onFocus={focusSearch}
       onBlur={blurSearch}
+      onNavigateDown={blurSearch}
       onQueryChange={updateFeedQuery}
     />
   ) : null;
@@ -309,6 +310,7 @@ export function TwitterFeedPane({ focused, width, height }: PaneProps) {
           load={loadActiveFeed}
           onResult={markFeedResult}
           onError={markFeedError}
+          onFocusSearch={focusSearch}
           emptyStateTitle={searchEnabled ? "No tweets" : "Enter a search query"}
           emptyStateHint={searchEnabled ? activeFeedQuery : undefined}
         />

package/src/plugins/builtin/cloud-tweets/search-bar.tsx

@@ -15,6 +15,7 @@ export function TwitterFeedSearchBar({
   inputRef,
   onFocus,
   onBlur,
+  onNavigateDown,
   onQueryChange,
 }: {
   feed: TwitterFeed;
@@ -25,6 +26,7 @@ export function TwitterFeedSearchBar({
   inputRef: RefObject<InputRenderable | null>;
   onFocus: () => void;
   onBlur: () => void;
+  onNavigateDown?: () => void;
   onQueryChange: (feedId: string, query: string) => void;
 }) {
   const updateQuery = useCallback((value: string) => {
@@ -43,6 +45,7 @@ export function TwitterFeedSearchBar({
       debounceMs={TWEET_SEARCH_DEBOUNCE_MS}
       onFocus={onFocus}
       onBlur={onBlur}
+      onNavigateDown={onNavigateDown}
       onQueryChange={updateQuery}
     />
   );

package/src/plugins/builtin/cloud-tweets/table.tsx

@@ -6,6 +6,7 @@ import {
   usePaneFooter,
   type DataTableCell,
   type DataTableKeyEvent,
+  type DataTableRootKeyContext,
 } from "../../../components";
 import { TickerBadgeText } from "../../../components/ticker/badge/text";
 import { RemoteImage } from "../../../components/ui";
@@ -15,6 +16,7 @@ import type { CloudTweetPayload, CloudTweetSearchResponse } from "../../../api-c
 import { formatTimeAgo } from "../../../utils/format";
 import { colors } from "../../../theme/colors";
 import { CloudAuthNotice } from "../cloud/auth-actions";
+import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import {
   buildTweetColumns,
   formatMetric,
@@ -152,6 +154,7 @@ export function TweetSearchTable({
   load,
   onResult,
   onError,
+  onFocusSearch,
   emptyStateTitle,
   emptyStateHint,
 }: {
@@ -165,6 +168,7 @@ export function TweetSearchTable({
   load: () => Promise<CloudTweetSearchResponse>;
   onResult?: (result: CloudTweetSearchResponse) => void;
   onError?: (message: string) => void;
+  onFocusSearch?: () => void;
   emptyStateTitle?: string;
   emptyStateHint?: string;
 }) {
@@ -219,13 +223,21 @@ export function TweetSearchTable({
     ));
   }, []);
 
-  const handleRootKeyDown = useCallback((event: DataTableKeyEvent) => {
+  const handleRootKeyDown = useCallback((
+    event: DataTableKeyEvent,
+    context: DataTableRootKeyContext,
+  ) => {
+    if (onFocusSearch && context.selectedIndex <= 0 && isPlainArrowUp(event)) {
+      stopSearchFocusNavigation(event);
+      onFocusSearch();
+      return true;
+    }
     if (event.name !== "r") return false;
     event.preventDefault?.();
     event.stopPropagation?.();
     reload();
     return true;
-  }, [reload]);
+  }, [onFocusSearch, reload]);
 
   const handleDetailKeyDown = useCallback((event: DataTableKeyEvent) => {
     if (event.name !== "o") return false;

package/src/plugins/builtin/comparison-chart/index.test.tsx

@@ -6,6 +6,7 @@ import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../
 import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
 import {
   AppContext,
+  type AppAction,
   createInitialState,
   PaneInstanceProvider,
 } from "../../../state/app/context";
@@ -13,7 +14,7 @@ import { Box } from "../../../ui";
 import { cloneLayout, createDefaultConfig } from "../../../types/config";
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
 import type { DataProvider } from "../../../types/data-provider";
-import type { TickerFinancials } from "../../../types/financials";
+import type { PricePoint, TickerFinancials } from "../../../types/financials";
 import type { PluginRegistry } from "../../registry";
 import { PluginRenderProvider, type PluginRuntimeAccess } from "../../runtime";
 import { setSharedMarketDataForTests, setSharedRegistryForTests } from "../../registry";
@@ -30,6 +31,12 @@ let root: ReturnType<typeof createRoot> | undefined;
 let sharedCoordinator: MarketDataCoordinator | null = null;
 const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
 
+interface ComparisonHarnessOptions {
+  dispatch?: (action: AppAction) => void;
+  focused?: boolean;
+  focusedPaneId?: string | null;
+}
+
 function makeTicker(symbol: string, currency: string): TickerRecord {
   return {
     metadata: {
@@ -68,6 +75,35 @@ function makeFinancials(symbol: string, currency: string, closes: number[]): Tic
   };
 }
 
+function makeDatedFinancials(symbol: string, currency: string, closes: Array<[string, number]>): TickerFinancials {
+  const latest = closes.at(-1);
+  const latestClose = latest?.[1] ?? 0;
+  const latestDate = latest ? Date.parse(`${latest[0]}T00:00:00Z`) : Date.now();
+  return {
+    annualStatements: [],
+    quarterlyStatements: [],
+    quote: {
+      symbol,
+      price: latestClose,
+      currency,
+      change: latestClose - (closes[0]?.[1] ?? latestClose),
+      changePercent: closes[0]?.[1] ? ((latestClose - closes[0]![1]) / closes[0]![1]) * 100 : 0,
+      lastUpdated: latestDate,
+    },
+    priceHistory: closes.map(([date, close]) => ({
+      date: new Date(`${date}T00:00:00Z`),
+      close,
+    })),
+  };
+}
+
+function makeDatedPriceHistory(closes: Array<[string, number]>): PricePoint[] {
+  return closes.map(([date, close]) => ({
+    date: new Date(`${date}T00:00:00Z`),
+    close,
+  }));
+}
+
 function createProvider(historyBySymbol: Record<string, number[]>, currencyBySymbol: Record<string, string>): DataProvider {
   return {
     id: "test-provider",
@@ -101,6 +137,46 @@ function createProvider(historyBySymbol: Record<string, number[]>, currencyBySym
   };
 }
 
+function createDatedProvider(financialsBySymbol: Record<string, TickerFinancials>): DataProvider {
+  const provider = createProvider({}, {});
+  provider.getTickerFinancials = async (symbol) => financialsBySymbol[symbol] ?? makeDatedFinancials(symbol, "USD", []);
+  provider.getQuote = async (symbol) => financialsBySymbol[symbol]?.quote ?? {
+    symbol,
+    price: 0,
+    currency: "USD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.now(),
+  };
+  provider.getPriceHistory = async (symbol) => financialsBySymbol[symbol]?.priceHistory ?? [];
+  provider.getPriceHistoryForResolution = async (symbol) => financialsBySymbol[symbol]?.priceHistory ?? [];
+  return provider;
+}
+
+function createRangeAwareDatedProvider({
+  fullHistoryBySymbol,
+  shortHistoryBySymbol,
+}: {
+  fullHistoryBySymbol: Record<string, Array<[string, number]>>;
+  shortHistoryBySymbol: Record<string, Array<[string, number]>>;
+}): DataProvider {
+  const financialsBySymbol = Object.fromEntries(
+    Object.entries(shortHistoryBySymbol).map(([symbol, history]) => [
+      symbol,
+      makeDatedFinancials(symbol, "USD", history),
+    ]),
+  );
+  const provider = createDatedProvider(financialsBySymbol);
+  const resolveHistory = (symbol: string, range: string) => makeDatedPriceHistory(
+    range === "5Y"
+      ? fullHistoryBySymbol[symbol] ?? shortHistoryBySymbol[symbol] ?? []
+      : shortHistoryBySymbol[symbol] ?? [],
+  );
+  provider.getPriceHistory = async (symbol, _exchange, range) => resolveHistory(symbol, range);
+  provider.getPriceHistoryForResolution = async (symbol, _exchange, range) => resolveHistory(symbol, range);
+  return provider;
+}
+
 function createRegistrySpy(spy: { selected: string[]; focused: string[] }): PluginRegistry {
   return {
     selectTicker: (symbol: string) => { spy.selected.push(symbol); },
@@ -133,7 +209,13 @@ function createComparisonHarness(
   tickers: TickerRecord[],
   financials: Array<[string, TickerFinancials]>,
   runtime: PluginRuntimeAccess,
+  options: ComparisonHarnessOptions = {},
 ) {
+  const {
+    dispatch = () => {},
+    focused = true,
+    focusedPaneId = focused ? TEST_PANE_ID : null,
+  } = options;
   const config = createDefaultConfig("/tmp/gloomberb-compare");
   const layout = {
     dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
@@ -151,7 +233,7 @@ function createComparisonHarness(
     layouts: [{ name: "Default", layout: cloneLayout(layout) }],
   };
   const state = createInitialState(nextConfig);
-  state.focusedPaneId = TEST_PANE_ID;
+  state.focusedPaneId = focusedPaneId;
   state.tickers = new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker]));
   state.financials = new Map(financials);
 
@@ -164,7 +246,7 @@ function createComparisonHarness(
   }) => ReactElement;
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
+    <AppContext value={{ state, dispatch }}>
       <PaneInstanceProvider paneId={TEST_PANE_ID}>
         <PluginRenderProvider pluginId="comparison-chart" runtime={runtime}>
           <PaneFooterProvider>
@@ -173,11 +255,11 @@ function createComparisonHarness(
                 <ComparisonPane
                   paneId={TEST_PANE_ID}
                   paneType="comparison-chart"
-                  focused
+                  focused={focused}
                   width={120}
                   height={19}
                 />
-                <PaneFooterBar footer={footer} focused width={120} />
+                <PaneFooterBar footer={footer} focused={focused} width={120} />
               </Box>
             )}
           </PaneFooterProvider>
@@ -203,13 +285,14 @@ async function mountComparisonHarness(
   tickers: TickerRecord[],
   financials: Array<[string, TickerFinancials]>,
   spy: { selected: string[]; focused: string[]; settings?: string[] } = { selected: [], focused: [] },
+  options: ComparisonHarnessOptions = {},
 ) {
   actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
   testSetup = await createTestRenderer({ width: 120, height: 20 });
   root = createRoot(testSetup.renderer);
   await act(async () => {
     root!.render(
-      createComparisonHarness(settings, tickers, financials, createRuntimeSpy(spy)),
+      createComparisonHarness(settings, tickers, financials, createRuntimeSpy(spy), options),
     );
     await Promise.resolve();
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -314,7 +397,7 @@ describe("comparisonChartPlugin", () => {
     expect(frame).not.toContain("side by side");
   });
 
-  test("updates every legend value from the crosshair position", async () => {
+  test("updates every return summary range value from the crosshair position", async () => {
     const provider = createProvider({
       AAPL: [100, 102, 104],
       MSFT: [200, 202, 204],
@@ -343,8 +426,12 @@ describe("comparisonChartPlugin", () => {
 
     let frame = testSetup!.captureCharFrame();
     expect(frame).not.toContain("AAPL - 1D");
-    expect(frame).toContain("AAPL $104.00 +4.00%");
-    expect(frame).toContain("MSFT $204.00 +2.00%");
+    expect(frame).toContain("Sym");
+    expect(frame).toContain("Rng");
+    expect(frame).toContain("1Y");
+    expect(frame).toContain("5Y");
+    expect(frame).toMatch(/> AAPL\s+\+4\.00%/);
+    expect(frame).toMatch(/MSFT\s+\+2\.00%/);
 
     await act(async () => {
       await testSetup!.mockMouse.moveTo(2, 4);
@@ -353,8 +440,124 @@ describe("comparisonChartPlugin", () => {
     await flushFrames();
 
     frame = testSetup!.captureCharFrame();
-    expect(frame).toContain("AAPL $100.00 0.00%");
-    expect(frame).toContain("MSFT $200.00 0.00%");
+    expect(frame).toMatch(/> AAPL\s+0\.00%/);
+    expect(frame).toMatch(/MSFT\s+0\.00%/);
+  });
+
+  test("focuses the pane when an unfocused comparison plot is clicked", async () => {
+    const dispatched: AppAction[] = [];
+    const provider = createProvider({
+      AAPL: [100, 102, 104],
+      MSFT: [200, 202, 204],
+    }, {
+      AAPL: "USD",
+      MSFT: "USD",
+    });
+    setSharedMarketDataForTests(provider);
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    await mountComparisonHarness({
+      axisMode: "percent",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+    ], [
+      ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104])],
+      ["MSFT", makeFinancials("MSFT", "USD", [200, 202, 204])],
+    ], { selected: [], focused: [] }, {
+      dispatch: (action) => { dispatched.push(action); },
+      focused: false,
+      focusedPaneId: "ticker-detail:main",
+    });
+
+    await flushFrames();
+    await act(async () => {
+      await testSetup!.mockMouse.click(20, 8);
+      await testSetup!.renderOnce();
+    });
+
+    expect(dispatched).toContainEqual({ type: "FOCUS_PANE", paneId: TEST_PANE_ID });
+  });
+
+  test("keeps fixed return horizons independent from the selected chart range", async () => {
+    const shortHistory = {
+      AAPL: [["2025-01-02", 180], ["2026-01-02", 200]],
+      MSFT: [["2025-01-02", 300], ["2026-01-02", 330]],
+    } satisfies Record<string, Array<[string, number]>>;
+    const fullHistory = {
+      AAPL: [["2021-01-02", 100], ["2023-01-02", 150], ["2025-01-02", 180], ["2026-01-02", 200]],
+      MSFT: [["2021-01-02", 220], ["2023-01-02", 270], ["2025-01-02", 300], ["2026-01-02", 330]],
+    } satisfies Record<string, Array<[string, number]>>;
+    const provider = createRangeAwareDatedProvider({
+      fullHistoryBySymbol: fullHistory,
+      shortHistoryBySymbol: shortHistory,
+    });
+    setSharedMarketDataForTests(provider);
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    await mountComparisonHarness({
+      axisMode: "percent",
+      rangePreset: "1Y",
+      chartResolution: "1d",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+    ], [
+      ["AAPL", makeDatedFinancials("AAPL", "USD", shortHistory.AAPL)],
+      ["MSFT", makeDatedFinancials("MSFT", "USD", shortHistory.MSFT)],
+    ]);
+
+    await flushFrames(8);
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("5Y");
+    expect(frame).toMatch(/> AAPL\s+\+11\.11%[^\n]*\+100\.00%/);
+    expect(frame).toMatch(/MSFT\s+\+10\.00%[^\n]*\+50\.00%/);
+  });
+
+  test("sorts comparison summary rows by one-year return", async () => {
+    const rows = {
+      SLOW: makeDatedFinancials("SLOW", "USD", [["2025-01-02", 100], ["2026-01-02", 105]]),
+      FAST: makeDatedFinancials("FAST", "USD", [["2025-01-02", 100], ["2026-01-02", 150]]),
+      MID: makeDatedFinancials("MID", "USD", [["2025-01-02", 100], ["2026-01-02", 125]]),
+    };
+    const provider = createDatedProvider(rows);
+    setSharedMarketDataForTests(provider);
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    await mountComparisonHarness({
+      axisMode: "percent",
+      symbols: ["SLOW", "FAST", "MID"],
+      symbolsText: "SLOW, FAST, MID",
+    }, [
+      makeTicker("SLOW", "USD"),
+      makeTicker("FAST", "USD"),
+      makeTicker("MID", "USD"),
+    ], Object.entries(rows));
+
+    await flushFrames();
+
+    const frame = testSetup!.captureCharFrame();
+    const table = frame.slice(frame.indexOf("Sym"));
+    const fastIndex = table.indexOf("FAST");
+    const midIndex = table.indexOf("MID");
+    const slowIndex = table.indexOf("SLOW");
+
+    expect(fastIndex).toBeGreaterThanOrEqual(0);
+    expect(midIndex).toBeGreaterThanOrEqual(0);
+    expect(slowIndex).toBeGreaterThanOrEqual(0);
+    expect(fastIndex).toBeLessThan(midIndex);
+    expect(midIndex).toBeLessThan(slowIndex);
   });
 
   test("extends lagging comparison histories with the latest quote", async () => {
@@ -406,11 +609,11 @@ describe("comparisonChartPlugin", () => {
     await flushFrames();
 
     const frame = testSetup!.captureCharFrame();
-    expect(frame).toContain("AAPL $150.00 +");
-    expect(frame).toContain("MSFT $250.00 +");
+    expect(frame).toMatch(/> AAPL\s+\+47\.06%/);
+    expect(frame).toMatch(/MSFT\s+\+23\.76%/);
   });
 
-  test("updates comparison legends from chart-owned quote streams", async () => {
+  test("updates comparison return summary from chart-owned quote streams", async () => {
     let emitQuote: ((symbol: string, price: number) => void) | null = null;
     const provider = createProvider({
       AAPL: [100, 102],
@@ -464,7 +667,7 @@ describe("comparisonChartPlugin", () => {
     await flushFrames();
 
     const frame = testSetup!.captureCharFrame();
-    expect(frame).toContain("AAPL $155.00 +");
+    expect(frame).toMatch(/> AAPL\s+\+51\.96%/);
   });
 
   test("does not refetch resolution support when only comparison prices update", async () => {