@patternfly/chatbot 6.3.0-prerelease.14 → 6.3.0-prerelease.16

package/dist/esm/MessageBox/MessageBox.js

@@ -10,29 +10,62 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState, useRef, useCallback, useEffect, forwardRef } from 'react';
+// ============================================================================
+// Chatbot Main - Messages
+// ============================================================================
+import { useState, useRef, useCallback, useEffect, forwardRef, useImperativeHandle } from 'react';
 import JumpButton from './JumpButton';
-const MessageBoxBase = (_a) => {
-    var { announcement, ariaLabel = 'Scrollable message log', children, innerRef, className, position = 'top', onScrollToTopClick, onScrollToBottomClick } = _a, props = __rest(_a, ["announcement", "ariaLabel", "children", "innerRef", "className", "position", "onScrollToTopClick", "onScrollToBottomClick"]);
+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 defaultRef = useRef(null);
-    let messageBoxRef;
-    if (innerRef) {
-        messageBoxRef = innerRef;
-    }
-    else {
-        messageBoxRef = defaultRef;
-    }
+    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 = 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 = useCallback(() => {
         const element = messageBoxRef.current;
@@ -41,35 +74,132 @@ const MessageBoxBase = (_a) => {
             setIsOverflowing(scrollHeight >= clientHeight);
         }
     }, [messageBoxRef]);
-    const scrollToTop = 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 = 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;
+        }
+        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]);
+    }, [messageBoxRef, enableSmartScroll]);
     // Detect scroll position
     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 (_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: innerRef !== null && innerRef !== void 0 ? innerRef : messageBoxRef }, props, { children: [children, _jsx("div", { className: "pf-chatbot__messagebox-announcement", "aria-live": "polite", children: announcement })] })), _jsx(JumpButton, { position: "bottom", isHidden: isOverflowing && atBottom, onClick: scrollToBottom })] }));
