gloomberb 0.7.4 → 0.8.0

package/src/components/ticker-badge-text.test.tsx

@@ -1,253 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { act } from "react";
-import { testRender } from "../renderers/opentui/test-utils";
-import { TickerBadgeText } from "./ticker-badge-text";
-import type { InlineTickerCatalogEntry } from "../state/use-inline-tickers";
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-afterEach(() => {
-  if (testSetup) {
-    testSetup.renderer.destroy();
-    testSetup = undefined;
-  }
-});
-
-function makeCatalogEntry(overrides?: Partial<InlineTickerCatalogEntry>): InlineTickerCatalogEntry {
-  return {
-    status: "ready",
-    ticker: null,
-    quote: {
-      symbol: "TSLA",
-      price: 250,
-      currency: "USD",
-      change: -12.5,
-      changePercent: -5,
-      lastUpdated: Date.now(),
-    },
-    ...overrides,
-  };
-}
-
-describe("TickerBadgeText", () => {
-  test("renders live ticker badges when quote data exists", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Watching $TSLA now"
-        lineWidth={40}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 40, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    expect(testSetup.captureCharFrame()).toContain("TSLA -5%");
-  });
-
-  test("falls back to the raw token when resolution failed", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Watching $TSLA now"
-        lineWidth={40}
-        catalog={{ TSLA: makeCatalogEntry({ status: "missing", quote: null }) }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 40, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("$TSLA");
-    expect(frame).not.toContain("TSLA -5%");
-  });
-
-  test("opens the ticker detail pane when a badge is clicked", async () => {
-    const opened: string[] = [];
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Watching $TSLA now"
-        lineWidth={40}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={(symbol) => opened.push(symbol)}
-      />,
-      { width: 40, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const lines = testSetup.captureCharFrame().split("\n");
-    const row = lines.findIndex((line) => line.includes("TSLA -5%"));
-    const col = lines[row]?.indexOf("TSLA -5%") ?? -1;
-
-    expect(row).toBeGreaterThanOrEqual(0);
-    expect(col).toBeGreaterThanOrEqual(0);
-
-    await act(async () => {
-      await testSetup!.mockMouse.click(col + 1, row);
-      await testSetup!.renderOnce();
-    });
-
-    expect(opened).toEqual(["TSLA"]);
-  });
-
-  test("renders inline links alongside ticker badges", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Read https://example.com while watching $TSLA"
-        lineWidth={60}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 60, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("https://example.com");
-    expect(frame).toContain("TSLA -5%");
-  });
-
-  test("wraps long text chunks at word boundaries", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Demand/supply unit economics move with ASML orders"
-        lineWidth={18}
-        catalog={{}}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 20, height: 5 },
-    );
-
-    await testSetup.renderOnce();
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Demand/supply");
-    expect(frame).toContain("economics");
-    expect(frame.split("\n").filter((line) => line.trim()).length).toBeGreaterThan(1);
-  });
-
-  test("renders hard line breaks as separate rows", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text={"First $TSLA line\nSecond line"}
-        lineWidth={60}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 60, height: 5 },
-    );
-
-    await testSetup.renderOnce();
-
-    const lines = testSetup.captureCharFrame().split("\n");
-    const firstRow = lines.findIndex((line) => line.includes("First"));
-    const secondRow = lines.findIndex((line) => line.includes("Second line"));
-
-    expect(firstRow).toBeGreaterThanOrEqual(0);
-    expect(secondRow).toBeGreaterThan(firstRow);
-    expect(lines[firstRow]).toContain("TSLA -5%");
-  });
-
-  test("opens detected links without trailing punctuation when clicked", async () => {
-    const opened: string[] = [];
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Read https://example.com/story."
-        lineWidth={60}
-        catalog={{}}
-        textColor="#ffffff"
-        openTicker={() => {}}
-        openLink={(url) => opened.push(url)}
-      />,
-      { width: 60, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const lines = testSetup.captureCharFrame().split("\n");
-    const row = lines.findIndex((line) => line.includes("https://example.com/story."));
-    const col = lines[row]?.indexOf("https://example.com/story") ?? -1;
-
-    expect(row).toBeGreaterThanOrEqual(0);
-    expect(col).toBeGreaterThanOrEqual(0);
-
-    await act(async () => {
-      await testSetup!.mockMouse.click(col + 1, row);
-      await testSetup!.renderOnce();
-    });
-
-    expect(opened).toEqual(["https://example.com/story"]);
-  });
-
-  test("shows the current price when the badge is hovered", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Watching $TSLA now"
-        lineWidth={40}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 40, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const lines = testSetup.captureCharFrame().split("\n");
-    const row = lines.findIndex((line) => line.includes("TSLA -5%"));
-    const col = lines[row]?.indexOf("TSLA -5%") ?? -1;
-
-    expect(row).toBeGreaterThanOrEqual(0);
-    expect(col).toBeGreaterThanOrEqual(0);
-
-    await act(async () => {
-      await testSetup!.mockMouse.moveTo(col + 1, row);
-      await testSetup!.renderOnce();
-    });
-
-    expect(testSetup.captureCharFrame()).toContain("TSLA $250.00");
-  });
-
-  test("restores the change label when the mouse leaves the badge", async () => {
-    testSetup = await testRender(
-      <TickerBadgeText
-        text="Watching $TSLA now"
-        lineWidth={40}
-        catalog={{ TSLA: makeCatalogEntry() }}
-        textColor="#ffffff"
-        openTicker={() => {}}
-      />,
-      { width: 40, height: 4 },
-    );
-
-    await testSetup.renderOnce();
-
-    const lines = testSetup.captureCharFrame().split("\n");
-    const row = lines.findIndex((line) => line.includes("TSLA -5%"));
-    const col = lines[row]?.indexOf("TSLA -5%") ?? -1;
-
-    expect(row).toBeGreaterThanOrEqual(0);
-    expect(col).toBeGreaterThanOrEqual(0);
-
-    await act(async () => {
-      await testSetup!.mockMouse.moveTo(col + 1, row);
-      await testSetup!.renderOnce();
-      await testSetup!.mockMouse.moveTo(0, 3);
-      await testSetup!.renderOnce();
-    });
-
-    const frame = testSetup.captureCharFrame();
-    expect(frame).toContain("TSLA -5%");
-    expect(frame).not.toContain("TSLA $250.00");
-  });
-});

