@developer.notchatbot/webchat 1.0.0

package/dist/components/ChatBot.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChatBotProps } from '../types';
+declare const ChatBot: React.FC<ChatBotProps>;
+export default ChatBot;

package/dist/components/ChatButton.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChatButtonProps } from '../types';
+declare const ChatButton: React.FC<ChatButtonProps>;
+export default ChatButton;

package/dist/components/ChatHeader.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChatHeaderProps } from '../types';
+declare const ChatHeader: React.FC<ChatHeaderProps>;
+export default ChatHeader;

package/dist/components/ChatWindow.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChatWindowProps } from '../types';
+declare const ChatWindow: React.FC<ChatWindowProps>;
+export default ChatWindow;

package/dist/components/Message.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { MessageProps } from '../types';
+declare const Message: React.FC<MessageProps>;
+export default Message;

package/dist/components/MessageInput.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { MessageInputProps } from '../types';
+declare const MessageInput: React.FC<MessageInputProps>;
+export default MessageInput;

package/dist/components/MessageList.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { MessageListProps } from '../types';
+declare const MessageList: React.FC<MessageListProps>;
+export default MessageList;

package/dist/components/SkeletonLoading.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface SkeletonLoadingProps {
+    avatar?: string;
+}
+declare const SkeletonLoading: React.FC<SkeletonLoadingProps>;
+export default SkeletonLoading;

package/dist/components/TypingIndicator.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TypingIndicatorProps } from '../types';
+declare const TypingIndicator: React.FC<TypingIndicatorProps>;
+export default TypingIndicator;

package/dist/config/company-config.d.ts

@@ -0,0 +1,26 @@
+export declare const COMPANY_CONFIG: {
+    readonly apiKey: "78457365-24c0-4fc5-8d83-3324d6aa8ef5";
+    readonly chatbotId: 68;
+    readonly primaryColor: "#f5a203";
+    readonly avatar: "https://n3v6oj3tw5ouoeeb.public.blob.vercel-storage.com/almohadovar-YwigR5IYdZVfSNI8uWilFrzAeVo4JZ.png";
+    readonly title: "Almohadovar ChatBot";
+    readonly placeholder: "Escribe tu mensaje...";
+    readonly initialMessage: "¡Hola! ¿En qué puedo ayudarte con nuestros productos?";
+    readonly position: "bottom-right";
+    readonly marginBottom: 20;
+    readonly marginSide: 20;
+    readonly mobile: {
+        readonly position: "bottom-right";
+        readonly marginBottom: 15;
+        readonly marginSide: 15;
+    };
+    readonly desktop: {
+        readonly position: "bottom-right";
+        readonly marginBottom: 25;
+        readonly marginSide: 25;
+    };
+    readonly closeButtonIcon: "default";
+    readonly closeButtonText: "Cerrar";
+    readonly closeButtonCustomIcon: "";
+    readonly aiEnabled: true;
+};

package/dist/config/company-config.template.d.ts

@@ -0,0 +1,26 @@
+export declare const COMPANY_CONFIG: {
+    readonly apiKey: "{{ API_KEY }}";
+    readonly chatbotId: "{{ CHATBOT_ID }}";
+    readonly primaryColor: "{{ PRIMARY_COLOR }}";
+    readonly avatar: "{{ AVATAR_URL }}";
+    readonly title: "{{ TITLE }}";
+    readonly placeholder: "{{ PLACEHOLDER }}";
+    readonly initialMessage: "{{ INITIAL_MESSAGE }}";
+    readonly position: "{{ POSITION }}";
+    readonly marginBottom: "{{ MARGIN_BOTTOM }}";
+    readonly marginSide: "{{ MARGIN_SIDE }}";
+    readonly mobile: {
+        readonly position: "{{ MOBILE_POSITION }}";
+        readonly marginBottom: "{{ MOBILE_MARGIN_BOTTOM }}";
+        readonly marginSide: "{{ MOBILE_MARGIN_SIDE }}";
+    };
+    readonly desktop: {
+        readonly position: "{{ DESKTOP_POSITION }}";
+        readonly marginBottom: "{{ DESKTOP_MARGIN_BOTTOM }}";
+        readonly marginSide: "{{ DESKTOP_MARGIN_SIDE }}";
+    };
+    readonly closeButtonIcon: "{{ CLOSE_BUTTON_ICON }}";
+    readonly closeButtonText: "{{ CLOSE_BUTTON_TEXT }}";
+    readonly closeButtonCustomIcon: "{{ CLOSE_BUTTON_CUSTOM_ICON }}";
+    readonly aiEnabled: "{{ AI_ENABLED }}";
+};

