@pokertools/sdk 1.0.4

package/dist/react/index.cjs

@@ -0,0 +1,1099 @@
+'use strict';
+
+var react = require('react');
+var types = require('@pokertools/types');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/index.tsx
+
+// src/types.ts
+var PokerSDKError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "PokerSDKError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_CONFIG = {
+  timeout: 3e4,
+  retry: {
+    count: 3,
+    delay: 1e3,
+    backoff: 2
+  }
+};
+var PokerClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout ?? DEFAULT_CONFIG.timeout;
+    this.retry = {
+      count: config.retry?.count ?? DEFAULT_CONFIG.retry.count,
+      delay: config.retry?.delay ?? DEFAULT_CONFIG.retry.delay,
+      backoff: config.retry?.backoff ?? DEFAULT_CONFIG.retry.backoff
+    };
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.debug = config.debug ?? false;
+    this.token = config.token ?? null;
+  }
+  // ============================================================================
+  // Configuration
+  // ============================================================================
+  /**
+   * Set the authentication token
+   */
+  setToken(token) {
+    this.token = token;
+  }
+  /**
+   * Get current token
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Check if client is authenticated
+   */
+  isAuthenticated() {
+    return this.token !== null;
+  }
+  // ============================================================================
+  // Authentication
+  // ============================================================================
+  /**
+   * Get a nonce for SIWE authentication
+   */
+  async getNonce() {
+    const response = await this.request("POST", "/auth/nonce");
+    return response.nonce;
+  }
+  /**
+   * Login with SIWE signature
+   */
+  async login(request) {
+    const response = await this.request("POST", "/auth/login", request);
+    this.token = response.token;
+    return response;
+  }
+  /**
+   * Logout and revoke session
+   */
+  async logout() {
+    await this.request("POST", "/auth/logout");
+    this.token = null;
+  }
+  // ============================================================================
+  // Tables
+  // ============================================================================
+  /**
+   * Get list of active tables
+   */
+  async getTables() {
+    const response = await this.request("GET", "/tables");
+    return response.tables;
+  }
+  /**
+   * Create a new table
+   */
+  async createTable(config) {
+    const response = await this.request("POST", "/tables", config);
+    return response.tableId;
+  }
+  /**
+   * Get table state
+   * @param tableId - Table ID
+   * @param since - Optional version for conditional fetch (returns null if unchanged)
+   */
+  async getTableState(tableId, since) {
+    const query = since !== void 0 ? `?since=${since}` : "";
+    try {
+      const response = await this.request(
+        "GET",
+        `/tables/${tableId}${query}`
+      );
+      return response.state;
+    } catch (error) {
+      if (error instanceof PokerSDKError && error.statusCode === 304) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Buy in to a table
+   */
+  async buyIn(tableId, request) {
+    await this.request("POST", `/tables/${tableId}/buy-in`, request);
+  }
+  /**
+   * Execute a game action
+   */
+  async action(tableId, request) {
+    const response = await this.request(
+      "POST",
+      `/tables/${tableId}/action`,
+      request
+    );
+    return response.state;
+  }
+  /**
+   * Add chips to stack (rebuy/top-up)
+   */
+  async addChips(tableId, request) {
+    await this.request("POST", `/tables/${tableId}/add-chips`, request);
+  }
+  /**
+   * Stand from table (leave and cash out)
+   */
+  async stand(tableId) {
+    await this.request("POST", `/tables/${tableId}/stand`);
+  }
+  // ============================================================================
+  // Convenience Action Methods
+  // ============================================================================
+  /**
+   * Fold hand
+   */
+  async fold(tableId) {
+    return this.action(tableId, { type: "FOLD" });
+  }
+  /**
+   * Check (pass action)
+   */
+  async check(tableId) {
+    return this.action(tableId, { type: "CHECK" });
+  }
+  /**
+   * Call current bet
+   */
+  async call(tableId) {
+    return this.action(tableId, { type: "CALL" });
+  }
+  /**
+   * Place a bet
+   */
+  async bet(tableId, amount) {
+    return this.action(tableId, { type: "BET", amount });
+  }
+  /**
+   * Raise the current bet
+   */
+  async raise(tableId, amount) {
+    return this.action(tableId, { type: "RAISE", amount });
+  }
+  /**
+   * Deal new hand
+   */
+  async deal(tableId) {
+    return this.action(tableId, { type: "DEAL" });
+  }
+  /**
+   * Show cards at showdown
+   */
+  async show(tableId, cardIndices) {
+    return this.action(tableId, { type: "SHOW", cardIndices });
+  }
+  /**
+   * Muck cards at showdown
+   */
+  async muck(tableId) {
+    return this.action(tableId, { type: "MUCK" });
+  }
+  /**
+   * Use time bank
+   */
+  async timeBank(tableId) {
+    return this.action(tableId, { type: "TIME_BANK" });
+  }
+  // ============================================================================
+  // User
+  // ============================================================================
+  /**
+   * Get current user profile and balances
+   */
+  async getProfile() {
+    return this.request("GET", "/user/me");
+  }
+  /**
+   * Get hand history
+   */
+  async getHandHistory() {
+    const response = await this.request("GET", "/user/history");
+    return response.history;
+  }
+  /**
+   * Request a withdrawal
+   */
+  async withdraw(request) {
+    return this.request("POST", "/user/withdraw", request);
+  }
+  /**
+   * Get withdrawal history
+   */
+  async getWithdrawals() {
+    const response = await this.request(
+      "GET",
+      "/user/withdrawals"
+    );
+    return response.withdrawals;
+  }
+  // ============================================================================
+  // Finance
+  // ============================================================================
+  /**
+   * Get supported blockchains and tokens
+   */
+  async getChains() {
+    return this.request("GET", "/finance/chains");
+  }
+  /**
+   * Start deposit monitoring session
+   */
+  async startDeposit() {
+    return this.request("POST", "/finance/deposit/start");
+  }
+  /**
+   * Get deposit address
+   */
+  async getDepositAddress() {
+    const response = await this.request("GET", "/finance/deposit/address");
+    return response.address;
+  }
+  /**
+   * Get deposit history
+   */
+  async getDeposits() {
+    const response = await this.request("GET", "/finance/deposits");
+    return response.deposits;
+  }
+  // ============================================================================
+  // Notes
+  // ============================================================================
+  /**
+   * Get all notes by current user
+   */
+  async getNotes() {
+    const response = await this.request("GET", "/notes");
+    return response.notes;
+  }
+  /**
+   * Get note for specific player
+   */
+  async getNote(targetId) {
+    const response = await this.request("GET", `/notes/${targetId}`);
+    return response.note;
+  }
+  /**
+   * Save or update note
+   */
+  async saveNote(targetId, content, label) {
+    const response = await this.request("POST", "/notes", {
+      targetId,
+      content,
+      label
+    });
+    return response.note;
+  }
+  /**
+   * Delete note
+   */
+  async deleteNote(targetId) {
+    await this.request("DELETE", `/notes/${targetId}`);
+  }
+  // ============================================================================
+  // Health
+  // ============================================================================
+  /**
+   * Health check
+   */
+  async health() {
+    return this.request("GET", "/health");
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Make HTTP request with retry logic
+   */
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retry.count; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        if (this.debug) {
+          console.log(`[PokerSDK] ${method} ${path}`, body);
+        }
+        const response = await this.fetchFn(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 304) {
+          throw new PokerSDKError("Not Modified", "NOT_MODIFIED", 304);
+        }
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new PokerSDKError(
+            errorData.message ?? errorData.error ?? `HTTP ${response.status}`,
+            errorData.code ?? errorData.error ?? "HTTP_ERROR",
+            response.status,
+            errorData
+          );
+        }
+        const data = await response.json();
+        if (this.debug) {
+          console.log(`[PokerSDK] Response:`, data);
+        }
+        return data;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof PokerSDKError) {
+          if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+            throw error;
+          }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new PokerSDKError("Request timeout", "TIMEOUT", void 0, {
+            timeout: this.timeout
+          });
+        }
+        if (attempt < this.retry.count) {
+          const delay = this.retry.delay * Math.pow(this.retry.backoff, attempt);
+          if (this.debug) {
+            console.log(`[PokerSDK] Retry ${attempt + 1}/${this.retry.count} in ${delay}ms`);
+          }
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new PokerSDKError("Request failed", "REQUEST_FAILED");
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var DEFAULT_SOCKET_CONFIG = {
+  heartbeatInterval: 25e3,
+  reconnectAttempts: 10,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4
+};
+var PokerSocket = class _PokerSocket {
+  constructor(config) {
+    this.ws = null;
+    this.connectionState = "disconnected";
+    this.reconnectCount = 0;
+    this.heartbeatTimer = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.joinedTables = /* @__PURE__ */ new Set();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.shouldReconnect = true;
+    // Latest state cache for each table
+    this.stateCache = /* @__PURE__ */ new Map();
+    const wsUrl = new URL(config.url);
+    wsUrl.searchParams.set("token", config.token);
+    this.url = wsUrl.toString();
+    this.token = config.token;
+    this.heartbeatInterval = config.heartbeatInterval ?? DEFAULT_SOCKET_CONFIG.heartbeatInterval;
+    this.reconnectAttempts = config.reconnectAttempts ?? DEFAULT_SOCKET_CONFIG.reconnectAttempts;
+    this.reconnectDelay = config.reconnectDelay ?? DEFAULT_SOCKET_CONFIG.reconnectDelay;
+    this.maxReconnectDelay = config.maxReconnectDelay ?? DEFAULT_SOCKET_CONFIG.maxReconnectDelay;
+    this.WebSocketImpl = config.WebSocket ?? globalThis.WebSocket;
+    this.debug = config.debug ?? false;
+  }
+  /**
+   * Create a PokerSocket from SDK config
+   */
+  static fromConfig(config) {
+    if (!config.token) {
+      throw new PokerSDKError("Token is required for WebSocket connection", "AUTH_REQUIRED");
+    }
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
+    const wsUrl = config.wsUrl ?? baseUrl.replace(/^http/, "ws") + "/ws/play";
+    return new _PokerSocket({
+      url: wsUrl,
+      token: config.token,
+      WebSocket: config.WebSocket,
+      debug: config.debug
+    });
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  /**
+   * Connect to the WebSocket server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.connectionState === "connected") {
+        resolve();
+        return;
+      }
+      if (this.connectionState === "connecting") {
+        const checkConnection = () => {
+          if (this.connectionState === "connected") {
+            resolve();
+          } else if (this.connectionState === "disconnected") {
+            reject(new PokerSDKError("Connection failed", "CONNECTION_FAILED"));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+        return;
+      }
+      this.shouldReconnect = true;
+      this.connectionState = "connecting";
+      this.log("Connecting to", this.url);
+      try {
+        this.ws = new this.WebSocketImpl(this.url);
+        this.ws.onopen = () => {
+          this.connectionState = "connected";
+          this.reconnectCount = 0;
+          this.startHeartbeat();
+          this.emit("connect");
+          this.log("Connected");
+          void this.rejoinTables();
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          this.handleDisconnect(event.reason || "Connection closed");
+        };
+        this.ws.onerror = (event) => {
+          this.log("WebSocket error:", event);
+          if (this.connectionState === "connecting") {
+            reject(new PokerSDKError("Connection failed", "CONNECTION_FAILED"));
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        this.connectionState = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    this.stopHeartbeat();
+    this.clearPendingRequests("Connection closed");
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.connectionState = "disconnected";
+    this.emit("disconnect", "Client disconnect");
+    this.log("Disconnected");
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.connectionState;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connectionState === "connected";
+  }
+  // ============================================================================
+  // Table Subscription
+  // ============================================================================
+  /**
+   * Join a table to receive real-time updates
+   */
+  async join(tableId) {
+    if (this.connectionState !== "connected") {
+      throw new PokerSDKError("Not connected", "NOT_CONNECTED");
+    }
+    const requestId = this.generateRequestId();
+    const message = {
+      type: "JOIN",
+      tableId,
+      requestId
+    };
+    this.joinedTables.add(tableId);
+    this.send(message);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new PokerSDKError("Join timeout", "TIMEOUT"));
+      }, 1e4);
+      this.pendingRequests.set(`snapshot:${tableId}`, {
+        resolve: (state) => {
+          clearTimeout(timeout);
+          resolve(state);
+        },
+        reject,
+        timeout
+      });
+    });
+  }
+  /**
+   * Leave a table
+   */
+  leave(tableId) {
+    if (this.connectionState !== "connected") {
+      return;
+    }
+    this.joinedTables.delete(tableId);
+    this.stateCache.delete(tableId);
+    const message = {
+      type: "LEAVE",
+      tableId
+    };
+    this.send(message);
+  }
+  /**
+   * Get currently joined tables
+   */
+  getJoinedTables() {
+    return Array.from(this.joinedTables);
+  }
+  /**
+   * Get cached state for a table
+   */
+  getCachedState(tableId) {
+    return this.stateCache.get(tableId);
+  }
+  // ============================================================================
+  // Event Handling
+  // ============================================================================
+  /**
+   * Subscribe to an event
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  /**
+   * Subscribe to an event (once)
+   */
+  once(event, listener) {
+    const onceWrapper = ((...args) => {
+      this.off(event, onceWrapper);
+      listener(...args);
+    });
+    return this.on(event, onceWrapper);
+  }
+  // ============================================================================
+  // Ping
+  // ============================================================================
+  /**
+   * Send application-level ping (not WebSocket ping)
+   */
+  async ping() {
+    if (this.connectionState !== "connected") {
+      throw new PokerSDKError("Not connected", "NOT_CONNECTED");
+    }
+    const requestId = this.generateRequestId();
+    const startTime = Date.now();
+    const message = {
+      type: "PING",
+      requestId,
+      timestamp: startTime
+    };
+    this.send(message);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new PokerSDKError("Ping timeout", "TIMEOUT"));
+      }, 5e3);
+      this.pendingRequests.set(requestId, {
+        resolve: () => {
+          resolve(Date.now() - startTime);
+        },
+        reject,
+        timeout
+      });
+    });
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (this.ws?.readyState !== this.WebSocketImpl.OPEN) {
+      throw new PokerSDKError("WebSocket not open", "NOT_CONNECTED");
+    }
+    this.log("Sending:", message);
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(data) {
+    try {
+      const parsed = JSON.parse(data);
+      const result = types.safeParseServerMessage(parsed);
+      if (!result.success) {
+        this.log("Invalid server message:", result.error);
+        return;
+      }
+      const message = result.data;
+      this.log("Received:", message);
+      switch (message.type) {
+        case "SNAPSHOT": {
+          this.stateCache.set(message.tableId, message.state);
+          const pending = this.pendingRequests.get(`snapshot:${message.tableId}`);
+          if (pending) {
+            this.pendingRequests.delete(`snapshot:${message.tableId}`);
+            pending.resolve(message.state);
+          }
+          this.emit("snapshot", message.tableId, message.state);
+          break;
+        }
+        case "STATE_UPDATE": {
+          const cachedState = this.stateCache.get(message.tableId);
+          if (cachedState) {
+            const updatedState = { ...cachedState, version: message.version };
+            this.stateCache.set(message.tableId, updatedState);
+            this.emit("stateUpdate", message.tableId, updatedState);
+          } else {
+            this.emit("stateUpdate", message.tableId, {
+              version: message.version
+            });
+          }
+          break;
+        }
+        case "ACTION": {
+          this.emit(
+            "action",
+            message.tableId,
+            message.playerId,
+            message.actionType,
+            message.amount
+          );
+          break;
+        }
+        case "ACK": {
+          const pending = this.pendingRequests.get(message.requestId);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(message.requestId);
+            pending.resolve(void 0);
+          }
+          break;
+        }
+        case "PONG": {
+          const pending = this.pendingRequests.get(message.requestId);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(message.requestId);
+            pending.resolve(message.timestamp);
+          }
+          break;
+        }
+        case "ERROR": {
+          this.log("Server error:", message);
+          if (message.requestId) {
+            const pending = this.pendingRequests.get(message.requestId);
+            if (pending) {
+              clearTimeout(pending.timeout);
+              this.pendingRequests.delete(message.requestId);
+              pending.reject(new PokerSDKError(message.message, message.code));
+            }
+          }
+          this.emit("error", new PokerSDKError(message.message, message.code));
+          break;
+        }
+      }
+    } catch (error) {
+      this.log("Failed to parse message:", error);
+    }
+  }
+  /**
+   * Handle disconnect
+   */
+  handleDisconnect(reason) {
+    this.stopHeartbeat();
+    this.ws = null;
+    const wasConnected = this.connectionState === "connected";
+    this.connectionState = "disconnected";
+    if (wasConnected) {
+      this.emit("disconnect", reason);
+    }
+    if (this.shouldReconnect && this.reconnectCount < this.reconnectAttempts) {
+      void this.reconnect();
+    }
+  }
+  /**
+   * Attempt to reconnect
+   */
+  async reconnect() {
+    this.reconnectCount++;
+    this.connectionState = "reconnecting";
+    const delay = Math.min(
+      this.reconnectDelay * Math.pow(2, this.reconnectCount - 1),
+      this.maxReconnectDelay
+    );
+    this.log(
+      `Reconnecting in ${delay}ms (attempt ${this.reconnectCount}/${this.reconnectAttempts})`
+    );
+    this.emit("reconnect", this.reconnectCount);
+    await this.sleep(delay);
+    if (!this.shouldReconnect) {
+      return;
+    }
+    try {
+      await this.connect();
+    } catch {
+    }
+  }
+  /**
+   * Rejoin previously joined tables
+   */
+  async rejoinTables() {
+    for (const tableId of this.joinedTables) {
+      try {
+        await this.join(tableId);
+      } catch (error) {
+        this.log("Failed to rejoin table:", tableId, error);
+      }
+    }
+  }
+  /**
+   * Start heartbeat timer
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.connectionState === "connected") {
+        void this.ping().catch(() => {
+          this.log("Heartbeat failed");
+        });
+      }
+    }, this.heartbeatInterval);
+  }
+  /**
+   * Stop heartbeat timer
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * Clear all pending requests
+   */
+  clearPendingRequests(reason) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new PokerSDKError(reason, "CONNECTION_CLOSED"));
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Emit event to listeners
+   */
+  emit(event, ...args) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.log("Listener error:", error);
+        }
+      }
+    }
+  }
+  /**
+   * Generate unique request ID
+   */
+  generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Debug logger
+   */
+  log(...args) {
+    if (this.debug) {
+      console.log("[PokerSocket]", ...args);
+    }
+  }
+};
+var PokerContext = react.createContext(null);
+function PokerProvider({ config, children, autoConnect = true }) {
+  const [connectionState, setConnectionState] = react.useState("disconnected");
+  const clientRef = react.useRef(null);
+  const socketRef = react.useRef(null);
+  clientRef.current ?? (clientRef.current = new PokerClient(config));
+  react.useEffect(() => {
+    if (clientRef.current) {
+      clientRef.current.setToken(config.token ?? null);
+    }
+  }, [config.token]);
+  react.useEffect(() => {
+    if (config.token && autoConnect && !socketRef.current) {
+      socketRef.current = PokerSocket.fromConfig(config);
+      socketRef.current.on("connect", () => setConnectionState("connected"));
+      socketRef.current.on("disconnect", () => setConnectionState("disconnected"));
+      socketRef.current.on("reconnect", () => setConnectionState("reconnecting"));
+      void socketRef.current.connect().catch(console.error);
+    }
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+    };
+  }, [config.token, autoConnect, config]);
+  const connect = react.useCallback(async () => {
+    if (!config.token) {
+      throw new Error("Token required to connect");
+    }
+    if (!socketRef.current) {
+      socketRef.current = PokerSocket.fromConfig(config);
+      socketRef.current.on("connect", () => setConnectionState("connected"));
+      socketRef.current.on("disconnect", () => setConnectionState("disconnected"));
+      socketRef.current.on("reconnect", () => setConnectionState("reconnecting"));
+    }
+    setConnectionState("connecting");
+    await socketRef.current.connect();
+  }, [config]);
+  const disconnect = react.useCallback(() => {
+    if (socketRef.current) {
+      socketRef.current.disconnect();
+    }
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      client: clientRef.current,
+      socket: socketRef.current,
+      isAuthenticated: !!config.token,
+      connectionState,
+      connect,
+      disconnect
+    }),
+    [config.token, connectionState, connect, disconnect]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PokerContext.Provider, { value, children });
+}
+function usePoker() {
+  const context = react.useContext(PokerContext);
+  if (!context) {
+    throw new Error("usePoker must be used within a PokerProvider");
+  }
+  return context;
+}
+function usePokerClient() {
+  return usePoker().client;
+}
+function usePokerSocket() {
+  return usePoker().socket;
+}
+function useTable(tableId, options = {}) {
+  const { pollInterval, autoJoin = true } = options;
+  const { client, socket } = usePoker();
+  const [state, setState] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const versionRef = react.useRef(0);
+  const refresh = react.useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const newState = await client.getTableState(tableId);
+      if (newState) {
+        setState(newState);
+        versionRef.current = newState.version;
+      }
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, tableId]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  react.useEffect(() => {
+    if (!socket || !autoJoin) return;
+    const handleStateUpdate = (id, newState) => {
+      if (id === tableId) {
+        setState(newState);
+        versionRef.current = newState.version;
+      }
+    };
+    const handleSnapshot = (id, newState) => {
+      if (id === tableId) {
+        setState(newState);
+        versionRef.current = newState.version;
+        setIsLoading(false);
+      }
+    };
+    socket.on("stateUpdate", handleStateUpdate);
+    socket.on("snapshot", handleSnapshot);
+    if (socket.isConnected()) {
+      void socket.join(tableId).catch(console.error);
+    }
+    return () => {
+      socket.off("stateUpdate", handleStateUpdate);
+      socket.off("snapshot", handleSnapshot);
+      socket.leave(tableId);
+    };
+  }, [socket, tableId, autoJoin]);
+  react.useEffect(() => {
+    if (!pollInterval) return;
+    const interval = setInterval(() => {
+      void (async () => {
+        const newState = await client.getTableState(tableId, versionRef.current);
+        if (newState) {
+          setState(newState);
+          versionRef.current = newState.version;
+        }
+      })();
+    }, pollInterval);
+    return () => clearInterval(interval);
+  }, [client, tableId, pollInterval]);
+  const action = react.useCallback(
+    async (type, amount) => {
+      const newState = await client.action(tableId, { type, amount });
+      setState(newState);
+      versionRef.current = newState.version;
+    },
+    [client, tableId]
+  );
+  const leave = react.useCallback(async () => {
+    await client.stand(tableId);
+    if (socket) {
+      socket.leave(tableId);
+    }
+  }, [client, socket, tableId]);
+  return { state, isLoading, error, refresh, action, leave };
+}
+function useUser() {
+  const { client, isAuthenticated } = usePoker();
+  const [profile, setProfile] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const refresh = react.useCallback(async () => {
+    if (!isAuthenticated) return;
+    try {
+      setIsLoading(true);
+      const data = await client.getProfile();
+      setProfile(data);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isAuthenticated]);
+  react.useEffect(() => {
+    if (isAuthenticated) {
+      void refresh();
+    } else {
+      setProfile(null);
+    }
+  }, [isAuthenticated, refresh]);
+  return {
+    profile,
+    balances: profile?.balances ?? null,
+    isLoading,
+    error,
+    refresh
+  };
+}
+function useTables() {
+  const { client } = usePoker();
+  const [tables, setTables] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const refresh = react.useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const data = await client.getTables();
+      setTables(data);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { tables, isLoading, error, refresh };
+}
+function useConnection() {
+  const { socket, connectionState, connect, disconnect } = usePoker();
+  const [latency, setLatency] = react.useState(null);
+  const ping = react.useCallback(async () => {
+    if (!socket?.isConnected()) return null;
+    try {
+      const ms = await socket.ping();
+      setLatency(ms);
+      return ms;
+    } catch {
+      return null;
+    }
+  }, [socket]);
+  return {
+    state: connectionState,
+    isConnected: connectionState === "connected",
+    isConnecting: connectionState === "connecting",
+    isReconnecting: connectionState === "reconnecting",
+    latency,
+    connect,
+    disconnect,
+    ping
+  };
+}
+
+exports.PokerProvider = PokerProvider;
+exports.useConnection = useConnection;
+exports.usePoker = usePoker;
+exports.usePokerClient = usePokerClient;
+exports.usePokerSocket = usePokerSocket;
+exports.useTable = useTable;
+exports.useTables = useTables;
+exports.useUser = useUser;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map