package/src/components/ticker-badge-text.tsx

@@ -1,113 +0,0 @@
-import { Box, Text } from "../ui";
-import { useState } from "react";
-import { TickerBadge } from "./ticker-badge";
-import { ExternalLinkText, openUrl } from "./ui";
-import { tokenizeInlineContent } from "../utils/inline-content-tokenizer";
-import type { InlineTickerCatalogEntry } from "../state/use-inline-tickers";
-import { displayWidth } from "../utils/format";
-
-export interface TickerBadgeTextProps {
-  text: string;
-  lineWidth: number;
-  catalog: Record<string, InlineTickerCatalogEntry>;
-  textColor: string;
-  openTicker: (symbol: string) => void;
-  openLink?: (url: string) => void;
-}
-
-function splitLongTextSegment(value: string, lineWidth: number): string[] {
-  if (displayWidth(value) <= lineWidth) return [value];
-
-  const chunks: string[] = [];
-  let current = "";
-  for (const char of Array.from(value)) {
-    const next = `${current}${char}`;
-    if (current && displayWidth(next) > lineWidth) {
-      chunks.push(current);
-      current = char;
-      continue;
-    }
-    current = next;
-  }
-  if (current) chunks.push(current);
-  return chunks;
-}
-
-function splitTextForWrap(value: string, lineWidth: number): string[] {
-  const width = Math.max(1, lineWidth);
-  const segments = value.match(/\S+\s*|\s+/g) ?? [value];
-  return segments.flatMap((segment) => splitLongTextSegment(segment, width));
-}
-
-export function TickerBadgeText({
-  text,
-  lineWidth,
-  catalog,
-  textColor,
-  openTicker,
-  openLink = openUrl,
-}: TickerBadgeTextProps) {
-  const [hoveredSymbol, setHoveredSymbol] = useState<string | null>(null);
-  const lines = text.split("\n");
-
-  return (
-    <Box
-      flexDirection="column"
-      width={lineWidth}
-    >
-      {lines.map((line, lineIndex) => {
-        if (!line) return <Box key={`line:${lineIndex}`} height={1} />;
-
-        return (
-          <Box
-            key={`line:${lineIndex}`}
-            flexDirection="row"
-            flexWrap="wrap"
-            width={lineWidth}
-          >
-            {tokenizeInlineContent(line).map((token, index) => {
-              if (token.kind === "text") {
-                if (!token.value) return null;
-                return splitTextForWrap(token.value, lineWidth).map((part, partIndex) => (
-                  <Text key={`text:${lineIndex}:${index}:${partIndex}`} fg={textColor}>{part}</Text>
-                ));
-              }
-
-              if (token.kind === "link") {
-                return (
-                  <ExternalLinkText
-                    key={`link:${lineIndex}:${index}`}
-                    url={token.url}
-                    label={token.value}
-                    color={textColor}
-                    onOpen={openLink}
-                  />
-                );
-              }
-
-              const entry = catalog[token.symbol];
-              if (!entry || entry.status === "missing") {
-                return <Text key={`raw:${lineIndex}:${index}`} fg={textColor}>{token.value}</Text>;
-              }
-
-              return (
-                <TickerBadge
-                  key={`badge:${lineIndex}:${index}:${token.symbol}`}
-                  symbol={token.symbol}
-                  status={entry.status}
-                  quote={entry.quote}
-                  hovered={hoveredSymbol === token.symbol}
-                  onHoverStart={() => setHoveredSymbol(token.symbol)}
-                  onHoverEnd={() => {
-                    setHoveredSymbol((current) => (current === token.symbol ? null : current));
-                  }}
-                  onOpen={openTicker}
-                />
-              );
-            })}
-          </Box>
-        );
-      })}
-    </Box>
-  );
-}

