@robylon/web-react-sdk 1.1.28-staging.7 → 1.1.28

package/dist/cjs/types/components/ChatbotContainer/ChatbotContainer.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { ChatbotConfig } from "../../types";
+interface ChatbotContainerProps {
+    children: React.ReactNode;
+    config: ChatbotConfig;
+}
+/**
+ * Container component that wraps the floating button and iframe
+ * to allow styling them as a single unit
+ */
+declare const ChatbotContainer: React.FC<ChatbotContainerProps>;
+export default ChatbotContainer;

package/dist/cjs/types/components/ChatbotContainer/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./ChatbotContainer";

package/dist/cjs/types/config.d.ts

@@ -1,5 +1,5 @@
 export declare const CONFIG: {
     readonly copilotUrl: string | undefined;
     readonly environment: string | undefined;
-    readonly apiUrl: string;
+    readonly apiUrl: string | undefined;
 };

package/dist/cjs/types/constants/fontStyles.d.ts

@@ -0,0 +1,2 @@
+export declare const FONT_FAMILY = "system-ui, Inter, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'";
+export declare const FONT_LINE_HEIGHT = "21px";

package/dist/cjs/types/core/api.d.ts

@@ -1,56 +1,8 @@
 /**
- * Error codes for API operations
+ * Fetches the chatbot configuration from the API
+ * @param apiKey The API key for the chatbot
+ * @param userId The user ID (optional)
+ * @param userToken The user token (optional)
+ * @returns The chatbot configuration
  */
-export declare enum ApiErrorCode {
-    NETWORK_ERROR = "NETWORK_ERROR",
-    API_REQUEST_FAILED = "API_REQUEST_FAILED",
-    INVALID_RESPONSE = "INVALID_RESPONSE",
-    MISSING_API_KEY = "MISSING_API_KEY"
-}
-/**
- * Response from the chatbot API
- */
-export interface ChatbotApiResponse {
-    user: {
-        token: string;
-        user_info: {
-            email: string;
-            user_id: string;
-            name: string;
-        };
-        org_info: {
-            org_id: string;
-            org_name: string;
-            role: string;
-            auth_status: string;
-            domain: string;
-            brand_config: {
-                display_name: string;
-                redirect_url: string;
-                colors?: {
-                    brand_color: string;
-                    title_bar_color?: string;
-                };
-                launcher_logo_url?: string;
-                welcome_message: string;
-                image_url: string;
-            };
-        };
-    };
-}
-/**
- * API error class for better error handling
- */
-export declare class ApiError extends Error {
-    code: ApiErrorCode;
-    context: Record<string, any>;
-    constructor(message: string, code: ApiErrorCode, context?: Record<string, any>);
-}
-/**
- * Fetch chatbot configuration from API
- */
-export declare const fetchChatbotConfig: (chatbotId: string, userId: string | null | number, token?: string) => Promise<ChatbotApiResponse>;
-/**
- * Record event logs with the API
- */
-export declare const recordEventLog: (apiKey: string, userId: string | null | number, eventType: string, eventData?: Record<string, any>, userProfile?: Record<string, any>) => Promise<boolean>;
+export declare const fetchChatbotConfig: (apiKey: string, userId?: string, userToken?: string) => Promise<any>;

package/dist/cjs/types/core/config.d.ts

@@ -0,0 +1,34 @@
+import { ChatbotConfig } from "../types";
+/**
+ * Normalizes the configuration properties
+ * @param props The configuration properties
+ * @returns Normalized configuration properties
+ */
+export declare const normalizeProps: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => {
+    api_key: string;
+    user_id: string | null;
+    user_token: string | undefined;
+    user_profile: Record<string, any>;
+};
+/**
+ * Normalizes the user profile by filtering allowed keys and converting values
+ * @param userProfile The user profile object
+ * @returns Normalized user profile
+ */
+export declare const normalizeUserProfile: (userProfile?: Record<string, any>) => any;
+/**
+ * Initializes the chatbot configuration
+ * @param props The configuration properties
+ * @returns The initialized chatbot configuration
+ */
+export declare const initializeChatbotConfig: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => Promise<ChatbotConfig>;

package/dist/cjs/types/core/events.d.ts

