@pushflodev/sdk 1.0.1

package/dist/react.js

@@ -0,0 +1,1295 @@
+import { createContext, useState, useRef, useEffect, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+/* @pushflo/sdk - https://pushflo.dev */
+
+
+// src/utils/EventEmitter.ts
+var TypedEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Register an event listener
+   */
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Register a one-time event listener
+   */
+  once(event, handler) {
+    const onceHandler = (...args) => {
+      this.off(event, onceHandler);
+      handler(...args);
+    };
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Remove an event listener
+   */
+  off(event, handler) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+    return this;
+  }
+  /**
+   * Emit an event to all registered listeners
+   */
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (!handlers || handlers.size === 0) {
+      return false;
+    }
+    handlers.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for "${String(event)}":`, error);
+      }
+    });
+    return true;
+  }
+  /**
+   * Remove all listeners for an event, or all listeners if no event specified
+   */
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+    return this;
+  }
+  /**
+   * Get the number of listeners for an event
+   */
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+  /**
+   * Get all event names with registered listeners
+   */
+  eventNames() {
+    return Array.from(this.listeners.keys());
+  }
+};
+
+// src/utils/constants.ts
+var DEFAULTS = {
+  /** Default PushFlo API base URL */
+  BASE_URL: "https://api.pushflo.dev",
+  /** WebSocket endpoint path */
+  WS_PATH: "/ws",
+  /** Connection timeout in milliseconds */
+  CONNECTION_TIMEOUT: 3e4,
+  /** Heartbeat interval in milliseconds */
+  HEARTBEAT_INTERVAL: 25e3,
+  /** Initial reconnection delay in milliseconds */
+  RECONNECT_DELAY: 1e3,
+  /** Maximum reconnection delay in milliseconds */
+  MAX_RECONNECT_DELAY: 3e4,
+  /** Reconnection delay multiplier for exponential backoff */
+  RECONNECT_MULTIPLIER: 1.5,
+  /** Maximum number of reconnection attempts (0 = infinite) */
+  MAX_RECONNECT_ATTEMPTS: 0};
+var WS_CLIENT_MESSAGES = {
+  SUBSCRIBE: "subscribe",
+  UNSUBSCRIBE: "unsubscribe",
+  PING: "ping"};
+var WS_SERVER_MESSAGES = {
+  CONNECTED: "connected",
+  SUBSCRIBED: "subscribed",
+  UNSUBSCRIBED: "unsubscribed",
+  MESSAGE: "message",
+  ERROR: "error",
+  PONG: "pong"
+};
+var ERROR_CODES = {
+  // Connection errors
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+  CONNECTION_CLOSED: "CONNECTION_CLOSED",
+  // Authentication errors
+  INVALID_API_KEY: "INVALID_API_KEY",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  SERVER_ERROR: "SERVER_ERROR"};
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  enabled;
+  prefix;
+  minLevel;
+  constructor(options = {}) {
+    this.enabled = options.debug ?? false;
+    this.prefix = options.prefix ?? "[PushFlo]";
+    this.minLevel = LOG_LEVELS[options.level ?? "debug"];
+  }
+  /**
+   * Enable or disable logging
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Set minimum log level
+   */
+  setLevel(level) {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  /**
+   * Log an info message
+   */
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  /**
+   * Log an error message
+   */
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  log(level, message, ...args) {
+    if (!this.enabled && level !== "error") {
+      return;
+    }
+    if (LOG_LEVELS[level] < this.minLevel) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const formattedMessage = `${this.prefix} ${timestamp} [${level.toUpperCase()}] ${message}`;
+    switch (level) {
+      case "debug":
+        console.debug(formattedMessage, ...args);
+        break;
+      case "info":
+        console.info(formattedMessage, ...args);
+        break;
+      case "warn":
+        console.warn(formattedMessage, ...args);
+        break;
+      case "error":
+        console.error(formattedMessage, ...args);
+        break;
+    }
+  }
+};
+function createLogger(options = {}) {
+  return new Logger(options);
+}
+
+// src/errors/PushFloError.ts
+var PushFloError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Whether this error is potentially recoverable through retry */
+  retryable;
+  /** Original error that caused this error, if any */
+  cause;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = "PushFloError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert error to JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      retryable: this.retryable,
+      stack: this.stack,
+      cause: this.cause?.message
+    };
+  }
+  /**
+   * Create a string representation
+   */
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+};
+
+// src/errors/AuthenticationError.ts
+var AuthenticationError = class _AuthenticationError extends PushFloError {
+  constructor(message, code = ERROR_CODES.UNAUTHORIZED, options = {}) {
+    super(message, code, { retryable: false, ...options });
+    this.name = "AuthenticationError";
+  }
+  /**
+   * Create an invalid API key error
+   */
+  static invalidKey(keyType) {
+    const message = keyType ? `Invalid ${keyType} API key` : "Invalid API key";
+    return new _AuthenticationError(message, ERROR_CODES.INVALID_API_KEY);
+  }
+  /**
+   * Create an unauthorized error
+   */
+  static unauthorized(reason) {
+    return new _AuthenticationError(
+      reason ?? "Unauthorized - check your API key",
+      ERROR_CODES.UNAUTHORIZED
+    );
+  }
+  /**
+   * Create a forbidden error
+   */
+  static forbidden(action) {
+    const message = action ? `Access forbidden: insufficient permissions for ${action}` : "Access forbidden: insufficient permissions";
+    return new _AuthenticationError(message, ERROR_CODES.FORBIDDEN);
+  }
+};
+
+// src/utils/retry.ts
+function calculateBackoff(attempt, options = {}) {
+  const {
+    initialDelay = DEFAULTS.RECONNECT_DELAY,
+    maxDelay = DEFAULTS.MAX_RECONNECT_DELAY,
+    multiplier = DEFAULTS.RECONNECT_MULTIPLIER
+  } = options;
+  const exponentialDelay = initialDelay * Math.pow(multiplier, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelay);
+  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+  return Math.floor(cappedDelay + jitter);
+}
+
+// src/errors/ConnectionError.ts
+var ConnectionError = class _ConnectionError extends PushFloError {
+  constructor(message, code = ERROR_CODES.CONNECTION_FAILED, options = {}) {
+    super(message, code, { retryable: true, ...options });
+    this.name = "ConnectionError";
+  }
+  /**
+   * Create a connection timeout error
+   */
+  static timeout(timeoutMs) {
+    return new _ConnectionError(
+      `Connection timed out after ${timeoutMs}ms`,
+      ERROR_CODES.CONNECTION_TIMEOUT,
+      { retryable: true }
+    );
+  }
+  /**
+   * Create a connection closed error
+   */
+  static closed(reason) {
+    return new _ConnectionError(
+      reason ? `Connection closed: ${reason}` : "Connection closed unexpectedly",
+      ERROR_CODES.CONNECTION_CLOSED,
+      { retryable: true }
+    );
+  }
+  /**
+   * Create a connection failed error
+   */
+  static failed(reason, cause) {
+    return new _ConnectionError(
+      reason ? `Connection failed: ${reason}` : "Failed to connect",
+      ERROR_CODES.CONNECTION_FAILED,
+      { retryable: true, cause }
+    );
+  }
+};
+
+// src/client/ConnectionStateMachine.ts
+var VALID_TRANSITIONS = [
+  { from: "disconnected", to: "connecting" },
+  { from: "connecting", to: "connected" },
+  { from: "connecting", to: "disconnected" },
+  { from: "connecting", to: "error" },
+  { from: "connected", to: "disconnected" },
+  { from: "connected", to: "error" },
+  { from: "error", to: "connecting" },
+  { from: "error", to: "disconnected" }
+];
+var ConnectionStateMachine = class {
+  _state = "disconnected";
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Get current connection state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Check if currently in a specific state
+   */
+  is(state) {
+    return this._state === state;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this._state === "connected";
+  }
+  /**
+   * Check if connecting
+   */
+  get isConnecting() {
+    return this._state === "connecting";
+  }
+  /**
+   * Check if disconnected
+   */
+  get isDisconnected() {
+    return this._state === "disconnected";
+  }
+  /**
+   * Check if in error state
+   */
+  get isError() {
+    return this._state === "error";
+  }
+  /**
+   * Transition to a new state
+   * @returns true if transition was successful
+   */
+  transition(to) {
+    if (this._state === to) {
+      return true;
+    }
+    const isValid = VALID_TRANSITIONS.some((t) => {
+      const fromStates = Array.isArray(t.from) ? t.from : [t.from];
+      return fromStates.includes(this._state) && t.to === to;
+    });
+    if (!isValid) {
+      console.warn(`Invalid state transition: ${this._state} -> ${to}`);
+      return false;
+    }
+    this._state = to;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(to);
+      } catch (error) {
+        console.error("Error in connection state listener:", error);
+      }
+    });
+    return true;
+  }
+  /**
+   * Force transition to a state (bypasses validation)
+   */
+  forceTransition(to) {
+    if (this._state === to) {
+      return;
+    }
+    this._state = to;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(to);
+      } catch (error) {
+        console.error("Error in connection state listener:", error);
+      }
+    });
+  }
+  /**
+   * Reset to disconnected state
+   */
+  reset() {
+    this.forceTransition("disconnected");
+  }
+  /**
+   * Subscribe to state changes
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/client/Heartbeat.ts
+var Heartbeat = class {
+  intervalId = null;
+  timeoutId = null;
+  interval;
+  pongTimeout;
+  onPing;
+  onTimeout;
+  running = false;
+  constructor(options) {
+    this.interval = options.interval ?? DEFAULTS.HEARTBEAT_INTERVAL;
+    this.pongTimeout = options.pongTimeout ?? this.interval * 2;
+    this.onPing = options.onPing;
+    this.onTimeout = options.onTimeout;
+  }
+  /**
+   * Start the heartbeat
+   */
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.scheduleNextPing();
+  }
+  /**
+   * Stop the heartbeat
+   */
+  stop() {
+    this.running = false;
+    this.clearTimers();
+  }
+  /**
+   * Called when a pong is received
+   */
+  receivedPong() {
+    if (!this.running) {
+      return;
+    }
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+    this.scheduleNextPing();
+  }
+  /**
+   * Reset the heartbeat (e.g., after any activity)
+   */
+  reset() {
+    if (!this.running) {
+      return;
+    }
+    this.clearTimers();
+    this.scheduleNextPing();
+  }
+  scheduleNextPing() {
+    if (!this.running) {
+      return;
+    }
+    this.intervalId = setTimeout(() => {
+      if (!this.running) {
+        return;
+      }
+      this.onPing();
+      this.timeoutId = setTimeout(() => {
+        if (this.running && this.onTimeout) {
+          this.onTimeout();
+        }
+      }, this.pongTimeout);
+    }, this.interval);
+  }
+  clearTimers() {
+    if (this.intervalId !== null) {
+      clearTimeout(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
+
+// src/client/WebSocketManager.ts
+var WebSocketManager = class extends TypedEventEmitter {
+  options;
+  logger;
+  stateMachine;
+  heartbeat;
+  ws = null;
+  connectionTimeoutId = null;
+  reconnectAttempt = 0;
+  reconnectTimeoutId = null;
+  intentionalDisconnect = false;
+  clientId = null;
+  constructor(options) {
+    super();
+    this.options = {
+      apiKey: options.apiKey,
+      baseUrl: (options.baseUrl ?? DEFAULTS.BASE_URL).replace(/\/$/, ""),
+      connectionTimeout: options.connectionTimeout ?? DEFAULTS.CONNECTION_TIMEOUT,
+      heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.HEARTBEAT_INTERVAL,
+      autoReconnect: options.autoReconnect ?? true,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? DEFAULTS.MAX_RECONNECT_ATTEMPTS,
+      reconnectDelay: options.reconnectDelay ?? DEFAULTS.RECONNECT_DELAY,
+      maxReconnectDelay: options.maxReconnectDelay ?? DEFAULTS.MAX_RECONNECT_DELAY
+    };
+    this.logger = createLogger({ debug: options.debug, prefix: "[PushFlo WS]" });
+    this.stateMachine = new ConnectionStateMachine();
+    this.heartbeat = new Heartbeat({
+      interval: this.options.heartbeatInterval,
+      onPing: () => this.sendPing(),
+      onTimeout: () => this.handleHeartbeatTimeout()
+    });
+  }
+  /**
+   * Get current connection state
+   */
+  get state() {
+    return this.stateMachine.state;
+  }
+  /**
+   * Get client ID (available after connected)
+   */
+  getClientId() {
+    return this.clientId;
+  }
+  /**
+   * Subscribe to state changes
+   */
+  onStateChange(listener) {
+    return this.stateMachine.onChange(listener);
+  }
+  /**
+   * Connect to WebSocket server
+   */
+  async connect() {
+    if (this.stateMachine.isConnected) {
+      throw new ConnectionError(
+        "Already connected",
+        "ALREADY_CONNECTED",
+        { retryable: false }
+      );
+    }
+    if (this.stateMachine.isConnecting) {
+      throw new ConnectionError(
+        "Connection in progress",
+        "CONNECTION_IN_PROGRESS",
+        { retryable: false }
+      );
+    }
+    this.intentionalDisconnect = false;
+    this.clearReconnectTimeout();
+    return this.establishConnection();
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.intentionalDisconnect = true;
+    this.cleanup();
+    this.stateMachine.transition("disconnected");
+    this.emit("disconnected", "Disconnected by client");
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+      this.logger.debug("Sent message:", message);
+      return true;
+    } catch (error) {
+      this.logger.error("Failed to send message:", error);
+      return false;
+    }
+  }
+  /**
+   * Subscribe to a channel
+   */
+  subscribe(channel) {
+    return this.send({
+      type: WS_CLIENT_MESSAGES.SUBSCRIBE,
+      channel
+    });
+  }
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribe(channel) {
+    return this.send({
+      type: WS_CLIENT_MESSAGES.UNSUBSCRIBE,
+      channel
+    });
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    this.intentionalDisconnect = true;
+    this.cleanup();
+    this.removeAllListeners();
+    this.stateMachine.removeAllListeners();
+  }
+  async establishConnection() {
+    this.stateMachine.transition("connecting");
+    this.logger.debug("Connecting...");
+    return new Promise((resolve, reject) => {
+      try {
+        const wsUrl = this.buildWsUrl();
+        this.logger.debug("WebSocket URL:", wsUrl);
+        this.ws = new WebSocket(wsUrl);
+        this.connectionTimeoutId = setTimeout(() => {
+          if (this.stateMachine.isConnecting) {
+            const error = ConnectionError.timeout(this.options.connectionTimeout);
+            this.cleanup();
+            this.stateMachine.transition("error");
+            this.emit("error", error);
+            reject(error);
+          }
+        }, this.options.connectionTimeout);
+        this.ws.onopen = () => {
+          this.logger.debug("WebSocket opened, waiting for connected message...");
+        };
+        this.ws.onclose = (event) => {
+          this.handleClose(event, reject);
+        };
+        this.ws.onerror = (event) => {
+          this.logger.error("WebSocket error:", event);
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event, resolve, reject);
+        };
+      } catch (error) {
+        this.cleanup();
+        this.stateMachine.transition("error");
+        const connError = ConnectionError.failed(
+          error instanceof Error ? error.message : "Unknown error",
+          error instanceof Error ? error : void 0
+        );
+        this.emit("error", connError);
+        reject(connError);
+      }
+    });
+  }
+  buildWsUrl() {
+    const baseUrl = this.options.baseUrl;
+    const protocol = baseUrl.startsWith("https") ? "wss" : "ws";
+    const host = baseUrl.replace(/^https?:\/\//, "");
+    return `${protocol}://${host}${DEFAULTS.WS_PATH}?token=${encodeURIComponent(this.options.apiKey)}`;
+  }
+  handleMessage(event, onConnect, onConnectError) {
+    try {
+      const message = JSON.parse(event.data);
+      this.logger.debug("Received message:", message);
+      switch (message.type) {
+        case WS_SERVER_MESSAGES.CONNECTED:
+          this.handleConnected(message, onConnect);
+          break;
+        case WS_SERVER_MESSAGES.PONG:
+          this.heartbeat.receivedPong();
+          break;
+        case WS_SERVER_MESSAGES.ERROR:
+          this.handleErrorMessage(message, onConnectError);
+          break;
+        default:
+          this.emit("message", message);
+      }
+    } catch (error) {
+      this.logger.error("Failed to parse message:", error);
+    }
+  }
+  handleConnected(message, onConnect) {
+    this.clearConnectionTimeout();
+    if (message.clientId) {
+      this.clientId = message.clientId;
+    }
+    const connectionInfo = {
+      clientId: message.clientId ?? "",
+      timestamp: message.timestamp ?? Date.now()
+    };
+    this.reconnectAttempt = 0;
+    this.stateMachine.transition("connected");
+    this.heartbeat.start();
+    this.logger.debug("Connected:", connectionInfo);
+    this.emit("connected", connectionInfo);
+    onConnect?.(connectionInfo);
+  }
+  handleErrorMessage(message, onConnectError) {
+    const errorMsg = message.error ?? "Unknown error";
+    const code = message.code;
+    let error;
+    if (code === "UNAUTHORIZED" || code === "INVALID_TOKEN") {
+      error = AuthenticationError.unauthorized(errorMsg);
+    } else {
+      error = new ConnectionError(errorMsg, code ?? "UNKNOWN");
+    }
+    this.emit("error", error);
+    if (this.stateMachine.isConnecting) {
+      this.cleanup();
+      this.stateMachine.transition("error");
+      onConnectError?.(error);
+    }
+  }
+  handleClose(event, onConnectError) {
+    this.logger.debug("WebSocket closed:", event.code, event.reason);
+    const wasConnected = this.stateMachine.isConnected;
+    this.cleanup();
+    if (this.intentionalDisconnect) {
+      this.stateMachine.transition("disconnected");
+      return;
+    }
+    if (this.stateMachine.isConnecting) {
+      this.stateMachine.transition("error");
+      const error = ConnectionError.failed(event.reason || "Connection closed");
+      this.emit("error", error);
+      onConnectError?.(error);
+      return;
+    }
+    this.stateMachine.transition("disconnected");
+    this.emit("disconnected", event.reason || void 0);
+    if (wasConnected && this.options.autoReconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  handleHeartbeatTimeout() {
+    this.logger.warn("Heartbeat timeout, reconnecting...");
+    this.cleanup();
+    this.stateMachine.transition("disconnected");
+    this.emit("disconnected", "Heartbeat timeout");
+    if (this.options.autoReconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.intentionalDisconnect) {
+      return;
+    }
+    const { maxReconnectAttempts } = this.options;
+    if (maxReconnectAttempts > 0 && this.reconnectAttempt >= maxReconnectAttempts) {
+      this.logger.error("Max reconnect attempts reached");
+      this.stateMachine.transition("error");
+      this.emit("error", new ConnectionError(
+        "Max reconnection attempts exceeded",
+        "MAX_RECONNECT_ATTEMPTS",
+        { retryable: false }
+      ));
+      return;
+    }
+    const delay = calculateBackoff(this.reconnectAttempt, {
+      initialDelay: this.options.reconnectDelay,
+      maxDelay: this.options.maxReconnectDelay
+    });
+    this.logger.debug(`Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempt + 1})`);
+    this.reconnectTimeoutId = setTimeout(() => {
+      this.reconnectAttempt++;
+      this.establishConnection().catch((error) => {
+        this.logger.error("Reconnect failed:", error);
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  sendPing() {
+    this.send({ type: WS_CLIENT_MESSAGES.PING });
+  }
+  cleanup() {
+    this.clearConnectionTimeout();
+    this.heartbeat.stop();
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+  clearConnectionTimeout() {
+    if (this.connectionTimeoutId !== null) {
+      clearTimeout(this.connectionTimeoutId);
+      this.connectionTimeoutId = null;
+    }
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeoutId !== null) {
+      clearTimeout(this.reconnectTimeoutId);
+      this.reconnectTimeoutId = null;
+    }
+  }
+};
+
+// src/client/SubscriptionManager.ts
+var SubscriptionManager = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Add a subscription
+   */
+  add(channel, options = {}) {
+    this.subscriptions.set(channel, {
+      channel,
+      options,
+      confirmed: false
+    });
+  }
+  /**
+   * Remove a subscription
+   */
+  remove(channel) {
+    const entry = this.subscriptions.get(channel);
+    if (entry) {
+      this.subscriptions.delete(channel);
+      entry.options.onUnsubscribed?.();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if subscribed to a channel
+   */
+  has(channel) {
+    return this.subscriptions.has(channel);
+  }
+  /**
+   * Get subscription options for a channel
+   */
+  get(channel) {
+    return this.subscriptions.get(channel)?.options;
+  }
+  /**
+   * Mark subscription as confirmed
+   */
+  confirm(channel) {
+    const entry = this.subscriptions.get(channel);
+    if (entry) {
+      entry.confirmed = true;
+      entry.options.onSubscribed?.();
+    }
+  }
+  /**
+   * Check if subscription is confirmed
+   */
+  isConfirmed(channel) {
+    return this.subscriptions.get(channel)?.confirmed ?? false;
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(message) {
+    const entry = this.subscriptions.get(message.channel);
+    if (entry) {
+      entry.options.onMessage?.(message);
+    }
+  }
+  /**
+   * Handle subscription error
+   */
+  handleError(channel, error) {
+    const entry = this.subscriptions.get(channel);
+    if (entry) {
+      entry.options.onError?.(error);
+    }
+  }
+  /**
+   * Get all subscribed channel names
+   */
+  getChannels() {
+    return Array.from(this.subscriptions.keys());
+  }
+  /**
+   * Get count of subscriptions
+   */
+  get size() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clear() {
+    this.subscriptions.forEach((entry) => {
+      entry.options.onUnsubscribed?.();
+    });
+    this.subscriptions.clear();
+  }
+  /**
+   * Reset confirmation status for all subscriptions (e.g., on reconnect)
+   */
+  resetConfirmations() {
+    this.subscriptions.forEach((entry) => {
+      entry.confirmed = false;
+    });
+  }
+};
+
+// src/client/PushFloClient.ts
+var PushFloClient = class extends TypedEventEmitter {
+  wsManager;
+  subscriptions;
+  logger;
+  connectionChangeListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    super();
+    if (!options.publishKey) {
+      throw new AuthenticationError(
+        "Publish key is required",
+        "MISSING_PUBLISH_KEY"
+      );
+    }
+    if (!options.publishKey.startsWith("pub_") && !options.publishKey.startsWith("sec_") && !options.publishKey.startsWith("mgmt_")) {
+      throw AuthenticationError.invalidKey("publish");
+    }
+    this.logger = createLogger({ debug: options.debug, prefix: "[PushFlo]" });
+    this.subscriptions = new SubscriptionManager();
+    this.wsManager = new WebSocketManager({
+      apiKey: options.publishKey,
+      baseUrl: options.baseUrl ?? DEFAULTS.BASE_URL,
+      connectionTimeout: options.connectionTimeout,
+      heartbeatInterval: options.heartbeatInterval,
+      autoReconnect: options.autoReconnect,
+      maxReconnectAttempts: options.maxReconnectAttempts,
+      reconnectDelay: options.reconnectDelay,
+      maxReconnectDelay: options.maxReconnectDelay,
+      debug: options.debug
+    });
+    this.setupEventHandlers();
+    if (options.autoConnect) {
+      this.connect().catch((error) => {
+        this.logger.error("Auto-connect failed:", error);
+      });
+    }
+  }
+  /**
+   * Get current connection state
+   */
+  get connectionState() {
+    return this.wsManager.state;
+  }
+  /**
+   * Get client ID (available after connected)
+   */
+  get clientId() {
+    return this.wsManager.getClientId();
+  }
+  /**
+   * Connect to PushFlo
+   */
+  async connect() {
+    this.logger.debug("Connecting...");
+    await this.wsManager.connect();
+    const channels = this.subscriptions.getChannels();
+    if (channels.length > 0) {
+      this.logger.debug("Re-subscribing to channels:", channels);
+      this.subscriptions.resetConfirmations();
+      channels.forEach((channel) => {
+        this.wsManager.subscribe(channel);
+      });
+    }
+  }
+  /**
+   * Disconnect from PushFlo
+   */
+  disconnect() {
+    this.logger.debug("Disconnecting...");
+    this.wsManager.disconnect();
+  }
+  /**
+   * Clean up all resources
+   */
+  destroy() {
+    this.logger.debug("Destroying client...");
+    this.subscriptions.clear();
+    this.wsManager.destroy();
+    this.connectionChangeListeners.clear();
+    this.removeAllListeners();
+  }
+  /**
+   * Subscribe to a channel
+   */
+  subscribe(channel, options = {}) {
+    if (!channel) {
+      throw new PushFloError("Channel is required", "INVALID_CHANNEL", { retryable: false });
+    }
+    this.logger.debug("Subscribing to channel:", channel);
+    this.subscriptions.add(channel, options);
+    if (this.wsManager.state === "connected") {
+      this.wsManager.subscribe(channel);
+    }
+    return {
+      channel,
+      unsubscribe: () => this.unsubscribe(channel)
+    };
+  }
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribe(channel) {
+    this.logger.debug("Unsubscribing from channel:", channel);
+    this.subscriptions.remove(channel);
+    if (this.wsManager.state === "connected") {
+      this.wsManager.unsubscribe(channel);
+    }
+  }
+  /**
+   * Register a connection state change listener
+   */
+  onConnectionChange(listener) {
+    this.connectionChangeListeners.add(listener);
+    return () => this.connectionChangeListeners.delete(listener);
+  }
+  /**
+   * Get list of subscribed channels
+   */
+  getSubscribedChannels() {
+    return this.subscriptions.getChannels();
+  }
+  /**
+   * Check if subscribed to a channel
+   */
+  isSubscribed(channel) {
+    return this.subscriptions.has(channel);
+  }
+  setupEventHandlers() {
+    this.wsManager.onStateChange((state) => {
+      this.connectionChangeListeners.forEach((listener) => {
+        try {
+          listener(state);
+        } catch (error) {
+          this.logger.error("Error in connection change listener:", error);
+        }
+      });
+    });
+    this.wsManager.on("connected", (info) => {
+      this.emit("connected", info);
+    });
+    this.wsManager.on("disconnected", (reason) => {
+      this.emit("disconnected", reason);
+    });
+    this.wsManager.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.wsManager.on("message", (message) => {
+      this.handleServerMessage(message);
+    });
+  }
+  handleServerMessage(message) {
+    switch (message.type) {
+      case WS_SERVER_MESSAGES.SUBSCRIBED:
+        if (message.channel) {
+          this.subscriptions.confirm(message.channel);
+          this.logger.debug("Subscribed to channel:", message.channel);
+        }
+        break;
+      case WS_SERVER_MESSAGES.UNSUBSCRIBED:
+        if (message.channel) {
+          this.logger.debug("Unsubscribed from channel:", message.channel);
+        }
+        break;
+      case WS_SERVER_MESSAGES.MESSAGE:
+        if (message.channel && message.message) {
+          const fullMessage = {
+            id: message.message.id,
+            channel: message.channel,
+            eventType: message.message.eventType,
+            clientId: message.message.clientId,
+            content: message.message.content,
+            timestamp: message.message.timestamp
+          };
+          this.subscriptions.handleMessage(fullMessage);
+          this.emit("message", fullMessage);
+        }
+        break;
+      case WS_SERVER_MESSAGES.ERROR:
+        if (message.channel) {
+          const error = new PushFloError(
+            message.error ?? "Unknown error",
+            message.code ?? ERROR_CODES.SERVER_ERROR
+          );
+          this.subscriptions.handleError(message.channel, error);
+        }
+        break;
+    }
+  }
+};
+var PushFloContext = createContext(null);
+function PushFloProvider({
+  children,
+  publishKey,
+  baseUrl,
+  debug,
+  connectionTimeout,
+  heartbeatInterval,
+  autoReconnect,
+  maxReconnectAttempts,
+  reconnectDelay,
+  maxReconnectDelay,
+  autoConnect = true
+}) {
+  const [connectionState, setConnectionState] = useState("disconnected");
+  const clientRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    const client = new PushFloClient({
+      publishKey,
+      baseUrl,
+      debug,
+      connectionTimeout,
+      heartbeatInterval,
+      autoReconnect,
+      maxReconnectAttempts,
+      reconnectDelay,
+      maxReconnectDelay,
+      autoConnect: false
+      // We handle auto-connect ourselves
+    });
+    clientRef.current = client;
+    const unsubscribe2 = client.onConnectionChange((state) => {
+      if (mountedRef.current) {
+        setConnectionState(state);
+      }
+    });
+    if (autoConnect) {
+      client.connect().catch((error) => {
+        if (debug) {
+          console.error("[PushFlo] Auto-connect failed:", error);
+        }
+      });
+    }
+    return () => {
+      mountedRef.current = false;
+      unsubscribe2();
+      client.destroy();
+      clientRef.current = null;
+    };
+  }, [
+    publishKey,
+    baseUrl,
+    debug,
+    connectionTimeout,
+    heartbeatInterval,
+    autoReconnect,
+    maxReconnectAttempts,
+    reconnectDelay,
+    maxReconnectDelay,
+    autoConnect
+  ]);
+  const connect = useCallback(async () => {
+    if (clientRef.current) {
+      await clientRef.current.connect();
+    }
+  }, []);
+  const disconnect = useCallback(() => {
+    if (clientRef.current) {
+      clientRef.current.disconnect();
+    }
+  }, []);
+  const subscribe = useCallback((channel, options) => {
+    if (clientRef.current) {
+      return clientRef.current.subscribe(channel, options);
+    }
+    return null;
+  }, []);
+  const unsubscribe = useCallback((channel) => {
+    if (clientRef.current) {
+      clientRef.current.unsubscribe(channel);
+    }
+  }, []);
+  const value = {
+    connectionState,
+    client: clientRef.current,
+    connect,
+    disconnect,
+    subscribe,
+    unsubscribe
+  };
+  return /* @__PURE__ */ jsx(PushFloContext.Provider, { value, children });
+}
+function usePushFloContext() {
+  const context = useContext(PushFloContext);
+  if (!context) {
+    throw new Error("usePushFloContext must be used within a PushFloProvider");
+  }
+  return context;
+}
+
+// src/react/usePushFlo.ts
+function usePushFlo() {
+  const { connectionState, connect, disconnect, subscribe, unsubscribe } = usePushFloContext();
+  return {
+    connectionState,
+    isConnected: connectionState === "connected",
+    isConnecting: connectionState === "connecting",
+    connect,
+    disconnect,
+    subscribe,
+    unsubscribe
+  };
+}
+function useChannel(channel, options = {}) {
+  const { connectionState, client } = usePushFloContext();
+  const [messages, setMessages] = useState([]);
+  const [isSubscribed, setIsSubscribed] = useState(false);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const maxMessages = options.maxMessages ?? 100;
+  const handleMessage = useCallback((message) => {
+    setMessages((prev) => {
+      const newMessages = [...prev, message];
+      if (newMessages.length > maxMessages) {
+        return newMessages.slice(-maxMessages);
+      }
+      return newMessages;
+    });
+    optionsRef.current.onMessage?.(message);
+  }, [maxMessages]);
+  const handleError = useCallback((error) => {
+    optionsRef.current.onError?.(error);
+  }, []);
+  useEffect(() => {
+    if (!client || !channel) {
+      return;
+    }
+    const subscription = client.subscribe(channel, {
+      onMessage: handleMessage,
+      onError: handleError,
+      onSubscribed: () => setIsSubscribed(true),
+      onUnsubscribed: () => setIsSubscribed(false)
+    });
+    if (!subscription) {
+      return;
+    }
+    return () => {
+      subscription.unsubscribe();
+      setIsSubscribed(false);
+    };
+  }, [client, channel, handleMessage, handleError]);
+  const clearMessages = useCallback(() => {
+    setMessages([]);
+  }, []);
+  return {
+    messages,
+    lastMessage: messages.length > 0 ? messages[messages.length - 1] : null,
+    connectionState,
+    isSubscribed,
+    clearMessages
+  };
+}
+
+export { PushFloProvider, useChannel, usePushFlo, usePushFloContext };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map