@robylon/whatsapp-react-sdk 1.0.0-staging.1

package/dist/esm/types/utils/proactive.d.ts

@@ -0,0 +1,25 @@
+import { ProactiveMessage, MessageDisplayType } from "src/types";
+export declare const hideProactiveForThisPage: () => void;
+export declare const isProactiveHiddenThisPage: () => boolean;
+export declare const setLastClickedProactive: (params: {
+    content_string: string | null;
+    message_id: string | null;
+    content_id: string | null;
+}) => void;
+export declare const getAndClearLastClickedProactive: () => {
+    input_id: null;
+    content_string: string | null;
+    message_id: string | null;
+    content_id?: string | null;
+} | null;
+export interface VisibleContent {
+    messageId: string;
+    contentIndex: number;
+    html: string;
+    delayMs: number;
+    contentId: string | null;
+    messageDisplayType: MessageDisplayType;
+    messageBubbleBg?: string;
+    urlToGo?: string;
+}
+export declare const evaluateProactiveMessages: (messages?: ProactiveMessage[]) => VisibleContent[];

package/dist/esm/types/utils/sanitize.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sanitizes HTML while preserving emojis and basic inline formatting.
+ */
+export declare const sanitizeHtml: (html?: string) => string;

package/dist/esm/types/utils/systemInfo.d.ts

@@ -0,0 +1,12 @@
+export interface SystemInfo {
+    platform: string;
+    os: string;
+    browser: string;
+    sdk_version: string;
+    device: string;
+    screen_size: {
+        width: number;
+        height: number;
+    };
+}
+export declare const getSystemInfo: () => SystemInfo;

package/dist/esm/types/utils/textDirection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Detects if text contains RTL (Right-to-Left) characters
+ * Supports Arabic, Hebrew, Persian/Farsi, Urdu, Yiddish, and other RTL scripts
+ * @param text - The text to analyze
+ * @returns "rtl" if RTL characters are dominant, "ltr" otherwise
+ */
+export declare function detectTextDirection(text?: string): 'rtl' | 'ltr';

package/dist/esm/types/utils/url.d.ts

@@ -0,0 +1,8 @@
+import { ConditionType, DisplayAttributesType } from "src/types";
+type UrlChangeListener = (href: string) => void;
+export declare const getCurrentHref: () => string;
+export declare const buildLocationKey: () => string;
+export declare const subscribeToUrlChanges: (cb: UrlChangeListener) => (() => void);
+export declare const initUrlObserver: () => void;
+export declare const matchCondition: (type: DisplayAttributesType, value: string, condition: ConditionType, href: string) => boolean;
+export {};

package/dist/esm/types/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION: string;

package/dist/esm/types/vanilla/components/ChatWidgetPopup.d.ts

@@ -0,0 +1,17 @@
+import { ChatbotConfig } from "../../types";
+interface ChatWidgetPopupConfig {
+    config: ChatbotConfig;
+    onCtaClick: () => void;
+}
+export declare class ChatWidgetPopup {
+    private popupElement;
+    private config;
+    constructor(config: ChatWidgetPopupConfig);
+    private createTitleBar;
+    private createContent;
+    private render;
+    getElement(): HTMLDivElement;
+    update(config: ChatWidgetPopupConfig): void;
+    destroy(): void;
+}
+export {};

package/dist/esm/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, position?: "Left" | "Right", sideSpacing?: number, bottomSpacing?: number);
+    /**
+     * 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/esm/types/vanilla/components/ChatbotFloatingButton.d.ts

@@ -0,0 +1,83 @@
+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;
+    position?: "Left" | "Right";
+    sideSpacing?: number;
+    bottomSpacing?: number;
+    launcher_size?: number;
+}
+/**
+ * Class representing the ChatbotFloatingButton component
+ */
+export declare class ChatbotFloatingButton {
+    private buttonElement;
+    private config;
+    private resizeObserver;
+    private handleResizeFunction;
+    private proactiveElement;
+    private urlUnsubscribe;
+    private delayTimers;
+    /**
+     * 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;
+    private clearProactiveDelays;
+    /**
+     * Hides proactive messages with animation
+     */
+    private hideProactiveMessages;
+    private injectAnimationStyles;
+    private renderProactiveIfNeeded;
+}
+export {};

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

