@vserifsaglam/chat-react-client 1.0.2

package/dist/api/chatApi.d.ts

@@ -0,0 +1,143 @@
+import { AuthConfig, Conversation, ConversationSearchResult, MessagesResponse, SendMessageRequest, SendMessageResponse, MarkConversationReadResponse, UpdateMessageRequest, UpdateMessageResponse, DeleteMessageResponse, FileUploadResponse, ApiResponse, BanClientRequest, UnbanClientRequest, AdminBanClientRequest, AdminUnbanClientRequest, BanStatusResponse, ClientProfileResponse, ClientPreferencesResponse, UpdatePreferencesRequest, UpdatePreferencesResponse } from '../types';
+/**
+ * Chat API client for making requests to the chat backend
+ */
+export declare class ChatApi {
+    private client;
+    /**
+     * Create a new ChatApi instance
+     * @param config Authentication configuration
+     */
+    constructor(config: AuthConfig);
+    /**
+     * Check if the API is running
+     * @returns A promise that resolves to "OK" if the API is running
+     */
+    healthCheck(): Promise<string>;
+    /**
+     * Get a list of conversations
+     * @param archived Whether to include archived conversations
+     * @param clientId Filter conversations by client ID
+     * @returns A promise that resolves to an array of conversations
+     */
+    listConversations(archived?: boolean, clientIds?: string): Promise<Conversation[]>;
+    /**
+     * Delete a conversation
+     * @param conversationUid The UID of the conversation to delete
+     * @returns A promise that resolves to an API response
+     */
+    deleteConversation(conversationUid: string): Promise<ApiResponse>;
+    /**
+     * Archive a conversation
+     * @param conversationUid The UID of the conversation to archive
+     * @returns A promise that resolves to an API response
+     */
+    archiveConversation(conversationUid: string): Promise<ApiResponse>;
+    /**
+     * Unarchive a conversation
+     * @param conversationUid The UID of the conversation to unarchive
+     * @returns A promise that resolves to an API response
+     */
+    unarchiveConversation(conversationUid: string): Promise<ApiResponse>;
+    /**
+     * Get details about a conversation
+     * @param conversationUid The UID of the conversation
+     * @returns A promise that resolves to conversation details
+     */
+    getConversationDetails(conversationUid: string): Promise<Conversation>;
+    /**
+     * Get conversation details with a specific receiver
+     * @param receiverId The ID of the receiver
+     * @returns A promise that resolves to conversation details
+     */
+    getConversationWithReceiver(receiverId: string): Promise<Conversation>;
+    /**
+     * Search for messages in a conversation
+     * @param conversationUid The UID of the conversation
+     * @param term The search term
+     * @returns A promise that resolves to search results
+     */
+    searchConversation(conversationUid: string, term: string): Promise<ConversationSearchResult>;
+    /**
+     * Get messages for a conversation
+     * @param conversationUid The UID of the conversation
+     * @param page The page number
+     * @param pageSize The number of messages per page
+     * @returns A promise that resolves to a messages response
+     */
+    getMessages(conversationUid: string, page?: number, pageSize?: number): Promise<MessagesResponse>;
+    /**
+     * Mark a message as read
+     * @param messageId The ID of the message
+     * @returns A promise that resolves to an API response
+     */
+    markMessageAsRead(messageId: number): Promise<ApiResponse>;
+    /**
+     * Send a message
+     * @param message The message to send
+     * @returns A promise that resolves to a send message response
+     */
+    sendMessage(message: SendMessageRequest): Promise<SendMessageResponse>;
+    /**
+     * Mark all messages in a conversation as read
+     * @param conversationUid The UID of the conversation
+     * @returns A promise that resolves to a mark conversation read response
+     */
+    markConversationAsRead(conversationUid: string): Promise<MarkConversationReadResponse>;
+    /**
+     * Update a message
+     * @param messageId The ID of the message
+     * @param update The update to apply
+     * @returns A promise that resolves to an update message response
+     */
+    updateMessage(messageId: number, update: UpdateMessageRequest): Promise<UpdateMessageResponse>;
+    /**
+     * Delete a message
+     * @param messageId The ID of the message
+     * @returns A promise that resolves to a delete message response
+     */
+    deleteMessage(messageId: number): Promise<DeleteMessageResponse>;
+    /**
+     * Upload a file
+     * @param file The file to upload
+     * @returns A promise that resolves to a file upload response
+     */
+    uploadFile(file: File): Promise<FileUploadResponse>;
+    /**
+     * Ban a client from communicating with the requesting client
+     * @param request The ban client request
+     * @returns A promise that resolves to an API response
+     */
+    banClient(request: BanClientRequest): Promise<ApiResponse>;
+    /**
+     * Unban a client that was previously banned by the requesting client
+     * @param request The unban client request
+     * @returns A promise that resolves to an API response
+     */
+    unbanClient(request: UnbanClientRequest): Promise<ApiResponse>;
+    /**
+     * Ban a client as an admin
+     * @param request The admin ban client request
+     * @returns A promise that resolves to an API response
+     */
+    adminBanClient(request: AdminBanClientRequest): Promise<ApiResponse>;
+    /**
+     * Unban a client that was previously banned by an admin
+     * @param request The admin unban client request
+     * @returns A promise that resolves to an API response
+     */
+    adminUnbanClient(request: AdminUnbanClientRequest): Promise<ApiResponse>;
+    /**
+     * Check if a client is banned by the requesting client or by an admin
+     * @param clientId The client ID to check the ban status for
+     * @returns A promise that resolves to a ban status response
+     */
+    checkBanStatus(clientId: string): Promise<BanStatusResponse>;
+    /**
+     * Get the profile information of the authenticated client
+     * @returns A promise that resolves to a client profile response
+     */
+    getClientProfile(): Promise<ClientProfileResponse>;
+    getClientPreferences(): Promise<ClientPreferencesResponse>;
+    updateClientPreferences(request: UpdatePreferencesRequest): Promise<UpdatePreferencesResponse>;
+}

