@patternfly/chatbot 1.0.0

package/dist/cjs/MessageBox/MessageBox.js

@@ -0,0 +1,211 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBox = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// ============================================================================
+// Chatbot Main - Messages
+// ============================================================================
+const react_1 = require("react");
+const JumpButton_1 = __importDefault(require("./JumpButton"));
+exports.MessageBox = (0, react_1.forwardRef)((_a, ref) => {
+    var { announcement, ariaLabel = 'Scrollable message log', children, className, position = 'top', onScrollToTopClick, onScrollToBottomClick, enableSmartScroll = false, jumpButtonTopProps, jumpButtonBottomProps, jumpButtonBottomTooltipProps, jumpButtonTopTooltipProps } = _a, props = __rest(_a, ["announcement", "ariaLabel", "children", "className", "position", "onScrollToTopClick", "onScrollToBottomClick", "enableSmartScroll", "jumpButtonTopProps", "jumpButtonBottomProps", "jumpButtonBottomTooltipProps", "jumpButtonTopTooltipProps"]);
+    const [atTop, setAtTop] = (0, react_1.useState)(false);
+    const [atBottom, setAtBottom] = (0, react_1.useState)(true);
+    const [isOverflowing, setIsOverflowing] = (0, react_1.useState)(false);
+    const [autoScroll, setAutoScroll] = (0, react_1.useState)(true);
+    const lastScrollTop = (0, react_1.useRef)(0);
+    const animationFrame = (0, react_1.useRef)(null);
+    const debounceTimeout = (0, react_1.useRef)(null);
+    const pauseAutoScrollRef = (0, react_1.useRef)(false);
+    const messageBoxRef = (0, react_1.useRef)(null);
+    const scrollQueued = (0, react_1.useRef)(false);
+    const resetUserScrollIntentTimeout = (0, react_1.useRef)();
+    // Configure handlers
+    const handleScroll = (0, react_1.useCallback)(() => {
+        const element = messageBoxRef.current;
+        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 = (0, react_1.useCallback)(() => {
+        const element = messageBoxRef.current;
+        if (element) {
+            const { scrollHeight, clientHeight } = element;
+            setIsOverflowing(scrollHeight >= clientHeight);
+        }
+    }, [messageBoxRef]);
+    const resumeAutoScroll = (0, react_1.useCallback)(() => {
+        if (!enableSmartScroll) {
+            return;
+        }
+        pauseAutoScrollRef.current = false;
+        setAutoScroll(true);
+    }, [enableSmartScroll]);
+    const pauseAutoScroll = (0, react_1.useCallback)(() => {
+        if (!enableSmartScroll) {
+            return;
+        }
+        pauseAutoScrollRef.current = true;
+        setAutoScroll(false);
+    }, [enableSmartScroll]);
+    /**
+     * Scrolls to the top of the message box.
+     *
+     */
+    const scrollToTop = (0, react_1.useCallback)((options) => {
+        const { behavior = 'smooth' } = options || {};
+        const element = messageBoxRef.current;
+        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]);
+    /**
+     * 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 = (0, react_1.useCallback)((options) => {
+        const { behavior = 'smooth', resumeSmartScroll = false } = options || {};
+        resumeSmartScroll && resumeAutoScroll();
+        const element = messageBoxRef.current;
+        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, enableSmartScroll]);
+    // Detect scroll position
+    (0, react_1.useEffect)(() => {
+        const element = messageBoxRef.current;
+        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]);
+    (0, react_1.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 ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(JumpButton_1.default, { position: "top", isHidden: isOverflowing && atTop, onClick: scrollToTop, jumpButtonProps: jumpButtonTopProps, jumpButtonTooltipProps: jumpButtonTopTooltipProps }), (0, jsx_runtime_1.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, (0, jsx_runtime_1.jsx)("div", { className: "pf-chatbot__messagebox-announcement pf-chatbot-m-hidden", "aria-live": "polite", children: announcement })] })), (0, jsx_runtime_1.jsx)(JumpButton_1.default, { position: "bottom", isHidden: isOverflowing && atBottom, onClick: () => scrollToBottom({ resumeSmartScroll: true }), jumpButtonProps: jumpButtonBottomProps, jumpButtonTooltipProps: jumpButtonBottomTooltipProps })] }));
+});
+exports.default = exports.MessageBox;

package/dist/cjs/MessageBox/MessageBox.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/MessageBox/MessageBox.test.js

@@ -0,0 +1,235 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_2 = require("@testing-library/react");
+const MessageBox_1 = require("./MessageBox");
+const user_event_1 = __importDefault(require("@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', () => {
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { children: (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "Chatbot Messages" }) }));
+        expect(react_2.screen.getByText('Chatbot Messages')).toBeTruthy();
+    });
+    it('should assign ref to Message box', () => {
+        var _a, _b, _c, _d;
+        const ref = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { "data-testid": "message-box", ref: ref, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        react_2.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 bottom button is clicked', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest.fn();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { onScrollToBottomClick: spy, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        // this forces button to show
+        const region = react_2.screen.getByRole('region');
+        Object.defineProperty(region, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(region, 'clientHeight', { configurable: true, value: 500 });
+        Object.defineProperty(region, 'scrollTop', { configurable: true, value: 0 });
+        (0, react_2.act)(() => {
+            region.dispatchEvent(new Event('scroll'));
+        });
+        yield (0, react_2.waitFor)(() => {
+            user_event_1.default.click(react_2.screen.getByRole('button', { name: /Back to bottom/i }));
+            expect(spy).toHaveBeenCalled();
+        });
+    }));
+    it('should call onScrollToTopClick when scroll to top button is clicked', () => __awaiter(void 0, void 0, void 0, function* () {
+        const spy = jest.fn();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { onScrollToTopClick: spy, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        // this forces button to show
+        const region = react_2.screen.getByRole('region');
+        Object.defineProperty(region, 'scrollHeight', { configurable: true, value: 1000 });
+        Object.defineProperty(region, 'clientHeight', { configurable: true, value: 500 });
+        Object.defineProperty(region, 'scrollTop', {
+            configurable: true,
+            value: 500
+        });
+        (0, react_2.act)(() => {
+            region.dispatchEvent(new Event('scroll'));
+        });
+        yield (0, react_2.waitFor)(() => {
+            user_event_1.default.click(react_2.screen.getByRole('button', { name: /Back to 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 = (0, react_1.createRef)();
+        const onWheel = jest.fn();
+        const onTouchMove = jest.fn();
+        const onTouchEnd = jest.fn();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, onWheel: onWheel, onTouchMove: onTouchMove, onTouchEnd: onTouchEnd, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        (0, react_2.act)(() => {
+            react_2.fireEvent.wheel(element, { deltaY: 10 });
+            react_2.fireEvent.touchMove(element, { touches: [{ clientY: 700 }] });
+            react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        const scrollSpy = jest.spyOn(element, 'scrollTo');
+        (0, react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.jsx)("div", { children: "Test message content" }) }));
+        const element = ref.current;
+        const scrollSpy = jest.spyOn(element, 'scrollTo');
+        (0, react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.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 });
+        (0, react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.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 });
+        (0, react_2.act)(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        (0, react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.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 });
+        (0, react_2.act)(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        (0, react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.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 });
+        (0, react_2.act)(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        // Simulate mouse wheel event
+        (0, react_2.act)(() => {
+            Object.defineProperty(element, 'scrollTop', { configurable: true, value: 650 });
+            react_2.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 = (0, react_1.createRef)();
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(MessageBox_1.MessageBox, { ref: ref, enableSmartScroll: true, children: (0, jsx_runtime_1.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 });
+        (0, react_2.act)(() => {
+            element.dispatchEvent(scrollEvent);
+        });
+        expect((_a = ref.current) === null || _a === void 0 ? void 0 : _a.isSmartScrollActive()).toBe(false);
+        // Simulate touch event - swipe up
+        (0, react_2.act)(() => {
+            Object.defineProperty(element, 'scrollTop', { configurable: true, value: 650 });
+            react_2.fireEvent.touchStart(element, { touches: [{ clientY: 700 }] });
+            react_2.fireEvent.touchMove(element, { touches: [{ clientY: 700 }] });
+            react_2.fireEvent.touchMove(element, { touches: [{ clientY: 600 }] });
+            react_2.fireEvent.touchEnd(element);
+        });
+        expect((_b = ref.current) === null || _b === void 0 ? void 0 : _b.isSmartScrollActive()).toBe(true);
+    }));
+});

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

@@ -0,0 +1,3 @@
+export { default } from './MessageBox';
+export * from './MessageBox';
+export * from './JumpButton';

package/dist/cjs/MessageBox/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var MessageBox_1 = require("./MessageBox");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(MessageBox_1).default; } });
+__exportStar(require("./MessageBox"), exports);
+__exportStar(require("./JumpButton"), exports);

package/dist/cjs/MessageDivider/MessageDivider.d.ts

@@ -0,0 +1,9 @@
+import type { FunctionComponent } from 'react';
+export interface MessageDividerProps {
+    /** Variant of the divider */
+    variant?: 'inset' | 'fullWidth';
+    /** Content of the message divider */
+    content?: string;
+}
+declare const MessageDivider: FunctionComponent<MessageDividerProps>;
+export default MessageDivider;

package/dist/cjs/MessageDivider/MessageDivider.js

@@ -0,0 +1,23 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_core_1 = require("@patternfly/react-core");
+const MessageDivider = (_a) => {
+    var { variant = 'inset', content = new Date().toLocaleDateString() } = _a, props = __rest(_a, ["variant", "content"]);
+    if (variant === 'inset') {
+        return ((0, jsx_runtime_1.jsxs)("div", Object.assign({ className: "pf-chatbot__message-divider pf-m-divider pf-m-wrap" }, props, { children: [(0, jsx_runtime_1.jsx)(react_core_1.Divider, {}), (0, jsx_runtime_1.jsx)(react_core_1.Label, { children: content })] })));
+    }
+    return ((0, jsx_runtime_1.jsx)("div", Object.assign({ className: "pf-chatbot__message-divider pf-m-wrap" }, props, { children: (0, jsx_runtime_1.jsx)(react_core_1.Label, { children: content }) })));
+};
+exports.default = MessageDivider;

package/dist/cjs/MessageDivider/MessageDivider.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/cjs/MessageDivider/MessageDivider.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@testing-library/react");
+require("@testing-library/jest-dom");
+const MessageDivider_1 = __importDefault(require("./MessageDivider"));
+describe('MessageDivider', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should render default correctly with variant = date and content = new Date().toLocaleDateString()', () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(MessageDivider_1.default, { "data-testid": "message-divider" }));
+        expect(react_1.screen.getByText(new Date().toLocaleDateString())).toBeInTheDocument();
+        expect(react_1.screen.getByTestId('message-divider')).toHaveClass('pf-m-divider');
+    });
+    it('should render inset variant correctly', () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(MessageDivider_1.default, { variant: "inset", content: "test", "data-testid": "message-divider" }));
+        expect(react_1.screen.getByText('test')).toBeInTheDocument();
+        expect(react_1.screen.getByTestId('message-divider')).toHaveClass('pf-m-divider');
+    });
+    it('should render fullWidth variant correctly', () => {
+        (0, react_1.render)((0, jsx_runtime_1.jsx)(MessageDivider_1.default, { variant: "fullWidth", content: "test", "data-testid": "message-divider" }));
+        expect(react_1.screen.getByText('test')).toBeInTheDocument();
+        expect(react_1.screen.getByTestId('message-divider')).not.toHaveClass('pf-m-divider');
+    });
+});

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

