gloomberb 0.1.0 → 0.3.1

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

@@ -0,0 +1,229 @@
+import type {
+  PredictionGroupedListRow,
+  PredictionListRow,
+  PredictionMarketSummary,
+  PredictionSingleListRow,
+} from "./types";
+import { getPredictionTopOutcome } from "./outcome-order";
+
+function coerceTimestamp(value: string | null | undefined): number | null {
+  if (!value) return null;
+  const timestamp = new Date(value).getTime();
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function minDefined(values: Array<number | null | undefined>): number | null {
+  const defined = values.filter(
+    (value): value is number => typeof value === "number" && Number.isFinite(value),
+  );
+  if (defined.length === 0) return null;
+  return Math.min(...defined);
+}
+
+function maxDefined(values: Array<number | null | undefined>): number | null {
+  const defined = values.filter(
+    (value): value is number => typeof value === "number" && Number.isFinite(value),
+  );
+  if (defined.length === 0) return null;
+  return Math.max(...defined);
+}
+
+function dedupeStrings(values: Array<string | null | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => !!value && value.length > 0))];
+}
+
+function buildPredictionGroupKey(summary: PredictionMarketSummary): string | null {
+  if (summary.venue === "polymarket" && summary.eventId) {
+    return `polymarket:event:${summary.eventId}`;
+  }
+  if (summary.venue === "kalshi" && summary.eventTicker) {
+    return `kalshi:event:${summary.eventTicker}`;
+  }
+  return null;
+}
+
+function buildGroupSubtitle(
+  markets: PredictionMarketSummary[],
+  focusMarket: PredictionMarketSummary | null,
+): string {
+  const focusLabel = focusMarket?.marketLabel?.trim();
+  if (focusLabel) {
+    return `${markets.length} targets · top: ${focusLabel}`;
+  }
+  return `${markets.length} targets`;
+}
+
+function sortGroupMembers(
+  markets: PredictionMarketSummary[],
+): PredictionMarketSummary[] {
+  return [...markets].sort((left, right) => {
+    const volumeDelta = (right.volume24h ?? 0) - (left.volume24h ?? 0);
+    if (volumeDelta !== 0) return volumeDelta;
+    const updatedDelta =
+      (coerceTimestamp(right.updatedAt) ?? 0) - (coerceTimestamp(left.updatedAt) ?? 0);
+    if (updatedDelta !== 0) return updatedDelta;
+    return left.marketLabel.localeCompare(right.marketLabel);
+  });
+}
+
+function buildSingleRow(summary: PredictionMarketSummary): PredictionSingleListRow {
+  return {
+    key: summary.key,
+    kind: "market",
+    venue: summary.venue,
+    representative: summary,
+    focusMarketKey: summary.key,
+    focusMarketLabel: summary.marketLabel,
+    focusYesPrice: summary.yesPrice,
+    markets: [summary],
+    title: summary.title,
+    marketId: summary.marketId,
+    marketLabel: summary.marketLabel,
+    eventLabel: summary.eventLabel,
+    category: summary.category,
+    tags: summary.tags,
+    status: summary.status,
+    url: summary.url,
+    description: summary.description,
+    endsAt: summary.endsAt,
+    updatedAt: summary.updatedAt,
+    yesPrice: summary.yesPrice,
+    noPrice: summary.noPrice,
+    spread: summary.spread,
+    lastTradePrice: summary.lastTradePrice,
+    volume24h: summary.volume24h,
+    volume24hUnit: summary.volume24hUnit,
+    totalVolume: summary.totalVolume,
+    totalVolumeUnit: summary.totalVolumeUnit,
+    openInterest: summary.openInterest,
+    openInterestUnit: summary.openInterestUnit,
+    liquidity: summary.liquidity,
+    liquidityUnit: summary.liquidityUnit,
+    searchText: [
+      summary.title,
+      summary.marketLabel,
+      summary.eventLabel,
+      summary.category ?? "",
+      summary.marketId,
+      ...(summary.tags ?? []),
+    ]
+      .join(" ")
+      .toLowerCase(),
+    watchMarketKeys: [summary.key],
+  };
+}
+
+function buildGroupedRow(markets: PredictionMarketSummary[]): PredictionGroupedListRow {
+  const sortedMarkets = sortGroupMembers(markets);
+  const representative = sortedMarkets[0]!;
+  const focusMarket = getPredictionTopOutcome(sortedMarkets) ?? representative;
+  const yesValues = sortedMarkets.map((market) => market.yesPrice);
+  const spreadValues = sortedMarkets.map((market) => market.spread);
+  const tags = dedupeStrings(
+    sortedMarkets.flatMap((market) => market.tags ?? []).concat(representative.category ?? []),
+  );
+  const latestUpdatedAt = sortedMarkets.reduce<string | null>((latest, market) => {
+    const latestTs = coerceTimestamp(latest);
+    const marketTs = coerceTimestamp(market.updatedAt);
+    if (marketTs == null) return latest;
+    if (latestTs == null || marketTs > latestTs) return market.updatedAt;
+    return latest;
+  }, representative.updatedAt);
+  const earliestEndsAt = sortedMarkets.reduce<string | null>((earliest, market) => {
+    const earliestTs = coerceTimestamp(earliest);
+    const marketTs = coerceTimestamp(market.endsAt);
+    if (marketTs == null) return earliest;
+    if (earliestTs == null || marketTs < earliestTs) return market.endsAt;
+    return earliest;
+  }, representative.endsAt);
+
+  return {
+    key: `group:${buildPredictionGroupKey(representative) ?? representative.key}`,
+    kind: "group",
+    venue: representative.venue,
+    representative,
+    focusMarketKey: focusMarket.key,
+    focusMarketLabel: focusMarket.marketLabel,
+    focusYesPrice: focusMarket.yesPrice,
+    markets: sortedMarkets,
+    title: representative.eventLabel,
+    marketId:
+      representative.venue === "polymarket"
+        ? representative.eventId ?? representative.marketId
+        : representative.eventTicker ?? representative.marketId,
+    marketLabel: representative.eventLabel,
+    eventLabel: buildGroupSubtitle(sortedMarkets, focusMarket),
+    category: representative.category,
+    tags,
+    status: representative.status,
+    url: representative.url,
+    description: representative.description,
+    endsAt: earliestEndsAt,
+    updatedAt: latestUpdatedAt,
+    yesPrice: representative.yesPrice,
+    noPrice: representative.noPrice,
+    spread: representative.spread,
+    lastTradePrice: representative.lastTradePrice,
+    volume24h: representative.volume24h,
+    volume24hUnit: representative.volume24hUnit,
+    totalVolume: representative.totalVolume,
+    totalVolumeUnit: representative.totalVolumeUnit,
+    openInterest: representative.openInterest,
+    openInterestUnit: representative.openInterestUnit,
+    liquidity: representative.liquidity,
+    liquidityUnit: representative.liquidityUnit,
+    searchText: [
+      representative.eventLabel,
+      buildGroupSubtitle(sortedMarkets, focusMarket),
+      ...sortedMarkets.flatMap((market) => [
+        market.title,
+        market.marketLabel,
+        market.eventLabel,
+        market.marketId,
+      ]),
+      ...tags,
+    ]
+      .join(" ")
+      .toLowerCase(),
+    watchMarketKeys: sortedMarkets.map((market) => market.key),
+    marketCount: sortedMarkets.length,
+    yesPriceLow: minDefined(yesValues),
+    yesPriceHigh: maxDefined(yesValues),
+    spreadLow: minDefined(spreadValues),
+    spreadHigh: maxDefined(spreadValues),
+  };
+}
+
+export function buildPredictionListRows(
+  markets: PredictionMarketSummary[],
+): PredictionListRow[] {
+  const groupedMarkets = new Map<string, PredictionMarketSummary[]>();
+  const standaloneMarkets: PredictionMarketSummary[] = [];
+
+  for (const market of markets) {
+    const groupKey = buildPredictionGroupKey(market);
+    if (!groupKey) {
+      standaloneMarkets.push(market);
+      continue;
+    }
+    if (!groupedMarkets.has(groupKey)) {
+      groupedMarkets.set(groupKey, []);
+    }
+    groupedMarkets.get(groupKey)!.push(market);
+  }
+
+  const rows: PredictionListRow[] = [];
+  for (const market of standaloneMarkets) {
+    rows.push(buildSingleRow(market));
+  }
+
+  for (const marketsForGroup of groupedMarkets.values()) {
+    if (marketsForGroup.length <= 1) {
+      rows.push(buildSingleRow(marketsForGroup[0]!));
+      continue;
+    }
+    rows.push(buildGroupedRow(marketsForGroup));
+  }
+
+  return rows;
+}

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