package/dist/connection/ConnectionManager.d.ts

@@ -0,0 +1,68 @@
+import { ChatApi } from '../api/chatApi';
+import { AuthConfig, ConnectionConfig, ConnectionStatus, EventType, RealtimeEvent, SendMessageRequest } from '../types';
+import { LoggerConfig } from '../utils/Logger';
+export interface ExtendedConnectionOptions extends Partial<ConnectionConfig> {
+    /** Extra HTTP headers – used when the runtime supports them (Node/RN)       */
+    headers?: Record<string, string>;
+    /** Extra values to send via auth/query in the browser (simulates headers)  */
+    extraAuth?: Record<string, unknown>;
+}
+declare type EventCallback = (e: RealtimeEvent) => void;
+declare type StatusCallback = (s: ConnectionStatus) => void;
+export declare class ConnectionManager {
+    private static instance;
+    static getInstance(auth: AuthConfig, api: ChatApi, options?: ExtendedConnectionOptions): ConnectionManager;
+    static resetInstance(): void;
+    private readonly cfg;
+    private readonly auth;
+    private readonly api;
+    private readonly logger;
+    private socket;
+    private status;
+    private eventListeners;
+    private statusListeners;
+    private errorListeners;
+    private readonly queue;
+    private processingQueue;
+    private connecting;
+    private reconnectCount;
+    private wsFailCount;
+    private isDegraded;
+    private constructor();
+    connect(): void;
+    disconnect(): void;
+    getStatus(): ConnectionStatus;
+    queueMessage(msg: SendMessageRequest, maxAttempts?: number): string;
+    on(evt: EventType, cb: EventCallback): void;
+    off(evt: EventType, cb: EventCallback): void;
+    emit(evt: any, ...args: any[]): void;
+    onStatusChange(cb: StatusCallback): void;
+    offStatusChange(cb: StatusCallback): void;
+    onError(cb: (err: any) => void): void;
+    offError(cb: (err: any) => void): void;
+    updateLogging(config: Partial<LoggerConfig>): void;
+    getLoggingConfig(): LoggerConfig;
+    private connectWS;
+    private buildSocketOpts;
+    private handleConnError;
+    private processQueue;
+    private sendMessageHttp;
+    private handleEvent;
+    private setStatus;
+    private scheduleReconnect;
+    private clearTimers;
+    private saveQueue;
+    private add;
+    private remove;
+    private storageAvailable;
+    private failKey;
+    private untilKey;
+    private getFailCount;
+    private setFailCount;
+    private resetWsFailures;
+    private getDegradeUntil;
+    private setDegradeUntil;
+    private clearDegradation;
+    private onWsFailure;
+}
+export {};

