sockr-client 1.0.0

package/dist/index.js

@@ -0,0 +1,682 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConnectionManager: () => ConnectionManager,
+  ConnectionState: () => ConnectionState,
+  EventEmitter: () => EventEmitter,
+  SocketClient: () => SocketClient,
+  SocketProvider: () => SocketProvider,
+  useMessages: () => useMessages,
+  usePresence: () => usePresence,
+  useSendMessage: () => useSendMessage,
+  useSocket: () => useSocket,
+  useSocketContext: () => useSocketContext,
+  useSocketEvent: () => useSocketEvent,
+  useTypingIndicator: () => useTypingIndicator
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/SocketClient.ts
+var import_socket = require("socket.io-client");
+var import_sockr_shared = require("sockr-shared");
+
+// src/core/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    const handlers = this.events.get(event);
+    handlers.push(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    const handlers = this.events.get(event);
+    if (!handlers) return;
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+    if (handlers.length === 0) {
+      this.events.delete(event);
+    }
+  }
+  emit(event, ...args) {
+    const handlers = this.events.get(event);
+    if (!handlers) return;
+    handlers.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for ${event}:`, error);
+      }
+    });
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+  }
+};
+
+// src/core/ConnectionManager.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["AUTHENTICATED"] = "authenticated";
+  ConnectionState2["ERROR"] = "error";
+  ConnectionState2["RECONNECTING"] = "reconnecting";
+  return ConnectionState2;
+})(ConnectionState || {});
+var ConnectionManager = class {
+  constructor(maxReconnectAttempts = 5) {
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = maxReconnectAttempts;
+  }
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.notifyListeners();
+    }
+  }
+  isConnected() {
+    return this.state === "connected" /* CONNECTED */ || this.state === "authenticated" /* AUTHENTICATED */;
+  }
+  isAuthenticated() {
+    return this.state === "authenticated" /* AUTHENTICATED */;
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners() {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.state);
+      } catch (error) {
+        console.error("Error in connection state listener:", error);
+      }
+    });
+  }
+  incrementReconnectAttempts() {
+    this.reconnectAttempts++;
+    return this.reconnectAttempts;
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempts = 0;
+  }
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  canReconnect() {
+    return this.reconnectAttempts < this.maxReconnectAttempts;
+  }
+  reset() {
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.reconnectAttempts = 0;
+    this.listeners.clear();
+  }
+};
+
+// src/core/SocketClient.ts
+var SocketClient = class {
+  constructor(config) {
+    this.socket = null;
+    this.userId = null;
+    this.reconnectTimer = null;
+    this.config = {
+      autoConnect: true,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1e3,
+      timeout: 2e4,
+      transports: ["websocket", "polling"],
+      ...config
+    };
+    this.eventEmitter = new EventEmitter();
+    this.connectionManager = new ConnectionManager(
+      this.config.reconnectionAttempts
+    );
+    if (this.config.autoConnect) {
+      this.connect();
+    }
+  }
+  connect() {
+    if (this.socket?.connected) {
+      console.warn("Socket already connected");
+      return;
+    }
+    this.connectionManager.setState("connecting" /* CONNECTING */);
+    this.socket = (0, import_socket.io)(this.config.url, {
+      autoConnect: true,
+      reconnection: false,
+      // We'll handle reconnection ourselves
+      timeout: this.config.timeout,
+      transports: this.config.transports
+    });
+    this.setupSocketListeners();
+  }
+  setupSocketListeners() {
+    if (!this.socket) return;
+    this.socket.on("connect", () => {
+      console.log("Socket connected");
+      this.connectionManager.setState("connected" /* CONNECTED */);
+      this.connectionManager.resetReconnectAttempts();
+      this.eventEmitter.emit("connect");
+    });
+    this.socket.on("disconnect", (reason) => {
+      console.log("Socket disconnected:", reason);
+      this.connectionManager.setState("disconnected" /* DISCONNECTED */);
+      this.userId = null;
+      this.eventEmitter.emit("disconnect", reason);
+      if (this.config.reconnection && this.shouldReconnect(reason)) {
+        this.scheduleReconnect();
+      }
+    });
+    this.socket.on("connect_error", (error) => {
+      console.error("Connection error:", error);
+      this.connectionManager.setState("error" /* ERROR */);
+      this.eventEmitter.emit("error", error);
+      if (this.config.reconnection) {
+        this.scheduleReconnect();
+      }
+    });
+    this.socket.on(
+      import_sockr_shared.SocketEvent.AUTHENTICATED,
+      (data) => {
+        console.log("Authenticated:", data.userId);
+        this.userId = data.userId;
+        this.connectionManager.setState("authenticated" /* AUTHENTICATED */);
+        this.eventEmitter.emit("authenticated", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.AUTH_ERROR,
+      (data) => {
+        console.error("Authentication error:", data.message);
+        this.eventEmitter.emit("auth_error", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.USER_ONLINE,
+      (data) => {
+        this.eventEmitter.emit("user_online", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.USER_OFFLINE,
+      (data) => {
+        this.eventEmitter.emit("user_offline", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.ONLINE_STATUS,
+      (data) => {
+        this.eventEmitter.emit("online_status", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.RECEIVE_MESSAGE,
+      (data) => {
+        this.eventEmitter.emit("message", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.MESSAGE_DELIVERED,
+      (data) => {
+        this.eventEmitter.emit("message_delivered", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.MESSAGE_ERROR,
+      (data) => {
+        this.eventEmitter.emit("message_error", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.TYPING_START,
+      (data) => {
+        this.eventEmitter.emit("typing_start", data);
+      }
+    );
+    this.socket.on(
+      import_sockr_shared.SocketEvent.TYPING_STOP,
+      (data) => {
+        this.eventEmitter.emit("typing_stop", data);
+      }
+    );
+  }
+  shouldReconnect(reason) {
+    return reason !== "io client disconnect" && this.connectionManager.canReconnect();
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    const attempt = this.connectionManager.incrementReconnectAttempts();
+    const delay = this.config.reconnectionDelay * attempt;
+    console.log(`Scheduling reconnect attempt ${attempt} in ${delay}ms`);
+    this.connectionManager.setState("reconnecting" /* RECONNECTING */);
+    this.reconnectTimer = setTimeout(() => {
+      console.log(`Reconnect attempt ${attempt}`);
+      this.connect();
+    }, delay);
+  }
+  authenticate(token) {
+    if (!this.socket?.connected) {
+      throw new Error("Socket not connected. Call connect() first.");
+    }
+    this.socket.emit(import_sockr_shared.SocketEvent.AUTHENTICATE, {
+      token
+    });
+  }
+  sendMessage(to, content, metadata) {
+    if (!this.isAuthenticated()) {
+      throw new Error("Not authenticated. Call authenticate() first.");
+    }
+    this.socket.emit(import_sockr_shared.SocketEvent.SEND_MESSAGE, {
+      to,
+      content,
+      metadata
+    });
+  }
+  getOnlineStatus(userIds) {
+    if (!this.isConnected()) {
+      throw new Error("Not connected.");
+    }
+    this.socket.emit(import_sockr_shared.SocketEvent.GET_ONLINE_STATUS, {
+      userIds
+    });
+  }
+  startTyping(to) {
+    if (!this.isAuthenticated()) return;
+    this.socket.emit(import_sockr_shared.SocketEvent.TYPING_START, { to });
+  }
+  stopTyping(to) {
+    if (!this.isAuthenticated()) return;
+    this.socket.emit(import_sockr_shared.SocketEvent.TYPING_STOP, { to });
+  }
+  on(event, handler) {
+    return this.eventEmitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.eventEmitter.off(event, handler);
+  }
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.connectionManager.reset();
+    this.userId = null;
+  }
+  isConnected() {
+    return this.connectionManager.isConnected();
+  }
+  isAuthenticated() {
+    return this.connectionManager.isAuthenticated();
+  }
+  getConnectionState() {
+    return this.connectionManager.getState();
+  }
+  getUserId() {
+    return this.userId;
+  }
+  onStateChange(listener) {
+    return this.connectionManager.onStateChange(listener);
+  }
+};
+
+// src/react/context/SocketContext.tsx
+var import_react = __toESM(require("react"));
+var SocketContext = (0, import_react.createContext)(void 0);
+var SocketProvider = ({
+  config,
+  token,
+  children
+}) => {
+  const clientRef = (0, import_react.useRef)(null);
+  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
+  const [isAuthenticated, setIsAuthenticated] = (0, import_react.useState)(false);
+  const [connectionState, setConnectionState] = (0, import_react.useState)(
+    "disconnected" /* DISCONNECTED */
+  );
+  const [userId, setUserId] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    const client = new SocketClient(config);
+    clientRef.current = client;
+    const unsubscribeConnect = client.on("connect", () => {
+      setIsConnected(true);
+      if (token) {
+        client.authenticate(token);
+      }
+    });
+    const unsubscribeDisconnect = client.on("disconnect", () => {
+      setIsConnected(false);
+      setIsAuthenticated(false);
+      setUserId(null);
+    });
+    const unsubscribeAuthenticated = client.on("authenticated", (data) => {
+      setIsAuthenticated(true);
+      setUserId(data.userId);
+    });
+    const unsubscribeAuthError = client.on("auth_error", () => {
+      setIsAuthenticated(false);
+      setUserId(null);
+    });
+    const unsubscribeStateChange = client.onStateChange((state) => {
+      setConnectionState(state);
+    });
+    return () => {
+      unsubscribeConnect();
+      unsubscribeDisconnect();
+      unsubscribeAuthenticated();
+      unsubscribeAuthError();
+      unsubscribeStateChange();
+      client.disconnect();
+    };
+  }, [config.url, token]);
+  const value = {
+    client: clientRef.current,
+    isConnected,
+    isAuthenticated,
+    connectionState,
+    userId
+  };
+  return /* @__PURE__ */ import_react.default.createElement(SocketContext.Provider, { value }, children);
+};
+var useSocketContext = () => {
+  const context = (0, import_react.useContext)(SocketContext);
+  if (!context) {
+    throw new Error("useSocketContext must be used within SocketProvider");
+  }
+  return context;
+};
+
+// src/react/hooks/useSocket.ts
+var useSocket = () => {
+  const context = useSocketContext();
+  return {
+    client: context.client,
+    isConnected: context.isConnected,
+    isAuthenticated: context.isAuthenticated,
+    connectionState: context.connectionState,
+    userId: context.userId
+  };
+};
+
+// src/react/hooks/useSocketEvent.ts
+var import_react2 = require("react");
+var useSocketEvent = (event, handler, deps = []) => {
+  const { client } = useSocketContext();
+  (0, import_react2.useEffect)(() => {
+    if (!client) return;
+    const unsubscribe = client.on(event, handler);
+    return () => {
+      unsubscribe();
+    };
+  }, [client, event, ...deps]);
+};
+
+// src/react/hooks/useMessages.ts
+var import_react3 = require("react");
+var useMessages = () => {
+  const [messages, setMessages] = (0, import_react3.useState)([]);
+  const addMessage = (0, import_react3.useCallback)((message) => {
+    setMessages((prev) => [...prev, message]);
+  }, []);
+  const clearMessages = (0, import_react3.useCallback)(() => {
+    setMessages([]);
+  }, []);
+  useSocketEvent(
+    "message",
+    (data) => {
+      addMessage({
+        id: data.messageId,
+        from: data.from,
+        content: data.content,
+        timestamp: data.timestamp,
+        metadata: data.metadata
+      });
+    }
+  );
+  return {
+    messages,
+    addMessage,
+    clearMessages
+  };
+};
+
+// src/react/hooks/useSendMessage.ts
+var import_react4 = require("react");
+var useSendMessage = () => {
+  const { client, isAuthenticated } = useSocket();
+  const [isSending, setIsSending] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [pendingMessages, setPendingMessages] = (0, import_react4.useState)(/* @__PURE__ */ new Set());
+  const sendMessage = (0, import_react4.useCallback)(
+    (to, content, metadata) => {
+      if (!client || !isAuthenticated) {
+        setError("Not authenticated");
+        return;
+      }
+      setIsSending(true);
+      setError(null);
+      try {
+        client.sendMessage(to, content, metadata);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to send message");
+        setIsSending(false);
+      }
+    },
+    [client, isAuthenticated]
+  );
+  useSocketEvent(
+    "message_delivered",
+    (data) => {
+      setIsSending(false);
+      setError(null);
+    }
+  );
+  useSocketEvent(
+    "message_error",
+    (data) => {
+      setIsSending(false);
+      setError(data.error);
+    }
+  );
+  return {
+    sendMessage,
+    isSending,
+    error
+  };
+};
+
+// src/react/hooks/usePresence.ts
+var import_react5 = require("react");
+var usePresence = () => {
+  const { client } = useSocket();
+  const [onlineUsers, setOnlineUsers] = (0, import_react5.useState)(/* @__PURE__ */ new Set());
+  const isUserOnline = (0, import_react5.useCallback)(
+    (userId) => {
+      return onlineUsers.has(userId);
+    },
+    [onlineUsers]
+  );
+  const checkOnlineStatus = (0, import_react5.useCallback)(
+    (userIds) => {
+      if (!client) return;
+      client.getOnlineStatus(userIds);
+    },
+    [client]
+  );
+  useSocketEvent(
+    "user_online",
+    (data) => {
+      setOnlineUsers((prev) => new Set(prev).add(data.userId));
+    }
+  );
+  useSocketEvent(
+    "user_offline",
+    (data) => {
+      setOnlineUsers((prev) => {
+        const next = new Set(prev);
+        next.delete(data.userId);
+        return next;
+      });
+    }
+  );
+  useSocketEvent(
+    "online_status",
+    (data) => {
+      setOnlineUsers((prev) => {
+        const next = new Set(prev);
+        Object.entries(data.statuses).forEach(([userId, isOnline]) => {
+          if (isOnline) {
+            next.add(userId);
+          } else {
+            next.delete(userId);
+          }
+        });
+        return next;
+      });
+    }
+  );
+  return {
+    onlineUsers,
+    isUserOnline,
+    checkOnlineStatus
+  };
+};
+
+// src/react/hooks/useTypingIndicator.ts
+var import_react6 = require("react");
+var useTypingIndicator = (typingTimeout = 3e3) => {
+  const { client } = useSocket();
+  const [usersTyping, setUsersTyping] = (0, import_react6.useState)(/* @__PURE__ */ new Set());
+  const timeoutsRef = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
+  const startTyping = (0, import_react6.useCallback)(
+    (to) => {
+      if (!client) return;
+      client.startTyping(to);
+    },
+    [client]
+  );
+  const stopTyping = (0, import_react6.useCallback)(
+    (to) => {
+      if (!client) return;
+      client.stopTyping(to);
+    },
+    [client]
+  );
+  const clearTypingTimeout = (0, import_react6.useCallback)((userId) => {
+    const timeout = timeoutsRef.current.get(userId);
+    if (timeout) {
+      clearTimeout(timeout);
+      timeoutsRef.current.delete(userId);
+    }
+  }, []);
+  useSocketEvent(
+    "typing_start",
+    (data) => {
+      setUsersTyping((prev) => new Set(prev).add(data.from));
+      clearTypingTimeout(data.from);
+      const timeout = setTimeout(() => {
+        setUsersTyping((prev) => {
+          const next = new Set(prev);
+          next.delete(data.from);
+          return next;
+        });
+        timeoutsRef.current.delete(data.from);
+      }, typingTimeout);
+      timeoutsRef.current.set(data.from, timeout);
+    }
+  );
+  useSocketEvent(
+    "typing_stop",
+    (data) => {
+      clearTypingTimeout(data.from);
+      setUsersTyping((prev) => {
+        const next = new Set(prev);
+        next.delete(data.from);
+        return next;
+      });
+    }
+  );
+  (0, import_react6.useEffect)(() => {
+    return () => {
+      timeoutsRef.current.forEach((timeout) => clearTimeout(timeout));
+      timeoutsRef.current.clear();
+    };
+  }, []);
+  return {
+    startTyping,
+    stopTyping,
+    usersTyping
+  };
+};
+
+// src/index.ts
+__reExport(index_exports, require("sockr-shared"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionManager,
+  ConnectionState,
+  EventEmitter,
+  SocketClient,
+  SocketProvider,
+  useMessages,
+  usePresence,
+  useSendMessage,
+  useSocket,
+  useSocketContext,
+  useSocketEvent,
+  useTypingIndicator,
+  ...require("sockr-shared")
+});
+//# sourceMappingURL=index.js.map