@@ -0,0 +1,97 @@
+import type { PluginPersistence } from "../../../types/plugin";
+
+const DEFAULT_SOURCE_KEY = "remote";
+
+export const PREDICTION_CACHE_POLICIES = {
+  catalog: { staleMs: 30_000, expireMs: 10 * 60_000 },
+  detail: { staleMs: 10_000, expireMs: 5 * 60_000 },
+  book: { staleMs: 5_000, expireMs: 30_000 },
+  trades: { staleMs: 5_000, expireMs: 2 * 60_000 },
+  history: { staleMs: 60_000, expireMs: 24 * 60 * 60_000 },
+  rules: { staleMs: 24 * 60 * 60_000, expireMs: 30 * 24 * 60 * 60_000 },
+} as const;
+
+let predictionMarketsPersistence: PluginPersistence | null = null;
+
+export function attachPredictionMarketsPersistence(
+  persistence: PluginPersistence,
+): void {
+  predictionMarketsPersistence = persistence;
+}
+
+export function getPredictionMarketsPersistence(): PluginPersistence | null {
+  return predictionMarketsPersistence;
+}
+
+export async function fetchJson<T>(url: string): Promise<T> {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(10_000),
+    headers: {
+      Accept: "application/json",
+      "User-Agent": "gloomberb-prediction-markets",
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Request failed (${response.status}) for ${url}`);
+  }
+  return (await response.json()) as T;
+}
+
+export function getCachedPredictionResource<T>(
+  kind: string,
+  key: string,
+  options?: { sourceKey?: string; allowExpired?: boolean },
+): T | null {
+  const record = predictionMarketsPersistence?.getResource<T>(kind, key, {
+    sourceKey: options?.sourceKey ?? DEFAULT_SOURCE_KEY,
+    allowExpired: options?.allowExpired,
+  });
+  return record?.value ?? null;
+}
+
+export function setCachedPredictionResource<T>(
+  kind: string,
+  key: string,
+  value: T,
+  cachePolicy: { staleMs: number; expireMs: number },
+  sourceKey = DEFAULT_SOURCE_KEY,
+): void {
+  predictionMarketsPersistence?.setResource(kind, key, value, {
+    sourceKey,
+    cachePolicy,
+  });
+}
+
+export async function loadCachedPredictionResource<T>(
+  kind: string,
+  key: string,
+  fetcher: () => Promise<T>,
+  cachePolicy: { staleMs: number; expireMs: number },
+): Promise<T> {
+  const cached = predictionMarketsPersistence?.getResource<T>(kind, key, {
+    sourceKey: DEFAULT_SOURCE_KEY,
+  });
+  try {
+    const nextValue = await fetcher();
+    setCachedPredictionResource(kind, key, nextValue, cachePolicy);
+    return nextValue;
+  } catch (error) {
+    if (cached) return cached.value;
+    throw error;
+  }
+}
+
+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;
+}