gloomberb 0.15.2 → 0.15.3

package/src/components/onboarding/wizard-positions.ts

@@ -243,7 +243,7 @@ export function useOnboardingPositions({
       if (created) {
         pluginRegistry.events.emit("ticker:added", { symbol: nextTicker.metadata.ticker, ticker: nextTicker });
       }
-      pluginRegistry.events.emit("command-bar:portfolio-membership-persisted", {
+      pluginRegistry.events.emit("host:portfolio-ticker-saved", {
         symbol: nextTicker.metadata.ticker,
         portfolioId,
       });

package/src/components/paged-rows.ts

@@ -0,0 +1,217 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+/** One page of an offset-paged source. Extra fields (an as-of date, warnings) stay on `pages`. */
+export interface RowPage<T> {
+  rows: T[];
+  hasMore?: boolean;
+  /** Where the next page starts. Omitted, it is this page's offset plus the rows it returned. */
+  nextOffset?: number | null;
+}
+
+export interface PageRequest {
+  offset: number;
+  /** Aborted once the answer can no longer be shown: a newer query, a reload, or unmount. */
+  signal: AbortSignal;
+  /** Set on the first page of a `reload()`, for loaders that sit behind a cache. */
+  force: boolean;
+}
+
+export type PageLoader<P> = (request: PageRequest) => Promise<P>;
+
+/** The row type of a page, so callers write only the loader and get typed rows. */
+type PageRow<P> = P extends RowPage<infer T> ? T : never;
+
+export interface PagedRowsOptions<T> {
+  /** Drops rows a later page repeats, as when new items land between two requests. */
+  getId?: (row: T) => string;
+  /**
+   * Leave the previous loader's rows on screen until the new loader's first
+   * page answers, for a search that refines as the user types. Without it a
+   * new loader starts from an empty list.
+   */
+  keepPreviousRows?: boolean;
+}
+
+export interface PagedRows<T, P> {
+  rows: T[];
+  /** Every page loaded so far, first page first. */
+  pages: P[];
+  status: "idle" | "loading" | "loaded" | "error";
+  /** The first page is in flight, on first load or on `reload()`. */
+  loading: boolean;
+  /** The first page failed. A failed reload keeps the rows it had. */
+  error: Error | null;
+  loadingMore: boolean;
+  /** The last later page failed. Its rows stay, and the next `loadMore()` asks again. */
+  moreError: Error | null;
+  hasMore: boolean;
+  /** Appends the next page. A no-op while a page is in flight or nothing is left. */
+  loadMore: () => void;
+  /** Asks for the first page again with `force`, keeping the rows until it answers. */
+  reload: () => void;
+}
+
+interface PagedState<T, P> {
+  /** The loader these pages came from. */
+  owner: unknown;
+  pages: P[];
+  rows: T[];
+  nextOffset: number;
+  hasMore: boolean;
+  loading: boolean;
+  loadingMore: boolean;
+  error: Error | null;
+  moreError: Error | null;
+}
+
+// Shared so an empty list keeps one identity across renders and memoized
+// sorts and selection effects downstream do not rerun for nothing.
+const NONE: never[] = [];
+
+function emptyState<T, P>(owner: unknown, loading: boolean): PagedState<T, P> {
+  return { owner, pages: NONE, rows: NONE, nextOffset: 0, hasMore: false, loading, loadingMore: false, error: null, moreError: null };
+}
+
+function toError(cause: unknown): Error {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+function appendRows<T>(current: T[], next: T[], getId: ((row: T) => string) | undefined): T[] {
+  if (next.length === 0) return current;
+  if (!getId) return [...current, ...next];
+  const seen = new Set(current.map(getId));
+  const merged = [...current];
+  for (const row of next) {
+    const id = getId(row);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    merged.push(row);
+  }
+  return merged;
+}
+
+/**
+ * An offset-paged list: the first page, later pages appended on demand, and
+ * their loading and failure state. Pair `loadMore` with `useTableLoadMore`.
+ * Like `useAsyncResource`, a stable loader owns the list: a new loader (a new
+ * query or filter) aborts what is in flight and starts over, and null clears
+ * it. Answers from a superseded request are ignored.
+ */
+export function usePagedRows<P extends RowPage<unknown>>(
+  loadPage: PageLoader<P> | null,
+  options: PagedRowsOptions<PageRow<P>> = {},
+): PagedRows<PageRow<P>, P> {
+  type T = PageRow<P>;
+  const keepPreviousRows = options.keepPreviousRows === true;
+  const [state, setState] = useState<PagedState<T, P>>(() => emptyState(loadPage, !!loadPage));
+  const firstRequest = useRef<AbortController | null>(null);
+  const moreRequest = useRef<AbortController | null>(null);
+  // Read when a page lands so an inline getter cannot restart the list.
+  const getIdRef = useRef(options.getId);
+  getIdRef.current = options.getId;
+
+  const load = useCallback(async (force: boolean) => {
+    firstRequest.current?.abort();
+    moreRequest.current?.abort();
+    moreRequest.current = null;
+    if (!loadPage) {
+      firstRequest.current = null;
+      setState(emptyState(null, false));
+      return;
+    }
+    const controller = new AbortController();
+    firstRequest.current = controller;
+    setState((current) => current.owner === loadPage || keepPreviousRows
+      ? { ...current, loading: true, loadingMore: false, error: null, moreError: null }
+      : emptyState(loadPage, true));
+    try {
+      const page = await loadPage({ offset: 0, signal: controller.signal, force });
+      if (firstRequest.current !== controller) return;
+      firstRequest.current = null;
+      setState({
+        owner: loadPage,
+        pages: [page],
+        rows: page.rows as T[],
+        nextOffset: page.nextOffset ?? page.rows.length,
+        hasMore: page.hasMore === true,
+        loading: false,
+        loadingMore: false,
+        error: null,
+        moreError: null,
+      });
+    } catch (cause) {
+      if (firstRequest.current !== controller) return;
+      firstRequest.current = null;
+      setState((current) => ({
+        ...(current.owner === loadPage ? current : emptyState<T, P>(loadPage, false)),
+        hasMore: false,
+        loading: false,
+        error: toError(cause),
+      }));
+    }
+  }, [keepPreviousRows, loadPage]);
+
+  useEffect(() => {
+    void load(false);
+    return () => {
+      firstRequest.current?.abort();
+      firstRequest.current = null;
+      moreRequest.current?.abort();
+      moreRequest.current = null;
+    };
+  }, [load]);
+
+  const owned = state.owner === loadPage;
+  const loadMore = useCallback(() => {
+    // The refs, not this render's state, say whether a request is in flight:
+    // a reload and a scroll in the same tick must not page the list being replaced.
+    if (!loadPage || !owned || !state.hasMore || firstRequest.current || moreRequest.current) return;
+    const controller = new AbortController();
+    moreRequest.current = controller;
+    const offset = state.nextOffset;
+    setState((current) => ({ ...current, loadingMore: true, moreError: null }));
+    void (async () => {
+      try {
+        const page = await loadPage({ offset, signal: controller.signal, force: false });
+        if (moreRequest.current !== controller) return;
+        moreRequest.current = null;
+        setState((current) => ({
+          ...current,
+          pages: [...current.pages, page],
+          rows: appendRows(current.rows, page.rows as T[], getIdRef.current),
+          nextOffset: page.nextOffset ?? offset + page.rows.length,
+          hasMore: page.hasMore === true,
+          loadingMore: false,
+        }));
+      } catch (cause) {
+        if (moreRequest.current !== controller) return;
+        moreRequest.current = null;
+        setState((current) => ({ ...current, loadingMore: false, moreError: toError(cause) }));
+      }
+    })();
+  }, [loadPage, owned, state.hasMore, state.nextOffset]);
+
+  const reload = useCallback(() => { void load(true); }, [load]);
+
+  // Before a new loader's effect runs, and while its first page loads, the
+  // previous list is either hidden or (with keepPreviousRows) shown but inert.
+  const view = owned ? state
+    : !loadPage ? emptyState<T, P>(null, false)
+      : keepPreviousRows ? { ...state, hasMore: false, loading: true, loadingMore: false, error: null, moreError: null }
+        : emptyState<T, P>(loadPage, true);
+  // Rows kept from a previous loader are a placeholder, not this loader's answer.
+  const status = !owned && loadPage ? "loading"
+    : view.error ? "error" : view.pages.length > 0 ? "loaded" : view.loading ? "loading" : "idle";
+  return {
+    rows: view.rows,
+    pages: view.pages,
+    status,
+    loading: view.loading,
+    error: view.error,
+    loadingMore: view.loadingMore,
+    moreError: view.moreError,
+    hasMore: view.hasMore,
+    loadMore,
+    reload,
+  };
+}

package/src/components/pane-settings-dialog/field-dialogs.tsx

@@ -1,4 +1,4 @@
-import { Box, Text, useUiHost } from "../../ui";
+import { Box, Text, useUiCapabilities } from "../../ui";
 import { t } from "../../i18n";
 import { type AlertContext, useDialogKeyboard } from "../../ui/dialog";
 import { useEffect, useRef, useState } from "react";
@@ -116,7 +116,7 @@ function useTextFieldDialogController({
 }
 
 export function TextFieldDialog(props: TextFieldDialogProps) {
-  return useUiHost().kind === "desktop-web"
+  return useUiCapabilities().nativePaneChrome === true
     ? <DesktopTextFieldDialog {...props} />
     : <TuiTextFieldDialog {...props} />;
 }

package/src/components/pane-settings-dialog.tsx

@@ -1,4 +1,4 @@
-import { useUiHost } from "../ui";
+import { useUiCapabilities } from "../ui";
 import { type AlertContext, useDialog, useDialogKeyboard } from "../ui/dialog";
 import { useEffect, useRef, useState } from "react";
 import type { PaneSettingField } from "../types/plugin";
@@ -34,7 +34,7 @@ export function PaneSettingsDialogContent({
   applyFieldValue,
 }: PaneSettingsDialogContentProps) {
   const dialog = useDialog();
-  const isDesktop = useUiHost().kind === "desktop-web";
+  const isDesktop = useUiCapabilities().nativePaneChrome === true;
   const descriptor = pluginRegistry.resolvePaneSettings(paneId);
   const fields = descriptor?.settingsDef.fields ?? [];
   // The cursor steps over action rows that cannot run, as the mouse does.

package/src/components/price-sparkline/model.ts

@@ -1,6 +1,8 @@
+import { parseHex } from "../../theme/color-utils";
 import { colors, type ThemeColors } from "../../theme/colors";
 import { appendLiveQuotePoint } from "../../time-series/chart-data";
 import type { PricePoint, Quote } from "../../types/financials";
+import { clamp } from "../../utils/math";
 import { getPricePointTimestamp } from "../../utils/price-history";
 
 const SPARKLINE_FALLBACK_POINTS = 22;
@@ -9,31 +11,35 @@ const LIVE_POINT_STEPS = 64;
 
 export type PriceSparklineTrend = "positive" | "negative" | "neutral";
 export type PriceSparklinePeriod = "1D" | "1W" | "1M" | "1Y";
+/** A window, or "all" for every point of a series whose span the caller already chose. */
+export type SparklineWindow = PriceSparklinePeriod | "all";
 
 export interface SparklineSample {
   x: number;
   y: number;
 }
 
-const PERIOD_WINDOW_DAYS: Record<PriceSparklinePeriod, number> = {
+const PERIOD_WINDOW_DAYS: Record<SparklineWindow, number> = {
   "1D": 1,
   "1W": 7,
   "1M": 30,
   "1Y": 365,
+  all: Number.POSITIVE_INFINITY,
 };
 
-const PERIOD_FALLBACK_POINTS: Record<PriceSparklinePeriod, number> = {
+const PERIOD_FALLBACK_POINTS: Record<SparklineWindow, number> = {
   "1D": 2,
   "1W": 7,
   "1M": SPARKLINE_FALLBACK_POINTS,
   "1Y": 252,
+  all: Number.POSITIVE_INFINITY,
 };
 
 function closeValue(point: PricePoint): number | null {
   return Number.isFinite(point.close) ? point.close : null;
 }
 
-export function resolveSparklineHistory(priceHistory: PricePoint[], period: PriceSparklinePeriod = "1M"): PricePoint[] {
+export function resolveSparklineHistory(priceHistory: PricePoint[], period: SparklineWindow = "1M"): PricePoint[] {
   const validHistory = priceHistory.filter((point) => Number.isFinite(getPricePointTimestamp(point)));
   const latest = validHistory.at(-1);
   if (!latest) return [];
@@ -100,11 +106,8 @@ export function svgAreaPath(samples: SparklineSample[], baseline: number): strin
 
 export function colorWithAlpha(color: string, alpha: number): string {
   if (!/^#[0-9a-f]{6}$/i.test(color)) return color;
-  const normalized = color.replace("#", "");
-  const r = parseInt(normalized.slice(0, 2), 16);
-  const g = parseInt(normalized.slice(2, 4), 16);
-  const b = parseInt(normalized.slice(4, 6), 16);
-  return `rgba(${r}, ${g}, ${b}, ${Math.max(0, Math.min(1, alpha))})`;
+  const [r, g, b] = parseHex(color);
+  return `rgba(${r}, ${g}, ${b}, ${clamp(alpha, 0, 1)})`;
 }
 
 export function resolvePriceSparklineRange(

package/src/components/price-sparkline/view.tsx

@@ -5,7 +5,6 @@ import {
   Text,
   useNativeRenderer,
   useUiCapabilities,
-  useUiHost,
 } from "../../ui";
 import { useThemeColors } from "../../theme/theme-context";
 import type { PricePoint } from "../../types/financials";
@@ -21,6 +20,7 @@ import {
   svgPath,
   type PriceSparklinePeriod,
   type PriceSparklineTrend,
+  type SparklineWindow,
 } from "./model";
 import { renderPriceSparkline } from "./index";
 
@@ -142,24 +142,27 @@ export function PriceSparkline({
   period = "1M",
   height = SPARKLINE_HEIGHT,
   area = false,
+  color: colorOverride,
 }: {
   priceHistory: PricePoint[] | undefined;
   width: number;
   trend?: PriceSparklineTrend;
-  period?: PriceSparklinePeriod;
+  period?: SparklineWindow;
   height?: number;
   area?: boolean;
+  /** A series colour instead of the trend's, for a sparkline standing in for a chart. */
+  color?: string;
 }) {
   const colors = useThemeColors();
-  const uiHost = useUiHost();
+  const { nativePaneChrome } = useUiCapabilities();
   const sparklineHistory = useMemo(() => resolveSparklineHistory(priceHistory ?? [], period), [period, priceHistory]);
   const values = useMemo(() => sparklineValues(sparklineHistory), [sparklineHistory]);
   if (values.length < 2) {
     return <Text fg={colors.textMuted}>{" "}</Text>;
   }
 
-  const color = sparklineColor(values, trend, colors);
-  return uiHost.kind === "desktop-web"
+  const color = colorOverride ?? sparklineColor(values, trend, colors);
+  return nativePaneChrome
     ? <DesktopPriceSparkline values={values} width={width} height={height} color={color} emptyColor={colors.textMuted} />
     : <TerminalPriceSparkline priceHistory={sparklineHistory} values={values} width={width} height={height} color={color} area={area} />;
 }
@@ -177,10 +180,10 @@ export function PriceAreaSparklineBackground({
   insetTop?: number;
 }) {
   const colors = useThemeColors();
-  const uiHost = useUiHost();
+  const { nativePaneChrome } = useUiCapabilities();
   const sparklineHistory = useMemo(() => resolveSparklineHistory(priceHistory ?? [], period), [period, priceHistory]);
   const values = useMemo(() => sparklineValues(sparklineHistory), [sparklineHistory]);
-  if (uiHost.kind !== "desktop-web" || values.length < 2) return null;
+  if (!nativePaneChrome || values.length < 2) return null;
 
   const color = sparklineColor(values, trend, colors);
   const baseline = 100;

package/src/components/sign-in-code-panel.tsx

@@ -0,0 +1,128 @@
+import { useMemo } from "react";
+import { t } from "../i18n";
+import { useAppLanguage } from "../i18n/react";
+import { useShortcut } from "../react/input";
+import { colors } from "../theme/colors";
+import { Box, Text, TextAttributes, useUiCapabilities, useRendererHost } from "../ui";
+import { Button } from "./ui/button";
+import { renderAsciiText } from "../ui/ascii-font";
+import { renderQrLines, renderQrSvgDataUri } from "../ui/qr";
+import { isPlainKey } from "../utils/keyboard";
+
+// Phone cameras need dark-on-light no matter what the terminal theme is.
+const QR_FG = "#000000";
+const QR_BG = "#ffffff";
+
+/**
+ * A browser hand-off: button, QR code, short code, the URL, and a live status.
+ * Used to sign in to Gloom and to connect a broker. Degrades by height: the QR
+ * needs its full module grid, so short terminals drop decoration first and
+ * finally fall back to the code plus URL, which works over SSH too.
+ */
+export function SignInCodePanel({
+  url,
+  code,
+  status,
+  height,
+  shortcutScope,
+}: {
+  url: string | null;
+  code: string | null;
+  status: { text: string; color: string };
+  /** Rows available to this panel; drives the degradation tiers. */
+  height: number;
+  /**
+   * Scope for the browser key. A host that holds every key it does not use
+   * (the sign-in gate) passes its own, so the key runs ahead of the hold.
+   */
+  shortcutScope: string;
+}) {
+  useAppLanguage();
+  const renderer = useRendererHost();
+  const desktop = useUiCapabilities().nativePaneChrome === true;
+  // Cell lines still drive layout on desktop: they give the code its row/column
+  // footprint, but the pixels come from the SVG below.
+  const qrLines = useMemo(() => (url ? renderQrLines(url) : []), [url]);
+  const qrImage = useMemo(() => (desktop && url ? renderQrSvgDataUri(url) : undefined), [desktop, url]);
+  useShortcut((event) => {
+    if (!isPlainKey(event, "b") || !url) return;
+    event.preventDefault(); event.stopPropagation();
+    void renderer.openExternal(url).catch(() => {});
+  }, { scope: shortcutScope, phase: "before" });
+
+  // Reserve the browser button before fitting the QR, code, and status.
+  const contentHeight = height - (url ? 2 : 0);
+  const showQr = qrLines.length > 0 && contentHeight >= qrLines.length + 2;
+  const spacious = showQr && contentHeight >= qrLines.length + 8;
+  const showUrl = !!url && (!showQr || contentHeight >= qrLines.length + 4);
+
+  return (
+    <Box flexDirection="column" alignItems="center">
+      {url && <Box height={2}>
+        <Button label="Continue in browser" shortcut="b" variant="primary" onPress={() => {
+          void renderer.openExternal(url).catch(() => {});
+        }} />
+      </Box>}
+      {showQr && (qrImage
+        ? (
+          <Box
+            width={qrLines[0]?.length ?? 0}
+            height={qrLines.length}
+            style={{
+              backgroundImage: qrImage,
+              backgroundColor: QR_BG,
+              backgroundSize: "contain",
+              backgroundPosition: "center",
+              backgroundRepeat: "no-repeat",
+            }}
+          />
+        )
+        : (
+          <Box flexDirection="column" height={qrLines.length}>
+            {qrLines.map((line, index) => (
+              <Box key={index} height={1}>
+                <Text fg={QR_FG} bg={QR_BG}>{line}</Text>
+              </Box>
+            ))}
+          </Box>
+        ))}
+      {!showQr && url && (
+        <Box height={1}>
+          <Text fg={colors.textDim}>{t("Terminal is too short to draw the QR code.")}</Text>
+        </Box>
+      )}
+      {code && (
+        <>
+          {spacious && <Box height={1} />}
+          {spacious
+            ? (
+              <Box flexDirection="column" height={2}>
+                {renderAsciiText(code, "tiny").map((line, index) => (
+                  <Box key={index} height={1}>
+                    <Text fg={colors.textBright}>{line}</Text>
+                  </Box>
+                ))}
+              </Box>
+            )
+            : (
+              <Box height={1}>
+                <Text fg={colors.textBright} attributes={TextAttributes.BOLD}>{code}</Text>
+              </Box>
+            )}
+        </>
+      )}
+      {showUrl && (
+        <>
+          {spacious && <Box height={1} />}
+          <Box height={1}>
+            <Text fg={colors.textMuted}>{url}</Text>
+          </Box>
+        </>
+      )}
+      {spacious && <Box height={1} />}
+      <Box height={1}>
+        <Text fg={status.color}>{status.text}</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/components/sign-in-gate.tsx

@@ -7,17 +7,17 @@
  * The gate closes by itself, because both sign-in paths install a session that
  * `usePlanAccess` observes.
  */
-import { useEffect, useRef, useState } from "react";
+import { useState } from "react";
 import { t } from "../i18n";
 import { useAppLanguage } from "../i18n/react";
 import { matchesKeyChord, parseKeyChord } from "../app/keybindings";
 import { AuthForm, authFormTitle } from "../plugins/builtin/cloud/auth-form";
 import type { AccountMode } from "../plugins/builtin/cloud/auth-model";
 import {
-  DeviceSignInController,
-  type DeviceSignInSnapshot,
-} from "../plugins/builtin/cloud/device-signin";
-import { DeviceSignInPanel } from "../plugins/builtin/cloud/device-signin-dialog";
+  DeviceSignInPanel,
+  isDeviceSignInRetryKey,
+  useDeviceSignIn,
+} from "../plugins/builtin/cloud/device-signin-dialog";
 import { useShortcut, useViewport } from "../react/input";
 import { useThemeColors } from "../theme/theme-context";
 import { Box, Text } from "../ui";
@@ -57,19 +57,7 @@ function HoldAppInput() {
  * is what dismisses the gate, so there is no completion callback here.
  */
 function GateQrPanel({ height, onUseEmail }: { height: number; onUseEmail: () => void }) {
-  const controllerRef = useRef<DeviceSignInController | null>(null);
-  if (!controllerRef.current) controllerRef.current = new DeviceSignInController();
-  const controller = controllerRef.current;
-  const [snapshot, setSnapshot] = useState<DeviceSignInSnapshot>(controller.getSnapshot());
-
-  useEffect(() => {
-    const unsubscribe = controller.subscribe(setSnapshot);
-    controller.start();
-    return () => {
-      unsubscribe();
-      controller.cancel();
-    };
-  }, [controller]);
+  const { snapshot, retry } = useDeviceSignIn();
 
   useShortcut((event) => {
     if (isPlainKey(event, "escape")) {
@@ -78,12 +66,10 @@ function GateQrPanel({ height, onUseEmail }: { height: number; onUseEmail: () =>
       onUseEmail();
       return;
     }
-    if (snapshot.phase === "approved") return;
-    const retry = isPlainKey(event, "r") || event.name === "enter" || event.name === "return";
-    if (!retry) return;
+    if (!isDeviceSignInRetryKey(event, snapshot)) return;
     event.preventDefault();
     event.stopPropagation();
-    controller.start();
+    retry();
   }, { scope: GATE_SCOPE, phase: "before", allowEditable: true });
 
   return <DeviceSignInPanel snapshot={snapshot} height={height} shortcutScope={GATE_SCOPE} />;

package/src/components/speedometer-gauge/index.tsx

@@ -1,4 +1,4 @@
-import { useUiHost } from "../../ui";
+import { useUiCapabilities } from "../../ui";
 import { DesktopSpeedometerGauge } from "./desktop";
 import {
   DEFAULT_MAX_WIDTH,
@@ -36,7 +36,7 @@ export function SpeedometerGauge({
     maxWidth,
     compact,
   };
-  return useUiHost().kind === "desktop-web"
+  return useUiCapabilities().nativePaneChrome === true
     ? <DesktopSpeedometerGauge {...props} />
     : <TerminalSpeedometerGauge {...props} />;
 }

package/src/components/speedometer-gauge/model.ts

@@ -1,4 +1,5 @@
 import { colors } from "../../theme/colors";
+import { clamp } from "../../utils/math";
 
 export interface SpeedometerSegment {
   from: number;
@@ -23,10 +24,6 @@ export interface SpeedometerGaugeProps {
 export const DEFAULT_MIN_WIDTH = 34;
 export const DEFAULT_MAX_WIDTH = 50;
 
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
 export function normalizeValue(value: number, min: number, max: number): number {
   if (max <= min) return 0;
   return clamp((value - min) / (max - min), 0, 1);

package/src/components/table-view-shared.tsx

@@ -6,7 +6,6 @@ import {
   type RefObject,
 } from "react";
 import { Box, useUiCapabilities, type ScrollBoxRenderable } from "../ui";
-import { isPlainKeyboardEvent } from "../utils/keyboard";
 import type { DataTableProps } from "./ui/data-table/types";
 
 function listenToScrollBarChange(
@@ -25,20 +24,6 @@ function listenToScrollBarChange(
   return () => scrollBar.off?.("change", handler);
 }
 
-export interface TableViewKeyEvent {
-  name?: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  super?: boolean;
-  alt?: boolean;
-  option?: boolean;
-  shift?: boolean;
-  readonly defaultPrevented?: boolean;
-  readonly propagationStopped?: boolean;
-  preventDefault?: () => void;
-  stopPropagation?: () => void;
-}
-
 export interface TableViewFrameProps {
   width?: number;
   height?: number;
@@ -81,35 +66,6 @@ export function TableViewFrame({
   );
 }
 
-export function isTableActivationKey(name: string | undefined): boolean {
-  return name === "enter" || name === "return";
-}
-
-function getTableKeyName(event: TableViewKeyEvent | string | undefined): string | undefined {
-  return typeof event === "string" ? event : event?.name;
-}
-
-function isPlainTableKey(event: TableViewKeyEvent | string | undefined): boolean {
-  return typeof event !== "object" || isPlainKeyboardEvent(event);
-}
-
-export function isNextTableRowKey(event: TableViewKeyEvent | string | undefined): boolean {
-  const name = getTableKeyName(event);
-  if (!isPlainTableKey(event)) return false;
-  return name === "j" || name === "down";
-}
-
-export function isPreviousTableRowKey(event: TableViewKeyEvent | string | undefined): boolean {
-  const name = getTableKeyName(event);
-  if (!isPlainTableKey(event)) return false;
-  return name === "k" || name === "up";
-}
-
-export function stopTableKey(event: TableViewKeyEvent) {
-  event.stopPropagation?.();
-  event.preventDefault?.();
-}
-
 export function useTableViewState({
   headerScrollRef,
   scrollRef,

package/src/components/ticker/badge/format.ts

@@ -70,7 +70,3 @@ export function getTickerBadgeText(options: TickerBadgeTextOptions): string {
   return candidates.find((text) => displayWidth(text) <= maxTextWidth)
     ?? candidates[candidates.length - 1]!;
 }
-
-export function getTickerBadgeCellWidth(options: TickerBadgeTextOptions): number {
-  return displayWidth(getTickerBadgeText(options)) + TICKER_BADGE_CHROME_WIDTH;
-}