@@ -0,0 +1,2 @@
+export { default } from './MessageDivider';
+export * from './MessageDivider';

package/dist/cjs/MessageDivider/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var MessageDivider_1 = require("./MessageDivider");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(MessageDivider_1).default; } });
+__exportStar(require("./MessageDivider"), exports);

package/dist/cjs/Onboarding/Onboarding.d.ts

@@ -0,0 +1,36 @@
+import type { FunctionComponent } from 'react';
+import { ModalProps } from '@patternfly/react-core';
+import { ChatbotDisplayMode } from '../Chatbot';
+export interface OnboardingProps extends ModalProps {
+    /** Class applied to modal */
+    className?: string;
+    /** Action assigned to primary modal button */
+    onPrimaryAction?: (event: React.MouseEvent | MouseEvent | KeyboardEvent) => void;
+    /** Action assigned to secondary modal button */
+    onSecondaryAction: (event: React.MouseEvent | MouseEvent | KeyboardEvent) => void;
+    /** Name of primary modal button */
+    primaryActionBtn?: string;
+    /** Name of secondary modal button */
+    secondaryActionBtn?: string;
+    /** Function that handles modal toggle */
+    handleModalToggle: (event: React.MouseEvent | MouseEvent | KeyboardEvent) => void;
+    /** Whether modal is open */
+    isModalOpen: boolean;
+    /** Title of modal */
+    title?: string;
+    /** Display mode for the Chatbot parent; this influences the styles applied */
+    displayMode?: ChatbotDisplayMode;
+    /** Optional image displayed in header */
+    headerImage?: string;
+    /** Alt text for optional image displayed in header */
+    headerImageAltText?: string;
+    /** Ref applied to modal */
+    innerRef?: React.Ref<HTMLDivElement>;
+    /** OuiaID applied to modal */
+    ouiaId?: string;
+    /** Sets modal to compact styling. */
+    isCompact?: boolean;
+}
+export declare const OnboardingBase: FunctionComponent<OnboardingProps>;
+declare const Onboarding: import("react").ForwardRefExoticComponent<Omit<OnboardingProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export default Onboarding;