@uipath/apollo-wind 2.66.1 → 2.67.0

package/dist/components/ui/message-scroller/primitive/use-message-scroller-controller.js

@@ -0,0 +1,440 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from "react";
+import { getContentBottom, getElementTop, getElementViewportTop, getFirstVisibleMessageItem, getFlexGap, getLastScrollAnchor, getMessageScrollerItems, getMessageScrollerScrollable, getMessageScrollerVisibilityState, getNewScrollAnchor, getUnanchoredScrollAnchor, hasMultipleNewScrollAnchors } from "./geometry.js";
+import { DEFAULT_SCROLL_EDGE_THRESHOLD, DEFAULT_SCROLL_MARGIN, DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK, EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, SCROLL_POSITION_EPSILON } from "./types.js";
+import { useMessageScrollerCommands } from "./use-message-scroller-commands.js";
+import { clearPendingDefaultScroll, markDefaultScrollPositionApplied, useMessageScrollerRefs } from "./use-message-scroller-refs.js";
+function useElementRef(elementRef, onMount) {
+    return useCallback((element)=>{
+        elementRef.current = element;
+        if (element) onMount();
+    }, [
+        elementRef,
+        onMount
+    ]);
+}
+function useMessageScrollerController({ autoScroll = false, defaultScrollPosition = 'end', scrollEdgeThreshold = DEFAULT_SCROLL_EDGE_THRESHOLD, scrollPreviousItemPeek = DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK, scrollMargin = DEFAULT_SCROLL_MARGIN }) {
+    const refs = useMessageScrollerRefs({
+        autoScroll,
+        defaultScrollPosition,
+        scrollEdgeThreshold,
+        scrollMargin,
+        scrollPreviousItemPeek
+    });
+    const { streamingTurnRef, autoScrollRef, autoscrollingRef, autoscrollingTimeoutRef, contentRef, defaultScrollPositionAppliedRef, firstItemRef, itemCountRef, lastScrollTopRef, messageElementsRef, modeRef, pendingScrollFrameRef, pendingScrollToMessageRef, prependRestoreRef, preserveScrollOnPrependRef, pendingDefaultScrollStore, rootRef, scrollEdgeThresholdRef, scrollMarginRef, scrollPreviousItemPeekRef, spacerGapRef, spacerHeightRef, spacerRef, stateFrameRef, stateStore, viewportRef, visibilityFrameRef, visibilityObserverRef, visibilityStore, visibleMessageIdsRef, handledScrollAnchorsRef } = refs;
+    const previousDefaultScrollPositionRef = useRef(defaultScrollPosition);
+    if (previousDefaultScrollPositionRef.current !== defaultScrollPosition) {
+        previousDefaultScrollPositionRef.current = defaultScrollPosition;
+        defaultScrollPositionAppliedRef.current = false;
+    }
+    const writeStateAttributes = useCallback((state)=>{
+        const root = rootRef.current;
+        const viewport = viewportRef.current;
+        const scrollable = [
+            state.start && 'start',
+            state.end && 'end'
+        ].filter(Boolean).join(' ');
+        const autoScrolling = autoscrollingRef.current;
+        for (const element of [
+            root,
+            viewport
+        ])if (element) {
+            if (scrollable) element.setAttribute('data-scrollable', scrollable);
+            else element.removeAttribute('data-scrollable');
+            element.toggleAttribute('data-autoscrolling', autoScrolling);
+        }
+    }, []);
+    const reconcileFollowMode = useCallback((scrollable)=>{
+        const scrollTop = viewportRef.current?.scrollTop ?? 0;
+        const scrolledUp = scrollTop < lastScrollTopRef.current - SCROLL_POSITION_EPSILON;
+        lastScrollTopRef.current = scrollTop;
+        if (autoScrollRef.current && !scrollable.end && 'settling-jump' !== modeRef.current && 'anchored-to-message' !== modeRef.current) modeRef.current = 'following-bottom';
+        else if ('following-bottom' === modeRef.current && scrollable.end && scrolledUp && !autoscrollingRef.current) modeRef.current = 'free-scrolling';
+    }, []);
+    const commitScrollState = useCallback(()=>{
+        const nextState = getMessageScrollerScrollable({
+            content: contentRef.current,
+            scrollEdgeThreshold: scrollEdgeThresholdRef.current,
+            spacer: spacerRef.current,
+            viewport: viewportRef.current
+        });
+        reconcileFollowMode(nextState);
+        const publishedState = 'following-bottom' === modeRef.current ? {
+            ...nextState,
+            end: false
+        } : nextState;
+        writeStateAttributes(publishedState);
+        stateStore.setSnapshot(publishedState);
+    }, [
+        reconcileFollowMode,
+        stateStore,
+        writeStateAttributes
+    ]);
+    const scheduleStateCommit = useCallback(()=>{
+        if (null !== stateFrameRef.current) return;
+        stateFrameRef.current = window.requestAnimationFrame(()=>{
+            stateFrameRef.current = null;
+            commitScrollState();
+        });
+    }, [
+        commitScrollState
+    ]);
+    const scheduleVisibilitySync = useCallback(()=>{
+        if (!visibilityStore.hasListeners()) return;
+        if (null !== visibilityFrameRef.current) return;
+        visibilityFrameRef.current = window.requestAnimationFrame(()=>{
+            visibilityFrameRef.current = null;
+            if (!visibilityStore.hasListeners()) return;
+            visibilityStore.setSnapshot(getMessageScrollerVisibilityState({
+                content: contentRef.current,
+                scrollMargin: scrollMarginRef.current,
+                scrollPreviousItemPeek: scrollPreviousItemPeekRef.current,
+                spacer: spacerRef.current,
+                viewport: viewportRef.current,
+                visibleMessageIds: visibleMessageIdsRef.current
+            }));
+        });
+    }, [
+        visibilityStore
+    ]);
+    const { flushPendingScrollToMessage, reanchorToAnchoredMessage, scrollToElement, scrollToEnd, scrollToMessage, scrollToStart } = useMessageScrollerCommands({
+        refs,
+        commitScrollState,
+        scheduleStateCommit,
+        scheduleVisibilitySync
+    });
+    const restorePrependedAnchor = useCallback(()=>{
+        const anchor = prependRestoreRef.current;
+        const viewport = viewportRef.current;
+        if (!anchor || !viewport || !anchor.element.isConnected) return false;
+        const nextViewportTop = getElementViewportTop(anchor.element, viewport);
+        const delta = nextViewportTop - anchor.viewportTop;
+        if (Math.abs(delta) <= SCROLL_POSITION_EPSILON) return false;
+        viewport.scrollTop += delta;
+        anchor.viewportTop = getElementViewportTop(anchor.element, viewport);
+        scheduleStateCommit();
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleStateCommit,
+        scheduleVisibilitySync
+    ]);
+    const capturePrependAnchor = useCallback(()=>{
+        const content = contentRef.current;
+        const viewport = viewportRef.current;
+        if (!content || !viewport) {
+            prependRestoreRef.current = null;
+            return;
+        }
+        const anchor = getFirstVisibleMessageItem({
+            content,
+            spacer: spacerRef.current,
+            viewport
+        });
+        prependRestoreRef.current = anchor ? {
+            element: anchor,
+            viewportTop: getElementViewportTop(anchor, viewport)
+        } : null;
+    }, []);
+    const schedulePendingScrollToMessageFlush = useCallback(()=>{
+        if (null !== pendingScrollFrameRef.current) return;
+        pendingScrollFrameRef.current = window.requestAnimationFrame(()=>{
+            pendingScrollFrameRef.current = null;
+            if (flushPendingScrollToMessage()) capturePrependAnchor();
+        });
+    }, [
+        capturePrependAnchor,
+        flushPendingScrollToMessage
+    ]);
+    const applyDefaultScrollPosition = useCallback(()=>{
+        if (!defaultScrollPosition || defaultScrollPositionAppliedRef.current || 0 === itemCountRef.current) return false;
+        let handled = false;
+        if ('last-anchor' === defaultScrollPosition) {
+            const content = contentRef.current;
+            const viewport = viewportRef.current;
+            const anchor = content && viewport ? getLastScrollAnchor(getMessageScrollerItems(content, spacerRef.current)) : null;
+            if (content && viewport && anchor) {
+                const anchorTop = getElementTop(anchor, viewport);
+                const contentBottom = getContentBottom({
+                    content,
+                    spacer: spacerRef.current,
+                    viewport
+                });
+                const lastTurnFits = contentBottom - anchorTop <= viewport.clientHeight;
+                handled = lastTurnFits ? scrollToEnd({
+                    behavior: 'auto'
+                }) : scrollToElement(anchor, {
+                    align: 'start'
+                }, {
+                    keepPreviousPeek: true
+                });
+            } else handled = scrollToEnd({
+                behavior: 'auto'
+            });
+        } else handled = 'end' === defaultScrollPosition ? scrollToEnd({
+            behavior: 'auto'
+        }) : scrollToStart({
+            behavior: 'auto'
+        });
+        if (!handled) return false;
+        markDefaultScrollPositionApplied(refs);
+        return true;
+    }, [
+        defaultScrollPosition,
+        scrollToElement,
+        scrollToEnd,
+        scrollToStart
+    ]);
+    const handleContentChange = useCallback(()=>{
+        const content = contentRef.current;
+        if (!content) return;
+        const items = getMessageScrollerItems(content, spacerRef.current);
+        const previousItemCount = itemCountRef.current;
+        const previousFirstItem = firstItemRef.current;
+        itemCountRef.current = items.length;
+        firstItemRef.current = items[0] ?? null;
+        const reconcileScrollPosition = ()=>{
+            if (flushPendingScrollToMessage()) return;
+            if (0 === previousItemCount) {
+                if (applyDefaultScrollPosition()) return;
+                if (items.length > 0 && autoScrollRef.current && scrollToEnd({
+                    behavior: 'auto'
+                })) return;
+                commitScrollState();
+                scheduleVisibilitySync();
+                return;
+            }
+            const previousFirstItemIndex = previousFirstItem ? items.indexOf(previousFirstItem) : -1;
+            const didPrepend = preserveScrollOnPrependRef.current && previousFirstItemIndex > 0;
+            if (didPrepend) return void restorePrependedAnchor();
+            if (items.length > previousItemCount) {
+                const anchor = getNewScrollAnchor(items, previousItemCount);
+                if (anchor) {
+                    if (autoScrollRef.current && 'following-bottom' === modeRef.current && hasMultipleNewScrollAnchors(items, previousItemCount)) return void scrollToEnd({
+                        behavior: 'auto'
+                    });
+                    scrollToElement(anchor, {
+                        align: 'start'
+                    }, {
+                        keepPreviousPeek: true
+                    });
+                    handledScrollAnchorsRef.current.add(anchor);
+                    return;
+                }
+            }
+            if (items.length === previousItemCount) {
+                const anchor = getUnanchoredScrollAnchor(items, handledScrollAnchorsRef.current);
+                if (anchor) {
+                    scrollToElement(anchor, {
+                        align: 'start'
+                    }, {
+                        keepPreviousPeek: true
+                    });
+                    handledScrollAnchorsRef.current.add(anchor);
+                    return;
+                }
+            }
+            if ('following-bottom' === modeRef.current && autoScrollRef.current) scrollToEnd({
+                behavior: 'auto'
+            });
+            else {
+                commitScrollState();
+                scheduleVisibilitySync();
+            }
+        };
+        reconcileScrollPosition();
+        capturePrependAnchor();
+    }, [
+        applyDefaultScrollPosition,
+        capturePrependAnchor,
+        commitScrollState,
+        flushPendingScrollToMessage,
+        restorePrependedAnchor,
+        scheduleVisibilitySync,
+        scrollToElement,
+        scrollToEnd
+    ]);
+    const handleResize = useCallback(()=>{
+        if ('following-bottom' === modeRef.current && autoScrollRef.current) return void scrollToEnd({
+            behavior: 'auto'
+        });
+        const previousSpacerHeight = spacerHeightRef.current;
+        if (reanchorToAnchoredMessage()) {
+            if (autoScrollRef.current && previousSpacerHeight > 0 && 0 === spacerHeightRef.current) scrollToEnd({
+                behavior: 'auto'
+            });
+            return;
+        }
+        scheduleStateCommit();
+        scheduleVisibilitySync();
+    }, [
+        reanchorToAnchoredMessage,
+        scheduleStateCommit,
+        scheduleVisibilitySync,
+        scrollToEnd
+    ]);
+    const observeVisibility = useCallback(()=>{
+        const viewport = viewportRef.current;
+        if (!viewport || !visibilityStore.hasListeners()) return;
+        if ("u" < typeof IntersectionObserver) return void scheduleVisibilitySync();
+        if (!visibilityObserverRef.current) visibilityObserverRef.current = new IntersectionObserver((entries)=>{
+            for (const entry of entries){
+                const messageId = entry.target.dataset.messageId;
+                if (messageId) if (entry.isIntersecting) visibleMessageIdsRef.current.add(messageId);
+                else visibleMessageIdsRef.current.delete(messageId);
+            }
+            scheduleVisibilitySync();
+        }, {
+            root: viewport,
+            rootMargin: `${-(scrollMarginRef.current + scrollPreviousItemPeekRef.current)}px 0px 0px 0px`,
+            threshold: [
+                0,
+                0.01,
+                0.5,
+                1
+            ]
+        });
+        messageElementsRef.current.forEach((element)=>{
+            visibilityObserverRef.current?.observe(element);
+        });
+        scheduleVisibilitySync();
+    }, [
+        scheduleVisibilitySync,
+        visibilityStore
+    ]);
+    const unobserveVisibility = useCallback(()=>{
+        if (null !== visibilityFrameRef.current) {
+            window.cancelAnimationFrame(visibilityFrameRef.current);
+            visibilityFrameRef.current = null;
+        }
+        visibilityObserverRef.current?.disconnect();
+        visibilityObserverRef.current = null;
+        visibleMessageIdsRef.current.clear();
+        visibilityStore.setSnapshot(EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE);
+    }, [
+        visibilityStore
+    ]);
+    const registerMessage = useCallback((messageId, element, removedElement)=>{
+        if (element) {
+            messageElementsRef.current.set(messageId, element);
+            visibilityObserverRef.current?.observe(element);
+            scheduleVisibilitySync();
+            if (pendingScrollToMessageRef.current?.messageId === messageId) schedulePendingScrollToMessageFlush();
+            return;
+        }
+        if (removedElement && messageElementsRef.current.get(messageId) === removedElement) {
+            messageElementsRef.current.delete(messageId);
+            visibleMessageIdsRef.current.delete(messageId);
+            visibilityObserverRef.current?.unobserve(removedElement);
+            scheduleVisibilitySync();
+        }
+    }, [
+        schedulePendingScrollToMessageFlush,
+        scheduleVisibilitySync
+    ]);
+    const userScrollIntent = useCallback(()=>{
+        if ('following-bottom' === modeRef.current || 'anchored-to-message' === modeRef.current || 'settling-jump' === modeRef.current) {
+            streamingTurnRef.current = null;
+            modeRef.current = 'free-scrolling';
+        }
+    }, []);
+    const mirrorStateAttributes = useCallback(()=>writeStateAttributes(stateStore.getSnapshot()), [
+        stateStore,
+        writeStateAttributes
+    ]);
+    const setRootElement = useElementRef(rootRef, mirrorStateAttributes);
+    const setViewportElement = useElementRef(viewportRef, mirrorStateAttributes);
+    const setContentElement = useCallback((element)=>{
+        contentRef.current = element;
+    }, []);
+    const setSpacerElement = useCallback((element)=>{
+        spacerRef.current = element;
+        spacerGapRef.current = getFlexGap(element?.parentElement ?? null);
+    }, []);
+    const syncAfterScroll = useCallback(()=>{
+        commitScrollState();
+        scheduleVisibilitySync();
+        capturePrependAnchor();
+    }, [
+        capturePrependAnchor,
+        commitScrollState,
+        scheduleVisibilitySync
+    ]);
+    const context = useMemo(()=>({
+            handleContentChange,
+            handleResize,
+            observeVisibility,
+            pendingDefaultScrollStore,
+            preserveScrollOnPrependRef,
+            scrollToEnd,
+            scrollToMessage,
+            scrollToStart,
+            setContentElement,
+            setRootElement,
+            setSpacerElement,
+            setViewportElement,
+            stateStore,
+            syncAfterScroll,
+            unobserveVisibility,
+            userScrollIntent,
+            viewportRef,
+            visibilityStore
+        }), [
+        handleContentChange,
+        handleResize,
+        observeVisibility,
+        pendingDefaultScrollStore,
+        scrollToEnd,
+        scrollToMessage,
+        scrollToStart,
+        setContentElement,
+        setRootElement,
+        setSpacerElement,
+        setViewportElement,
+        stateStore,
+        syncAfterScroll,
+        unobserveVisibility,
+        userScrollIntent,
+        visibilityStore
+    ]);
+    useLayoutEffect(()=>{
+        if (applyDefaultScrollPosition()) return;
+        if (0 === itemCountRef.current) clearPendingDefaultScroll(refs);
+    }, [
+        applyDefaultScrollPosition
+    ]);
+    useEffect(()=>()=>{
+            if (null !== stateFrameRef.current) {
+                window.cancelAnimationFrame(stateFrameRef.current);
+                stateFrameRef.current = null;
+            }
+            if (null !== visibilityFrameRef.current) {
+                window.cancelAnimationFrame(visibilityFrameRef.current);
+                visibilityFrameRef.current = null;
+            }
+            if (null !== autoscrollingTimeoutRef.current) {
+                window.clearTimeout(autoscrollingTimeoutRef.current);
+                autoscrollingTimeoutRef.current = null;
+            }
+            if (null !== pendingScrollFrameRef.current) {
+                window.cancelAnimationFrame(pendingScrollFrameRef.current);
+                pendingScrollFrameRef.current = null;
+            }
+            visibilityObserverRef.current?.disconnect();
+            visibilityObserverRef.current = null;
+        }, []);
+    useLayoutEffect(()=>{
+        if (autoScroll && 'following-bottom' === modeRef.current && itemCountRef.current > 0) return void scrollToEnd({
+            behavior: 'auto'
+        });
+        commitScrollState();
+    }, [
+        autoScroll,
+        commitScrollState,
+        scrollToEnd
+    ]);
+    return {
+        context,
+        registerMessage
+    };
+}
+export { useMessageScrollerController };