package/dist/connection/ConnectionManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/context/ChatContext.d.ts

@@ -0,0 +1,20 @@
+import React, { ReactNode, Dispatch, SetStateAction } from 'react';
+import { ChatApi } from '../api/chatApi';
+import { AuthConfig, Conversation, ConnectionOptions } from '../types';
+interface ChatContextType {
+    api: ChatApi | null;
+    isInitialized: boolean;
+    isAuthenticated: boolean;
+    initialize: (config: AuthConfig) => void;
+    conversations: Conversation[];
+    refreshConversations: (archived?: boolean, clientIds?: string) => Promise<Conversation[]>;
+    setConversations: Dispatch<SetStateAction<Conversation[]>>;
+}
+interface ChatProviderProps {
+    children: ReactNode;
+    config?: AuthConfig;
+    connectionOptions?: ConnectionOptions;
+}
+export declare const ChatProvider: React.FC<ChatProviderProps>;
+export declare const useChatContext: () => ChatContextType;
+export {};

package/dist/context/ConnectionContext.d.ts

@@ -0,0 +1,28 @@
+import React, { ReactNode } from 'react';
+import { ConnectionManager } from '../connection/ConnectionManager';
+import { ChatApi } from '../api/chatApi';
+import { AuthConfig, ConnectionOptions, ConnectionStatus, EventType, RealtimeEvent, SendMessageRequest } from '../types';
+import { LoggerConfig } from '../utils/Logger';
+interface ConnectionContextType {
+    connection: ConnectionManager | null;
+    status: ConnectionStatus;
+    connect: () => void;
+    disconnect: () => void;
+    sendMessage: (message: SendMessageRequest, maxAttempts?: number) => string | null;
+    on: (eventType: EventType, callback: (event: RealtimeEvent) => void) => void;
+    off: (eventType: EventType, callback: (event: RealtimeEvent) => void) => void;
+    onError: (cb: (err: any) => void) => void;
+    offError: (cb: (err: any) => void) => void;
+    updateLogging: (config: Partial<LoggerConfig>) => void;
+    getLoggingConfig: () => LoggerConfig | null;
+}
+interface ConnectionProviderProps {
+    children: ReactNode;
+    authConfig?: AuthConfig;
+    api?: ChatApi;
+    connectionOptions?: ConnectionOptions;
+    autoConnect?: boolean;
+}
+export declare const ConnectionProvider: React.FC<ConnectionProviderProps>;
+export declare const useConnectionContext: () => ConnectionContextType;
+export {};

package/dist/context/ConnectionContext.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useBans.d.ts

@@ -0,0 +1,14 @@
+import { ApiResponse, BanStatusResponse } from '../types';
+/**
+ * Hook for managing client bans
+ */
+export declare const useBans: () => {
+    loading: boolean;
+    error: Error | null;
+    banStatus: BanStatusResponse | null;
+    banClient: (clientId: string) => Promise<ApiResponse | null>;
+    unbanClient: (clientId: string) => Promise<ApiResponse | null>;
+    adminBanClient: (clientId: string, reason?: string | undefined, durationDays?: number | undefined) => Promise<ApiResponse | null>;
+    adminUnbanClient: (clientId: string) => Promise<ApiResponse | null>;
+    checkBanStatus: (clientId: string) => Promise<BanStatusResponse | null>;
+};

