@antzsoft/chat-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,811 @@
+"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 __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 src_exports = {};
+__export(src_exports, {
+  AntzChatClient: () => AntzChatClient,
+  authApi: () => authApi,
+  connectSocket: () => connectSocket,
+  conversationsApi: () => conversationsApi,
+  createAuthStore: () => createAuthStore,
+  devicesApi: () => devicesApi,
+  disconnectSocket: () => disconnectSocket,
+  getApiClient: () => getApiClient,
+  getAuthStore: () => getAuthStore,
+  getSocket: () => getSocket,
+  getSocketStatus: () => getSocketStatus,
+  initApiClient: () => initApiClient,
+  initAuthStore: () => initAuthStore,
+  messagesApi: () => messagesApi,
+  normalizeConversation: () => normalizeConversation,
+  onSocketStatus: () => onSocketStatus,
+  reconnectSocket: () => reconnectSocket,
+  resetAuthStore: () => resetAuthStore,
+  resolveConfig: () => resolveConfig,
+  setApiClientInstance: () => setApiClientInstance,
+  socketEmit: () => socketEmit,
+  storageApi: () => storageApi,
+  tryGetSocket: () => tryGetSocket,
+  uploadBatch: () => uploadBatch,
+  useChatStore: () => useChatStore
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config/types.ts
+function resolveConfig(config) {
+  const socketUrl = config.socketUrl ?? config.apiUrl.replace(/\/api\/v\d+\/?$/, "").replace(/\/$/, "");
+  const raw = config.upload?.maxFileSizeMB;
+  let limits;
+  if (typeof raw === "number") {
+    limits = { image: raw, video: raw, audio: raw, document: raw, default: raw };
+  } else {
+    const fallback = raw?.default ?? 25;
+    limits = {
+      image: raw?.image ?? 5,
+      video: raw?.video ?? 25,
+      audio: raw?.audio ?? 10,
+      document: raw?.document ?? 10,
+      default: fallback
+    };
+  }
+  return {
+    apiUrl: config.apiUrl.replace(/\/$/, ""),
+    socketUrl,
+    authToken: config.authToken,
+    authProvider: config.authProvider,
+    userId: config.userId,
+    tenantId: config.tenantId,
+    encryptionMode: config.encryptionMode ?? "none",
+    upload: {
+      maxFileSizeMB: limits,
+      maxFilesPerMessage: config.upload?.maxFilesPerMessage ?? 10,
+      allowedTypes: config.upload?.allowedTypes ?? ["image", "video", "audio", "document"],
+      onUploadError: config.upload?.onUploadError,
+      onProgress: config.upload?.onProgress
+    },
+    platformUploadFn: config.platformUploadFn,
+    persistStorage: config.persistStorage
+  };
+}
+
+// src/api/client.ts
+var import_axios = __toESM(require("axios"), 1);
+var _tokenStore = null;
+var _config = null;
+function initApiClient(config, tokenStore) {
+  _config = config;
+  _tokenStore = tokenStore;
+  const client = import_axios.default.create({
+    baseURL: config.apiUrl,
+    headers: { "Content-Type": "application/json" }
+  });
+  client.interceptors.request.use((req) => {
+    const token = _tokenStore?.getAccessToken();
+    if (token) req.headers["Authorization"] = `Bearer ${token}`;
+    if (_config?.userId) req.headers["x-user-id"] = _config.userId;
+    if (_config?.tenantId) req.headers["X-Tenant-ID"] = _config.tenantId;
+    return req;
+  });
+  let isRefreshing = false;
+  let refreshQueue = [];
+  client.interceptors.response.use(
+    (response) => {
+      if (response.data && typeof response.data === "object" && "success" in response.data && "data" in response.data) {
+        response.data = response.data.data;
+      }
+      return response;
+    },
+    async (error) => {
+      const original = error.config;
+      if (error.response?.status === 401 && !original._retry) {
+        const refreshToken = _tokenStore?.getRefreshToken();
+        if (!refreshToken) {
+          _tokenStore?.clearTokens();
+          return Promise.reject(error);
+        }
+        if (isRefreshing) {
+          return new Promise((resolve) => {
+            refreshQueue.push((newToken) => {
+              original.headers["Authorization"] = `Bearer ${newToken}`;
+              resolve(client(original));
+            });
+          });
+        }
+        original._retry = true;
+        isRefreshing = true;
+        try {
+          const { data } = await import_axios.default.post(
+            `${_config.apiUrl}/auth/refresh`,
+            { refreshToken }
+          );
+          const tokens = data.data ?? data;
+          _tokenStore?.setTokens(tokens);
+          refreshQueue.forEach((cb) => cb(tokens.accessToken));
+          refreshQueue = [];
+          original.headers["Authorization"] = `Bearer ${tokens.accessToken}`;
+          return client(original);
+        } catch {
+          _tokenStore?.clearTokens();
+          return Promise.reject(error);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return client;
+}
+var _instance = null;
+function setApiClientInstance(instance) {
+  _instance = instance;
+}
+function getApiClient() {
+  if (!_instance) throw new Error("[AntzChat] API client not initialized. Call initApiClient first.");
+  return _instance;
+}
+
+// src/api/auth.ts
+var authApi = {
+  async login(credentials) {
+    const { data } = await getApiClient().post("/auth/login", credentials);
+    return data;
+  },
+  async register(payload) {
+    const { data } = await getApiClient().post("/auth/register", payload);
+    return data;
+  },
+  async refresh(refreshToken) {
+    const { data } = await getApiClient().post("/auth/refresh", { refreshToken });
+    return data;
+  },
+  async logout(refreshToken) {
+    await getApiClient().post("/auth/logout", refreshToken ? { refreshToken } : {});
+  },
+  async logoutAll() {
+    await getApiClient().post("/auth/logout-all");
+  },
+  async getMe() {
+    const { data } = await getApiClient().get("/users/me");
+    return data;
+  }
+};
+
+// src/api/messages.ts
+var messagesApi = {
+  async list(conversationId, params = {}) {
+    const { data } = await getApiClient().get(
+      `/conversations/${conversationId}/messages`,
+      { params }
+    );
+    return data;
+  },
+  async get(messageId) {
+    const { data } = await getApiClient().get(`/messages/${messageId}`);
+    return data;
+  },
+  async send(conversationId, payload) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/messages`,
+      payload
+    );
+    return data;
+  },
+  async update(messageId, text) {
+    const { data } = await getApiClient().put(`/messages/${messageId}`, { text });
+    return data;
+  },
+  async delete(messageId) {
+    await getApiClient().delete(`/messages/${messageId}`);
+  },
+  async addReaction(messageId, emoji) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/reactions`, { emoji });
+    return data;
+  },
+  async removeReaction(messageId, emoji) {
+    const { data } = await getApiClient().delete(
+      `/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`
+    );
+    return data;
+  },
+  async star(messageId) {
+    await getApiClient().post(`/messages/${messageId}/star`);
+  },
+  async unstar(messageId) {
+    await getApiClient().delete(`/messages/${messageId}/star`);
+  },
+  async getStarred(params = {}) {
+    const { data } = await getApiClient().get("/messages/starred", { params });
+    return data;
+  },
+  async search(params) {
+    const { data } = await getApiClient().get("/messages/search", { params });
+    return data;
+  },
+  async markAsRead(conversationId, messageId) {
+    await getApiClient().post(`/conversations/${conversationId}/read`, messageId ? { messageId } : {});
+  },
+  async pin(messageId) {
+    const { data } = await getApiClient().post(`/messages/${messageId}/pin`);
+    return data;
+  },
+  async unpin(messageId) {
+    const { data } = await getApiClient().delete(`/messages/${messageId}/pin`);
+    return data;
+  },
+  async getPinned(conversationId) {
+    const { data } = await getApiClient().get(`/conversations/${conversationId}/pinned-messages`);
+    return data;
+  }
+};
+
+// src/api/conversations.ts
+function normalizeParticipant(p) {
+  const hasUserDetails = p.displayName || p.username || p.avatarUrl;
+  return {
+    userId: p.userId,
+    role: p.role,
+    joinedAt: p.joinedAt,
+    user: hasUserDetails ? {
+      id: p.userId,
+      tenantId: "",
+      email: "",
+      username: p.username ?? "",
+      displayName: p.displayName ?? p.username ?? "",
+      avatarUrl: p.avatarUrl,
+      status: "offline",
+      createdAt: p.joinedAt ?? "",
+      updatedAt: p.joinedAt ?? ""
+    } : p.user
+  };
+}
+function normalizeLastMessage(lastMsg) {
+  if (!lastMsg) return void 0;
+  if (lastMsg.content !== void 0) return lastMsg;
+  return {
+    id: lastMsg.messageId ?? "",
+    tenantId: "",
+    conversationId: "",
+    senderId: "",
+    content: {
+      type: lastMsg.hasAttachments ? "attachment" : "text",
+      text: lastMsg.contentPreview
+    },
+    reactions: [],
+    status: "sent",
+    isEdited: false,
+    sentAt: lastMsg.sentAt ?? "",
+    createdAt: lastMsg.sentAt ?? ""
+  };
+}
+function normalizeConversation(conv) {
+  return {
+    ...conv,
+    id: conv.id ?? conv.conversationId,
+    participants: (conv.participants ?? []).map(normalizeParticipant),
+    lastMessage: normalizeLastMessage(conv.lastMessage)
+  };
+}
+var conversationsApi = {
+  async list(params = {}) {
+    const { data } = await getApiClient().get("/conversations", { params });
+    return { ...data, data: data.data.map(normalizeConversation) };
+  },
+  async get(conversationId) {
+    const { data } = await getApiClient().get(`/conversations/${conversationId}`);
+    return normalizeConversation(data);
+  },
+  async createGroup(payload) {
+    const { data } = await getApiClient().post("/conversations", payload);
+    return normalizeConversation(data);
+  },
+  async createDirect(payload) {
+    const { data } = await getApiClient().post("/conversations/direct", payload);
+    return normalizeConversation(data);
+  },
+  async update(conversationId, payload) {
+    const { data } = await getApiClient().put(`/conversations/${conversationId}`, payload);
+    return normalizeConversation(data);
+  },
+  async delete(conversationId) {
+    await getApiClient().delete(`/conversations/${conversationId}`);
+  },
+  async addParticipants(conversationId, userIds) {
+    const { data } = await getApiClient().post(
+      `/conversations/${conversationId}/participants`,
+      { userIds }
+    );
+    return normalizeConversation(data);
+  },
+  async removeParticipant(conversationId, userId) {
+    const { data } = await getApiClient().delete(
+      `/conversations/${conversationId}/participants/${userId}`
+    );
+    return normalizeConversation(data);
+  },
+  async updateParticipantRole(conversationId, userId, role) {
+    const { data } = await getApiClient().put(
+      `/conversations/${conversationId}/participants/${userId}/role`,
+      { role }
+    );
+    return normalizeConversation(data);
+  },
+  async mute(conversationId, mutedUntil) {
+    await getApiClient().post(`/conversations/${conversationId}/mute`, mutedUntil ? { mutedUntil } : {});
+  },
+  async unmute(conversationId) {
+    await getApiClient().delete(`/conversations/${conversationId}/mute`);
+  },
+  async pin(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/pin`);
+  },
+  async unpin(conversationId) {
+    await getApiClient().delete(`/conversations/${conversationId}/pin`);
+  },
+  async leave(conversationId) {
+    await getApiClient().delete(`/conversations/${conversationId}/leave`);
+  },
+  async getMembers(conversationId) {
+    const { data } = await getApiClient().get(`/conversations/${conversationId}/participants`);
+    return data;
+  },
+  async searchUsers(query) {
+    const { data } = await getApiClient().get("/users/search", { params: { query } });
+    return data.data;
+  }
+};
+
+// src/api/storage.ts
+var storageApi = {
+  async requestPresignedUrl(payload) {
+    const { data } = await getApiClient().post("/storage/presigned-url", payload);
+    return data;
+  },
+  async requestPresignedUrlBatch(files) {
+    const { data } = await getApiClient().post("/storage/presigned-url/batch", { files });
+    return data;
+  },
+  async confirmUpload(fileId) {
+    const { data } = await getApiClient().post(`/storage/confirm/${fileId}`);
+    return data;
+  },
+  async getFile(fileId) {
+    const { data } = await getApiClient().get(`/storage/files/${fileId}`);
+    return data;
+  },
+  async getFileUrl(fileId, expiresIn) {
+    const { data } = await getApiClient().get(`/storage/files/${fileId}/url`, {
+      params: expiresIn ? { expiresIn } : {}
+    });
+    return data;
+  },
+  async deleteFile(fileId) {
+    await getApiClient().delete(`/storage/files/${fileId}`);
+  },
+  async getConversationFiles(conversationId, params = {}) {
+    const { data } = await getApiClient().get(
+      `/storage/conversations/${conversationId}/files`,
+      { params }
+    );
+    return data;
+  },
+  async getMyFiles(params = {}) {
+    const { data } = await getApiClient().get("/storage/my-files", { params });
+    return data;
+  }
+};
+async function uploadBatch(files, platformUploadFn, conversationId, onProgress) {
+  const requests = files.map((f) => ({
+    filename: f.name,
+    mimeType: f.type,
+    size: f.size,
+    conversationId
+  }));
+  const { urls, errors: requestErrors } = await storageApi.requestPresignedUrlBatch(requests);
+  const progressMap = {};
+  const reportProgress = () => {
+    if (!onProgress) return;
+    const vals = Object.values(progressMap);
+    const avg = vals.reduce((s, v) => s + v, 0) / Math.max(vals.length, 1);
+    onProgress(Math.round(avg));
+  };
+  const successful = [];
+  const failed = [...requestErrors];
+  await Promise.all(
+    urls.map(async (presigned, idx) => {
+      const file = files[idx];
+      progressMap[idx] = 0;
+      try {
+        await platformUploadFn(presigned, file, (pct) => {
+          progressMap[idx] = Math.round(pct * 0.9);
+          reportProgress();
+        });
+        const result = await storageApi.confirmUpload(presigned.fileId);
+        progressMap[idx] = 100;
+        reportProgress();
+        successful.push(result);
+      } catch (err) {
+        failed.push({ filename: file.name, error: err.message });
+      }
+    })
+  );
+  return { successful, failed };
+}
+
+// src/api/devices.ts
+var devicesApi = {
+  /**
+   * Register or update a device push token with the chat server.
+   *
+   * Upserts by `deviceId` — calling this multiple times with the same deviceId
+   * simply refreshes the token value (tokens can rotate silently on some platforms).
+   *
+   * The SDK never calls this automatically. The parent app or the `tokenProvider`
+   * option in `pushNotifications` config is responsible for calling it after
+   * obtaining the token from the OS / browser.
+   */
+  async register(payload) {
+    await getApiClient().post("/users/me/devices", payload);
+  },
+  /**
+   * Remove a device token from the chat server.
+   * Call this on logout so the user stops receiving push notifications on this device.
+   */
+  async remove(deviceId) {
+    await getApiClient().delete(`/users/me/devices/${deviceId}`);
+  }
+};
+
+// src/socket/socket.ts
+var import_socket = require("socket.io-client");
+var _socket = null;
+var _status = "disconnected";
+var _statusListeners = /* @__PURE__ */ new Set();
+function setStatus(s) {
+  _status = s;
+  _statusListeners.forEach((l) => l(s));
+}
+function getSocket() {
+  if (!_socket) throw new Error("[AntzChat] Socket not initialized. Call connectSocket first.");
+  return _socket;
+}
+function tryGetSocket() {
+  return _socket?.connected ? _socket : null;
+}
+function getSocketStatus() {
+  return _status;
+}
+function onSocketStatus(listener) {
+  _statusListeners.add(listener);
+  return () => _statusListeners.delete(listener);
+}
+async function connectSocket(config, getToken) {
+  if (_socket?.connected) return _socket;
+  const token = getToken();
+  _socket = (0, import_socket.io)(`${config.socketUrl}/chat`, {
+    auth: { token: token ? `Bearer ${token}` : "" },
+    transports: ["websocket", "polling"],
+    reconnection: true,
+    reconnectionAttempts: 10,
+    reconnectionDelay: 1e3,
+    reconnectionDelayMax: 5e3,
+    autoConnect: true
+  });
+  setStatus("connecting");
+  _socket.on("connect", () => setStatus("connected"));
+  _socket.on("disconnect", () => setStatus("disconnected"));
+  _socket.on("connect_error", () => setStatus("error"));
+  _socket.on("reconnecting", () => setStatus("reconnecting"));
+  _socket.on("reconnect", () => setStatus("connected"));
+  return _socket;
+}
+function disconnectSocket() {
+  if (_socket) {
+    _socket.disconnect();
+    _socket = null;
+    setStatus("disconnected");
+  }
+}
+function reconnectSocket(token) {
+  if (_socket) {
+    _socket.auth = { token: `Bearer ${token}` };
+    _socket.connect();
+  }
+}
+
+// src/socket/emitters.ts
+var ACK_TIMEOUT = 5e3;
+function withAck(event, payload) {
+  const socket = tryGetSocket();
+  if (!socket) return Promise.reject(new Error(`[AntzChat] Socket not connected (event: ${event})`));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Socket ack timeout: ${event}`)), ACK_TIMEOUT);
+    socket.emit(event, payload, (response) => {
+      clearTimeout(timer);
+      resolve(response);
+    });
+  });
+}
+function fireAndForget(event, payload) {
+  const socket = tryGetSocket();
+  if (!socket) return;
+  socket.emit(event, payload);
+}
+var socketEmit = {
+  joinRoom(conversationId) {
+    fireAndForget("join_room", { conversationId });
+  },
+  leaveRoom(conversationId) {
+    fireAndForget("leave_room", { conversationId });
+  },
+  sendMessage(payload) {
+    return withAck("send_message", payload);
+  },
+  updateMessage(messageId, text) {
+    return withAck("update_message", { messageId, text });
+  },
+  deleteMessage(messageId) {
+    return withAck("delete_message", { messageId });
+  },
+  addReaction(messageId, emoji) {
+    return withAck("add_reaction", { messageId, emoji });
+  },
+  removeReaction(messageId, emoji) {
+    return withAck("remove_reaction", { messageId, emoji });
+  },
+  pinMessage(messageId) {
+    return withAck("pin_message", { messageId });
+  },
+  unpinMessage(messageId) {
+    return withAck("unpin_message", { messageId });
+  },
+  // markRead and typing are best-effort — silently dropped if socket not ready
+  typing(conversationId, isTyping) {
+    fireAndForget("typing", { conversationId, isTyping });
+  },
+  markRead(conversationId, messageId) {
+    fireAndForget("mark_read", { conversationId, ...messageId ? { messageId } : {} });
+  },
+  getOnlineUsers(userIds) {
+    const socket = tryGetSocket();
+    if (!socket) return Promise.resolve([]);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("get_online_users timeout")), ACK_TIMEOUT);
+      socket.emit("get_online_users", { userIds }, (response) => {
+        clearTimeout(timer);
+        if (response && typeof response === "object" && "onlineStatus" in response) {
+          const status = response.onlineStatus;
+          resolve(Object.entries(status).filter(([, v]) => v).map(([k]) => k));
+        } else if (Array.isArray(response)) {
+          resolve(response);
+        } else {
+          resolve([]);
+        }
+      });
+    });
+  },
+  getTypingUsers(conversationId) {
+    return withAck("get_typing_users", { conversationId });
+  }
+};
+
+// src/stores/auth.store.ts
+var import_zustand = require("zustand");
+var import_middleware = require("zustand/middleware");
+function createAuthStore(storage) {
+  if (!storage) throw new Error("[AntzChat] createAuthStore requires a valid PersistStorage \u2014 received undefined. Make sure the SDK config is fully resolved before initializing the store.");
+  const ref = { store: null };
+  const store = (0, import_zustand.create)()(
+    (0, import_middleware.persist)(
+      (set) => ({
+        user: null,
+        tokens: null,
+        isAuthenticated: false,
+        isLoading: false,
+        isHydrated: false,
+        setAuth: (user, tokens) => set({ user, tokens, isAuthenticated: true, isLoading: false }),
+        setTokens: (tokens) => set({ tokens }),
+        setUser: (user) => set({ user }),
+        logout: () => set({ user: null, tokens: null, isAuthenticated: false, isLoading: false }),
+        setLoading: (isLoading) => set({ isLoading }),
+        setHydrated: (isHydrated) => set({ isHydrated })
+      }),
+      {
+        name: "antz-chat-auth",
+        storage: {
+          getItem: (name) => {
+            const result = storage.getItem(name);
+            if (result instanceof Promise) {
+              return result.then((str) => str ? JSON.parse(str) : null);
+            }
+            return result ? JSON.parse(result) : null;
+          },
+          setItem: (name, value) => {
+            storage.setItem(name, JSON.stringify(value));
+          },
+          removeItem: (name) => storage.removeItem(name)
+        },
+        partialize: (state) => ({
+          user: state.user,
+          tokens: state.tokens,
+          isAuthenticated: state.isAuthenticated
+        }),
+        onRehydrateStorage: () => (state, error) => {
+          if (error) {
+            console.warn("[AntzChat] Auth store rehydration failed:", error);
+          }
+          ref.store?.setState({ isHydrated: true });
+        }
+      }
+    )
+  );
+  ref.store = store;
+  if (!store.getState().isHydrated) {
+    const hydrationTimeout = setTimeout(() => {
+      if (!store.getState().isHydrated) {
+        store.setState({ isHydrated: true });
+      }
+    }, 3e3);
+    const unsub = store.subscribe((s) => {
+      if (s.isHydrated) {
+        clearTimeout(hydrationTimeout);
+        unsub();
+      }
+    });
+  }
+  const tokenStore = {
+    getAccessToken: () => store.getState().tokens?.accessToken,
+    getRefreshToken: () => store.getState().tokens?.refreshToken,
+    setTokens: (tokens) => store.getState().setTokens(tokens),
+    clearTokens: () => store.getState().logout()
+  };
+  return { useAuthStore: store, authTokenStore: tokenStore };
+}
+var _authStore = null;
+function initAuthStore(storage) {
+  if (!_authStore) {
+    _authStore = createAuthStore(storage);
+  }
+  return _authStore;
+}
+function getAuthStore() {
+  if (!_authStore) throw new Error("[AntzChat] Auth store not initialized. Call initAuthStore first.");
+  return _authStore;
+}
+function resetAuthStore() {
+  _authStore = null;
+}
+
+// src/stores/chat.store.ts
+var import_zustand2 = require("zustand");
+var useChatStore = (0, import_zustand2.create)((set) => ({
+  activeConversationId: null,
+  pendingTarget: null,
+  typingUsers: {},
+  onlineUsers: [],
+  replyingTo: null,
+  editingMessage: null,
+  isSidebarOpen: true,
+  isGroupInfoOpen: false,
+  isStarredPanelOpen: false,
+  setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null }),
+  setPendingTarget: (target) => set({ pendingTarget: target }),
+  addTypingUser: (conversationId, user) => set((state) => {
+    const existing = state.typingUsers[conversationId] ?? [];
+    const deduped = existing.filter((u) => u.userId !== user.userId);
+    return { typingUsers: { ...state.typingUsers, [conversationId]: [...deduped, user] } };
+  }),
+  removeTypingUser: (conversationId, userId) => set((state) => ({
+    typingUsers: {
+      ...state.typingUsers,
+      [conversationId]: (state.typingUsers[conversationId] ?? []).filter(
+        (u) => u.userId !== userId
+      )
+    }
+  })),
+  setUserOnline: (userId) => set((state) => ({
+    onlineUsers: state.onlineUsers.includes(userId) ? state.onlineUsers : [...state.onlineUsers, userId]
+  })),
+  setUserOffline: (userId) => set((state) => ({ onlineUsers: state.onlineUsers.filter((id) => id !== userId) })),
+  setOnlineUsers: (userIds) => set({ onlineUsers: userIds }),
+  setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),
+  setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),
+  toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),
+  setSidebarOpen: (open) => set({ isSidebarOpen: open }),
+  toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),
+  setGroupInfoOpen: (open) => set({ isGroupInfoOpen: open }),
+  toggleStarredPanel: () => set((state) => ({ isStarredPanelOpen: !state.isStarredPanelOpen })),
+  setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open })
+}));
+
+// src/client-facade.ts
+var AntzChatClient = class {
+  constructor(rawConfig) {
+    this.auth = authApi;
+    this.messages = messagesApi;
+    this.conversations = conversationsApi;
+    this.storage = storageApi;
+    this.socket = {
+      emit: socketEmit,
+      on: (event, handler) => getSocket().on(event, handler),
+      off: (event, handler) => getSocket().off(event, handler)
+    };
+    this._config = resolveConfig(rawConfig);
+    this._authStore = initAuthStore(rawConfig.persistStorage);
+    if (rawConfig.authToken) {
+      this._authStore.authTokenStore.setTokens({
+        accessToken: rawConfig.authToken,
+        refreshToken: "",
+        tokenType: "Bearer",
+        expiresIn: 0
+      });
+    }
+    const instance = initApiClient(this._config, this._authStore.authTokenStore);
+    setApiClientInstance(instance);
+  }
+  async connect() {
+    await connectSocket(this._config, () => this._authStore.authTokenStore.getAccessToken());
+  }
+  disconnect() {
+    disconnectSocket();
+  }
+  uploadFiles(files, conversationId) {
+    return uploadBatch(files, this._config.platformUploadFn, conversationId, this._config.upload.onProgress);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AntzChatClient,
+  authApi,
+  connectSocket,
+  conversationsApi,
+  createAuthStore,
+  devicesApi,
+  disconnectSocket,
+  getApiClient,
+  getAuthStore,
+  getSocket,
+  getSocketStatus,
+  initApiClient,
+  initAuthStore,
+  messagesApi,
+  normalizeConversation,
+  onSocketStatus,
+  reconnectSocket,
+  resetAuthStore,
+  resolveConfig,
+  setApiClientInstance,
+  socketEmit,
+  storageApi,
+  tryGetSocket,
+  uploadBatch,
+  useChatStore
+});
+//# sourceMappingURL=index.cjs.map