package/src/components/ticker-badge.tsx

@@ -1,109 +0,0 @@
-import { Box, Text, useTickerContextMenu, useUiCapabilities } from "../ui";
-import { TextAttributes } from "../ui";
-import { colors, priceColor } from "../theme/colors";
-import { getSharedRegistry } from "../plugins/registry";
-import { formatMarketPriceWithCurrency } from "../utils/market-format";
-import type { Quote } from "../types/financials";
-
-export interface TickerBadgeProps {
-  symbol: string;
-  status: "loading" | "ready";
-  quote: Quote | null;
-  hovered?: boolean;
-  onHoverStart?: () => void;
-  onHoverEnd?: () => void;
-  onOpen: (symbol: string) => void;
-}
-
-function blendHex(base: string, accent: string, ratio: number): string {
-  const parse = (hex: string) => {
-    const value = hex.replace("#", "");
-    return [
-      parseInt(value.slice(0, 2), 16),
-      parseInt(value.slice(2, 4), 16),
-      parseInt(value.slice(4, 6), 16),
-    ] as const;
-  };
-  const [br, bg, bb] = parse(base);
-  const [ar, ag, ab] = parse(accent);
-  const mix = (left: number, right: number) => Math.round(left + (right - left) * ratio)
-    .toString(16)
-    .padStart(2, "0");
-  return `#${mix(br, ar)}${mix(bg, ag)}${mix(bb, ab)}`;
-}
-
-function formatBadgeChange(changePercent: number): string {
-  const rounded = Math.round(changePercent * 10) / 10;
-  const normalized = Object.is(rounded, -0) ? 0 : rounded;
-  if (normalized === 0) return "0%";
-  const abs = Math.abs(normalized);
-  const body = Number.isInteger(abs) ? abs.toFixed(0) : abs.toFixed(1);
-  return `${normalized > 0 ? "+" : "-"}${body}%`;
-}
-
-export function TickerBadge({
-  symbol,
-  status,
-  quote,
-  hovered = false,
-  onHoverStart,
-  onHoverEnd,
-  onOpen,
-}: TickerBadgeProps) {
-  const registry = getSharedRegistry();
-  const { nativeContextMenu } = useUiCapabilities();
-  const ticker = typeof registry?.getTickerFn === "function" ? registry.getTickerFn(symbol) : null;
-  const financials = typeof registry?.getDataFn === "function" ? registry.getDataFn(symbol) : null;
-  const openTickerContextMenu = useTickerContextMenu({
-    ticker,
-    financials,
-    onOpen,
-  });
-  const tone = status === "ready" && quote ? priceColor(quote.changePercent) : colors.borderFocused;
-  const label = hovered && quote
-    ? `${symbol} ${formatMarketPriceWithCurrency(quote.price, quote.currency, { minimumFractionDigits: 2 })}`
-    : status === "ready" && quote
-    ? formatBadgeChange(quote.changePercent)
-    : "…";
-  const text = hovered && quote ? label : `${symbol} ${label}`;
-  const color = hovered ? colors.textBright : tone;
-  const backgroundColor = hovered
-    ? blendHex(colors.bg, tone, 0.42)
-    : blendHex(colors.bg, tone, 0.18);
-  const interactive = status === "ready";
-
-  return (
-    <Box paddingRight={1} flexShrink={0}>
-      <Box
-        paddingX={1}
-        backgroundColor={backgroundColor}
-        data-gloom-context-menu-surface="true"
-        onMouseOver={() => {
-          onHoverStart?.();
-        }}
-        onMouseOut={() => {
-          onHoverEnd?.();
-        }}
-        onMouseDown={(event: any) => {
-          if (event.button === 2) {
-            if (nativeContextMenu !== true) {
-              void openTickerContextMenu(event);
-            }
-            return;
-          }
-          event.stopPropagation?.();
-          event.preventDefault?.();
-          if (!interactive) return;
-          onOpen(symbol);
-        }}
-        onContextMenu={(event: any) => {
-          void openTickerContextMenu(event);
-        }}
-      >
-        <Text fg={color} attributes={TextAttributes.BOLD}>
-          {text}
-        </Text>
-      </Box>
-    </Box>
-  );
-}