-};
-export const MessageBox = forwardRef((props, ref) => (_jsx(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;

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

@@ -9,21 +9,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { createRef } from 'react';
-import { render, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { MessageBox } from './MessageBox';
 import userEvent from '@testing-library/user-event';
 describe('MessageBox', () => {
+    beforeEach(() => {
+        jest.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => {
+            cb(0); // Immediately call the callback
+            return 0;
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
     it('should render Message box', () => {
         render(_jsx(MessageBox, { children: _jsx(_Fragment, { children: "Chatbot Messages" }) }));
         expect(screen.getByText('Chatbot Messages')).toBeTruthy();
     });
     it('should assign ref to Message box', () => {
+        var _a, _b, _c, _d;
         const ref = createRef();
-        render(_jsx(MessageBox, { ref: ref, children: _jsx("div", { children: "Test message content" }) }));
+        render(_jsx(MessageBox, { "data-testid": "message-box", ref: ref, children: _jsx("div", { children: "Test message content" }) }));
+        screen.getByText('Test message content');
         expect(ref.current).not.toBeNull();
+        // should contain custom methods exposed by the ref
+        expect(typeof ((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive)).toBe('function');
+        expect(typeof ((_b = ref.current) === null || _b === void 0 ? void 0 : _b.scrollToTop)).toBe('function');
+        expect(typeof ((_c = ref.current) === null || _c === void 0 ? void 0 : _c.scrollToBottom)).toBe('function');
+        expect((_d = ref.current) === null || _d === void 0 ? void 0 : _d.isSmartScrollActive()).toBe(false);
         expect(ref.current).toBeInstanceOf(HTMLDivElement);
     });
-    it('should call onScrollToBottomClick when scroll to top button is clicked', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should call onScrollToBottomClick when scroll to bottom button is clicked', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest.fn();
         render(_jsx(MessageBox, { onScrollToBottomClick: spy, children: _jsx("div", { children: "Test message content" }) }));
         // this forces button to show
@@ -31,7 +47,9 @@ describe('MessageBox', () => {
         Object.defineProperty(region, 'scrollHeight', { configurable: true, value: 1000 });
         Object.defineProperty(region, 'clientHeight', { configurable: true, value: 500 });
         Object.defineProperty(region, 'scrollTop', { configurable: true, value: 0 });
-        region.dispatchEvent(new Event('scroll'));
+        act(() => {
+            region.dispatchEvent(new Event('scroll'));
+        });
         yield waitFor(() => {
             userEvent.click(screen.getByRole('button', { name: /Jump bottom/i }));
             expect(spy).toHaveBeenCalled();
@@ -48,10 +66,165 @@ describe('MessageBox', () => {
             configurable: true,
             value: 500
         });
-        region.dispatchEvent(new Event('scroll'));
+        act(() => {
+            region.dispatchEvent(new Event('scroll'));
+        });
         yield waitFor(() => {
             userEvent.click(screen.getByRole('button', { name: /Jump top/i }));
             expect(spy).toHaveBeenCalled();
         });
     }));
+    it('should call user defined onWheel, onTouchMove and onTouchEnd handlers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ref = createRef();
+        const onWheel = jest.fn();
+        const onTouchMove = jest.fn();
+        const onTouchEnd = jest.fn();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, onWheel: onWheel, onTouchMove: onTouchMove, onTouchEnd: onTouchEnd, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        act(() => {
+            fireEvent.wheel(element, { deltaY: 10 });
+            fireEvent.touchMove(element, { touches: [{ clientY: 700 }] });
+            fireEvent.touchEnd(element);
+        });
+        expect(onWheel).toHaveBeenCalled();
+        expect(onTouchMove).toHaveBeenCalled();
+        expect(onTouchEnd).toHaveBeenCalled();
+    }));
+    it('should scroll to the bottom when the method is called ', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        const scrollSpy = jest.spyOn(element, 'scrollTo');
+        act(() => {
+            var _a, _b, _c;
+            (_a = ref.current) === null || _a === void 0 ? void 0 : _a.scrollToBottom();
+            (_b = ref.current) === null || _b === void 0 ? void 0 : _b.scrollToBottom();
+            (_c = ref.current) === null || _c === void 0 ? void 0 : _c.scrollToBottom();
+        });
+        expect(scrollSpy).toHaveBeenCalledWith({ top: element.scrollHeight, behavior: 'smooth' });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(true);
+    }));
+    it('should scroll to the top when the method is called ', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        const scrollSpy = jest.spyOn(element, 'scrollTo');
+        act(() => {
+            var _a;
+            (_a = ref.current) === null || _a === void 0 ? void 0 : _a.scrollToTop();
+        });
+        expect(scrollSpy).toHaveBeenCalledWith({ top: 0, behavior: 'smooth' });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+    }));
+    it('should pause automatic scrolling when user scrolls up ', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(true);
+        const element = ref.current;
+        // Manually set scrollHeight and clientHeight for calculations
+        Object.defineProperty(element, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(element, 'clientHeight', { configurable: true, value: 300 });
+        // Simulate scroll up by changing scrollTop
+        element.scrollTop = 200;
+        const scrollEvent = new Event('scroll', { bubbles: true });
+        act(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(false);
+    }));
+    it('should resume automatic scrolling when user scrolls down to the bottom using scroll event', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        jest.useFakeTimers();
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        // Manually set scrollHeight and clientHeight for calculations
+        Object.defineProperty(element, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(element, 'clientHeight', { configurable: true, value: 300 });
+        // Simulate scroll up by changing scrollTop
+        element.scrollTop = 100;
+        const scrollEvent = new Event('scroll', { bubbles: true });
+        act(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        act(() => {
+            // Simulate scroll down by changing scrollTop
+            element.scrollTop = 650; // scrollHeight - scrollTop - clientHeight - DELTA_DOWN (50) = 0
+            const scrollEvent = new Event('scroll', { bubbles: true });
+            element.dispatchEvent(scrollEvent);
+            jest.advanceTimersByTime(250);
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(true);
+        jest.useRealTimers();
+    }));
+    it('should resume automatic scrolling when scrollToBottom method is used', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        // Manually set scrollHeight and clientHeight for calculations
+        Object.defineProperty(element, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(element, 'clientHeight', { configurable: true, value: 300 });
+        // Simulate scroll up by changing scrollTop
+        element.scrollTop = 100;
+        const scrollEvent = new Event('scroll', { bubbles: true });
+        act(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        act(() => {
+            var _a;
+            (_a = ref.current) === null || _a === void 0 ? void 0 : _a.scrollToBottom({ resumeSmartScroll: true, behavior: 'auto' }); // resumes auto scroll and scrolls to bottom.
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(true);
+    }));
+    it('should resume automatic scrolling when mouse wheel event is used', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        // Manually set scrollHeight and clientHeight for calculations
+        Object.defineProperty(element, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(element, 'clientHeight', { configurable: true, value: 300 });
+        Object.defineProperty(element, 'scrollTop', { configurable: true, value: 350 });
+        const scrollEvent = new Event('scroll', { bubbles: true });
+        act(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        // Simulate mouse wheel event
+        act(() => {
+            Object.defineProperty(element, 'scrollTop', { configurable: true, value: 650 });
+            fireEvent.wheel(element, { deltaY: 10 });
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(true);
+    }));
+    it('should resume automatic scrolling when user swipes up in touch screen', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const ref = createRef();
+        render(_jsx(MessageBox, { ref: ref, enableSmartScroll: true, children: _jsx("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        // Manually set scrollHeight and clientHeight for calculations
+        Object.defineProperty(element, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(element, 'clientHeight', { configurable: true, value: 300 });
+        Object.defineProperty(element, 'scrollTop', { configurable: true, value: 350 });
+        const scrollEvent = new Event('scroll', { bubbles: true });
+        act(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        // Simulate touch event - swipe up
+        act(() => {
+            Object.defineProperty(element, 'scrollTop', { configurable: true, value: 650 });
+            fireEvent.touchStart(element, { touches: [{ clientY: 700 }] });
+            fireEvent.touchMove(element, { touches: [{ clientY: 700 }] });
+            fireEvent.touchMove(element, { touches: [{ clientY: 600 }] });
+            fireEvent.touchEnd(element);
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(true);
+    }));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patternfly/chatbot",
-  "version": "6.3.0-prerelease.14",
+  "version": "6.3.0-prerelease.16",
   "description": "This library provides React components based on PatternFly 6 that can be used to build chatbots.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/patternfly-docs/content/extensions/chatbot/examples/demos/AttachmentDemos.md

@@ -45,6 +45,8 @@ import PFIconLogoReverse from '../UI/PF-IconLogo-Reverse.svg';
 import userAvatar from '../Messages/user_avatar.svg';
 import patternflyAvatar from '../Messages/patternfly_avatar.jpg';
 import { FunctionComponent, useState, useRef, isValidElement, cloneElement, Children, ReactNode, MouseEvent } from 'react';
+import { getTrackingProviders } from "@patternfly/chatbot/dist/dynamic/tracking";
+import ChatbotConversationHistoryNav from '@patternfly/chatbot/dist/dynamic/ChatbotConversationHistoryNav';
 
 ## Demos
 
@@ -62,6 +64,40 @@ It is also important to announce when new content appears onscreen for accessibi
 
 ```
 
+### Message auto-scrolling
+
+This demo shows auto-scrolling functionality, which automatically scrolls to the bottom of the active chat.
+
+To enable auto-scroll behavior pass the `enableSmartScroll` prop to the [`<MessageBox>`](/patternfly-ai/chatbot/ui#message-box) component.
+
+When enabled:
+
+- Scroll position is automatically managed based on user interaction.
+- Scrolling is _not_ forced to the bottom when new messages arrive, unless explicitly triggered via the `scrollToBottom()` method.
+- If the user scrolls up or interacts with UI controls like "Back to top" or "Back to bottom", the component pauses auto-scroll to respect user intent.
+- Auto-scroll resumes only when the user scrolls back down manually or programmatically via the `scrollToBottom({resumeSmartScroll: true})` method.
+
+#### Imperative methods via `ref`
+
+When using `ref`, the `<MessageBox>` component exposes the following methods:
+
+- `scrollToBottom()`: Scrolls to the bottom of the message container.
+- `scrollToTop()`: Scrolls to the top of the message container.
+- `isSmartScrollActive()`: Returns `true` if smart auto-scroll is currently active.
+- Native `HTMLDivElement` methods like `scrollTo()`.
+
+This demo includes broader ChatBot features, including:
+
+1. A [`<ChatbotToggle>`](/patternfly-ai/chatbot/ui#toggle) that controls the [`<Chatbot>`](/patternfly-ai/chatbot/ui#container) container.
+2. A `<ChatbotContent>` and [`<MessageBox>`](/patternfly-ai/chatbot/ui#content-and-message-box) with:
+   - A `<ChatbotWelcomePrompt>`
+   - An initial user message and initial bot message
+3. A [`<ChatbotFooter>`](/patternfly-ai/chatbot/ui#footer) with a [`<ChatbotFootnote>`](/patternfly-ai/chatbot/ui#footnote-with-popover) and a `<MessageBar>`
+
+```js file="./ChatbotScrolling.tsx" isFullscreen
+
+```
+
 ### Attach via upload button in message bar
 
 This demo displays unique attachment features, including: