@liberfi.io/react-predict 0.3.66 → 0.3.68

package/dist/index.js

@@ -84,6 +84,67 @@ var PredictClient = class {
     const url = `${this.endpoint}/api/v1/events/${encodeURIComponent(slug)}/similar${query}`;
     return await utils.httpGet(url);
   }
+  // -------------------------------------------------------------------------
+  // Sports / esports
+  // -------------------------------------------------------------------------
+  /** Maps to `GET /api/v1/sports/taxonomy`. */
+  async getSportsTaxonomy(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/sports/taxonomy${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/sports/matches`. */
+  async getSportsMatches(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/sports/matches${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/sports/props`. */
+  async getSportsProps(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/sports/props${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/esports/taxonomy`. */
+  async getEsportsTaxonomy(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/esports/taxonomy${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/esports/matches`. */
+  async getEsportsMatches(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/esports/matches${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/esports/props`. */
+  async getEsportsProps(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/esports/props${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/sports/routing/:slug`. */
+  async getSportsRouting(slug, params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/sports/routing/${encodeURIComponent(slug)}${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Maps to `GET /api/v1/sports/matches/:match_group_slug`. */
+  async getSportsMatchDetail(section, matchGroupSlug, params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/${encodeURIComponent(section)}/matches/${encodeURIComponent(matchGroupSlug)}${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
+  /** Convenience wrapper for `GET /api/v1/esports/matches/:match_group_slug`. */
+  async getEsportsMatchDetail(matchGroupSlug, params) {
+    return this.getSportsMatchDetail("esports", matchGroupSlug, params);
+  }
+  /** Maps to `GET /api/v1/search`. */
+  async search(params) {
+    const query = buildQuery(params ?? {});
+    const url = `${this.endpoint}/api/v1/search${query}`;
+    return await utils.httpGet(url, this.requestOptions());
+  }
   /**
    * List comments for a prediction event.
    *
@@ -145,8 +206,9 @@ var PredictClient = class {
     return await utils.httpGet(url);
   }
   /** Maps to `GET /api/v1/markets/:slug/price-history?source=...&range=...`. */
-  async getPriceHistory(slug, source, range) {
-    const query = buildQuery({ source, range });
+  async getPriceHistory(slug, sourceOrParams, range) {
+    const params = typeof sourceOrParams === "string" ? { source: sourceOrParams, range } : sourceOrParams;
+    const query = buildQuery(params);
     const url = `${this.endpoint}/api/v1/markets/${encodeURIComponent(slug)}/price-history${query}`;
     return await utils.httpGet(url);
   }
@@ -1221,6 +1283,355 @@ function useEvent(params, queryOptions = {}) {
     ...queryOptions
   });
 }
+
+// src/hooks/predict/search.params.ts
+function predictSearchQueryKey(params) {
+  return ["predict", "search-documents", params];
+}
+function resolvePredictSearchParams(params = {}) {
+  const q = params.q ?? "";
+  return {
+    ...params,
+    q,
+    sort_by: params.sort_by ?? (q ? "relevance" : "volume"),
+    sort_asc: params.sort_asc ?? (q ? void 0 : false)
+  };
+}
+async function fetchPredictSearch(client, params) {
+  return client.search(resolvePredictSearchParams(params));
+}
+
+// src/hooks/predict/usePredictSearch.ts
+function usePredictSearch(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolvePredictSearchParams(params);
+  return reactQuery.useQuery({
+    queryKey: predictSearchQueryKey(resolved),
+    queryFn: () => fetchPredictSearch(client, resolved),
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+function useInfinitePredictSearch(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolvePredictSearchParams(params);
+  return reactQuery.useInfiniteQuery({
+    queryKey: predictSearchQueryKey(resolved),
+    queryFn: ({ pageParam }) => fetchPredictSearch(client, {
+      ...resolved,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+
+// src/hooks/predict/sports.params.ts
+function sportsTaxonomyQueryKey(params) {
+  return ["predict", "sports", "taxonomy", params];
+}
+function sportsMatchesQueryKey(params) {
+  return ["predict", "sports", "matches", params];
+}
+function sportsPropsQueryKey(params) {
+  return ["predict", "sports", "props", params];
+}
+function resolveSportsTaxonomyParams(params = {}) {
+  return { ...params, section: "sports" };
+}
+function resolveSportsMatchesParams(params = {}) {
+  return params;
+}
+function resolveSportsPropsParams(params = {}) {
+  return params;
+}
+async function fetchSportsTaxonomy(client, params) {
+  return client.getSportsTaxonomy(resolveSportsTaxonomyParams(params));
+}
+async function fetchSportsMatches(client, params) {
+  return client.getSportsMatches(resolveSportsMatchesParams(params));
+}
+async function fetchSportsProps(client, params) {
+  return client.getSportsProps(resolveSportsPropsParams(params));
+}
+
+// src/hooks/predict/useSportsTaxonomy.ts
+function useSportsTaxonomy(params = {}, queryOptions = {}) {
+  const client = usePredictClient();
+  const resolved = resolveSportsTaxonomyParams(params);
+  return reactQuery.useQuery({
+    queryKey: sportsTaxonomyQueryKey(resolved),
+    queryFn: () => fetchSportsTaxonomy(client, resolved),
+    ...queryOptions
+  });
+}
+function useSportsMatches(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolveSportsMatchesParams(params);
+  return reactQuery.useInfiniteQuery({
+    queryKey: sportsMatchesQueryKey(resolved),
+    queryFn: ({ pageParam }) => fetchSportsMatches(client, {
+      ...resolved,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+function useSportsProps(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolveSportsPropsParams(params);
+  return reactQuery.useInfiniteQuery({
+    queryKey: sportsPropsQueryKey(resolved),
+    queryFn: ({ pageParam }) => fetchSportsProps(client, {
+      ...resolved,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+
+// src/hooks/predict/esports.params.ts
+function esportsTaxonomyQueryKey(params) {
+  return ["predict", "esports", "taxonomy", params];
+}
+function esportsMatchesQueryKey(params) {
+  return ["predict", "esports", "matches", params];
+}
+function esportsPropsQueryKey(params) {
+  return ["predict", "esports", "props", params];
+}
+function resolveEsportsTaxonomyParams(params = {}) {
+  return params;
+}
+function resolveEsportsMatchesParams(params = {}) {
+  return params;
+}
+function resolveEsportsPropsParams(params = {}) {
+  return params;
+}
+async function fetchEsportsTaxonomy(client, params) {
+  return client.getEsportsTaxonomy(resolveEsportsTaxonomyParams(params));
+}
+async function fetchEsportsMatches(client, params) {
+  return client.getEsportsMatches(resolveEsportsMatchesParams(params));
+}
+async function fetchEsportsProps(client, params) {
+  return client.getEsportsProps(resolveEsportsPropsParams(params));
+}
+
+// src/hooks/predict/useEsportsTaxonomy.ts
+function useEsportsTaxonomy(params = {}, queryOptions = {}) {
+  const client = usePredictClient();
+  const resolved = resolveEsportsTaxonomyParams(params);
+  return reactQuery.useQuery({
+    queryKey: esportsTaxonomyQueryKey(resolved),
+    queryFn: () => fetchEsportsTaxonomy(client, resolved),
+    ...queryOptions
+  });
+}
+function useEsportsMatches(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolveEsportsMatchesParams(params);
+  return reactQuery.useInfiniteQuery({
+    queryKey: esportsMatchesQueryKey(resolved),
+    queryFn: ({ pageParam }) => fetchEsportsMatches(client, {
+      ...resolved,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+function useEsportsProps(params = {}, queryOptions) {
+  const client = usePredictClient();
+  const resolved = resolveEsportsPropsParams(params);
+  return reactQuery.useInfiniteQuery({
+    queryKey: esportsPropsQueryKey(resolved),
+    queryFn: ({ pageParam }) => fetchEsportsProps(client, {
+      ...resolved,
+      ...pageParam !== void 0 ? { cursor: pageParam } : {}
+    }),
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage.has_more && lastPage.next_cursor ? lastPage.next_cursor : void 0,
+    enabled: queryOptions?.enabled ?? true
+  });
+}
+
+// src/hooks/predict/sports-routing.params.ts
+function sportsRoutingQueryKey(slug, params) {
+  return ["predict", "sports", "routing", slug, params];
+}
+function resolveSportsRoutingParams(params = {}) {
+  return params;
+}
+async function fetchSportsRouting(client, slug, params) {
+  return client.getSportsRouting(slug, resolveSportsRoutingParams(params));
+}
+
+// src/hooks/predict/useSportsRouting.ts
+function useSportsRouting(slug, params = {}, queryOptions = {}) {
+  const client = usePredictClient();
+  const resolved = resolveSportsRoutingParams(params);
+  return reactQuery.useQuery({
+    queryKey: sportsRoutingQueryKey(slug, resolved),
+    queryFn: () => fetchSportsRouting(client, slug, resolved),
+    enabled: Boolean(slug),
+    ...queryOptions
+  });
+}
+
+// src/hooks/predict/sports-match-detail.params.ts
+function sportsMatchDetailQueryKey(section, matchGroupSlug, params) {
+  return ["predict", section, "match-detail", matchGroupSlug, params];
+}
+function resolveSportsMatchDetailParams(params = {}) {
+  return params;
+}
+async function fetchSportsMatchDetail(client, section, matchGroupSlug, params) {
+  return client.getSportsMatchDetail(
+    section,
+    matchGroupSlug,
+    resolveSportsMatchDetailParams(params)
+  );
+}
+
+// src/hooks/predict/useSportsMatchDetail.ts
+function useSportsMatchDetail(section, matchGroupSlug, params = {}, queryOptions = {}) {
+  const client = usePredictClient();
+  const resolved = resolveSportsMatchDetailParams(params);
+  return reactQuery.useQuery({
+    queryKey: sportsMatchDetailQueryKey(section, matchGroupSlug, resolved),
+    queryFn: () => fetchSportsMatchDetail(client, section, matchGroupSlug, resolved),
+    enabled: Boolean(section && matchGroupSlug),
+    ...queryOptions
+  });
+}
+function orderbookQueryKey(slug, source, outcome = "yes") {
+  return ["predict", "orderbook", slug, source, outcome];
+}
+function useOrderbook(params, queryOptions = {}) {
+  const client = usePredictClient();
+  const outcome = params.outcome ?? "yes";
+  return reactQuery.useQuery({
+    queryKey: orderbookQueryKey(params.slug, params.source, outcome),
+    queryFn: () => client.getOrderbook(params.slug, params.source, outcome),
+    enabled: Boolean(params.slug),
+    refetchInterval: 3e4,
+    ...queryOptions
+  });
+}
+function useOrderbookSubscription({
+  wsClient,
+  slug,
+  enabled = true,
+  outcome,
+  onUpdate
+}) {
+  const [orderbook, setOrderbook] = react.useState(null);
+  const [isSubscribed, setIsSubscribed] = react.useState(false);
+  const onUpdateRef = react.useRef(onUpdate);
+  onUpdateRef.current = onUpdate;
+  const handleUpdate = react.useCallback(
+    (msg) => {
+      if (msg.data.market_slug === slug) {
+        if (!outcome || msg.data.outcome === outcome) {
+          setOrderbook(msg.data);
+        }
+        onUpdateRef.current?.(msg);
+      }
+    },
+    [slug, outcome]
+  );
+  react.useEffect(() => {
+    if (!wsClient || !enabled || !slug) {
+      setIsSubscribed(false);
+      return;
+    }
+    setOrderbook(null);
+    const unsub = wsClient.subscribeOrderbook([slug], handleUpdate);
+    setIsSubscribed(true);
+    return () => {
+      unsub();
+      setIsSubscribed(false);
+    };
+  }, [wsClient, enabled, slug, handleUpdate]);
+  return { orderbook, isSubscribed };
+}
+function usePredictWsClient() {
+  const context = react.useContext(PredictContext);
+  if (!context) {
+    throw new Error("usePredictWsClient must be used within a PredictProvider");
+  }
+  const { wsClient } = context;
+  const [wsStatus, setWsStatus] = react.useState(
+    wsClient?.getStatus() ?? "disconnected"
+  );
+  react.useEffect(() => {
+    if (!wsClient) {
+      setWsStatus("disconnected");
+      return;
+    }
+    setWsStatus(wsClient.getStatus());
+    return wsClient.onStatusChange(setWsStatus);
+  }, [wsClient]);
+  return {
+    wsClient,
+    wsStatus,
+    isWsConnected: wsStatus === "connected"
+  };
+}
+
+// src/hooks/predict/useRealtimeOrderbook.ts
+var REST_POLL_INTERVAL = 5e3;
+function useRealtimeOrderbook(params, queryOptions = {}) {
+  const { wsClient } = usePredictWsClient();
+  const queryClient = reactQuery.useQueryClient();
+  const outcome = params.outcome ?? "yes";
+  const handleUpdate = react.useCallback(
+    (msg) => {
+      if (msg.data.market_slug !== params.slug) return;
+      if (msg.data.outcome !== "yes" && msg.data.outcome !== "no") return;
+      const ob = {
+        market_id: msg.data.market_slug,
+        outcome: msg.data.outcome,
+        bids: msg.data.bids,
+        asks: msg.data.asks,
+        spread: msg.data.spread
+      };
+      queryClient.setQueryData(
+        orderbookQueryKey(params.slug, params.source, msg.data.outcome),
+        ob
+      );
+    },
+    [params.slug, params.source, queryClient]
+  );
+  const subParams = {
+    wsClient,
+    slug: params.slug,
+    enabled: Boolean(params.slug),
+    outcome,
+    onUpdate: handleUpdate
+  };
+  const { isSubscribed } = useOrderbookSubscription(subParams);
+  return useOrderbook(params, {
+    refetchInterval: isSubscribed ? false : REST_POLL_INTERVAL,
+    ...queryOptions
+  });
+}
+
+// src/hooks/predict/useSportsOrderbook.ts
+function useSportsOrderbook(key) {
+  return useRealtimeOrderbook({
+    slug: key.market_slug,
+    source: key.source,
+    outcome: key.outcome
+  });
+}
 function useInfiniteEvents(params, queryOptions = {}) {
   const client = usePredictClient();
   return reactQuery.useInfiniteQuery({
@@ -1319,8 +1730,8 @@ function useMarket(params, queryOptions = {}) {
     ...queryOptions
   });
 }
-function priceHistoryQueryKey(slug, source, range) {
-  return ["predict", "price-history", slug, source, range];
+function priceHistoryQueryKey(slug, source, rangeOrParams) {
+  return ["predict", "price-history", slug, source, rangeOrParams];
 }
 function usePriceHistory(params, queryOptions = {}) {
   const client = usePredictClient();
@@ -1335,73 +1746,147 @@ function usePriceHistory(params, queryOptions = {}) {
 
 // src/hooks/predict/useMarketHistory.ts
 var ChartRange = {
+  ONE_HOUR: "1h",
+  SIX_HOURS: "6h",
   ONE_DAY: "1d",
-  ONE_WEEK: "1w",
   ONE_MONTH: "1m",
   ALL: "all"
 };
 var RANGE_MAP = {
+  [ChartRange.ONE_HOUR]: "1h",
+  [ChartRange.SIX_HOURS]: "6h",
   [ChartRange.ONE_DAY]: "1d",
-  [ChartRange.ONE_WEEK]: "1w",
   [ChartRange.ONE_MONTH]: "1m",
   [ChartRange.ALL]: "all"
 };
-function useMarketHistory(markets, range = ChartRange.ALL) {
+var RANGE_DURATION_SECONDS = {
+  [ChartRange.ONE_HOUR]: 60 * 60,
+  [ChartRange.SIX_HOURS]: 6 * 60 * 60,
+  [ChartRange.ONE_DAY]: 24 * 60 * 60,
+  [ChartRange.ONE_MONTH]: 30 * 24 * 60 * 60,
+  [ChartRange.ALL]: null
+};
+var RANGE_FIDELITY_MINUTES = {
+  [ChartRange.ONE_HOUR]: 1,
+  [ChartRange.SIX_HOURS]: 1,
+  [ChartRange.ONE_DAY]: 5,
+  [ChartRange.ONE_MONTH]: 15,
+  [ChartRange.ALL]: 15
+};
+var LONG_RANGE_FIDELITY_MINUTES = {
+  SHORT: 15,
+  MONTH: 4 * 60,
+  LONG: 24 * 60
+};
+var LONG_RANGE_SPAN_SECONDS = {
+  WEEK: 7 * 24 * 60 * 60,
+  MONTH: 31 * 24 * 60 * 60
+};
+function unixSecondsFromIso(value) {
+  if (!value) return void 0;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : void 0;
+}
+function firstFinitePrice(market) {
+  const yesOutcome = market.outcomes?.find((o) => o.label.toLowerCase() === "yes") ?? market.outcomes?.[0];
+  const price = yesOutcome?.best_ask ?? yesOutcome?.best_bid ?? yesOutcome?.price;
+  return price != null && Number.isFinite(price) ? price : 0.5;
+}
+function fidelityMinutesForRange(range, startTs, endTs) {
+  if (range !== ChartRange.ONE_MONTH && range !== ChartRange.ALL) {
+    return RANGE_FIDELITY_MINUTES[range];
+  }
+  const spanSeconds = startTs != null ? Math.max(0, endTs - startTs) : 0;
+  if (spanSeconds <= LONG_RANGE_SPAN_SECONDS.WEEK) {
+    return LONG_RANGE_FIDELITY_MINUTES.SHORT;
+  }
+  if (spanSeconds <= LONG_RANGE_SPAN_SECONDS.MONTH) {
+    return LONG_RANGE_FIDELITY_MINUTES.MONTH;
+  }
+  return LONG_RANGE_FIDELITY_MINUTES.LONG;
+}
+function buildRangeParams(range, market, anchoredEndTs) {
+  const endTs = anchoredEndTs;
+  const duration = RANGE_DURATION_SECONDS[range];
+  const createdAt = unixSecondsFromIso(market.created_at);
+  const rangeStartTs = duration == null ? void 0 : Math.max(0, endTs - duration);
+  const startTs = createdAt != null && rangeStartTs != null ? Math.max(createdAt, rangeStartTs) : createdAt ?? rangeStartTs;
+  return {
+    range: RANGE_MAP[range],
+    startTs,
+    endTs,
+    fidelity: fidelityMinutesForRange(range, startTs, endTs)
+  };
+}
+function normalizeHistoryPoints(points, params, fallbackPrice) {
+  const startMs = params.startTs != null ? params.startTs * 1e3 : void 0;
+  const endMs = params.endTs != null ? params.endTs * 1e3 : void 0;
+  const sorted = points.filter((pt) => Number.isFinite(pt.t) && Number.isFinite(pt.p)).map((pt) => ({ timestamp: pt.t * 1e3, price: pt.p })).filter((pt) => {
+    if (startMs != null && pt.timestamp < startMs) return false;
+    if (endMs != null && pt.timestamp > endMs) return false;
+    return true;
+  }).sort((a, b) => a.timestamp - b.timestamp);
+  if (sorted.length === 0) {
+    const now = endMs ?? Date.now();
+    const start = startMs ?? now - 7 * 864e5;
+    return [
+      { timestamp: start, price: fallbackPrice },
+      { timestamp: now, price: fallbackPrice }
+    ];
+  }
+  const result = [...sorted];
+  if (endMs != null && result[result.length - 1].timestamp < endMs) {
+    result.push({
+      timestamp: endMs,
+      price: result[result.length - 1].price
+    });
+  }
+  return result;
+}
+function useMarketHistory(markets, range = ChartRange.ALL, options = {}) {
   const client = usePredictClient();
-  const apiRange = RANGE_MAP[range];
+  const rangeAnchorRef = react.useRef(null);
+  const requestedEndTs = options.endTs;
+  if (rangeAnchorRef.current?.range !== range || requestedEndTs != null && rangeAnchorRef.current?.endTs !== requestedEndTs) {
+    rangeAnchorRef.current = {
+      range,
+      endTs: requestedEndTs ?? Math.floor(Date.now() / 1e3)
+    };
+  }
+  const anchoredEndTs = rangeAnchorRef.current.endTs;
+  const marketParams = react.useMemo(
+    () => markets.map((market) => ({
+      market,
+      params: buildRangeParams(range, market, anchoredEndTs)
+    })),
+    [markets, range, anchoredEndTs]
+  );
   const queries = reactQuery.useQueries({
-    queries: markets.map((market) => ({
-      queryKey: priceHistoryQueryKey(market.slug, market.source, apiRange),
-      queryFn: () => client.getPriceHistory(market.slug, market.source, apiRange),
+    queries: marketParams.map(({ market, params }) => ({
+      queryKey: priceHistoryQueryKey(market.slug, market.source, params),
+      queryFn: () => client.getPriceHistory(market.slug, {
+        source: market.source,
+        ...params
+      }),
       staleTime: 6e4,
       enabled: Boolean(market.slug)
     }))
   });
   const isLoading = queries.some((q) => q.isLoading);
   const series = react.useMemo(() => {
-    return markets.map((market, idx) => {
+    return marketParams.map(({ market, params }, idx) => {
       const result = queries[idx];
       const points = result?.data?.points ?? [];
-      if (points.length > 0) {
-        return {
-          marketSlug: market.slug,
-          label: market.outcomes?.[0]?.label ?? market.question,
-          data: points.map((pt) => ({
-            timestamp: pt.t * 1e3,
-            price: pt.p
-          }))
-        };
-      }
-      const yesOutcome = market.outcomes?.find((o) => o.label.toLowerCase() === "yes") ?? market.outcomes?.[0];
-      const currentPrice = yesOutcome?.price ?? 0.5;
-      const now = Date.now();
-      const dayMs = 864e5;
+      const fallbackPrice = firstFinitePrice(market);
       return {
         marketSlug: market.slug,
         label: market.outcomes?.[0]?.label ?? market.question,
-        data: [
-          { timestamp: now - 7 * dayMs, price: currentPrice },
-          { timestamp: now, price: currentPrice }
-        ]
+        data: normalizeHistoryPoints(points, params, fallbackPrice)
       };
     });
-  }, [markets, queries]);
+  }, [marketParams, queries]);
   return { series, isLoading };
 }
-function orderbookQueryKey(slug, source, outcome = "yes") {
-  return ["predict", "orderbook", slug, source, outcome];
-}
-function useOrderbook(params, queryOptions = {}) {
-  const client = usePredictClient();
-  const outcome = params.outcome ?? "yes";
-  return reactQuery.useQuery({
-    queryKey: orderbookQueryKey(params.slug, params.source, outcome),
-    queryFn: () => client.getOrderbook(params.slug, params.source, outcome),
-    enabled: Boolean(params.slug),
-    refetchInterval: 3e4,
-    ...queryOptions
-  });
-}
 function marketTradesQueryKey(slug, params) {
   return ["predict", "market-trades", slug, params];
 }
@@ -2595,29 +3080,6 @@ function useRebateConfig(queryOptions = {}) {
     ...queryOptions
   });
 }
-function usePredictWsClient() {
-  const context = react.useContext(PredictContext);
-  if (!context) {
-    throw new Error("usePredictWsClient must be used within a PredictProvider");
-  }
-  const { wsClient } = context;
-  const [wsStatus, setWsStatus] = react.useState(
-    wsClient?.getStatus() ?? "disconnected"
-  );
-  react.useEffect(() => {
-    if (!wsClient) {
-      setWsStatus("disconnected");
-      return;
-    }
-    setWsStatus(wsClient.getStatus());
-    return wsClient.onStatusChange(setWsStatus);
-  }, [wsClient]);
-  return {
-    wsClient,
-    wsStatus,
-    isWsConnected: wsStatus === "connected"
-  };
-}
 function usePricesSubscription({
   wsClient,
   slugs,
@@ -2653,43 +3115,6 @@ function usePricesSubscription({
   }, [wsClient, enabled, slugsKey, handleUpdate]);
   return { prices, isSubscribed };
 }
-function useOrderbookSubscription({
-  wsClient,
-  slug,
-  enabled = true,
-  outcome,
-  onUpdate
-}) {
-  const [orderbook, setOrderbook] = react.useState(null);
-  const [isSubscribed, setIsSubscribed] = react.useState(false);
-  const onUpdateRef = react.useRef(onUpdate);
-  onUpdateRef.current = onUpdate;
-  const handleUpdate = react.useCallback(
-    (msg) => {
-      if (msg.data.market_slug === slug) {
-        if (!outcome || msg.data.outcome === outcome) {
-          setOrderbook(msg.data);
-        }
-        onUpdateRef.current?.(msg);
-      }
-    },
-    [slug, outcome]
-  );
-  react.useEffect(() => {
-    if (!wsClient || !enabled || !slug) {
-      setIsSubscribed(false);
-      return;
-    }
-    setOrderbook(null);
-    const unsub = wsClient.subscribeOrderbook([slug], handleUpdate);
-    setIsSubscribed(true);
-    return () => {
-      unsub();
-      setIsSubscribed(false);
-    };
-  }, [wsClient, enabled, slug, handleUpdate]);
-  return { orderbook, isSubscribed };
-}
 var DEFAULT_MAX_HISTORY = 100;
 function useTradesSubscription({
   wsClient,
@@ -2734,42 +3159,6 @@ function useTradesSubscription({
   }, [wsClient, enabled, slug, handleUpdate]);
   return { trades, isSubscribed, clearHistory };
 }
-var REST_POLL_INTERVAL = 5e3;
-function useRealtimeOrderbook(params, queryOptions = {}) {
-  const { wsClient } = usePredictWsClient();
-  const queryClient = reactQuery.useQueryClient();
-  const outcome = params.outcome ?? "yes";
-  const handleUpdate = react.useCallback(
-    (msg) => {
-      if (msg.data.market_slug !== params.slug) return;
-      if (msg.data.outcome !== "yes" && msg.data.outcome !== "no") return;
-      const ob = {
-        market_id: msg.data.market_slug,
-        outcome: msg.data.outcome,
-        bids: msg.data.bids,
-        asks: msg.data.asks,
-        spread: msg.data.spread
-      };
-      queryClient.setQueryData(
-        orderbookQueryKey(params.slug, params.source, msg.data.outcome),
-        ob
-      );
-    },
-    [params.slug, params.source, queryClient]
-  );
-  const subParams = {
-    wsClient,
-    slug: params.slug,
-    enabled: Boolean(params.slug),
-    outcome,
-    onUpdate: handleUpdate
-  };
-  const { isSubscribed } = useOrderbookSubscription(subParams);
-  return useOrderbook(params, {
-    refetchInterval: isSubscribed ? false : REST_POLL_INTERVAL,
-    ...queryOptions
-  });
-}
 
 // src/hooks/predict/useRealtimePrices.ts
 function useRealtimePrices({
@@ -3318,16 +3707,28 @@ exports.createPredictWsClient = createPredictWsClient;
 exports.derivePolymarketApiKey = derivePolymarketApiKey;
 exports.dflowKYCQueryKey = dflowKYCQueryKey;
 exports.dflowQuoteQueryKey = dflowQuoteQueryKey;
+exports.esportsMatchesQueryKey = esportsMatchesQueryKey;
+exports.esportsPropsQueryKey = esportsPropsQueryKey;
+exports.esportsTaxonomyQueryKey = esportsTaxonomyQueryKey;
 exports.eventQueryKey = eventQueryKey;
 exports.eventStatsQueryKey = eventStatsQueryKey;
 exports.eventsQueryKey = eventsQueryKey;
 exports.feeRateQueryKey = feeRateQueryKey;
+exports.fetchEsportsMatches = fetchEsportsMatches;
+exports.fetchEsportsProps = fetchEsportsProps;
+exports.fetchEsportsTaxonomy = fetchEsportsTaxonomy;
 exports.fetchEvent = fetchEvent;
 exports.fetchEvents = fetchEvents;
 exports.fetchEventsPage = fetchEventsPage;
 exports.fetchMarket = fetchMarket;
 exports.fetchMatchMarketsPage = fetchMatchMarketsPage;
 exports.fetchMatchesPage = fetchMatchesPage;
+exports.fetchPredictSearch = fetchPredictSearch;
+exports.fetchSportsMatchDetail = fetchSportsMatchDetail;
+exports.fetchSportsMatches = fetchSportsMatches;
+exports.fetchSportsProps = fetchSportsProps;
+exports.fetchSportsRouting = fetchSportsRouting;
+exports.fetchSportsTaxonomy = fetchSportsTaxonomy;
 exports.getPolymarketSharesPrecision = getPolymarketSharesPrecision;
 exports.hmacSha256Base64 = hmacSha256Base64;
 exports.infiniteCommentsQueryKey = infiniteCommentsQueryKey;
@@ -3355,11 +3756,17 @@ exports.positionValueMultiQueryKey = positionValueMultiQueryKey;
 exports.positionValueQueryKey = positionValueQueryKey;
 exports.positionsMultiQueryKey = positionsMultiQueryKey;
 exports.positionsQueryKey = positionsQueryKey;
+exports.predictSearchQueryKey = predictSearchQueryKey;
 exports.priceHistoryQueryKey = priceHistoryQueryKey;
 exports.rebateConfigQueryKey = rebateConfigQueryKey;
 exports.resolveEventsParams = resolveEventsParams;
 exports.resolveTagSlug = resolveTagSlug;
 exports.similarEventsQueryKey = similarEventsQueryKey;
+exports.sportsMatchDetailQueryKey = sportsMatchDetailQueryKey;
+exports.sportsMatchesQueryKey = sportsMatchesQueryKey;
+exports.sportsPropsQueryKey = sportsPropsQueryKey;
+exports.sportsRoutingQueryKey = sportsRoutingQueryKey;
+exports.sportsTaxonomyQueryKey = sportsTaxonomyQueryKey;
 exports.tickSizeQueryKey = tickSizeQueryKey;
 exports.tradesQueryKey = tradesQueryKey;
 exports.updatePolymarketBalanceAllowance = updatePolymarketBalanceAllowance;
@@ -3372,6 +3779,9 @@ exports.useDFlowKYC = useDFlowKYC;
 exports.useDFlowQuote = useDFlowQuote;
 exports.useDFlowSubmit = useDFlowSubmit;
 exports.useDeployPolymarketDepositWallet = useDeployPolymarketDepositWallet;
+exports.useEsportsMatches = useEsportsMatches;
+exports.useEsportsProps = useEsportsProps;
+exports.useEsportsTaxonomy = useEsportsTaxonomy;
 exports.useEvent = useEvent;
 exports.useEventStats = useEventStats;
 exports.useEvents = useEvents;
@@ -3381,6 +3791,7 @@ exports.useInfiniteEvents = useInfiniteEvents;
 exports.useInfiniteMatchMarkets = useInfiniteMatchMarkets;
 exports.useInfiniteMatches = useInfiniteMatches;
 exports.useInfiniteOrders = useInfiniteOrders;
+exports.useInfinitePredictSearch = useInfinitePredictSearch;
 exports.useInfiniteTrades = useInfiniteTrades;
 exports.useInfiniteTradesMulti = useInfiniteTradesMulti;
 exports.useMarket = useMarket;
@@ -3408,6 +3819,7 @@ exports.usePositionValueMulti = usePositionValueMulti;
 exports.usePositions = usePositions;
 exports.usePositionsMulti = usePositionsMulti;
 exports.usePredictClient = usePredictClient;
+exports.usePredictSearch = usePredictSearch;
 exports.usePredictWsClient = usePredictWsClient;
 exports.usePriceHistory = usePriceHistory;
 exports.usePricesSubscription = usePricesSubscription;
@@ -3419,6 +3831,12 @@ exports.useRedeemPosition = useRedeemPosition;
 exports.useRunPolymarketSetup = useRunPolymarketSetup;
 exports.useSearchEvents = useSearchEvents;
 exports.useSimilarEvents = useSimilarEvents;
+exports.useSportsMatchDetail = useSportsMatchDetail;
+exports.useSportsMatches = useSportsMatches;
+exports.useSportsOrderbook = useSportsOrderbook;
+exports.useSportsProps = useSportsProps;
+exports.useSportsRouting = useSportsRouting;
+exports.useSportsTaxonomy = useSportsTaxonomy;
 exports.useTickSize = useTickSize;
 exports.useTradeResultConfirmation = useTradeResultConfirmation;
 exports.useTrades = useTrades;