package/dist/hooks/useClientProfile.d.ts

@@ -0,0 +1,10 @@
+import { ClientProfileResponse } from '../types';
+/**
+ * Hook for accessing client profile information
+ */
+export declare const useClientProfile: () => {
+    loading: boolean;
+    error: Error | null;
+    profile: ClientProfileResponse | null;
+    fetchProfile: () => Promise<ClientProfileResponse | null>;
+};

package/dist/hooks/useConnection.d.ts

@@ -0,0 +1,14 @@
+import { ConnectionStatus, SendMessageRequest } from '../types';
+/**
+ * Hook for managing the realtime connection
+ */
+export declare const useConnection: () => {
+    status: ConnectionStatus;
+    isConnected: boolean;
+    isConnecting: boolean;
+    hasError: boolean;
+    connect: () => void;
+    disconnect: () => void;
+    sendMessage: (message: SendMessageRequest, maxAttempts?: any) => string | null;
+    connection: import("../connection/ConnectionManager").ConnectionManager | null;
+};

package/dist/hooks/useConversationDetails.d.ts

@@ -0,0 +1,15 @@
+import type { Conversation } from '../types';
+/**
+ * Hook to get conversation details with a specific receiver
+ * @returns Functions and state for working with conversation details
+ */
+export declare const useConversationDetails: () => {
+    conversationDetails: Conversation | null;
+    receiverId: string | null;
+    loading: boolean;
+    error: Error | null;
+    getConversationWithReceiver: (receiverId: string) => Promise<{
+        details: Conversation | null;
+        receiverId: string;
+    }>;
+};

package/dist/hooks/useConversationManagements.d.ts

@@ -0,0 +1,12 @@
+import { Conversation } from '../types';
+export declare function useConversationManagement(): {
+    conversations: Conversation[];
+    conversationsLoading: boolean;
+    selectedConversationId: string;
+    selectedConversation: Conversation | undefined;
+    deleteConversation: (conversationUid: string) => Promise<import("../types").ApiResponse | null>;
+    archiveConversation: (conversationUid: string) => Promise<import("../types").ApiResponse | null>;
+    unarchiveConversation: (conversationUid: string) => Promise<import("../types").ApiResponse | null>;
+    handleSelectConversation: (conversation: Conversation | null) => void;
+    getConversations: (archived?: boolean | undefined, clientIds?: string | undefined) => Promise<Conversation[]>;
+};

package/dist/hooks/useConversations.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { ConversationSearchResult, ApiResponse, Conversation } from '../types';
+/**
+ * Hook for managing conversations
+ */
+export declare const useConversations: () => {
+    conversations: Conversation[];
+    loading: boolean;
+    error: Error | null;
+    getConversations: (archived?: boolean | undefined, clientIds?: string | undefined) => Promise<Conversation[]>;
+    deleteConversation: (conversationUid: string) => Promise<ApiResponse | null>;
+    archiveConversation: (conversationUid: string) => Promise<ApiResponse | null>;
+    unarchiveConversation: (conversationUid: string) => Promise<ApiResponse | null>;
+    getConversationDetails: (conversationUid: string) => Promise<Conversation | null>;
+    searchConversation: (conversationUid: string, term: string) => Promise<ConversationSearchResult | null>;
+    setConversations: import("react").Dispatch<import("react").SetStateAction<Conversation[]>>;
+};

package/dist/hooks/useCustomEvents.d.ts

@@ -0,0 +1,14 @@
+import { EventType } from '../types';
+declare type CustomEventListener<T = any> = (data: T) => void;
+/**
+ * Hook for managing custom events
+ *
+ * @returns Object with methods to register, unregister, and emit custom events
+ */
+export declare function useCustomEvents(): {
+    registerCustomEventListener: <T = any>(key: string, eventType: EventType, callback: CustomEventListener<T>) => () => void;
+    unregisterCustomEventListener: (key: string, callback: CustomEventListener) => void;
+    unregisterAllCustomEventListeners: (key: string) => void;
+    emitCustomEvent: (eventType: EventType, data: any) => void;
+};
+export {};