@@ -0,0 +1,22 @@
+import { ChatbotEvent, ChatbotEventType, AllEventTypes } from "../types/events";
+/**
+ * Event emitter interface for handling chatbot events
+ */
+export interface EventEmitter {
+    emit: (eventType: ChatbotEventType, data?: any) => void;
+    onInternalEvent: (eventType: AllEventTypes, additionalData?: Record<string, any>) => void;
+}
+/**
+ * Creates an event emitter for handling chatbot events
+ * @param props Configuration for the event emitter
+ * @returns An event emitter object
+ */
+export declare const createEventEmitter: (props: {
+    api_key: string;
+    user_profile?: Record<string, any>;
+    onEvent?: (event: ChatbotEvent) => void;
+    chatbotConfig?: {
+        isAnonymous?: boolean;
+        userId?: string | null | number;
+    } | null;
+}) => EventEmitter;

package/dist/cjs/types/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./api";
+export * from "./config";
+export * from "./events";
+export * from "./state";

package/dist/cjs/types/core/state.d.ts

@@ -0,0 +1,34 @@
+import { ChatbotConfig } from "../types";
+/**
+ * Interface for the chatbot state
+ */
+export interface ChatbotState {
+    isInitialized: boolean;
+    isInitializing: boolean;
+    error: string | null;
+    chatbotConfig: ChatbotConfig | null;
+    isIframeVisible: boolean;
+}
+/**
+ * Interface for the chatbot state manager
+ */
+export interface ChatbotStateManager {
+    getState: () => ChatbotState;
+    initialize: () => Promise<void>;
+    toggleIframeVisibility: () => void;
+    closeIframe: () => void;
+    updateState: (partialState: Partial<ChatbotState>) => void;
+    subscribe: (listener: (state: ChatbotState) => void) => () => void;
+    unsubscribe: (listener: (state: ChatbotState) => void) => void;
+}
+/**
+ * Creates a state manager for the chatbot
+ * @param props Configuration properties
+ * @returns A state manager object
+ */
+export declare const createChatbotStateManager: (props: {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+}) => ChatbotStateManager;

package/dist/cjs/types/index.d.ts

@@ -1,9 +1,5 @@
-import { Chatbot as RobylonChatbot } from "./react/components/Chatbot";
-export declare const Chatbot: import("node_modules/@types/react").FC<import("./react/components/Chatbot").ChatbotProps>;
-export default RobylonChatbot;
-export type { ChatbotProps } from "./react/components/Chatbot";
-export declare const init: (config: Record<string, string>) => void;
-export declare const logging: {
-    setEnabled: (enabled: boolean) => void;
-    setLevel: (level: "debug" | "info" | "warn" | "error" | "none") => void;
-};
+export { Chatbot } from "./components/RobylonChatbot";
+export * from "./types";
+export * from "./hooks/useChatbot";
+import RobylonChatbot from "./vanilla";
+export { RobylonChatbot };

package/dist/cjs/types/types.d.ts