package/dist/config/defaults.d.ts

@@ -0,0 +1,16 @@
+import { Message } from '../types';
+/**
+ * Default configuration values for WebChat
+ */
+/**
+ * Creates the default initial message with optional company name
+ * @param companyName Optional company name for personalization
+ * @returns Default initial message text
+ */
+export declare const createDefaultInitialMessage: (companyName?: string) => string;
+/**
+ * Creates the default initial message object
+ * @param companyName Optional company name for personalization
+ * @returns Default initial message
+ */
+export declare const createDefaultInitialMessageObject: (companyName?: string) => Message;

package/dist/config/endpoints.d.ts

@@ -0,0 +1,25 @@
+export interface EndpointConfig {
+    baseUrl: string;
+    chatEndpoint: string;
+    conversationEndpoint: string;
+}
+/**
+ * Detecta si estamos en ambiente de desarrollo
+ */
+export declare function isDevelopmentEnvironment(): boolean;
+/**
+ * Obtiene la configuración de endpoints según el ambiente
+ */
+export declare function getEndpointConfig(): EndpointConfig;
+/**
+ * Obtiene el endpoint de chat
+ */
+export declare function getChatEndpoint(): string;
+/**
+ * Obtiene el endpoint de conversación
+ */
+export declare function getConversationEndpoint(): string;
+/**
+ * Obtiene la URL base según el ambiente
+ */
+export declare function getBaseUrl(): string;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { WebChatAPI } from './types';
+declare const WebChat: WebChatAPI;
+export default WebChat;

package/dist/types.d.ts

@@ -0,0 +1,93 @@
+export interface WebChatPositionConfig {
+    position?: 'bottom-right' | 'bottom-left';
+    marginBottom?: number;
+    marginSide?: number;
+}
+export interface WebChatConfig {
+    elementId: string;
+    title?: string;
+    placeholder?: string;
+    primaryColor?: string;
+    avatar?: string;
+    apiKey?: string;
+    chatbotId?: number;
+    position?: 'bottom-right' | 'bottom-left';
+    conversationId?: string;
+    initialMessage?: string;
+    closeButtonIcon?: 'default' | 'text' | 'custom';
+    closeButtonText?: string;
+    closeButtonCustomIcon?: string;
+    marginBottom?: number;
+    marginSide?: number;
+    aiEnabled?: boolean;
+    mobile?: WebChatPositionConfig;
+    desktop?: WebChatPositionConfig;
+}
+export interface Message {
+    id: string;
+    text: string;
+    sender: 'user' | 'bot';
+    timestamp: Date;
+    conversationId?: string;
+}
+export interface ChatBotProps {
+    config: WebChatConfig;
+}
+export interface ChatButtonProps {
+    isOpen: boolean;
+    onClick: () => void;
+    primaryColor?: string;
+    position?: 'bottom-right' | 'bottom-left';
+    marginBottom?: number;
+    marginSide?: number;
+    hasNewMessages?: boolean;
+    isMobile?: boolean;
+}
+export interface ChatWindowProps {
+    isOpen: boolean;
+    onClose: () => void;
+    config: WebChatConfig;
+    messages: Message[];
+    onSendMessage: (message: string) => void;
+    isLoading?: boolean;
+    isAiTyping?: boolean;
+    position?: 'bottom-right' | 'bottom-left';
+    marginBottom?: number;
+    marginSide?: number;
+    isMobile?: boolean;
+}
+export interface ChatHeaderProps {
+    title: string;
+    onClose: () => void;
+    primaryColor?: string;
+    avatar?: string;
+    closeButtonIcon?: 'default' | 'text' | 'custom';
+    closeButtonText?: string;
+    closeButtonCustomIcon?: string;
+}
+export interface MessageListProps {
+    messages: Message[];
+    isTyping: boolean;
+    avatar?: string;
+}
+export interface MessageProps {
+    message: Message;
+    avatar?: string;
+}
+export interface MessageInputProps {
+    onSendMessage: (message: string) => void;
+    placeholder?: string;
+    primaryColor?: string;
+    disabled?: boolean;
+}
+export interface TypingIndicatorProps {
+    avatar?: string;
+}
+export interface WebChatInstance {
+    root: any;
+    destroy: () => void;
+    getConversationId: () => string | null;
+}
+export interface WebChatAPI {
+    initialize: (config?: Partial<WebChatConfig>) => WebChatInstance | null;
+}

