gloomberb 0.1.0 → 0.3.1

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

@@ -0,0 +1,108 @@
+import type { PredictionBookLevel, PredictionTrade } from "../types";
+import { parseFloatSafe } from "./fetch";
+
+interface PolymarketLiveCallbacks {
+  onBestBidAsk?: (
+    assetId: string,
+    bestBid: number | null,
+    bestAsk: number | null,
+    spread: number | null,
+  ) => void;
+  onBook?: (
+    assetId: string,
+    bids: PredictionBookLevel[],
+    asks: PredictionBookLevel[],
+    lastTradePrice: number | null,
+  ) => void;
+  onTrade?: (assetId: string, trade: PredictionTrade) => void;
+}
+
+function toBookLevels(
+  levels: Array<{ price: string; size: string }> | undefined,
+): PredictionBookLevel[] {
+  return (levels ?? [])
+    .map((level) => {
+      const price = parseFloatSafe(level.price);
+      const size = parseFloatSafe(level.size);
+      return price == null || size == null ? null : { price, size };
+    })
+    .filter((level): level is PredictionBookLevel => level != null);
+}
+
+export function subscribePolymarketMarket(
+  assetIds: string[],
+  callbacks: PolymarketLiveCallbacks,
+): () => void {
+  if (assetIds.length === 0) return () => {};
+
+  let closed = false;
+  let socket: WebSocket | null = null;
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const connect = () => {
+    socket = new WebSocket(
+      "wss://ws-subscriptions-clob.polymarket.com/ws/market",
+    );
+    socket.addEventListener("open", () => {
+      socket?.send(
+        JSON.stringify({
+          assets_ids: assetIds,
+          type: "market",
+          custom_feature_enabled: true,
+        }),
+      );
+    });
+    socket.addEventListener("message", (event) => {
+      try {
+        const payload = JSON.parse(String(event.data)) as any;
+        switch (payload.event_type) {
+          case "book":
+            callbacks.onBook?.(
+              String(payload.asset_id),
+              toBookLevels(payload.bids),
+              toBookLevels(payload.asks),
+              parseFloatSafe(payload.last_trade_price),
+            );
+            break;
+          case "best_bid_ask":
+            callbacks.onBestBidAsk?.(
+              String(payload.asset_id),
+              parseFloatSafe(payload.best_bid),
+              parseFloatSafe(payload.best_ask),
+              parseFloatSafe(payload.spread),
+            );
+            break;
+          case "last_trade_price":
+            callbacks.onTrade?.(String(payload.asset_id), {
+              id: `${payload.asset_id}:${payload.timestamp}:${payload.price}`,
+              timestamp: Number.parseInt(String(payload.timestamp), 10),
+              side:
+                String(payload.side).toUpperCase() === "SELL" ? "sell" : "buy",
+              outcome: "yes",
+              price: parseFloatSafe(payload.price) ?? 0,
+              size: parseFloatSafe(payload.size) ?? 0,
+            });
+            break;
+        }
+      } catch {
+        // ignore malformed messages
+      }
+    });
+    socket.addEventListener("close", () => {
+      socket = null;
+      if (closed) return;
+      reconnectTimer = setTimeout(connect, 1_500);
+    });
+    socket.addEventListener("error", () => {
+      socket?.close();
+    });
+  };
+
+  connect();
+
+  return () => {
+    closed = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    socket?.close();
+  };
+}

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