package/src/components/ticker-list-table-view.tsx

@@ -1,233 +0,0 @@
-import {
-  useCallback,
-  useEffect,
-  useRef,
-  type ReactNode,
-  type RefObject,
-} from "react";
-import type { ScrollBoxRenderable } from "../ui";
-import { useShortcut } from "../react/input";
-import { TickerListTable, type TickerListTableProps } from "./ticker-list-table";
-import type { TickerRecord } from "../types/ticker";
-import type { DataTableKeyEvent } from "./data-table-view";
-import {
-  isNextTableRowKey,
-  isPreviousTableRowKey,
-  isTableActivationKey,
-  stopTableKey,
-  TableViewFrame,
-  useResetTableScroll,
-  useTableBodyScrollActivity,
-  useTableViewState,
-} from "./table-view-shared";
-
-export interface TickerListVisibleRange {
-  start: number;
-  end: number;
-}
-
-export interface TickerListTableViewProps extends Omit<
-  TickerListTableProps,
-  | "headerScrollRef"
-  | "scrollRef"
-  | "syncHeaderScroll"
-  | "onBodyScrollActivity"
-  | "hoveredIdx"
-  | "setHoveredIdx"
-> {
-  focused?: boolean;
-  rootBefore?: ReactNode;
-  rootAfter?: ReactNode;
-  rootWidth?: number;
-  rootHeight?: number;
-  rootBackgroundColor?: string;
-  headerScrollRef?: RefObject<ScrollBoxRenderable | null>;
-  scrollRef?: RefObject<ScrollBoxRenderable | null>;
-  syncHeaderScroll?: () => void;
-  onBodyScrollActivity?: () => void;
-  hoveredIdx?: number | null;
-  setHoveredIdx?: (index: number | null) => void;
-  keyboardNavigation?: boolean;
-  onRootKeyDown?: (event: DataTableKeyEvent) => boolean | void;
-  onSelectIndex?: (index: number, ticker: TickerRecord) => void;
-  onActivateIndex?: (index: number, ticker: TickerRecord) => void;
-  onVisibleRangeChange?: (range: TickerListVisibleRange) => void;
-  visibleRangeBuffer?: number;
-  resetScrollKey?: unknown;
-}
-
-export function TickerListTableView({
-  focused = false,
-  rootBefore,
-  rootAfter,
-  rootWidth,
-  rootHeight,
-  rootBackgroundColor,
-  headerScrollRef,
-  scrollRef,
-  syncHeaderScroll,
-  onBodyScrollActivity,
-  hoveredIdx,
-  setHoveredIdx,
-  keyboardNavigation = true,
-  onRootKeyDown,
-  onSelectIndex,
-  onActivateIndex,
-  onVisibleRangeChange,
-  visibleRangeBuffer = 0,
-  resetScrollKey,
-  ...tableProps
-}: TickerListTableViewProps) {
-  const {
-    effectiveHeaderScrollRef,
-    effectiveScrollRef,
-    effectiveHoveredIdx,
-    effectiveSetHoveredIdx,
-    effectiveSyncHeaderScroll,
-  } = useTableViewState({
-    headerScrollRef,
-    scrollRef,
-    syncHeaderScroll,
-    hoveredIdx,
-    setHoveredIdx,
-  });
-  const selectedIndex = tableProps.tickers.findIndex(
-    (ticker) => ticker.metadata.ticker === tableProps.cursorSymbol,
-  );
-  const lastScrollCursorSymbolRef = useRef<string | null | undefined>(undefined);
-
-  const emitVisibleRange = useCallback(() => {
-    if (!onVisibleRangeChange) return;
-    const scrollBox = effectiveScrollRef.current;
-    if (!scrollBox?.viewport) return;
-    const start = Math.max(0, scrollBox.scrollTop - visibleRangeBuffer);
-    const end = Math.min(
-      tableProps.tickers.length,
-      scrollBox.scrollTop + scrollBox.viewport.height + visibleRangeBuffer,
-    );
-    onVisibleRangeChange({ start, end });
-  }, [effectiveScrollRef, onVisibleRangeChange, tableProps.tickers.length, visibleRangeBuffer]);
-
-  const handleBodyScrollActivity = useTableBodyScrollActivity({
-    onBodyScrollActivity,
-    syncHeaderScroll: effectiveSyncHeaderScroll,
-    afterScroll: emitVisibleRange,
-  });
-
-  useEffect(() => {
-    const scrollBox = effectiveScrollRef.current;
-    if (!scrollBox?.viewport || !scrollBox.verticalScrollBar) return;
-    scrollBox.verticalScrollBar.visible = tableProps.tickers.length > scrollBox.viewport.height;
-    emitVisibleRange();
-  }, [emitVisibleRange, effectiveScrollRef, rootHeight, tableProps.tickers.length]);
-
-  useResetTableScroll({
-    headerScrollRef: effectiveHeaderScrollRef,
-    scrollRef: effectiveScrollRef,
-    resetScrollKey,
-    afterReset: emitVisibleRange,
-  });
-
-  const selectIndex = useCallback((index: number) => {
-    if (index < 0 || index >= tableProps.tickers.length) return;
-    const ticker = tableProps.tickers[index]!;
-    if (onSelectIndex) {
-      onSelectIndex(index, ticker);
-      return;
-    }
-    tableProps.setCursorSymbol(ticker.metadata.ticker);
-  }, [onSelectIndex, tableProps]);
-
-  const activateIndex = useCallback((index: number) => {
-    if (index < 0 || index >= tableProps.tickers.length) return;
-    const ticker = tableProps.tickers[index]!;
-    if (onActivateIndex) {
-      onActivateIndex(index, ticker);
-      return;
-    }
-    tableProps.onRowActivate?.(ticker);
-  }, [onActivateIndex, tableProps]);
-
-  const selectByOffset = useCallback((offset: -1 | 1) => {
-    if (tableProps.tickers.length === 0) return;
-    const nextIndex = selectedIndex >= 0
-      ? Math.max(0, Math.min(selectedIndex + offset, tableProps.tickers.length - 1))
-      : 0;
-    selectIndex(nextIndex);
-  }, [selectIndex, selectedIndex, tableProps.tickers.length]);
-
-  const activateSelection = useCallback(() => {
-    if (tableProps.tickers.length === 0) return;
-    activateIndex(selectedIndex >= 0 ? selectedIndex : 0);
-  }, [activateIndex, selectedIndex, tableProps.tickers.length]);
-
-  useShortcut((event) => {
-    if (event.defaultPrevented || event.propagationStopped) return;
-    if (!focused || !keyboardNavigation) return;
-
-    if (onRootKeyDown?.(event)) return;
-    if (tableProps.tickers.length === 0) return;
-
-    if (isNextTableRowKey(event)) {
-      stopTableKey(event);
-      selectByOffset(1);
-      return;
-    }
-
-    if (isPreviousTableRowKey(event)) {
-      stopTableKey(event);
-      selectByOffset(-1);
-      return;
-    }
-
-    if (isTableActivationKey(event.name)) {
-      stopTableKey(event);
-      activateSelection();
-    }
-  });
-
-  useEffect(() => {
-    const scrollBox = effectiveScrollRef.current;
-    if (!scrollBox?.viewport || selectedIndex < 0) {
-      queueMicrotask(emitVisibleRange);
-      return;
-    }
-
-    const shouldScrollToCursor =
-      lastScrollCursorSymbolRef.current !== tableProps.cursorSymbol;
-    lastScrollCursorSymbolRef.current = tableProps.cursorSymbol;
-
-    if (!shouldScrollToCursor) {
-      queueMicrotask(emitVisibleRange);
-      return;
-    }
-
-    const viewportHeight = Math.max(scrollBox.viewport.height, 1);
-    if (selectedIndex < scrollBox.scrollTop) {
-      scrollBox.scrollTo(selectedIndex);
-    } else if (selectedIndex >= scrollBox.scrollTop + viewportHeight) {
-      scrollBox.scrollTo(selectedIndex - viewportHeight + 1);
-    }
-    queueMicrotask(emitVisibleRange);
-  }, [effectiveScrollRef, emitVisibleRange, selectedIndex, tableProps.cursorSymbol]);
-
-  return (
-    <TableViewFrame
-      width={rootWidth}
-      height={rootHeight}
-      backgroundColor={rootBackgroundColor}
-      before={rootBefore}
-      after={rootAfter}
-    >
-      <TickerListTable
-        {...tableProps}
-        headerScrollRef={effectiveHeaderScrollRef}
-        scrollRef={effectiveScrollRef}
-        syncHeaderScroll={effectiveSyncHeaderScroll}
-        onBodyScrollActivity={handleBodyScrollActivity}
-        hoveredIdx={effectiveHoveredIdx}
-        setHoveredIdx={effectiveSetHoveredIdx}
-      />
-    </TableViewFrame>
-  );
-}