@@ -1,12 +1,22 @@
-export * from "./types/events";
-export * from "./types/config";
-export * from "./types/state";
-import { ChatbotEvent } from "./core/chatbotEmbed";
-export type { ChatbotEvent };
-import { ChatbotProps } from "./react/components/Chatbot";
-export type { ChatbotProps };
-import { RobylonConfig, RobylonInstance } from "./vanilla";
-export type { RobylonConfig, RobylonInstance };
+export declare enum ChatbotInterfaceType {
+    WIDGET = "WIDGET",
+    POPOVER = "POPOVER",
+    EMBED = "EMBED"
+}
+export declare enum WidgetPositionEnums {
+    RIGHT = "Right",
+    LEFT = "Left"
+}
+export interface WidgetInterfaceProperties {
+    position: WidgetPositionEnums;
+    side_spacing?: number;
+    bottom_spacing?: number;
+}
+export declare enum LauncherType {
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    TEXTUAL_IMAGE = "TEXTUAL_IMAGE"
+}
 export interface ChatbotConfig {
     chatbotId: string;
     userId: string | null | number;
@@ -17,8 +27,22 @@ export interface ChatbotConfig {
     image_url?: string;
     chat_interface_config?: {
         chat_bubble_prompts?: string[];
+        display_name?: string;
+        welcome_message?: string;
+        redirect_url?: string;
     };
     isAnonymous?: boolean;
+    interface_type?: ChatbotInterfaceType;
+    interface_properties?: WidgetInterfaceProperties;
+    launcher_type: LauncherType;
+    launcher_properties: {
+        text?: string;
+    };
+    images: {
+        launcher_image_url?: {
+            url: string;
+        };
+    };
 }
 interface RobylonSdkConfig {
     chatbot_id: string;
@@ -44,3 +68,4 @@ declare global {
         initializeRobylonSdk: (config: RobylonSdkConfig) => void;
     }
 }
+export {};

package/dist/cjs/types/utils/fetchData.d.ts

@@ -1,3 +1,4 @@
+import { ChatbotInterfaceType, LauncherType, WidgetPositionEnums } from "../types";
 interface ChatbotResponse {
     user: {
         token: string;
@@ -22,6 +23,21 @@ interface ChatbotResponse {
                 launcher_logo_url?: string;
                 welcome_message: string;
                 image_url: string;
+                interface_properties: {
+                    position: WidgetPositionEnums;
+                    side_spacing: number;
+                    bottom_spacing: number;
+                };
+                interface_type: ChatbotInterfaceType;
+                launcher_type: LauncherType;
+                launcher_properties: {
+                    text: string;
+                };
+                images: {
+                    launcher_image_url: {
+                        url: string;
+                    };
+                };
             };
         };
     };

package/dist/cjs/types/vanilla/components/ChatbotContainer.d.ts

@@ -0,0 +1,45 @@
+import { ChatbotConfig } from "../../types";
+/**
+ * Class representing the ChatbotContainer component
+ * Container component that wraps the floating button and iframe
+ * to allow styling them as a single unit
+ */
+export declare class ChatbotContainer {
+    private containerElement;
+    private resizeObserver;
+    private handleResizeFunction;
+    private config;
+    /**
+     * Creates a new ChatbotContainer
+     */
+    constructor(config: ChatbotConfig);
+    /**
+     * Renders the container element
+     */
+    private render;
+    /**
+     * Apply styles based on screen width
+     */
+    private applyStyles;
+    /**
+     * Handle resize event
+     */
+    private handleResize;
+    /**
+     * Set up resize listener to adjust styles on window resize
+     */
+    private setupResizeListener;
+    /**
+     * Mounts the container to the DOM
+     */
+    private mount;
+    /**
+     * Gets the container element
+     * @returns The container element
+     */
+    getElement(): HTMLDivElement;
+    /**
+     * Unmounts and destroys the container
+     */
+    destroy(): void;
+}

package/dist/cjs/types/vanilla/components/ChatbotFloatingButton.d.ts

@@ -0,0 +1,69 @@
+import { ChatbotConfig } from "../../types";
+import { ChatbotEventType, AllEventTypes } from "../../types/events";
+/**
+ * Interface for the ChatbotFloatingButton configuration
+ */
+interface ChatbotFloatingButtonConfig {
+    config: ChatbotConfig;
+    toggleIframe: () => void;
+    isIframeVisible: boolean;
+    onEvent?: (event: {
+        type: ChatbotEventType;
+        timestamp: number;
+        data?: any;
+    }) => void;
+    onInternalEvent: (eventType: AllEventTypes, additionalData?: Record<string, any>) => void;
+}
+/**
+ * Class representing the ChatbotFloatingButton component
+ */
+export declare class ChatbotFloatingButton {
+    private buttonElement;
+    private config;
+    private resizeObserver;
+    private handleResizeFunction;
+    /**
+     * Creates a new ChatbotFloatingButton
+     * @param config The button configuration
+     */
+    constructor(config: ChatbotFloatingButtonConfig);
+    /**
+     * Renders the button element
+     */
+    private render;
+    private createLauncherElement;
+    private createTextLauncher;
+    private createTextualImageLauncher;
+    /**
+     * Apply responsive styles based on screen width
+     * @param baseStyles The base styles to apply
+     */
+    private applyResponsiveStyles;
+    /**
+     * Handle resize event
+     */
+    private handleResize;
+    /**
+     * Set up resize listener to adjust styles on window resize
+     */
+    private setupResizeListener;
+    /**
+     * Gets the button element
+     * @returns The button element
+     */
+    getElement(): HTMLDivElement;
+    /**
+     * Mounts the button to the DOM
+     */
+    private mount;
+    /**
+     * Updates the button with new configuration
+     * @param config The new configuration
+     */
+    update(config: Partial<ChatbotFloatingButtonConfig>): void;
+    /**
+     * Unmounts and destroys the button
+     */
+    destroy(): void;
+}
+export {};

package/dist/cjs/types/vanilla/components/ChatbotIframe.d.ts

@@ -0,0 +1,71 @@
+import { ChatbotConfig } from "../../types";
+import { ChatbotEventType, AllEventTypes } from "../../types/events";
+/**
+ * Interface for the ChatbotIframe configuration
+ */
+interface ChatbotIframeConfig {
+    config: ChatbotConfig;
+    isVisible: boolean;
+    onClose: () => void;
+    onEvent?: (event: {
+        type: ChatbotEventType;
+        timestamp: number;
+        data?: any;
+    }) => void;
+    onInternalEvent: (eventType: AllEventTypes, additionalData?: Record<string, any>) => void;
+}
+/**
+ * Class representing the ChatbotIframe component
+ */
+export declare class ChatbotIframe {
+    private iframeElement;
+    private config;
+    private isInitialized;
+    private hasRegistered;
+    private resizeHandler;
+    /**
+     * Creates a new ChatbotIframe
+     * @param config The iframe configuration
+     */
+    constructor(config: ChatbotIframeConfig);
+    /**
+     * Gets the iframe element
+     * @returns The iframe element
+     */
+    getElement(): HTMLIFrameElement;
+    /**
+     * Renders the iframe element
+     */
+    private render;
+    /**
+     * Applies responsive styles based on window width
+     */
+    private applyResponsiveStyles;
+    /**
+     * Initializes the iframe
+     */
+    private initialize;
+    /**
+     * Sets up event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Handles messages from the iframe
+     */
+    private handleMessage;
+    /**
+     * Updates the iframe visibility
+     * @param isVisible Whether the iframe should be visible
+     */
+    updateVisibility(isVisible: boolean): void;
+    /**
+     * Updates the iframe with new configuration
+     * @param config The new configuration
+     */
+    update(config: Partial<ChatbotIframeConfig>): void;
+    /**
+     * Unmounts and destroys the iframe
+     */
+    destroy(): void;
+}
+export {};

package/dist/cjs/types/vanilla/index.d.ts

@@ -1,8 +1,8 @@
-import { ChatbotEvent } from "../core/chatbotEmbed";
+import { ChatbotEvent } from "../types/events";
 /**
- * Robylon SDK configuration interface
+ * Interface for the RobylonChatbot configuration
  */
-export interface RobylonConfig {
+export interface RobylonChatbotConfig {
     api_key: string;
     user_id?: string | null | number;
     user_token?: string;
@@ -10,37 +10,23 @@ export interface RobylonConfig {
     onEvent?: (event: ChatbotEvent) => void;
 }
 /**
- * Public API for the chatbot instance
+ * RobylonChatbot instance interface
  */
-export interface RobylonInstance {
-    /**
-     * Show the chatbot
-     */
+export interface RobylonChatbotInstance {
     show: () => void;
-    /**
-     * Hide the chatbot
-     */
     hide: () => void;
-    /**
-     * Toggle the chatbot visibility
-     */
     toggle: () => void;
-    /**
-     * Update the chatbot configuration
-     */
-    update: (config: Partial<RobylonConfig>) => void;
-    /**
-     * Destroy the chatbot instance and clean up
-     */
     destroy: () => void;
+    getState: () => string;
 }
 /**
- * Initialize the SDK with custom environment settings
- * @internal This is primarily for internal use and advanced debugging.
- * Normal users should not need to call this function.
+ * Creates a new RobylonChatbot instance
+ * @param config The chatbot configuration
+ * @returns A RobylonChatbot instance
  */
-export declare function init(config: Record<string, string>): void;
-/**
- * Create a new Robylon chatbot instance
- */
-export declare function create(config: RobylonConfig): Promise<RobylonInstance>;
+export declare function create(config: RobylonChatbotConfig): RobylonChatbotInstance;
+declare const _default: {
+    create: typeof create;
+    getState: () => string;
+};
+export default _default;