@@ -0,0 +1,164 @@
+import type { AppConfig } from "../../types/config";
+import type { PaneSettingOption, PaneSettingsDef } from "../../types/plugin";
+import {
+  DEFAULT_PREDICTION_COLUMN_IDS,
+  PREDICTION_COLUMN_DEFS,
+  PREDICTION_COLUMNS_BY_ID,
+} from "./columns";
+import type {
+  PredictionBrowseTab,
+  PredictionPaneSettings,
+  PredictionVenueScope,
+} from "./types";
+
+const VENUE_SCOPE_OPTIONS: PaneSettingOption[] = [
+  {
+    value: "all",
+    label: "All Venues",
+    description: "Merge Polymarket and Kalshi into one browser.",
+  },
+  {
+    value: "polymarket",
+    label: "Polymarket",
+    description: "Lock this pane to Polymarket.",
+  },
+  {
+    value: "kalshi",
+    label: "Kalshi",
+    description: "Lock this pane to Kalshi.",
+  },
+];
+
+const BROWSE_TAB_OPTIONS: PaneSettingOption[] = [
+  { value: "top", label: "Top", description: "Sort by 24-hour volume." },
+  {
+    value: "ending",
+    label: "Ending",
+    description: "Sort by soonest expiration.",
+  },
+  { value: "new", label: "New", description: "Sort by newest markets." },
+  {
+    value: "watchlist",
+    label: "Watchlist",
+    description: "Show only starred prediction markets.",
+  },
+];
+
+function isVenueScope(value: unknown): value is PredictionVenueScope {
+  return value === "all" || value === "polymarket" || value === "kalshi";
+}
+
+function isBrowseTab(value: unknown): value is PredictionBrowseTab {
+  return (
+    value === "top" ||
+    value === "ending" ||
+    value === "new" ||
+    value === "watchlist"
+  );
+}
+
+export function getPredictionMarketsPaneSettings(
+  settings: Record<string, unknown> | undefined,
+): PredictionPaneSettings {
+  const columnIds = Array.isArray(settings?.columnIds)
+    ? settings.columnIds.filter(
+        (value): value is string => typeof value === "string",
+      )
+    : DEFAULT_PREDICTION_COLUMN_IDS;
+
+  return {
+    columnIds: columnIds.length > 0 ? columnIds : DEFAULT_PREDICTION_COLUMN_IDS,
+    hideTabs: settings?.hideTabs === true,
+    lockedVenueScope: isVenueScope(settings?.lockedVenueScope)
+      ? settings.lockedVenueScope
+      : "all",
+    hideHeader: settings?.hideHeader === true,
+    defaultBrowseTab: isBrowseTab(settings?.defaultBrowseTab)
+      ? settings.defaultBrowseTab
+      : "top",
+  };
+}
+
+export function createPredictionMarketsPaneSettings(
+  overrides: Partial<PredictionPaneSettings> = {},
+): PredictionPaneSettings {
+  return {
+    columnIds: [...(overrides.columnIds ?? DEFAULT_PREDICTION_COLUMN_IDS)],
+    hideTabs: overrides.hideTabs ?? false,
+    lockedVenueScope: overrides.lockedVenueScope ?? "all",
+    hideHeader: overrides.hideHeader ?? false,
+    defaultBrowseTab: overrides.defaultBrowseTab ?? "top",
+  };
+}
+
+export function resolvePredictionColumns(columnIds: string[]) {
+  const resolved = columnIds
+    .map((columnId) => PREDICTION_COLUMNS_BY_ID.get(columnId))
+    .filter(
+      (column): column is (typeof PREDICTION_COLUMN_DEFS)[number] =>
+        column != null,
+    );
+  return resolved.length > 0
+    ? resolved
+    : DEFAULT_PREDICTION_COLUMN_IDS.map((columnId) =>
+        PREDICTION_COLUMNS_BY_ID.get(columnId),
+      ).filter(
+        (column): column is (typeof PREDICTION_COLUMN_DEFS)[number] =>
+          column != null,
+      );
+}
+
+export function buildPredictionMarketsPaneSettingsDef(
+  _config: AppConfig,
+  settings: PredictionPaneSettings,
+): PaneSettingsDef {
+  const fields: PaneSettingsDef["fields"] = [
+    {
+      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,
+        label: column.label,
+        description: column.description,
+      })),
+    },
+    {
+      key: "hideTabs",
+      label: "Hide Venue Tabs",
+      description: "Hide the top venue tabs and lock this pane to one scope.",
+      type: "toggle",
+    },
+  ];
+
+  if (settings.hideTabs) {
+    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,
+    });
+  }
+
+  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,
+  });
+
+  return {
+    title: "Prediction Markets Settings",
+    fields,
+  };
+}

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

