gloomberb 0.5.1 → 0.6.0

package/src/plugins/prediction-markets/pane.tsx

@@ -1,30 +1,107 @@
-import { TextAttributes } from "@opentui/core";
-import { PageStackView, TabBar } from "../../components";
+import { Box, Input, Text } from "../../ui";
+import { useCallback, useMemo, useRef } from "react";
+import { DataTableStackView, Tabs, usePaneFooter } from "../../components";
+import { createRowValueCache } from "../../components/ui/row-value-cache";
 import type { PaneProps } from "../../types/plugin";
 import { colors } from "../../theme/colors";
 import { PREDICTION_CATEGORY_OPTIONS } from "./categories";
 import { usePredictionMarketsController } from "./controller";
 import { PredictionMarketDetailPane } from "./detail/pane";
+import { getPredictionColumnValue } from "./metrics";
 import { BROWSE_TABS, VENUE_TABS } from "./navigation";
-import { PredictionMarketsTable } from "./table";
-import type { PredictionBrowseTab, PredictionCategoryId } from "./types";
+import type {
+  PredictionBrowseTab,
+  PredictionCategoryId,
+  PredictionColumnDef,
+  PredictionListRow,
+} from "./types";
+
+const PREDICTION_CELL_CACHE_SIZE = 12_000;
+const RELATIVE_TIME_CELL_BUCKET_MS = 60_000;
+
+const predictionRowVersions = new WeakMap<object, number>();
+let nextPredictionRowVersion = 1;
+
+function predictionRowVersion(row: PredictionListRow): number {
+  const existing = predictionRowVersions.get(row);
+  if (existing != null) return existing;
+  const next = nextPredictionRowVersion;
+  nextPredictionRowVersion += 1;
+  predictionRowVersions.set(row, next);
+  return next;
+}
+
+function predictionCellVersion(
+  row: PredictionListRow,
+  column: PredictionColumnDef,
+  watchlisted: boolean,
+  relativeTimeBucket: number,
+): string {
+  return [
+    predictionRowVersion(row),
+    column.id,
+    watchlisted ? 1 : 0,
+    column.id === "ends" || column.id === "updated" ? relativeTimeBucket : 0,
+  ].join("|");
+}
 
 export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
   const controller = usePredictionMarketsController({ focused });
+  const cellCacheRef = useRef(
+    createRowValueCache<string, ReturnType<typeof getPredictionColumnValue>>(
+      PREDICTION_CELL_CACHE_SIZE,
+    ),
+  );
+  const relativeTimeBucket = Math.floor(Date.now() / RELATIVE_TIME_CELL_BUCKET_MS);
+  const watchlistedRowKeys = useMemo(() => {
+    const keys = new Set<string>();
+    for (const row of controller.visibleRows) {
+      if (row.watchMarketKeys.some((marketKey) => controller.watchlistSet.has(marketKey))) {
+        keys.add(row.key);
+      }
+    }
+    return keys;
+  }, [controller.visibleRows, controller.watchlistSet]);
   const catalogStatusColor =
     controller.catalogStatus?.tone === "danger"
       ? colors.negative
       : colors.borderFocused;
+  usePaneFooter("prediction-markets", () => ({
+    info: [
+      ...(controller.searchQuery.trim() ? [{ id: "search", parts: [{ text: `search: ${controller.searchQuery.trim()}`, tone: "value" as const }] }] : []),
+      ...(controller.searchLoading ? [{ id: "search-loading", parts: [{ text: "searching", tone: "muted" as const }] }] : []),
+      ...(controller.catalogStatus ? [{
+        id: "catalog",
+        parts: [{ text: controller.catalogStatus.message, tone: controller.catalogStatus.tone === "danger" ? "warning" as const : "muted" as const, color: catalogStatusColor }],
+      }] : []),
+    ],
+    hints: [
+      { id: "search", key: "/", label: "search", onPress: controller.actions.focusSearch },
+      { id: "watch", key: "w", label: "atch", onPress: controller.selectedRow ? () => controller.actions.toggleWatchlist(controller.selectedRow!) : undefined, disabled: !controller.selectedRow },
+      {
+        id: "browse",
+        key: "1-4",
+        label: "browse",
+        onPress: () => {
+          const index = BROWSE_TABS.findIndex((tab) => tab.value === controller.browseTab);
+          controller.actions.selectBrowseTab(BROWSE_TABS[(index + 1) % BROWSE_TABS.length]!.value as PredictionBrowseTab);
+        },
+      },
+    ],
+  }), [
+    catalogStatusColor,
+    controller.browseTab,
+    controller.catalogStatus?.message,
+    controller.catalogStatus?.tone,
+    controller.searchLoading,
+    controller.searchQuery,
+    controller.selectedRow,
+  ]);
 