package/dist/hooks/useFiles.d.ts

@@ -0,0 +1,10 @@
+import { FileUploadResponse } from '../types';
+/**
+ * Hook for managing file uploads
+ */
+export declare const useFiles: () => {
+    loading: boolean;
+    error: Error | null;
+    uploadProgress: number;
+    uploadFile: (file: File) => Promise<FileUploadResponse | null>;
+};

package/dist/hooks/useLogging.d.ts

@@ -0,0 +1,9 @@
+import { LogLevel, LoggerConfig } from '../utils/Logger';
+export interface UseLoggingReturn {
+    enableLogging: (level?: LogLevel) => void;
+    disableLogging: () => void;
+    setLogLevel: (level: LogLevel) => void;
+    updateLoggingConfig: (config: Partial<LoggerConfig>) => void;
+    getLoggingConfig: () => LoggerConfig | null;
+}
+export declare function useLogging(): UseLoggingReturn;

package/dist/hooks/useMessageManagements.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { Message, SenderReceiverUser } from '../index';
+export declare function useMessageManagement(selectedConversationId: string): {
+    messages: Message[];
+    messagesLoading: boolean;
+    fileLoading: boolean;
+    uploadProgress: number;
+    uploadFile: (file: File) => Promise<import("..").FileUploadResponse | null>;
+    handleSendMessage: (content: string, receiver: SenderReceiverUser) => Promise<boolean | undefined>;
+    handleSendFileMessage: (content: string, fileId: number, receiver: SenderReceiverUser, filename?: string | undefined, url?: string | undefined) => Promise<boolean | undefined>;
+    deleteMessage: (messageId: number) => Promise<import("..").DeleteMessageResponse | null>;
+    updateMessage: (messageId: number, update: import("..").UpdateMessageRequest) => Promise<import("..").UpdateMessageResponse | null>;
+    getMessages: (conversationId?: any, page?: any, pageSize?: any) => Promise<import("..").MessagesResponse | null>;
+    loadMoreMessages: () => Promise<void>;
+    hasMore: boolean;
+    setMessages: import("react").Dispatch<import("react").SetStateAction<import("..").MessagesResponse | null>>;
+    preferences: import("..").ClientPreferences | null;
+    updatePreferences: (enableRead: boolean) => Promise<boolean>;
+};

package/dist/hooks/useMessages.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { MessagesResponse, SendMessageRequest, SendMessageResponse, MarkConversationReadResponse, UpdateMessageRequest, UpdateMessageResponse, DeleteMessageResponse, ApiResponse, Message, ClientPreferences } from '../types';
+/**
+ * Hook for managing messages
+ */
+export declare const useMessages: (conversationUid?: string | undefined) => {
+    messages: Message[];
+    pagination: import("../types").MessagesPagination | undefined;
+    loading: boolean;
+    error: Error | null;
+    queueLength: number;
+    getMessages: (conversationId?: any, page?: any, pageSize?: any) => Promise<MessagesResponse | null>;
+    markMessageAsRead: (messageId: number) => Promise<ApiResponse | null>;
+    sendMessage: (message: Omit<SendMessageRequest, 'conversation_uid'> & {
+        conversation_uid?: string;
+    }) => Promise<SendMessageResponse | null>;
+    markConversationAsRead: (conversationId?: any) => Promise<MarkConversationReadResponse | null>;
+    updateMessage: (messageId: number, update: UpdateMessageRequest) => Promise<UpdateMessageResponse | null>;
+    deleteMessage: (messageId: number) => Promise<DeleteMessageResponse | null>;
+    setMessages: import("react").Dispatch<import("react").SetStateAction<MessagesResponse | null>>;
+    updatePreferences: (enableRead: boolean) => Promise<boolean>;
+    preferences: ClientPreferences | null;
+};

package/dist/hooks/useQueue.d.ts

