@patternfly/chatbot 6.3.0-prerelease.8 → 6.3.0

package/dist/esm/MessageBar/SendButton.test.js

@@ -7,35 +7,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import userEvent from '@testing-library/user-event';
 import { SendButton } from './SendButton';
 const renderSend = (props) => {
     const spy = jest.fn();
-    render(React.createElement(SendButton, Object.assign({ onClick: spy }, props)));
+    render(_jsx(SendButton, Object.assign({ onClick: spy }, props)));
 };
 describe('Send button', () => {
     it('should render button correctly', () => {
         renderSend();
-        expect(screen.getByRole('button', { name: 'Send button' })).toBeTruthy();
+        expect(screen.getByRole('button', { name: 'Send' })).toBeTruthy();
     });
     it('should handle onClick correctly', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest.fn();
-        render(React.createElement(SendButton, { onClick: spy }));
-        yield userEvent.click(screen.getByRole('button', { name: 'Send button' }));
+        render(_jsx(SendButton, { onClick: spy }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Send' }));
         expect(screen.getByRole('tooltip', { name: 'Send' })).toBeTruthy();
         expect(spy).toHaveBeenCalledTimes(1);
     }));
     it('should handle custom tooltip correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-        render(React.createElement(SendButton, { onClick: jest.fn, tooltipContent: "Test" }));
-        yield userEvent.click(screen.getByRole('button', { name: 'Send button' }));
+        render(_jsx(SendButton, { onClick: jest.fn, tooltipContent: "Test" }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Send' }));
         expect(screen.getByRole('tooltip', { name: 'Test' })).toBeTruthy();
     }));
     it('should handle className prop', () => {
         renderSend({ className: 'test' });
-        expect(screen.getByRole('button', { name: 'Send button' })).toHaveClass('test');
+        expect(screen.getByRole('button', { name: 'Send' })).toHaveClass('test');
     });
     it('should handle spread props, including aria-label', () => {
         renderSend({ 'aria-label': 'test' });
@@ -43,7 +43,7 @@ describe('Send button', () => {
     });
     it('should handle tooltipProps prop', () => __awaiter(void 0, void 0, void 0, function* () {
         renderSend({ tooltipProps: { id: 'test' } });
-        yield userEvent.click(screen.getByRole('button', { name: 'Send button' }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Send' }));
         expect(screen.getByRole('tooltip', { name: 'Send' })).toHaveAttribute('id', 'test');
     }));
     it('should handle isCompact', () => {

package/dist/esm/MessageBar/StopButton.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type { FunctionComponent } from 'react';
 import { ButtonProps, TooltipProps } from '@patternfly/react-core';
 export interface StopButtonProps extends ButtonProps {
     /** Callback for when button is clicked */
@@ -9,7 +9,8 @@ export interface StopButtonProps extends ButtonProps {
     tooltipProps?: Omit<TooltipProps, 'content'>;
     /** English text "Stop" used in the tooltip */
     tooltipContent?: string;
+    /** Whether stop button has compact styling */
     isCompact?: boolean;
 }
-export declare const StopButton: React.FunctionComponent<StopButtonProps>;
+export declare const StopButton: FunctionComponent<StopButtonProps>;
 export default StopButton;

package/dist/esm/MessageBar/StopButton.js

@@ -9,19 +9,13 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-// ============================================================================
-// Chatbot Footer - Message Bar - Stop
-// ============================================================================
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 // Import PatternFly components
 import { Button, Tooltip, Icon } from '@patternfly/react-core';
 export const StopButton = (_a) => {
     var { className, onClick, tooltipProps, tooltipContent = 'Stop', isCompact } = _a, props = __rest(_a, ["className", "onClick", "tooltipProps", "tooltipContent", "isCompact"]);
-    return (React.createElement(Tooltip, Object.assign({ id: "pf-chatbot__tooltip--stop", content: tooltipContent, position: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.position) || 'top', entryDelay: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.entryDelay) || 0, exitDelay: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.exitDelay) || 0, distance: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.distance) || 8, animationDuration: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.animationDuration) || 0, 
+    return (_jsx(Tooltip, Object.assign({ id: "pf-chatbot__tooltip--stop", content: tooltipContent, position: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.position) || 'top', entryDelay: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.entryDelay) || 0, exitDelay: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.exitDelay) || 0, distance: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.distance) || 8, animationDuration: (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.animationDuration) || 0, 
         // prevents VO announcements of both aria label and tooltip
-        aria: "none" }, tooltipProps),
-        React.createElement(Button, Object.assign({ className: `pf-chatbot__button--stop ${isCompact ? 'pf-m-compact' : ''} ${className !== null && className !== void 0 ? className : ''}`, variant: "link", "aria-label": props['aria-label'] || 'Stop button', onClick: onClick, icon: React.createElement(Icon, { iconSize: isCompact ? 'lg' : 'xl', isInline: true },
-                React.createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg" },
-                    React.createElement("path", { d: "M0.5 3C0.5 1.62109 1.62109 0.5 3 0.5H13C14.3789 0.5 15.5 1.62109 15.5 3V13C15.5 14.3789 14.3789 15.5 13 15.5H3C1.62109 15.5 0.5 14.3789 0.5 13V3Z", fill: "currentColor" }))), size: isCompact ? 'sm' : undefined }, props))));
+        aria: "none" }, tooltipProps, { children: _jsx(Button, Object.assign({ className: `pf-chatbot__button--stop ${isCompact ? 'pf-m-compact' : ''} ${className !== null && className !== void 0 ? className : ''}`, variant: "link", "aria-label": props['aria-label'] || 'Stop', onClick: onClick, icon: _jsx(Icon, { iconSize: isCompact ? 'lg' : 'xl', isInline: true, children: _jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M0.5 3C0.5 1.62109 1.62109 0.5 3 0.5H13C14.3789 0.5 15.5 1.62109 15.5 3V13C15.5 14.3789 14.3789 15.5 13 15.5H3C1.62109 15.5 0.5 14.3789 0.5 13V3Z", fill: "currentColor" }) }) }), size: isCompact ? 'sm' : undefined }, props)) })));
 };
 export default StopButton;

package/dist/esm/MessageBar/StopButton.test.js

@@ -7,35 +7,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import userEvent from '@testing-library/user-event';
 import { StopButton } from './StopButton';
 const renderStop = (props) => {
     const spy = jest.fn();
-    render(React.createElement(StopButton, Object.assign({ onClick: spy }, props)));
+    render(_jsx(StopButton, Object.assign({ onClick: spy }, props)));
 };
 describe('Stop button', () => {
     it('should render button correctly', () => {
         renderStop();
-        expect(screen.getByRole('button', { name: 'Stop button' })).toBeTruthy();
+        expect(screen.getByRole('button', { name: 'Stop' })).toBeTruthy();
     });
     it('should handle onClick correctly', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest.fn();
-        render(React.createElement(StopButton, { onClick: spy }));
-        yield userEvent.click(screen.getByRole('button', { name: 'Stop button' }));
+        render(_jsx(StopButton, { onClick: spy }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Stop' }));
         expect(screen.getByRole('tooltip', { name: 'Stop' })).toBeTruthy();
         expect(spy).toHaveBeenCalledTimes(1);
     }));
     it('should handle custom tooltip correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-        render(React.createElement(StopButton, { onClick: jest.fn, tooltipContent: "Test" }));
-        yield userEvent.click(screen.getByRole('button', { name: 'Stop button' }));
+        render(_jsx(StopButton, { onClick: jest.fn, tooltipContent: "Test" }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Stop' }));
         expect(screen.getByRole('tooltip', { name: 'Test' })).toBeTruthy();
     }));
     it('should handle className prop', () => {
         renderStop({ className: 'test' });
-        expect(screen.getByRole('button', { name: 'Stop button' })).toHaveClass('test');
+        expect(screen.getByRole('button', { name: 'Stop' })).toHaveClass('test');
     });
     it('should handle spread props, including aria-label', () => {
         renderStop({ 'aria-label': 'test' });
@@ -43,7 +43,7 @@ describe('Stop button', () => {
     });
     it('should handle tooltipProps prop', () => __awaiter(void 0, void 0, void 0, function* () {
         renderStop({ tooltipProps: { id: 'test' } });
-        yield userEvent.click(screen.getByRole('button', { name: 'Stop button' }));
+        yield userEvent.click(screen.getByRole('button', { name: 'Stop' }));
         expect(screen.getByRole('tooltip', { name: 'Stop' })).toHaveAttribute('id', 'test');
     }));
     it('should handle isCompact', () => {

package/dist/esm/MessageBox/JumpButton.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type { FunctionComponent } from 'react';
 export interface JumpButtonProps {
     /** Position of the Jump Button(top/bottom) */
     position: 'top' | 'bottom';
@@ -7,5 +7,5 @@ export interface JumpButtonProps {
     /** Flag to change the visibilty of the button */
     isHidden?: boolean;
 }
-declare const JumpButton: React.FunctionComponent<JumpButtonProps>;
+declare const JumpButton: FunctionComponent<JumpButtonProps>;
 export default JumpButton;

package/dist/esm/MessageBox/JumpButton.js

@@ -1,12 +1,7 @@
-// ============================================================================
-// Chatbot Main - Messages - Jump to Top
-// ============================================================================
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 // Import PatternFly components
 import { Button, Tooltip, Icon } from '@patternfly/react-core';
 import { ArrowUpIcon } from '@patternfly/react-icons/dist/esm/icons/arrow-up-icon';
 import { ArrowDownIcon } from '@patternfly/react-icons/dist/esm/icons/arrow-down-icon';
-const JumpButton = ({ position, isHidden, onClick }) => isHidden ? null : (React.createElement(Tooltip, { id: `pf-chatbot__tooltip--jump-${position}`, content: `Back to ${position}`, position: "top" },
-    React.createElement(Button, { variant: "plain", className: `pf-chatbot__jump pf-chatbot__jump--${position}`, "aria-label": `Jump ${position} button`, onClick: onClick },
-        React.createElement(Icon, { iconSize: "lg", isInline: true }, position === 'top' ? React.createElement(ArrowUpIcon, null) : React.createElement(ArrowDownIcon, null)))));
+const JumpButton = ({ position, isHidden, onClick }) => isHidden ? null : (_jsx(Tooltip, { id: `pf-chatbot__tooltip--jump-${position}`, content: `Back to ${position}`, position: "top", children: _jsx(Button, { variant: "plain", className: `pf-chatbot__jump pf-chatbot__jump--${position}`, "aria-label": `Jump ${position}`, onClick: onClick, children: _jsx(Icon, { iconSize: "lg", isInline: true, children: position === 'top' ? _jsx(ArrowUpIcon, {}) : _jsx(ArrowDownIcon, {}) }) }) }));
 export default JumpButton;

package/dist/esm/MessageBox/JumpButton.test.js

@@ -7,28 +7,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import JumpButton from './JumpButton';
 import userEvent from '@testing-library/user-event';
 describe('JumpButton', () => {
     it('should render top button correctly', () => {
-        render(React.createElement(JumpButton, { position: "top", onClick: jest.fn() }));
-        expect(screen.getByRole('button', { name: /Jump top button/i })).toBeTruthy();
+        render(_jsx(JumpButton, { position: "top", onClick: jest.fn() }));
+        expect(screen.getByRole('button', { name: /Jump top/i })).toBeTruthy();
     });
     it('should render bottom button correctly', () => {
-        render(React.createElement(JumpButton, { position: "bottom", onClick: jest.fn() }));
-        expect(screen.getByRole('button', { name: /Jump bottom button/i })).toBeTruthy();
+        render(_jsx(JumpButton, { position: "bottom", onClick: jest.fn() }));
+        expect(screen.getByRole('button', { name: /Jump bottom/i })).toBeTruthy();
     });
     it('should call onClick appropriately', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest.fn();
-        render(React.createElement(JumpButton, { position: "bottom", onClick: spy }));
-        yield userEvent.click(screen.getByRole('button', { name: /Jump bottom button/i }));
+        render(_jsx(JumpButton, { position: "bottom", onClick: spy }));
+        yield userEvent.click(screen.getByRole('button', { name: /Jump bottom/i }));
         expect(spy).toHaveBeenCalledTimes(1);
     }));
     it('should be hidden if isHidden prop is used', () => __awaiter(void 0, void 0, void 0, function* () {
-        render(React.createElement(JumpButton, { position: "bottom", onClick: jest.fn(), isHidden: true }));
-        expect(screen.queryByRole('button', { name: /Jump bottom button/i })).toBeFalsy();
+        render(_jsx(JumpButton, { position: "bottom", onClick: jest.fn(), isHidden: true }));
+        expect(screen.queryByRole('button', { name: /Jump bottom/i })).toBeFalsy();
     }));
 });

package/dist/esm/MessageBox/MessageBox.d.ts

@@ -1,17 +1,33 @@
-import React from 'react';
-export interface MessageBoxProps extends React.HTMLProps<HTMLDivElement> {
+import { HTMLProps, ReactNode } from 'react';
+export interface MessageBoxProps extends HTMLProps<HTMLDivElement> {
     /** Content that can be announced, such as a new message, for screen readers */
     announcement?: string;
     /** Custom aria-label for scrollable portion of message box */
     ariaLabel?: string;
     /** Content to be displayed in the message box */
-    children: React.ReactNode;
+    children: ReactNode;
     /** Custom classname for the MessageBox component */
     className?: string;
-    /** Ref applied to message box */
+    /** @deprecated innerRef has been deprecated. Use ref instead. Ref applied to message box  */
     innerRef?: React.Ref<HTMLDivElement>;
     /** Modifier that controls how content in MessageBox is positioned within the container */
     position?: 'top' | 'bottom';
+    /** Click handler for additional logic for when scroll to top jump button is clicked */
+    onScrollToTopClick?: () => void;
+    /** Click handler for additional logic for when scroll to bottom jump button is clicked */
+    onScrollToBottomClick?: () => void;
+    /** Flag to enable automatic scrolling when new messages are added */
+    enableSmartScroll?: boolean;
 }
-export declare const MessageBox: React.ForwardRefExoticComponent<Omit<MessageBoxProps, "ref"> & React.RefAttributes<any>>;
+export interface MessageBoxHandle extends HTMLDivElement {
+    /** Scrolls to the top of the message box */
+    scrollToTop: (options?: ScrollOptions) => void;
+    /** Scrolls to the bottom of the message box */
+    scrollToBottom: (options?: {
+        resumeSmartScroll?: boolean;
+    } & ScrollOptions) => void;
+    /** Returns whether the smart scroll feature is currently active */
+    isSmartScrollActive: () => boolean;
+}
+export declare const MessageBox: import("react").ForwardRefExoticComponent<Omit<MessageBoxProps, "ref"> & import("react").RefAttributes<MessageBoxHandle | null>>;
 export default MessageBox;

package/dist/esm/MessageBox/MessageBox.js

@@ -1,68 +1,205 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // ============================================================================
 // Chatbot Main - Messages
 // ============================================================================
-import React from 'react';
+import { useState, useRef, useCallback, useEffect, forwardRef, useImperativeHandle } from 'react';
 import JumpButton from './JumpButton';
-const MessageBoxBase = ({ announcement, ariaLabel = 'Scrollable message log', children, innerRef, className, position = 'top' }) => {
-    const [atTop, setAtTop] = React.useState(false);
-    const [atBottom, setAtBottom] = React.useState(true);
-    const [isOverflowing, setIsOverflowing] = React.useState(false);
-    const defaultRef = React.useRef(null);
-    let messageBoxRef;
-    if (innerRef) {
-        messageBoxRef = innerRef;
-    }
-    else {
-        messageBoxRef = defaultRef;
-    }
+export const MessageBox = forwardRef((_a, ref) => {
+    var { announcement, ariaLabel = 'Scrollable message log', children, className, position = 'top', onScrollToTopClick, onScrollToBottomClick, enableSmartScroll = false } = _a, props = __rest(_a, ["announcement", "ariaLabel", "children", "className", "position", "onScrollToTopClick", "onScrollToBottomClick", "enableSmartScroll"]);
+    const [atTop, setAtTop] = useState(false);
+    const [atBottom, setAtBottom] = useState(true);
+    const [isOverflowing, setIsOverflowing] = useState(false);
+    const [autoScroll, setAutoScroll] = useState(true);
+    const lastScrollTop = useRef(0);
+    const animationFrame = useRef(null);
+    const debounceTimeout = useRef(null);
+    const pauseAutoScrollRef = useRef(false);
+    const messageBoxRef = useRef(null);
+    const scrollQueued = useRef(false);
+    const resetUserScrollIntentTimeout = useRef();
     // Configure handlers
-    const handleScroll = React.useCallback(() => {
+    const handleScroll = useCallback(() => {
         const element = messageBoxRef.current;
-        if (element) {
-            const { scrollTop, scrollHeight, clientHeight } = element;
-            setAtTop(scrollTop === 0);
-            setAtBottom(Math.round(scrollTop) + Math.round(clientHeight) >= Math.round(scrollHeight) - 1); // rounding means it could be within a pixel of the bottom
+        if (!element) {
+            return;
+        }
+        const { scrollTop, scrollHeight, clientHeight } = element;
+        const roundedScrollTop = Math.round(scrollTop);
+        const roundedClientHeight = Math.round(clientHeight);
+        const roundedScrollHeight = Math.round(scrollHeight);
+        const distanceFromBottom = roundedScrollHeight - roundedScrollTop - roundedClientHeight;
+        const isScrollingDown = roundedScrollTop > lastScrollTop.current;
+        const DELTA_UP = 10;
+        const DELTA_DOWN = 50;
+        const DEBOUNCE_DELAY = 200;
+        const delta = isScrollingDown ? DELTA_DOWN : DELTA_UP;
+        const isAtBottom = distanceFromBottom <= delta;
+        setAtTop(roundedScrollTop === 0);
+        setAtBottom(roundedScrollTop + roundedClientHeight >= roundedScrollHeight - 1); // rounding means it could be within a pixel of the bottom
+        if (!enableSmartScroll || scrollQueued.current) {
+            return;
+        }
+        if (roundedScrollTop === 0) {
+            pauseAutoScrollRef.current = false;
+        }
+        if (debounceTimeout.current) {
+            clearTimeout(debounceTimeout.current);
         }
+        if (!isAtBottom && !pauseAutoScrollRef.current) {
+            setAutoScroll(false);
+        }
+        // User is near bottom and scrolling down - debounce re-enabling auto-scroll
+        if (isAtBottom && isScrollingDown && !pauseAutoScrollRef.current) {
+            debounceTimeout.current = setTimeout(() => {
+                setAutoScroll(true);
+            }, DEBOUNCE_DELAY);
+        }
+        lastScrollTop.current = roundedScrollTop;
     }, [messageBoxRef]);
-    const checkOverflow = React.useCallback(() => {
+    const checkOverflow = useCallback(() => {
         const element = messageBoxRef.current;
         if (element) {
             const { scrollHeight, clientHeight } = element;
             setIsOverflowing(scrollHeight >= clientHeight);
         }
     }, [messageBoxRef]);
-    const scrollToTop = React.useCallback(() => {
+    const resumeAutoScroll = useCallback(() => {
+        if (!enableSmartScroll) {
+            return;
+        }
+        pauseAutoScrollRef.current = false;
+        setAutoScroll(true);
+    }, [enableSmartScroll]);
+    const pauseAutoScroll = useCallback(() => {
+        if (!enableSmartScroll) {
+            return;
+        }
+        pauseAutoScrollRef.current = true;
+        setAutoScroll(false);
+    }, [enableSmartScroll]);
+    /**
+     * Scrolls to the top of the message box.
+     *
+     */
+    const scrollToTop = useCallback((options) => {
+        const { behavior = 'smooth' } = options || {};
         const element = messageBoxRef.current;
-        if (element) {
-            element.scrollTo({ top: 0, behavior: 'smooth' });
+        if (!element || scrollQueued.current) {
+            return;
         }
+        scrollQueued.current = true;
+        pauseAutoScroll();
+        if (animationFrame.current) {
+            cancelAnimationFrame(animationFrame.current);
+            animationFrame.current = null;
+        }
+        animationFrame.current = requestAnimationFrame(() => {
+            element.scrollTo({ top: 0, behavior });
+            scrollQueued.current = false;
+        });
+        onScrollToTopClick && onScrollToTopClick();
     }, [messageBoxRef]);
-    const scrollToBottom = React.useCallback(() => {
+    /**
+     * Scrolls to the bottom of the message box.
+     *
+     * @param options.resumeSmartScroll - If true, resumes smart scroll behavior;
+     *                                    if false or omitted, scrolls without resuming auto-scroll.
+     * @param options.scrollOptions - Additional scroll options. behavior can be 'smooth' or 'auto'.
+     */
+    const scrollToBottom = useCallback((options) => {
+        const { behavior = 'smooth', resumeSmartScroll = false } = options || {};
+        resumeSmartScroll && resumeAutoScroll();
         const element = messageBoxRef.current;
-        if (element) {
-            element.scrollTo({ top: element.scrollHeight, behavior: 'smooth' });
+        if (!element || pauseAutoScrollRef.current || scrollQueued.current) {
+            return;
         }
-    }, [messageBoxRef]);
+        scrollQueued.current = true;
+        if (animationFrame.current) {
+            cancelAnimationFrame(animationFrame.current);
+        }
+        animationFrame.current = requestAnimationFrame(() => {
+            element.scrollTo({ top: element.scrollHeight, behavior });
+            resumeAutoScroll();
+            scrollQueued.current = false;
+        });
+        onScrollToBottomClick && onScrollToBottomClick();
+    }, [messageBoxRef, enableSmartScroll]);
     // Detect scroll position
-    React.useEffect(() => {
+    useEffect(() => {
         const element = messageBoxRef.current;
-        if (element) {
-            // Listen for scroll events
-            element.addEventListener('scroll', handleScroll);
-            // Check initial position and overflow
-            handleScroll();
-            checkOverflow();
-            return () => {
-                element.removeEventListener('scroll', handleScroll);
-            };
+        if (!element) {
+            return;
         }
+        // Listen for scroll events
+        element.addEventListener('scroll', handleScroll);
+        // Check initial position and overflow
+        handleScroll();
+        checkOverflow();
+        return () => {
+            element.removeEventListener('scroll', handleScroll);
+        };
     }, [checkOverflow, handleScroll, messageBoxRef]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(JumpButton, { position: "top", isHidden: isOverflowing && atTop, onClick: scrollToTop }),
-        React.createElement("div", { role: "region", tabIndex: 0, "aria-label": ariaLabel, className: `pf-chatbot__messagebox ${position === 'bottom' && 'pf-chatbot__messagebox--bottom'} ${className !== null && className !== void 0 ? className : ''}`, ref: innerRef !== null && innerRef !== void 0 ? innerRef : messageBoxRef },
-            children,
-            React.createElement("div", { className: "pf-chatbot__messagebox-announcement", "aria-live": "polite" }, announcement)),
-        React.createElement(JumpButton, { position: "bottom", isHidden: isOverflowing && atBottom, onClick: scrollToBottom })));
-};
-export const MessageBox = React.forwardRef((props, ref) => (React.createElement(MessageBoxBase, Object.assign({ innerRef: ref }, props))));
+    useImperativeHandle(ref, () => {
+        const node = messageBoxRef.current;
+        // Attach custom methods to the element
+        node.scrollToTop = scrollToTop;
+        node.scrollToBottom = scrollToBottom;
+        node.isSmartScrollActive = () => enableSmartScroll && autoScroll;
+        return node;
+    });
+    let lastTouchY = null;
+    const onTouchEnd = (event) => {
+        lastTouchY = null;
+        props.onTouchEnd && props.onTouchEnd(event);
+    };
+    const handleUserScroll = (isScrollingDown) => {
+        const container = messageBoxRef.current;
+        if (!enableSmartScroll || !container) {
+            return;
+        }
+        if (!isScrollingDown) {
+            pauseAutoScrollRef.current = true;
+            clearTimeout(resetUserScrollIntentTimeout.current);
+            return;
+        }
+        const { scrollTop, scrollHeight, clientHeight } = container;
+        const distanceFromBottom = scrollHeight - scrollTop - clientHeight;
+        if (distanceFromBottom < 100) {
+            pauseAutoScrollRef.current = false;
+            setAutoScroll(true);
+        }
+    };
+    const onWheel = (event) => {
+        const isScrollingDown = event.deltaY > 0;
+        handleUserScroll(isScrollingDown);
+        props.onWheel && props.onWheel(event);
+    };
+    const onTouchMove = (event) => {
+        const currentTouchY = event.touches[0].clientY;
+        let isScrollingDown = false;
+        if (lastTouchY !== null) {
+            isScrollingDown = currentTouchY < lastTouchY;
+        }
+        lastTouchY = currentTouchY;
+        handleUserScroll(isScrollingDown);
+        props.onTouchMove && props.onTouchMove(event);
+    };
+    const smartScrollHandlers = {
+        onWheel,
+        onTouchMove,
+        onTouchEnd
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(JumpButton, { position: "top", isHidden: isOverflowing && atTop, onClick: scrollToTop }), _jsxs("div", Object.assign({ role: "region", tabIndex: 0, "aria-label": ariaLabel, className: `pf-chatbot__messagebox ${position === 'bottom' && 'pf-chatbot__messagebox--bottom'} ${className !== null && className !== void 0 ? className : ''}`, ref: messageBoxRef }, props, (enableSmartScroll ? Object.assign({}, smartScrollHandlers) : {}), { children: [children, _jsx("div", { className: "pf-chatbot__messagebox-announcement", "aria-live": "polite", children: announcement })] })), _jsx(JumpButton, { position: "bottom", isHidden: isOverflowing && atBottom, onClick: () => scrollToBottom({ resumeSmartScroll: true }) })] }));
+});
 export default MessageBox;