@greatapps/greatchat-ui 0.1.1 → 0.1.2

package/dist/index.js

@@ -130,6 +130,568 @@ function formatMessageTime(dateStr) {
   return format(new Date(dateStr), "HH:mm");
 }
 
+// src/hooks/types.ts
+import { useMemo } from "react";
+var DEFAULT_INBOX_POLLING = 5e3;
+var DEFAULT_MESSAGES_POLLING = 3e3;
+var DEFAULT_CHANNEL_STATUS_POLLING = 5e3;
+var DEFAULT_QR_POLLING = 2e3;
+function useGchatClient(config) {
+  return useMemo(
+    () => createGchatClient({
+      baseUrl: config.baseUrl,
+      token: config.token,
+      language: config.language,
+      idWl: config.idWl
+    }),
+    [config.baseUrl, config.token, config.language, config.idWl]
+  );
+}
+
+// src/hooks/use-inboxes.ts
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+function useInboxes(config, statusFilter, pollingInterval) {
+  const client = useGchatClient(config);
+  return useQuery({
+    queryKey: ["greatchat", "inboxes", config.accountId, statusFilter],
+    queryFn: () => {
+      const params = {};
+      if (statusFilter && statusFilter !== "all") {
+        params.status = statusFilter;
+      }
+      return client.listInboxes(config.accountId, params);
+    },
+    enabled: !!config.accountId && !!config.token,
+    refetchInterval: pollingInterval ?? DEFAULT_INBOX_POLLING,
+    select: (res) => res.data || []
+  });
+}
+function useInbox(config, id) {
+  const client = useGchatClient(config);
+  return useQuery({
+    queryKey: ["greatchat", "inbox", config.accountId, id],
+    queryFn: () => client.getInbox(config.accountId, id),
+    enabled: !!config.accountId && !!config.token && !!id,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    }
+  });
+}
+function useInboxStats(config, pollingInterval) {
+  const client = useGchatClient(config);
+  return useQuery({
+    queryKey: ["greatchat", "inbox-stats", config.accountId],
+    queryFn: () => client.getInboxStats(config.accountId),
+    enabled: !!config.accountId && !!config.token,
+    refetchInterval: pollingInterval ?? DEFAULT_INBOX_POLLING,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    }
+  });
+}
+function useCreateInbox(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => client.createInbox(config.accountId, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inboxes"]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inbox-stats"]
+      });
+    }
+  });
+}
+function useUpdateInbox(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      id,
+      body
+    }) => client.updateInbox(config.accountId, id, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inboxes"]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inbox-stats"]
+      });
+    }
+  });
+}
+function useDeleteInbox(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id) => client.deleteInbox(config.accountId, id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inboxes"]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inbox-stats"]
+      });
+    }
+  });
+}
+
+// src/hooks/use-inbox-messages.ts
+import { useMemo as useMemo2, useSyncExternalStore } from "react";
+import { useQuery as useQuery2, useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+var optimisticStore = /* @__PURE__ */ new Map();
+var nextOptimisticId = -1;
+var storeVersion = 0;
+var listeners = /* @__PURE__ */ new Set();
+function subscribeStore(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function getStoreVersion() {
+  return storeVersion;
+}
+function storeKey(accountId, idInbox) {
+  return `${accountId}:${idInbox}`;
+}
+function getOptimistic(accountId, idInbox) {
+  return optimisticStore.get(storeKey(accountId, idInbox)) || [];
+}
+function setOptimistic(accountId, idInbox, msgs) {
+  const key = storeKey(accountId, idInbox);
+  if (msgs.length === 0) {
+    optimisticStore.delete(key);
+  } else {
+    optimisticStore.set(key, msgs);
+  }
+  storeVersion++;
+  listeners.forEach((fn) => fn());
+}
+function cleanupOptimistic(accountId, idInbox, msgs) {
+  const key = storeKey(accountId, idInbox);
+  if (msgs.length === 0) {
+    optimisticStore.delete(key);
+  } else {
+    optimisticStore.set(key, msgs);
+  }
+}
+function useInboxMessages(config, idInbox, pollingInterval) {
+  const client = useGchatClient(config);
+  const optimisticVersion = useSyncExternalStore(
+    subscribeStore,
+    getStoreVersion,
+    getStoreVersion
+  );
+  const query = useQuery2({
+    queryKey: ["greatchat", "inbox-messages", config.accountId, idInbox],
+    queryFn: () => client.listInboxMessages(config.accountId, {
+      id_inbox: String(idInbox),
+      sort: "datetime_add:asc",
+      limit: "100"
+    }),
+    enabled: !!config.accountId && !!config.token && !!idInbox,
+    refetchInterval: pollingInterval ?? DEFAULT_MESSAGES_POLLING,
+    select: (res) => res.data || []
+  });
+  const messages = useMemo2(() => {
+    const serverMessages = query.data || [];
+    if (!config.accountId || !idInbox) return serverMessages;
+    const optimistic = getOptimistic(config.accountId, idInbox);
+    if (!optimistic.length) return serverMessages;
+    const overrides = /* @__PURE__ */ new Map();
+    const newOptimistic = [];
+    for (const om of optimistic) {
+      if (om.id > 0) {
+        overrides.set(om.id, om);
+      } else {
+        newOptimistic.push(om);
+      }
+    }
+    const merged = overrides.size > 0 ? serverMessages.map((sm) => overrides.get(sm.id) ?? sm) : serverMessages;
+    if (overrides.size > 0) {
+      for (const [id] of overrides) {
+        const sm = serverMessages.find((s) => s.id === id);
+        if (sm && sm.status !== "failed") {
+          overrides.delete(id);
+        }
+      }
+    }
+    const stillNeeded = [];
+    const claimed = /* @__PURE__ */ new Set();
+    for (const om of newOptimistic) {
+      if (om.status === "failed") {
+        stillNeeded.push(om);
+        continue;
+      }
+      const matchIdx = merged.findIndex(
+        (sm, i) => !claimed.has(i) && sm.direction === "outbound" && sm.content === om.content && sm.content_type === om.content_type && sm.source === om.source
+      );
+      if (matchIdx >= 0) {
+        claimed.add(matchIdx);
+      } else {
+        stillNeeded.push(om);
+      }
+    }
+    const allKept = [...Array.from(overrides.values()), ...stillNeeded];
+    if (allKept.length !== optimistic.length) {
+      cleanupOptimistic(config.accountId, idInbox, allKept);
+    }
+    const result = [...merged, ...stillNeeded];
+    result.sort(
+      (a, b) => new Date(a.datetime_add).getTime() - new Date(b.datetime_add).getTime()
+    );
+    return result;
+  }, [query.data, config.accountId, idInbox, optimisticVersion]);
+  return { ...query, data: messages };
+}
+function useSendMessage(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: async ({
+      idInbox,
+      content
+    }) => {
+      const result = await client.sendMessage(config.accountId, {
+        id_inbox: idInbox,
+        content,
+        content_type: "text",
+        source: "agent",
+        direction: "outbound"
+      });
+      if (result.status === 0) {
+        throw new Error(result.message || "Erro desconhecido ao enviar");
+      }
+      return result;
+    },
+    onMutate: (variables) => {
+      const msg = {
+        id: nextOptimisticId--,
+        id_account: config.accountId,
+        id_inbox: variables.idInbox,
+        id_contact: null,
+        direction: "outbound",
+        content: variables.content,
+        content_type: "text",
+        content_url: null,
+        metadata: null,
+        external_id: null,
+        status: "pending",
+        source: "agent",
+        is_private: false,
+        datetime_add: (/* @__PURE__ */ new Date()).toISOString(),
+        datetime_alt: null
+      };
+      const current = getOptimistic(config.accountId, variables.idInbox);
+      setOptimistic(config.accountId, variables.idInbox, [...current, msg]);
+      return { optimisticMsg: msg };
+    },
+    onError: (error, variables, context) => {
+      if (!context) return;
+      const { optimisticMsg } = context;
+      const current = getOptimistic(config.accountId, variables.idInbox);
+      setOptimistic(
+        config.accountId,
+        variables.idInbox,
+        current.map(
+          (m) => m.id === optimisticMsg.id ? { ...m, status: "failed", _error: error.message } : m
+        )
+      );
+    },
+    onSuccess: (_result, variables, context) => {
+      if (!context) return;
+      const { optimisticMsg } = context;
+      const current = getOptimistic(config.accountId, variables.idInbox);
+      setOptimistic(
+        config.accountId,
+        variables.idInbox,
+        current.filter((m) => m.id !== optimisticMsg.id)
+      );
+      queryClient.invalidateQueries({
+        queryKey: [
+          "greatchat",
+          "inbox-messages",
+          config.accountId,
+          variables.idInbox
+        ]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inboxes"]
+      });
+    }
+  });
+}
+function useRetryMessage(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient2();
+  return async (message) => {
+    if (!config.accountId || !config.token || !message.content) return;
+    const current = getOptimistic(config.accountId, message.id_inbox);
+    setOptimistic(config.accountId, message.id_inbox, [
+      ...current.filter((m) => m.id !== message.id),
+      {
+        ...message,
+        status: "pending",
+        _error: void 0,
+        datetime_add: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]);
+    try {
+      const result = await client.sendMessage(config.accountId, {
+        id_inbox: message.id_inbox,
+        content: message.content,
+        content_type: message.content_type,
+        source: "agent",
+        direction: "outbound"
+      });
+      if (result.status === 0) {
+        throw new Error(result.message || "Erro desconhecido ao enviar");
+      }
+      const after = getOptimistic(config.accountId, message.id_inbox);
+      setOptimistic(
+        config.accountId,
+        message.id_inbox,
+        after.filter((m) => m.id !== message.id)
+      );
+      queryClient.invalidateQueries({
+        queryKey: [
+          "greatchat",
+          "inbox-messages",
+          config.accountId,
+          message.id_inbox
+        ]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "inboxes"]
+      });
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Erro ao enviar mensagem";
+      const after = getOptimistic(config.accountId, message.id_inbox);
+      setOptimistic(
+        config.accountId,
+        message.id_inbox,
+        after.map(
+          (m) => m.id === message.id ? { ...m, status: "failed", _error: errorMessage } : m
+        )
+      );
+    }
+  };
+}
+function useRevokeMessage(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: async ({ id }) => client.revokeMessage(config.accountId, id),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [
+          "greatchat",
+          "inbox-messages",
+          config.accountId,
+          variables.idInbox
+        ]
+      });
+    }
+  });
+}
+function useEditMessage(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: async ({
+      id,
+      content
+    }) => client.editMessage(config.accountId, id, { content }),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [
+          "greatchat",
+          "inbox-messages",
+          config.accountId,
+          variables.idInbox
+        ]
+      });
+    }
+  });
+}
+
+// src/hooks/use-contacts.ts
+import { useQuery as useQuery3, useMutation as useMutation3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useContacts(config, params) {
+  const client = useGchatClient(config);
+  return useQuery3({
+    queryKey: ["greatchat", "contacts", config.accountId, params],
+    queryFn: () => client.listContacts(config.accountId, params),
+    enabled: !!config.accountId && !!config.token,
+    select: (res) => ({ data: res.data || [], total: res.total || 0 })
+  });
+}
+function useGetContact(config, contactId) {
+  const client = useGchatClient(config);
+  return useQuery3({
+    queryKey: ["greatchat", "contact", config.accountId, contactId],
+    queryFn: () => client.getContact(config.accountId, contactId),
+    enabled: !!config.accountId && !!config.token && !!contactId,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    }
+  });
+}
+function useCreateContact(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (body) => client.createContact(config.accountId, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "contacts"]
+      });
+    }
+  });
+}
+function useUpdateContact(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: ({
+      id,
+      body
+    }) => client.updateContact(config.accountId, id, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "contacts"]
+      });
+    }
+  });
+}
+function useDeleteContact(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: (id) => client.deleteContact(config.accountId, id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "contacts"]
+      });
+    }
+  });
+}
+
+// src/hooks/use-channels.ts
+import { useQuery as useQuery4, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+function useChannels(config) {
+  const client = useGchatClient(config);
+  return useQuery4({
+    queryKey: ["greatchat", "channels", config.accountId],
+    queryFn: () => client.listChannels(config.accountId),
+    enabled: !!config.accountId && !!config.token,
+    select: (res) => res.data || []
+  });
+}
+function useChannelWhatsappStatus(config, channelId, enabled = true, pollingInterval) {
+  const client = useGchatClient(config);
+  return useQuery4({
+    queryKey: ["greatchat", "channel-status", config.accountId, channelId],
+    queryFn: () => client.getChannelWhatsappStatus(config.accountId, channelId),
+    enabled: !!config.accountId && !!config.token && !!channelId && enabled,
+    refetchInterval: pollingInterval ?? DEFAULT_CHANNEL_STATUS_POLLING,
+    select: (res) => {
+      const d = res.data;
+      return Array.isArray(d) ? d[0] : d;
+    }
+  });
+}
+function useChannelQR(config, channelId, enabled = false, pollingInterval) {
+  const client = useGchatClient(config);
+  return useQuery4({
+    queryKey: ["greatchat", "channel-qr", config.accountId, channelId],
+    queryFn: () => client.getChannelQR(config.accountId, channelId),
+    enabled: !!config.accountId && !!config.token && !!channelId && enabled,
+    refetchInterval: pollingInterval ?? DEFAULT_QR_POLLING
+  });
+}
+function useCreateChannel(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: (body) => client.createChannel(config.accountId, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channels"]
+      });
+    }
+  });
+}
+function useUpdateChannel(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: ({
+      id,
+      body
+    }) => client.updateChannel(config.accountId, id, body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channels"]
+      });
+    }
+  });
+}
+function useDeleteChannel(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: (channelId) => client.deleteChannel(config.accountId, channelId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channels"]
+      });
+    }
+  });
+}
+function useConnectChannel(config) {
+  const client = useGchatClient(config);
+  return useMutation4({
+    mutationFn: (channelId) => client.connectChannel(config.accountId, channelId)
+  });
+}
+function useDisconnectChannel(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: (channelId) => client.disconnectChannel(config.accountId, channelId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channel-status"]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channels"]
+      });
+    }
+  });
+}
+function useLogoutChannel(config) {
+  const client = useGchatClient(config);
+  const queryClient = useQueryClient4();
+  return useMutation4({
+    mutationFn: (channelId) => client.logoutChannel(config.accountId, channelId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channel-status"]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["greatchat", "channels"]
+      });
+    }
+  });
+}
+
 // src/components/chat-view.tsx
 import { useRef as useRef2, useEffect } from "react";
 
@@ -978,11 +1540,40 @@ function ChatView({
 export {
   ChatInput,
   ChatView,
+  DEFAULT_CHANNEL_STATUS_POLLING,
+  DEFAULT_INBOX_POLLING,
+  DEFAULT_MESSAGES_POLLING,
+  DEFAULT_QR_POLLING,
   MessageBubble,
   cn,
   createGchatClient,
   formatDateGroup,
   formatMessageTime,
-  groupMessagesByDate
+  groupMessagesByDate,
+  useChannelQR,
+  useChannelWhatsappStatus,
+  useChannels,
+  useConnectChannel,
+  useContacts,
+  useCreateChannel,
+  useCreateContact,
+  useCreateInbox,
+  useDeleteChannel,
+  useDeleteContact,
+  useDeleteInbox,
+  useDisconnectChannel,
+  useEditMessage,
+  useGetContact,
+  useInbox,
+  useInboxMessages,
+  useInboxStats,
+  useInboxes,
+  useLogoutChannel,
+  useRetryMessage,
+  useRevokeMessage,
+  useSendMessage,
+  useUpdateChannel,
+  useUpdateContact,
+  useUpdateInbox
 };
 //# sourceMappingURL=index.js.map