@@ -0,0 +1,12 @@
+import { ChatApi } from '../api/chatApi';
+import { SendMessageRequest, SendMessageResponse } from '../types';
+/**
+ * Hook for managing a message queue with retry functionality
+ * @param api The ChatApi instance
+ */
+export declare const useQueue: (api: ChatApi | null) => {
+    enqueueMessage: (message: SendMessageRequest) => string;
+    sendMessageWithRetry: (message: SendMessageRequest) => Promise<SendMessageResponse | null>;
+    queueLength: number;
+    isProcessing: boolean;
+};

package/dist/hooks/useRealtime.d.ts

@@ -0,0 +1,56 @@
+import { EventType, RealtimeEvent, MessageSentEvent, MessageEditedEvent, MessageDeletedEvent, MessageReadEvent, ConversationReadEvent } from '../types';
+/**
+ * Hook for subscribing to realtime events
+ * @param eventType The event type to subscribe to
+ */
+export declare function useRealtime<T = any>(eventType: EventType): {
+    event: RealtimeEvent<T> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to message sent events
+ */
+export declare function useMessageSentEvents(): {
+    event: RealtimeEvent<MessageSentEvent> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to message edited events
+ */
+export declare function useMessageEditedEvents(): {
+    event: RealtimeEvent<MessageEditedEvent> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to message deleted events
+ */
+export declare function useMessageDeletedEvents(): {
+    event: RealtimeEvent<MessageDeletedEvent> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to message read events
+ */
+export declare function useMessageReadEvents(): {
+    event: RealtimeEvent<MessageReadEvent> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to conversation read events
+ */
+export declare function useConversationReadEvents(): {
+    event: RealtimeEvent<ConversationReadEvent> | null;
+    clearEvent: () => void;
+};
+/**
+ * Hook for subscribing to all message events
+ * @param callback Optional callback function that will be called when any message event is received
+ */
+export declare function useAllMessageEvents(callback?: (eventType: EventType, data: any) => void): {
+    messageSent: RealtimeEvent<MessageSentEvent> | null;
+    messageEdited: RealtimeEvent<MessageEditedEvent> | null;
+    messageDeleted: RealtimeEvent<MessageDeletedEvent> | null;
+    messageRead: RealtimeEvent<MessageReadEvent> | null;
+    conversationRead: RealtimeEvent<ConversationReadEvent> | null;
+    clearEvents: () => void;
+};

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { ConnectionOptions } from './types';
+import { useAllMessageEvents as useAllMessageEventsHook } from './hooks/useRealtime';
+export * from './types';
+export { LogLevel } from './utils/Logger';
+export type { LoggerConfig } from './utils/Logger';
+export { ChatApi } from './api/chatApi';
+export { ChatProvider, useChatContext } from './context/ChatContext';
+export { useConversations } from './hooks/useConversations';
+export { useMessages } from './hooks/useMessages';
+export { useFiles } from './hooks/useFiles';
+export { useConnection } from './hooks/useConnection';
+export { useClientProfile } from './hooks/useClientProfile';
+export { useConversationDetails } from './hooks/useConversationDetails';
+export type { Message, Conversation, MessagesPagination, MessagesResponse, ConnectionOptions, ClientProfileResponse } from './types';
+export { useRealtime, useMessageSentEvents, useMessageEditedEvents, useMessageDeletedEvents } from './hooks/useRealtime';
+export { useConversationManagement } from './hooks/useConversationManagements';
+export { useBans } from './hooks/useBans';
+export { useMessageManagement } from './hooks/useMessageManagements';
+export { useCustomEvents } from './hooks/useCustomEvents';
+export { useLogging } from './hooks/useLogging';
+export declare const useAllMessageEvents: typeof useAllMessageEventsHook;
+interface ChatClientProps {
+    children: React.ReactNode;
+    token?: string;
+    baseUrl?: string;
+    socketBaseUrl?: string;
+    connectionOptions?: ConnectionOptions;
+    client_id: string;
+}
+export declare const ChatClient: React.FC<ChatClientProps>;