-  const browseContent = (
-    <box
-      flexDirection="column"
-      width={width}
-      height={height}
-      backgroundColor={colors.panel}
-    >
+  const browseControls = (
+    <>
       {!controller.paneSettings.hideTabs ? (
-        <TabBar
+        <Tabs
           tabs={VENUE_TABS.map((tab) => ({
             label: tab.label,
             value: tab.value,
@@ -35,16 +112,16 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
         />
       ) : null}
 
-      <box flexDirection="row" height={1} paddingX={1} gap={2}>
-        <box
+      <Box flexDirection="row" height={1} paddingX={1} gap={2}>
+        <Box
           flexDirection="row"
           onMouseDown={controller.actions.focusSearch}
           width={Math.max(18, Math.floor(width * 0.32))}
         >
-          <text fg={colors.textDim}>{controller.searchFocused ? "?" : "/"}</text>
-          <box width={1} />
+          <Text fg={colors.textDim}>{controller.searchFocused ? "?" : "/"}</Text>
+          <Box width={1} />
           {controller.searchFocused ? (
-            <input
+            <Input
               ref={controller.searchInputRef}
               value={controller.searchQuery}
               focused={focused}
@@ -58,8 +135,8 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
               onSubmit={controller.actions.blurSearch}
             />
           ) : (
-            <box flexGrow={1}>
-              <text
+            <Box flexGrow={1}>
+              <Text
                 fg={
                   controller.searchQuery.trim().length > 0
                     ? colors.text
@@ -69,13 +146,13 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
                 {controller.searchQuery.trim().length > 0
                   ? controller.searchQuery
                   : "search markets"}
-              </text>
-            </box>
+              </Text>
+            </Box>
           )}
-        </box>
+        </Box>
 
-        <box flexGrow={1}>
-          <TabBar
+        <Box flexGrow={1}>
+          <Tabs
             tabs={BROWSE_TABS.map((tab) => ({
               label: tab.label,
               value: tab.value,
@@ -86,68 +163,63 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
             }
             compact
           />
-        </box>
-      </box>
+        </Box>
+      </Box>
 
       {PREDICTION_CATEGORY_OPTIONS.length > 1 ? (
-        <scrollbox height={1} scrollX focusable={false}>
-          <box flexDirection="row" paddingX={1} gap={2}>
-            {PREDICTION_CATEGORY_OPTIONS.map((category) => {
-              const active = category.id === controller.categoryId;
-              return (
-                <box
-                  key={category.id}
-                  onMouseDown={(event) => {
-                    event.preventDefault();
-                    controller.actions.selectCategory(
-                      category.id as PredictionCategoryId,
-                    );
-                  }}
-                >
-                  <text
-                    fg={active ? colors.textBright : colors.textDim}
-                    attributes={active ? TextAttributes.BOLD : 0}
-                  >
-                    {category.label}
-                  </text>
-                </box>
-              );
-            })}
-          </box>
-        </scrollbox>
-      ) : null}
-
-      {controller.catalogStatus ? (
-        <box height={1} paddingX={1} width={width} backgroundColor={colors.panel}>
-          <text fg={catalogStatusColor}>{controller.catalogStatus.message}</text>
-        </box>
+        <Box height={1} paddingX={1}>
+          <Tabs
+            tabs={PREDICTION_CATEGORY_OPTIONS.map((category) => ({
+              label: category.label,
+              value: category.id,
+            }))}
+            activeValue={controller.categoryId}
+            onSelect={(value) =>
+              controller.actions.selectCategory(value as PredictionCategoryId)
+            }
+            compact
+            variant="bare"
+          />
+        </Box>
       ) : null}
 
-      <box flexDirection="column" flexGrow={1}>
-        <PredictionMarketsTable
-          columns={controller.visibleColumns}
-          rows={controller.visibleRows}
-          selectedRowKey={controller.selectedRow?.key ?? null}
-          hoveredIdx={controller.hoveredIdx}
-          setHoveredIdx={controller.actions.setHoveredIdx}
-          onSelectRow={(rowKey) => controller.actions.setBrowseSelection(rowKey)}
-          onOpenRow={controller.actions.openSelectedRow}
-          watchlist={controller.watchlistSet}
-          onToggleWatchlist={controller.actions.toggleWatchlist}
-          sortPreference={controller.sortPreference}
-          onHeaderClick={controller.actions.handleSortHeaderClick}
-          headerScrollRef={controller.headerScrollRef}
-          scrollRef={controller.scrollRef}
-          syncHeaderScroll={controller.layout.syncHeaderScroll}
-          onBodyScrollActivity={controller.layout.onBodyScrollActivity}
-        />
-      </box>
-    </box>
+    </>
   );
 
+  const renderCell = useCallback((
+    row: PredictionListRow,
+    column: PredictionColumnDef,
+  ) => {
+    const watchlisted = watchlistedRowKeys.has(row.key);
+    const value = cellCacheRef.current.get(
+      `${row.key}:${column.id}`,
+      predictionCellVersion(row, column, watchlisted, relativeTimeBucket),
+      () => getPredictionColumnValue(column, row, watchlisted),
+    );
+    if (column.id === "watch") {
+      return {
+        text: value.text,
+        color: value.color,
+        onMouseDown: (event: any) => {
+          event.preventDefault();
+          event.stopPropagation?.();
+          controller.actions.toggleWatchlist(row);
+        },
+      };
+    }
+    return {
+      text: value.text,
+      color: value.color,
+    };
+  }, [
+    controller.actions.toggleWatchlist,
+    relativeTimeBucket,
+    watchlistedRowKeys,
+  ]);
+
   const detailContent =
     controller.selectedSummary && controller.selectedRow ? (
-      <box
+      <Box
         flexDirection="column"
         flexGrow={1}
         width={width}
@@ -172,18 +244,44 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
           selectedRow={controller.selectedRow}
           selectedSummary={controller.selectedSummary}
         />
-      </box>
+      </Box>
     ) : (
-      <box flexGrow={1} backgroundColor={colors.panel} />
+      <Box flexGrow={1} backgroundColor={colors.panel} />
     );
 
   return (
-    <PageStackView
+    <DataTableStackView<PredictionListRow, PredictionColumnDef>
       focused={focused}
+      keyboardNavigation={!controller.searchFocused}
       detailOpen={controller.detailOpen && !!controller.selectedSummary}
       onBack={controller.actions.closeDetail}
-      rootContent={browseContent}
       detailContent={detailContent}
+      rootBefore={browseControls}
+      rootWidth={width}
+      rootHeight={height}
+      rootBackgroundColor={colors.panel}
+      selectedIndex={controller.selectedIndex}
+      onSelectIndex={(_index, row) =>
+        controller.actions.setBrowseSelection(row.key, {
+          debounceDetail: true,
+        })}
+      onActivateIndex={(_index, row) =>
+        controller.actions.openSelectedRow(row.key)}
+      columns={controller.visibleColumns}
+      items={controller.visibleRows}
+      sortColumnId={controller.sortPreference.columnId}
+      sortDirection={controller.sortPreference.direction}
+      onHeaderClick={controller.actions.handleSortHeaderClick}
+      headerScrollRef={controller.headerScrollRef}
+      scrollRef={controller.scrollRef}
+      getItemKey={(row) => row.key}
+      isSelected={(row) => controller.selectedRow?.key === row.key}
+      onSelect={(row) => controller.actions.setBrowseSelection(row.key)}
+      onActivate={(row) => controller.actions.openSelectedRow(row.key)}
+      virtualize
+      renderCell={renderCell}
+      emptyStateTitle="No markets matched."
+      emptyStateHint="Change the venue, browse tab, or search query."
     />
   );
 }

package/src/plugins/prediction-markets/plugin.test.tsx

@@ -1,10 +1,18 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { cleanupPredictionTest, createConfig, installPredictionMarketMocks } from "./test-helpers";
+import {
+  cleanupPredictionTest,
+  installPredictionMarketMocks,
+  MemoryPersistence,
+} from "./test-helpers";
 import { colors } from "../../theme/colors";
-import { predictionMarketsPlugin } from "./index";
 import { resolvePredictionKeyboardCommand } from "./keyboard";
 import { buildPredictionListRows } from "./rows";
 import { getPredictionColumnValue } from "./metrics";
+import {
+  attachPredictionMarketsPersistence,
+  loadCachedPredictionResource,
+  PREDICTION_CACHE_POLICIES,
+} from "./services/fetch";
 import {
   loadKalshiCatalog,
   loadKalshiHistory,
@@ -21,51 +29,35 @@ afterEach(async () => {
 });
 
 describe("prediction markets plugin registration and services", () => {
-  test("exposes the pane template and search command", () => {
-    const commands: string[] = [];
-    const ctx = {
-      persistence: {
-        getState: () => null,
-        setState: () => {},
-        deleteState: () => {},
-        getResource: () => null,
-        setResource: (_kind: string, _key: string, value: unknown) => ({
-          value,
-          fetchedAt: Date.now(),
-          staleAt: Date.now(),
-          expiresAt: Date.now(),
-          sourceKey: "test",
-          schemaVersion: 1,
-          provenance: null,
-          stale: false,
-          expired: false,
-        }),
-        deleteResource: () => {},
-      },
-      registerCommand: (command: { id: string }) => {
-        commands.push(command.id);
-      },
-      resume: {
-        getState: () => null,
-        setState: () => {},
-        deleteState: () => {},
-        getPaneState: () => null,
-        setPaneState: () => {},
-        deletePaneState: () => {},
+  test("uses fresh prediction resource cache without refetching", async () => {
+    const persistence = new MemoryPersistence();
+    attachPredictionMarketsPersistence(persistence);
+    const cached = [
+      normalizePolymarketMarket({
+        id: "pm-cache",
+        question: "Will cached data be used?",
+        outcomes: '["Yes","No"]',
+        outcomePrices: '["0.7","0.3"]',
+      })!,
+    ];
+    persistence.setResource("catalog", "fresh", cached, {
+      cachePolicy: PREDICTION_CACHE_POLICIES.catalog,
+      sourceKey: "remote",
+    });
+    let fetchCount = 0;
+
+    const result = await loadCachedPredictionResource(
+      "catalog",
+      "fresh",
+      async () => {
+        fetchCount += 1;
+        return [];
       },
-      focusPane: () => {},
-      getConfig: () => createConfig(),
-    } as any;
-
-    predictionMarketsPlugin.setup?.(ctx);
-
-    expect(predictionMarketsPlugin.toggleable).toBe(true);
-    expect(predictionMarketsPlugin.panes?.[0]?.defaultMode).toBe("floating");
-    expect(predictionMarketsPlugin.paneTemplates?.[0]?.shortcut?.prefix).toBe(
-      "PM",
+      PREDICTION_CACHE_POLICIES.catalog,
     );
-    expect(commands).toContain("prediction-markets-open");
-    expect(commands).toContain("prediction-markets-search");
+
+    expect(result).toBe(cached);
+    expect(fetchCount).toBe(0);
   });
 
   test("normalizes venue payloads", () => {

package/src/plugins/prediction-markets/services/fetch.ts

@@ -1,5 +1,9 @@
 import type { PluginPersistence } from "../../../types/plugin";
-import { createThrottledFetch } from "../../../utils/throttled-fetch";
+import { httpFetch } from "../../../utils/http-transport";
+import { measurePerf } from "../../../utils/perf-marks";
+import {
+  createThrottledFetch,
+} from "../../../utils/throttled-fetch";
 
 const DEFAULT_SOURCE_KEY = "remote";
 const PREDICTION_FETCH = createThrottledFetch({
@@ -12,6 +16,7 @@ const PREDICTION_FETCH = createThrottledFetch({
     Accept: "application/json",
     "User-Agent": "gloomberb-prediction-markets",
   },
+  transport: httpFetch,
 });
 
 export const PREDICTION_CACHE_POLICIES = {
@@ -44,7 +49,15 @@ export async function fetchJson<T>(url: string): Promise<T> {
   if (!response.ok) {
     throw new Error(`Request failed (${response.status}) for ${url}`);
   }
-  return (await response.json()) as T;
+  const body = await response.text();
+  return measurePerf(
+    "prediction.fetch.parse-json",
+    () => JSON.parse(body) as T,
+    {
+      sizeBytes: body.length,
+      url: summarizePredictionFetchUrl(url),
+    },
+  );
 }
 
 export function getCachedPredictionResource<T>(
@@ -81,6 +94,9 @@ export async function loadCachedPredictionResource<T>(
   const cached = predictionMarketsPersistence?.getResource<T>(kind, key, {
     sourceKey: DEFAULT_SOURCE_KEY,
   });
+  if (cached && cached.stale !== true && cached.staleAt > Date.now()) {
+    return cached.value;
+  }
   try {
     const nextValue = await fetcher();
     setCachedPredictionResource(kind, key, nextValue, cachePolicy);
@@ -91,17 +107,18 @@ export async function loadCachedPredictionResource<T>(
   }
 }
 
+function summarizePredictionFetchUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.hostname}${parsed.pathname}`;
+  } catch {
+    return url.slice(0, 120);
+  }
+}
+
 export function parseFloatSafe(value: unknown): number | null {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value !== "string" || value.trim().length === 0) return null;
   const parsed = Number.parseFloat(value);
   return Number.isFinite(parsed) ? parsed : null;
 }
-
-export function parseIntegerSafe(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value))
-    return Math.trunc(value);
-  if (typeof value !== "string" || value.trim().length === 0) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}

package/src/plugins/prediction-markets/services/kalshi-adapter.ts

@@ -19,6 +19,7 @@ import {
   parseFloatSafe,
   PREDICTION_CACHE_POLICIES,
 } from "./fetch";
+import { measurePerf } from "../../../utils/perf-marks";
 
 interface KalshiMarketRecord {
   ticker: string;
@@ -257,6 +258,24 @@ function sortKalshiMarkets(
   );
 }
 
+function normalizeKalshiCatalog(
+  events: KalshiEventRecord[],
+  searchQuery: string,
+  categoryId: PredictionCategoryId,
+): PredictionMarketSummary[] {
+  return measurePerf(
+    "prediction.catalog.kalshi.normalize",
+    () => sortKalshiMarkets(
+      flattenKalshiEvents(events, searchQuery, categoryId),
+    ),
+    {
+      categoryId,
+      eventCount: events.length,
+      search: searchQuery.trim().length > 0,
+    },
+  );
+}
+
 async function fetchKalshiCatalogEvents(
   maxPages = DEFAULT_KALSHI_EVENT_MAX_PAGES,
 ): Promise<KalshiEventRecord[]> {
@@ -363,9 +382,7 @@ export async function loadKalshiCatalog(
         categoryId === "all"
           ? await fetchKalshiCatalogEvents(maxPages)
           : await fetchKalshiCatalogEventsForCategory(categoryId, maxPages);
-      return sortKalshiMarkets(
-        flattenKalshiEvents(events, normalizedQuery, categoryId),
-      );
+      return normalizeKalshiCatalog(events, normalizedQuery, categoryId);
     },
     PREDICTION_CACHE_POLICIES.catalog,
   );

package/src/plugins/prediction-markets/services/polymarket-adapter.ts

@@ -23,6 +23,7 @@ import {
   parseFloatSafe,
   PREDICTION_CACHE_POLICIES,
 } from "./fetch";
+import { measurePerf } from "../../../utils/perf-marks";
 
 interface PolymarketEventRecord {
   id: string;
@@ -334,6 +335,25 @@ function sortPolymarketMarkets(
   );
 }
 
+function normalizePolymarketCatalog(
+  events: PolymarketEventRecord[],
+  searchQuery: string,
+  categoryId: PredictionCategoryId,
+): PredictionMarketSummary[] {
+  return measurePerf(
+    "prediction.catalog.polymarket.normalize",
+    () =>
+      sortPolymarketMarkets(
+        flattenPolymarketEvents(events, searchQuery, categoryId),
+      ),
+    {
+      categoryId,
+      eventCount: events.length,
+      search: searchQuery.trim().length > 0,
+    },
+  );
+}
+
 function reconcilePolymarketSearchEvents(
   searchEvents: PolymarketEventRecord[],
   hydratedEvents: PolymarketEventRecord[],
@@ -369,12 +389,10 @@ export async function loadPolymarketCatalog(
           searchEvents,
           hydratedEvents,
         );
-        return sortPolymarketMarkets(
-          flattenPolymarketEvents(
-            resolvedEvents,
-            normalizedQuery,
-            categoryId,
-          ),
+        return normalizePolymarketCatalog(
+          resolvedEvents,
+          normalizedQuery,
+          categoryId,
         );
       }
 
@@ -388,8 +406,10 @@ export async function loadPolymarketCatalog(
             ).catch(() => []),
           ),
         );
-        const categorized = sortPolymarketMarkets(
-          flattenPolymarketEvents(categoryPages.flat(), "", categoryId),
+        const categorized = normalizePolymarketCatalog(
+          categoryPages.flat(),
+          "",
+          categoryId,
         );
         if (categorized.length > 0) return categorized;
       }
@@ -397,9 +417,7 @@ export async function loadPolymarketCatalog(
       const pages = await loadPolymarketCatalogPages(
         POLYMARKET_CATALOG_OFFSETS,
       );
-      return sortPolymarketMarkets(
-        flattenPolymarketEvents(pages, "", categoryId),
-      );
+      return normalizePolymarketCatalog(pages, "", categoryId);
     },
     PREDICTION_CACHE_POLICIES.catalog,
   );

package/src/plugins/prediction-markets/settings.ts

@@ -116,8 +116,6 @@ export function buildPredictionMarketsPaneSettingsDef(
     {
       key: "columnIds",
       label: "Columns",
-      description:
-        "Choose which columns this prediction-markets pane shows and in what order.",
       type: "ordered-multi-select",
       options: PREDICTION_COLUMN_DEFS.map((column) => ({
         value: column.id,
@@ -137,7 +135,6 @@ export function buildPredictionMarketsPaneSettingsDef(
     fields.push({
       key: "lockedVenueScope",
       label: "Locked Venue Scope",
-      description: "Choose the venue scope to show when tabs are hidden.",
       type: "select",
       options: VENUE_SCOPE_OPTIONS,
     });
@@ -146,13 +143,11 @@ export function buildPredictionMarketsPaneSettingsDef(
   fields.push({
     key: "hideHeader",
     label: "Hide Header",
-    description: "Hide the compact status header above the table.",
     type: "toggle",
   });
   fields.push({
     key: "defaultBrowseTab",
     label: "Default Browse Tab",
-    description: "Choose the initial market slice for new panes.",
     type: "select",
     options: BROWSE_TAB_OPTIONS,
   });