@@ -0,0 +1,42 @@
+import { ChatbotEvent } from "../types/events";
+/**
+ * Interface for the RobylonChatbot configuration
+ */
+export interface RobylonChatbotConfig {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+    onEvent?: (event: ChatbotEvent) => void;
+    position?: "Left" | "Right" | string;
+    sideSpacing?: number | string;
+    bottomSpacing?: number | string;
+    show_launcher?: boolean | null;
+    overrides?: {
+        header_avatar?: string | null;
+        agent_avatar?: string | null;
+        header_title?: string | null;
+    };
+    launcher_size?: number;
+}
+/**
+ * RobylonChatbot instance interface
+ */
+export interface RobylonChatbotInstance {
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+    destroy: () => void;
+    getState: () => string;
+}
+/**
+ * Creates a new RobylonChatbot instance
+ * @param config The chatbot configuration
+ * @returns A RobylonChatbot instance
+ */
+export declare function create(config: RobylonChatbotConfig): RobylonChatbotInstance;
+declare const _default: {
+    create: typeof create;
+    getState: () => string;
+};
+export default _default;

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import React from 'react';
+
+declare enum ChatbotEventType {
+    CHATBOT_BUTTON_LOADED = "CHATBOT_BUTTON_LOADED",// Internal SDK event
+    CHATBOT_BUTTON_CLICKED = "CHATBOT_BUTTON_CLICKED",// Internal SDK event
+    CHATBOT_OPENED = "CHATBOT_OPENED",// Internal SDK event
+    CHATBOT_CLOSED = "CHATBOT_CLOSED",// Internal SDK event
+    CHATBOT_APP_READY = "CHATBOT_APP_READY",// Internal SDK event
+    CHATBOT_LOADED = "CHATBOT_LOADED",// From Robylon Chatbot
+    CHAT_INITIALIZED = "CHAT_INITIALIZED",// From Robylon Chatbot
+    SESSION_REFRESHED = "SESSION_REFRESHED",// From Robylon Chatbot
+    CHAT_INITIALIZATION_FAILED = "CHAT_INITIALIZATION_FAILED",// From Robylon Chatbot
+    CHATBOT_READY = "CHATBOT_READY"
+}
+interface ChatbotEvent {
+    type: ChatbotEventType;
+    timestamp: number;
+    data?: any;
+}
+type ChatbotEventHandler = (event: ChatbotEvent) => void;
+interface ChatbotRef {
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+    isReady: boolean;
+}
+
+interface Overrides {
+    header_avatar?: string | null;
+    agent_avatar?: string | null;
+    header_title?: string | null;
+    header_subtitle?: string | null;
+    header_title_text_color?: string | null;
+    header_subtitle_text_color?: string | null;
+    header_bg?: string | null;
+}
+interface ChatbotProps {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+    onEvent?: ChatbotEventHandler;
+    position?: "Left" | "Right";
+    sideSpacing?: number;
+    bottomSpacing?: number;
+    show_launcher?: boolean | null;
+    launcher_type?: "TEXT" | "IMAGE" | "TEXTUAL_IMAGE";
+    launcher_properties_text?: string;
+    overrides?: Overrides;
+    launcher_size?: number;
+}
+declare const MemoizedRobylonChatbot: React.MemoExoticComponent<React.ForwardRefExoticComponent<ChatbotProps & React.RefAttributes<ChatbotRef>>>;
+
+declare enum ChatbotInterfaceType {
+    WIDGET = "WIDGET",
+    POPOVER = "POPOVER",
+    EMBED = "EMBED"
+}
+declare enum WidgetPositionEnums {
+    RIGHT = "Right",
+    LEFT = "Left"
+}
+interface WidgetInterfaceProperties {
+    position: WidgetPositionEnums;
+    side_spacing?: number;
+    bottom_spacing?: number;
+}
+declare enum LauncherType {
+    TEXT = "TEXT",
+    IMAGE = "IMAGE",
+    TEXTUAL_IMAGE = "TEXTUAL_IMAGE"
+}
+interface ChatbotConfig {
+    chatbotId: string;
+    userId: string | null | number;
+    token?: string;
+    userProfile?: Record<string, any>;
+    domain: string;
+    show_launcher: boolean;
+    brand_colour: string;
+    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;
+        };
+    };
+    proactive_message_obj?: ProactiveMessage[] | undefined;
+    launcher_delay: {
+        enabled: boolean;
+        delay: number;
+    };
+    launcher_size_multiplier?: number;
+    redirect_chat_link?: string;
+    pre_filled_message?: string;
+    widget_type?: string;
+    widget_title?: string;
+    widget_subtitle?: string;
+    title_bar_color?: string;
+    button_content?: string;
+    powered_by_robylon?: boolean;
+}
+interface RobylonSdkConfig {
+    chatbot_id: string;
+    user_id: string;
+    token?: string;
+    user_profile?: {
+        email?: string;
+        name?: string;
+        mobile?: string;
+        platform: string;
+        OS: string;
+        browser: string;
+        sdk_version: string;
+    };
+}
+interface ChatbotState {
+    isLoading: boolean;
+    isInitialized: boolean;
+    error: string | null;
+}
+declare global {
+    interface Window {
+        initializeRobylonSdk: (config: RobylonSdkConfig) => void;
+    }
+}
+declare enum ProactiveSendTimeType {
+    WORKING_HOURS = "WORKING_HOURS",
+    ALWAYS = "ALWAYS"
+}
+declare enum DisplayAttributesType {
+    "URL" = "URL"
+}
+declare enum LogicalConditionType {
+    AND = "AND",
+    OR = "OR"
+}
+declare enum ConditionType {
+    IS = "IS",
+    IS_NOT = "IS_NOT",
+    CONTAINS = "CONTAINS",
+    DOES_NOT_CONTAIN = "DOES_NOT_CONTAIN",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH"
+}
+declare enum MessageDisplayType {
+    BUTTON = "BUTTON",
+    TEXT = "TEXT"
+}
+interface ContentDisplayAttribute {
+    type: DisplayAttributesType;
+    value: string;
+    condition: ConditionType;
+}
+interface LogicalConditionAttribute {
+    logical_condition: LogicalConditionType;
+}
+interface ProactiveMessage {
+    message_id: string;
+    org_id: string;
+    name?: string;
+    content?: string;
+    send_time_type?: ProactiveSendTimeType | string;
+    created_by_name?: string;
+    updated_by_name?: string;
+    updated_at?: string;
+    created_at?: string;
+    delay?: number;
+    content_multiple?: {
+        message: string;
+        content_id?: string;
+        message_display_type?: MessageDisplayType;
+        message_bubble_bg?: string;
+        url_to_go?: string;
+        message_display_attributes: (ContentDisplayAttribute | LogicalConditionAttribute)[];
+    }[];
+}
+
+declare const useChatbot: (config: ChatbotConfig) => ChatbotState;
+
+/**
+ * Interface for the RobylonChatbot configuration
+ */
+interface RobylonChatbotConfig {
+    api_key: string;
+    user_id?: string | null | number;
+    user_token?: string;
+    user_profile?: Record<string, any>;
+    onEvent?: (event: ChatbotEvent) => void;
+    position?: "Left" | "Right" | string;
+    sideSpacing?: number | string;
+    bottomSpacing?: number | string;
+    show_launcher?: boolean | null;
+    overrides?: {
+        header_avatar?: string | null;
+        agent_avatar?: string | null;
+        header_title?: string | null;
+    };
+    launcher_size?: number;
+}
+/**
+ * RobylonChatbot instance interface
+ */
+interface RobylonChatbotInstance {
+    show: () => void;
+    hide: () => void;
+    toggle: () => void;
+    destroy: () => void;
+    getState: () => string;
+}
+/**
+ * Creates a new RobylonChatbot instance
+ * @param config The chatbot configuration
+ * @returns A RobylonChatbot instance
+ */
+declare function create(config: RobylonChatbotConfig): RobylonChatbotInstance;
+declare const _default: {
+    create: typeof create;
+    getState: () => string;
+};
+
+export { MemoizedRobylonChatbot as Chatbot, ChatbotInterfaceType, ConditionType, DisplayAttributesType, LauncherType, LogicalConditionType, MessageDisplayType, ProactiveSendTimeType, _default as RobylonChatbot, WidgetPositionEnums, useChatbot };
+export type { ChatbotConfig, ChatbotRef, ChatbotState, ContentDisplayAttribute, LogicalConditionAttribute, ProactiveMessage, WidgetInterfaceProperties };