package/dist/utils/ably.d.ts

@@ -0,0 +1,28 @@
+import { default as Ably } from 'ably';
+import { Message } from '../types';
+export interface AblyConnectionData {
+    client: Ably.Realtime;
+    channel: Ably.Types.RealtimeChannelBase;
+}
+/**
+ * Initializes Ably connection with provided token details
+ * @param tokenDetails Token details from API
+ * @param chatbotUid Chatbot UID
+ * @param conversationId Conversation ID
+ * @param onMessage Callback for new messages
+ * @param onConnectionChange Callback for connection status changes
+ * @returns Promise that resolves to Ably connection data
+ */
+export declare const initializeAblyConnection: (tokenDetails: any, chatbotUid: string, conversationId: string, onMessage: (message: Message) => void, onConnectionChange?: (status: string) => void) => Promise<AblyConnectionData>;
+/**
+ * Fetches Ably token from conversation endpoint
+ * @param conversationId Conversation ID
+ * @param apiKey API key for authentication
+ * @returns Promise that resolves to conversation data with token details
+ */
+export declare const fetchAblyToken: (conversationId: string, apiKey: string) => Promise<any>;
+/**
+ * Closes Ably connection safely
+ * @param client Ably client to close
+ */
+export declare const closeAblyConnection: (client: Ably.Realtime | null) => void;

package/dist/utils/config.d.ts

@@ -0,0 +1,22 @@
+import { WebChatConfig, WebChatPositionConfig } from '../types';
+/**
+ * Resolved configuration with device-specific overrides applied
+ */
+export interface ResolvedWebChatConfig extends WebChatConfig {
+    position: 'bottom-right' | 'bottom-left';
+    marginBottom: number;
+    marginSide: number;
+    aiEnabled: boolean;
+}
+/**
+ * Resolves the final configuration by applying device-specific overrides
+ * @param config Base configuration
+ * @returns Resolved configuration with device-specific settings applied
+ */
+export declare const resolveWebChatConfig: (config: WebChatConfig) => ResolvedWebChatConfig;
+/**
+ * Gets only the position-related configuration for the current device
+ * @param config Base configuration
+ * @returns Position configuration for current device
+ */
+export declare const getDevicePositionConfig: (config: WebChatConfig) => Required<WebChatPositionConfig>;

package/dist/utils/conversation.d.ts

@@ -0,0 +1,21 @@
+import { Message } from '../types';
+/**
+ * Fetches conversation history from the API
+ * @param conversationId The conversation ID to fetch history for
+ * @param apiKey The API key for authentication
+ * @returns Promise that resolves to conversation data or null if failed
+ */
+export declare const fetchConversationHistory: (conversationId: string, apiKey: string) => Promise<any>;
+/**
+ * Transforms API messages to WebChat message format
+ * @param apiMessages Array of messages from the API
+ * @returns Array of WebChat Message objects
+ */
+export declare const transformApiMessagesToWebChat: (apiMessages: any[]) => Message[];
+/**
+ * Transforms WebChat messages to API format
+ * @param messages Array of WebChat Message objects
+ * @param conversationId The conversation ID
+ * @returns Array of messages in API format
+ */
+export declare const transformWebChatMessagesToApi: (messages: Message[], conversationId: string) => any[];