@@ -0,0 +1,24 @@
+import { colors } from "../../theme/colors";
+import type { PredictionTransportState } from "./types";
+
+export function formatPredictionTransportBadge(
+  transport: PredictionTransportState,
+): {
+  label: string;
+  color: string;
+} {
+  switch (transport) {
+    case "live":
+      return { label: "Live WS", color: colors.positive };
+    case "polling":
+      return { label: "Polling", color: colors.text };
+    case "stale":
+      return { label: "Stale", color: colors.textDim };
+    case "error":
+      return { label: "Error", color: colors.negative };
+    case "loading":
+      return { label: "Loading", color: colors.text };
+    default:
+      return { label: "Idle", color: colors.textDim };
+  }
+}

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

@@ -0,0 +1,84 @@
+import type { RefObject } from "react";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { DataTable } from "../../components";
+import { getPredictionColumnValue } from "./metrics";
+import type {
+  PredictionColumnDef,
+  PredictionListRow,
+  PredictionSortPreference,
+} from "./types";
+
+export function PredictionMarketsTable({
+  columns,
+  rows,
+  selectedRowKey,
+  hoveredIdx,
+  setHoveredIdx,
+  setSelectedRowKey,
+  watchlist,
+  onToggleWatchlist,
+  sortPreference,
+  onHeaderClick,
+  headerScrollRef,
+  scrollRef,
+  syncHeaderScroll,
+  onBodyScrollActivity,
+}: {
+  columns: PredictionColumnDef[];
+  rows: PredictionListRow[];
+  selectedRowKey: string | null;
+  hoveredIdx: number | null;
+  setHoveredIdx: (index: number | null) => void;
+  setSelectedRowKey: (rowKey: string) => void;
+  watchlist: Set<string>;
+  onToggleWatchlist: (row: PredictionListRow) => void;
+  sortPreference: PredictionSortPreference;
+  onHeaderClick: (columnId: string) => void;
+  headerScrollRef: RefObject<ScrollBoxRenderable | null>;
+  scrollRef: RefObject<ScrollBoxRenderable | null>;
+  syncHeaderScroll: () => void;
+  onBodyScrollActivity: () => void;
+}) {
+  return (
+    <DataTable
+      columns={columns}
+      items={rows}
+      sortColumnId={sortPreference.columnId}
+      sortDirection={sortPreference.direction}
+      onHeaderClick={onHeaderClick}
+      headerScrollRef={headerScrollRef}
+      scrollRef={scrollRef}
+      syncHeaderScroll={syncHeaderScroll}
+      onBodyScrollActivity={onBodyScrollActivity}
+      emptyStateTitle="No markets matched."
+      emptyStateHint="Change the venue, browse tab, or search query."
+      hoveredIdx={hoveredIdx}
+      setHoveredIdx={setHoveredIdx}
+      getItemKey={(row) => row.key}
+      isSelected={(row) => selectedRowKey === row.key}
+      onSelect={(row) => setSelectedRowKey(row.key)}
+      virtualize
+      renderCell={(row, column, _index, rowState) => {
+        const watchlisted = row.watchMarketKeys.some((marketKey) =>
+          watchlist.has(marketKey),
+        );
+        const value = getPredictionColumnValue(column, row, watchlisted);
+        if (column.id === "watch") {
+          return {
+            text: value.text,
+            color: value.color,
+            onMouseDown: (event) => {
+              event.preventDefault();
+              event.stopPropagation?.();
+              onToggleWatchlist(row);
+            },
+          };
+        }
+        return {
+          text: value.text,
+          color: value.color,
+        };
+      }}
+    />
+  );
+}