package/dist/components/ui/message-scroller/primitive/use-message-scroller-refs.cjs

@@ -0,0 +1,124 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    clearPendingDefaultScroll: ()=>clearPendingDefaultScroll,
+    markDefaultScrollPositionApplied: ()=>markDefaultScrollPositionApplied,
+    useMessageScrollerRefs: ()=>useMessageScrollerRefs
+});
+const external_react_namespaceObject = require("react");
+const external_stores_cjs_namespaceObject = require("./stores.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+function useMessageScrollerRefs({ autoScroll, defaultScrollPosition, scrollEdgeThreshold, scrollMargin, scrollPreviousItemPeek }) {
+    const autoScrollRef = external_react_namespaceObject.useRef(autoScroll);
+    const autoscrollingRef = external_react_namespaceObject.useRef(false);
+    const contentRef = external_react_namespaceObject.useRef(null);
+    const defaultScrollPositionAppliedRef = external_react_namespaceObject.useRef(false);
+    const scrollEdgeThresholdRef = external_react_namespaceObject.useRef(scrollEdgeThreshold);
+    const itemCountRef = external_react_namespaceObject.useRef(0);
+    const firstItemRef = external_react_namespaceObject.useRef(null);
+    const lastScrollTopRef = external_react_namespaceObject.useRef(0);
+    const modeRef = external_react_namespaceObject.useRef(autoScroll ? 'following-bottom' : 'free-scrolling');
+    const messageElementsRef = external_react_namespaceObject.useRef(new Map());
+    const pendingScrollToMessageRef = external_react_namespaceObject.useRef(null);
+    const prependRestoreRef = external_react_namespaceObject.useRef(null);
+    const streamingTurnRef = external_react_namespaceObject.useRef(null);
+    const scrollPreviousItemPeekRef = external_react_namespaceObject.useRef(scrollPreviousItemPeek);
+    const preserveScrollOnPrependRef = external_react_namespaceObject.useRef(true);
+    const rootRef = external_react_namespaceObject.useRef(null);
+    const scrollMarginRef = external_react_namespaceObject.useRef(scrollMargin);
+    const pendingScrollFrameRef = external_react_namespaceObject.useRef(null);
+    const spacerGapRef = external_react_namespaceObject.useRef(0);
+    const spacerHeightRef = external_react_namespaceObject.useRef(0);
+    const spacerRef = external_react_namespaceObject.useRef(null);
+    const stateFrameRef = external_react_namespaceObject.useRef(null);
+    const pendingDefaultScrollStoreRef = external_react_namespaceObject.useRef(null);
+    const stateStoreRef = external_react_namespaceObject.useRef(null);
+    const autoscrollingTimeoutRef = external_react_namespaceObject.useRef(null);
+    const viewportRef = external_react_namespaceObject.useRef(null);
+    const visibilityFrameRef = external_react_namespaceObject.useRef(null);
+    const visibilityObserverRef = external_react_namespaceObject.useRef(null);
+    const visibilityStoreRef = external_react_namespaceObject.useRef(null);
+    const visibleMessageIdsRef = external_react_namespaceObject.useRef(new Set());
+    const handledScrollAnchorsRef = external_react_namespaceObject.useRef(new WeakSet());
+    if (null === pendingDefaultScrollStoreRef.current) pendingDefaultScrollStoreRef.current = (0, external_stores_cjs_namespaceObject.createMessageScrollerStore)('end' === defaultScrollPosition || 'last-anchor' === defaultScrollPosition, (current, next)=>current === next);
+    if (null === stateStoreRef.current) stateStoreRef.current = (0, external_stores_cjs_namespaceObject.createMessageScrollerStore)(external_types_cjs_namespaceObject.EMPTY_MESSAGE_SCROLLER_SCROLLABLE, external_stores_cjs_namespaceObject.areScrollStatesEqual);
+    if (null === visibilityStoreRef.current) visibilityStoreRef.current = (0, external_stores_cjs_namespaceObject.createMessageScrollerVisibilityStore)();
+    autoScrollRef.current = autoScroll;
+    scrollEdgeThresholdRef.current = scrollEdgeThreshold;
+    scrollMarginRef.current = scrollMargin;
+    scrollPreviousItemPeekRef.current = scrollPreviousItemPeek;
+    return {
+        autoScrollRef,
+        autoscrollingRef,
+        autoscrollingTimeoutRef,
+        streamingTurnRef,
+        contentRef,
+        defaultScrollPositionAppliedRef,
+        firstItemRef,
+        itemCountRef,
+        lastScrollTopRef,
+        messageElementsRef,
+        modeRef,
+        pendingScrollFrameRef,
+        pendingScrollToMessageRef,
+        prependRestoreRef,
+        preserveScrollOnPrependRef,
+        pendingDefaultScrollStore: pendingDefaultScrollStoreRef.current,
+        rootRef,
+        scrollEdgeThresholdRef,
+        scrollMarginRef,
+        scrollPreviousItemPeekRef,
+        spacerGapRef,
+        spacerHeightRef,
+        spacerRef,
+        stateFrameRef,
+        stateStore: stateStoreRef.current,
+        viewportRef,
+        visibilityFrameRef,
+        visibilityObserverRef,
+        visibilityStore: visibilityStoreRef.current,
+        visibleMessageIdsRef,
+        handledScrollAnchorsRef
+    };
+}
+function clearPendingDefaultScroll(refs) {
+    refs.pendingDefaultScrollStore.setSnapshot(false);
+}
+function markDefaultScrollPositionApplied(refs) {
+    refs.defaultScrollPositionAppliedRef.current = true;
+    clearPendingDefaultScroll(refs);
+}
+exports.clearPendingDefaultScroll = __webpack_exports__.clearPendingDefaultScroll;
+exports.markDefaultScrollPositionApplied = __webpack_exports__.markDefaultScrollPositionApplied;
+exports.useMessageScrollerRefs = __webpack_exports__.useMessageScrollerRefs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clearPendingDefaultScroll",
+    "markDefaultScrollPositionApplied",
+    "useMessageScrollerRefs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/message-scroller/primitive/use-message-scroller-refs.d.ts