package/dist/utils/cookies.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Secure cookie management utilities for WebChat
+ */
+interface CookieOptions {
+    expires?: Date;
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+/**
+ * Set a secure cookie with proper security flags
+ */
+export declare function setCookie(name: string, value: string, options?: CookieOptions): void;
+/**
+ * Get a cookie value by name
+ */
+export declare function getCookie(name: string): string | null;
+/**
+ * Delete a cookie by setting it to expire in the past
+ */
+export declare function deleteCookie(name: string, options?: Pick<CookieOptions, 'domain' | 'path'>): void;
+/**
+ * Check if cookies are supported/enabled
+ */
+export declare function areCookiesSupported(): boolean;
+export {};

package/dist/utils/device.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Device detection utilities for WebChat
+ */
+/**
+ * Detects if the current device is mobile based on user agent and screen size
+ * @returns {boolean} true if mobile, false if desktop
+ */
+export declare const isMobileDevice: () => boolean;
+/**
+ * Gets the current device type
+ * @returns {'mobile' | 'desktop'}
+ */
+export declare const getDeviceType: () => "mobile" | "desktop";
+/**
+ * Adds a resize listener to detect device type changes
+ * @param callback Function to call when device type changes
+ * @returns Cleanup function to remove the listener
+ */
+export declare const onDeviceTypeChange: (callback: (deviceType: "mobile" | "desktop") => void) => (() => void);

package/dist/utils/messaging.d.ts

@@ -0,0 +1,56 @@
+import { Message } from '../types';
+export interface SendMessagePayload {
+    conversationId: string;
+    conversation: {
+        id: string;
+        chatbotId: string | null;
+        senderId: string;
+        createdAt: string;
+        chatbotActivated: boolean;
+        updatedAt: string;
+        source: string;
+        lastUserMessage: null;
+        qualification: null;
+        contactId: null;
+        conversationType: null;
+        language: null;
+        region: null;
+        website: string;
+        messages: any[];
+    };
+    chatbotUid: string;
+}
+/**
+ * Creates a fallback bot message for error scenarios
+ * @returns Fallback bot message
+ */
+export declare const createFallbackMessage: () => Message;
+/**
+ * Creates a notification message for when AI is disabled
+ * @returns Notification message
+ */
+export declare const createNotificationMessage: () => Message;
+/**
+ * Builds the payload for sending messages to the API
+ * @param conversationId Conversation ID
+ * @param messages Array of messages
+ * @param config Chat configuration
+ * @param userIP User's IP address
+ * @returns API payload
+ */
+export declare const buildMessagePayload: (conversationId: string, messages: Message[], config: {
+    apiKey: string;
+    chatbotId?: string;
+}, userIP: string) => SendMessagePayload;
+/**
+ * Sends messages to the chat API
+ * @param payload Message payload
+ * @returns Promise that resolves to API response or null if failed
+ */
+export declare const sendMessageToAPI: (payload: SendMessagePayload) => Promise<any>;
+/**
+ * Creates a bot message from API response
+ * @param responseData API response data
+ * @returns Bot message or null if no content
+ */
+export declare const createBotMessageFromResponse: (responseData: any) => Message | null;

package/dist/utils/notchatbot-cookie.d.ts

@@ -0,0 +1,32 @@
+export interface NotChatbotCookieData {
+    conversationId: string;
+    conversationStarted: boolean;
+}
+/**
+ * Get the notchatbot cookie data, creating it if it doesn't exist
+ */
+export declare function getNotChatbotCookie(): NotChatbotCookieData;
+/**
+ * Set the notchatbot cookie with specified data
+ */
+export declare function setNotChatbotCookie(data: NotChatbotCookieData): void;
+/**
+ * Update the conversationStarted flag in the cookie
+ */
+export declare function setConversationStarted(started: boolean): NotChatbotCookieData;
+/**
+ * Get current conversation ID from the cookie
+ */
+export declare function getConversationId(): string;
+/**
+ * Check if conversation has been started
+ */
+export declare function isConversationStarted(): boolean;
+/**
+ * Reset the conversation by creating a new conversation ID and setting conversationStarted to false
+ */
+export declare function resetConversation(): NotChatbotCookieData;
+/**
+ * Delete the notchatbot cookie
+ */
+export declare function deleteNotChatbotCookie(): void;

package/dist/utils/user.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fetches the user's IP address from an external service
+ * @returns Promise that resolves to the user's IP address or a fallback identifier
+ */
+export declare const getUserIP: () => Promise<string>;

package/dist/utils/uuid.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate a UUIDv7 (time-ordered UUID)
+ * UUIDv7 is designed to be time-ordered and includes a timestamp component
+ */
+export declare function generateUUIDv7(): string;
+/**
+ * Validate if a string is a valid UUIDv7
+ */
+export declare function isValidUUIDv7(uuid: string): boolean;