@@ -0,0 +1,52 @@
+import * as React from 'react';
+import type { MessageScrollerDefaultScrollPosition, MessageScrollerMode, MessageScrollerScrollable, MessageScrollerScrollOptions, MessageScrollerStore, MessageScrollerVisibilityStore } from './types';
+type MessageScrollerRefs = {
+    autoScrollRef: React.RefObject<boolean>;
+    autoscrollingRef: React.RefObject<boolean>;
+    autoscrollingTimeoutRef: React.RefObject<number | null>;
+    streamingTurnRef: React.RefObject<HTMLElement | null>;
+    contentRef: React.RefObject<HTMLDivElement | null>;
+    defaultScrollPositionAppliedRef: React.RefObject<boolean>;
+    firstItemRef: React.RefObject<HTMLElement | null>;
+    itemCountRef: React.RefObject<number>;
+    lastScrollTopRef: React.RefObject<number>;
+    messageElementsRef: React.RefObject<Map<string, HTMLElement>>;
+    modeRef: React.RefObject<MessageScrollerMode>;
+    pendingScrollFrameRef: React.RefObject<number | null>;
+    pendingScrollToMessageRef: React.RefObject<{
+        messageId: string;
+        options?: MessageScrollerScrollOptions;
+    } | null>;
+    prependRestoreRef: React.RefObject<{
+        element: HTMLElement;
+        viewportTop: number;
+    } | null>;
+    preserveScrollOnPrependRef: React.RefObject<boolean>;
+    pendingDefaultScrollStore: MessageScrollerStore<boolean>;
+    rootRef: React.RefObject<HTMLDivElement | null>;
+    scrollEdgeThresholdRef: React.RefObject<number>;
+    scrollMarginRef: React.RefObject<number>;
+    scrollPreviousItemPeekRef: React.RefObject<number>;
+    spacerGapRef: React.RefObject<number>;
+    spacerHeightRef: React.RefObject<number>;
+    spacerRef: React.RefObject<HTMLDivElement | null>;
+    stateFrameRef: React.RefObject<number | null>;
+    stateStore: MessageScrollerStore<MessageScrollerScrollable>;
+    viewportRef: React.RefObject<HTMLDivElement | null>;
+    visibilityFrameRef: React.RefObject<number | null>;
+    visibilityObserverRef: React.RefObject<IntersectionObserver | null>;
+    visibilityStore: MessageScrollerVisibilityStore;
+    visibleMessageIdsRef: React.RefObject<Set<string>>;
+    handledScrollAnchorsRef: React.RefObject<WeakSet<HTMLElement>>;
+};
+declare function useMessageScrollerRefs({ autoScroll, defaultScrollPosition, scrollEdgeThreshold, scrollMargin, scrollPreviousItemPeek, }: {
+    autoScroll: boolean;
+    defaultScrollPosition: MessageScrollerDefaultScrollPosition;
+    scrollEdgeThreshold: number;
+    scrollMargin: number;
+    scrollPreviousItemPeek: number;
+}): MessageScrollerRefs;
+declare function clearPendingDefaultScroll(refs: MessageScrollerRefs): void;
+declare function markDefaultScrollPositionApplied(refs: MessageScrollerRefs): void;
+export { clearPendingDefaultScroll, markDefaultScrollPositionApplied, useMessageScrollerRefs };
+export type { MessageScrollerRefs };