@uipath/apollo-wind 2.66.1 → 2.67.0

package/dist/components/ui/message-scroller/primitive/types.cjs

@@ -0,0 +1,82 @@
+"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__, {
+    AUTOSCROLLING_CLEAR_DELAY: ()=>AUTOSCROLLING_CLEAR_DELAY,
+    DEFAULT_SCROLL_EDGE_THRESHOLD: ()=>DEFAULT_SCROLL_EDGE_THRESHOLD,
+    DEFAULT_SCROLL_MARGIN: ()=>DEFAULT_SCROLL_MARGIN,
+    DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK: ()=>DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK,
+    EMPTY_MESSAGE_SCROLLER_SCROLLABLE: ()=>EMPTY_MESSAGE_SCROLLER_SCROLLABLE,
+    EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE: ()=>EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE,
+    EMPTY_VISIBLE_MESSAGE_IDS: ()=>EMPTY_VISIBLE_MESSAGE_IDS,
+    SCROLL_POSITION_EPSILON: ()=>SCROLL_POSITION_EPSILON,
+    USER_SCROLL_KEYS: ()=>USER_SCROLL_KEYS
+});
+const DEFAULT_SCROLL_EDGE_THRESHOLD = 8;
+const DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK = 64;
+const DEFAULT_SCROLL_MARGIN = 0;
+const SCROLL_POSITION_EPSILON = 0.5;
+const AUTOSCROLLING_CLEAR_DELAY = 180;
+const USER_SCROLL_KEYS = new Set([
+    'ArrowDown',
+    'ArrowUp',
+    'End',
+    'Home',
+    'PageDown',
+    'PageUp',
+    ' '
+]);
+const EMPTY_MESSAGE_SCROLLER_SCROLLABLE = {
+    start: false,
+    end: false
+};
+const EMPTY_VISIBLE_MESSAGE_IDS = [];
+const EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE = {
+    currentAnchorId: null,
+    visibleMessageIds: EMPTY_VISIBLE_MESSAGE_IDS
+};
+exports.AUTOSCROLLING_CLEAR_DELAY = __webpack_exports__.AUTOSCROLLING_CLEAR_DELAY;
+exports.DEFAULT_SCROLL_EDGE_THRESHOLD = __webpack_exports__.DEFAULT_SCROLL_EDGE_THRESHOLD;
+exports.DEFAULT_SCROLL_MARGIN = __webpack_exports__.DEFAULT_SCROLL_MARGIN;
+exports.DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK = __webpack_exports__.DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK;
+exports.EMPTY_MESSAGE_SCROLLER_SCROLLABLE = __webpack_exports__.EMPTY_MESSAGE_SCROLLER_SCROLLABLE;
+exports.EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE = __webpack_exports__.EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE;
+exports.EMPTY_VISIBLE_MESSAGE_IDS = __webpack_exports__.EMPTY_VISIBLE_MESSAGE_IDS;
+exports.SCROLL_POSITION_EPSILON = __webpack_exports__.SCROLL_POSITION_EPSILON;
+exports.USER_SCROLL_KEYS = __webpack_exports__.USER_SCROLL_KEYS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AUTOSCROLLING_CLEAR_DELAY",
+    "DEFAULT_SCROLL_EDGE_THRESHOLD",
+    "DEFAULT_SCROLL_MARGIN",
+    "DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK",
+    "EMPTY_MESSAGE_SCROLLER_SCROLLABLE",
+    "EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE",
+    "EMPTY_VISIBLE_MESSAGE_IDS",
+    "SCROLL_POSITION_EPSILON",
+    "USER_SCROLL_KEYS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,89 @@
+import * as React from 'react';
+import type { UseRenderComponentProps } from './use-render';
+declare const DEFAULT_SCROLL_EDGE_THRESHOLD = 8;
+declare const DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK = 64;
+declare const DEFAULT_SCROLL_MARGIN = 0;
+declare const SCROLL_POSITION_EPSILON = 0.5;
+declare const AUTOSCROLLING_CLEAR_DELAY = 180;
+declare const USER_SCROLL_KEYS: Set<string>;
+type MessageScrollerMode = 'following-bottom' | 'free-scrolling' | 'anchored-to-message' | 'settling-jump';
+type MessageScrollerDefaultScrollPosition = 'start' | 'end' | 'last-anchor';
+type MessageScrollerButtonDirection = 'start' | 'end';
+type MessageScrollerScrollAlign = 'start' | 'center' | 'end' | 'nearest';
+type MessageScrollerScrollOptions = {
+    align?: MessageScrollerScrollAlign;
+    behavior?: ScrollBehavior;
+    scrollMargin?: number;
+};
+type MessageScrollerScrollable = {
+    start: boolean;
+    end: boolean;
+};
+type MessageScrollerVisibilityState = {
+    currentAnchorId: string | null;
+    visibleMessageIds: string[];
+};
+type MessageScrollerProviderProps = {
+    children?: React.ReactNode;
+    autoScroll?: boolean;
+    defaultScrollPosition?: MessageScrollerDefaultScrollPosition;
+    scrollEdgeThreshold?: number;
+    scrollPreviousItemPeek?: number;
+    scrollMargin?: number;
+};
+type MessageScrollerProps = React.ComponentPropsWithoutRef<'div'>;
+type MessageScrollerViewportProps = React.ComponentPropsWithoutRef<'div'> & {
+    preserveScrollOnPrepend?: boolean;
+};
+type MessageScrollerContentProps = React.ComponentPropsWithoutRef<'div'> & {
+    spacerClassName?: string;
+};
+type MessageScrollerItemProps = React.ComponentPropsWithoutRef<'div'> & {
+    messageId?: string;
+    scrollAnchor?: boolean;
+};
+type MessageScrollerButtonRenderState = {
+    active: boolean;
+    direction: MessageScrollerButtonDirection;
+};
+type MessageScrollerButtonProps = UseRenderComponentProps<'button', MessageScrollerButtonRenderState> & {
+    behavior?: ScrollBehavior;
+    direction?: MessageScrollerButtonDirection;
+};
+type MessageScrollerStore<T> = {
+    getSnapshot: () => T;
+    setSnapshot: (nextSnapshot: T) => void;
+    subscribe: (listener: () => void) => () => void;
+};
+type MessageScrollerVisibilityStore = {
+    getSnapshot: () => MessageScrollerVisibilityState;
+    hasListeners: () => boolean;
+    setSnapshot: (nextSnapshot: MessageScrollerVisibilityState) => void;
+    subscribe: (listener: () => void, onFirstSubscribe: () => void, onLastUnsubscribe: () => void) => () => void;
+};
+type MessageScrollerRegisterMessage = (messageId: string, element: HTMLElement | null, removedElement?: HTMLElement | null) => void;
+type MessageScrollerContextValue = {
+    handleContentChange: () => void;
+    handleResize: () => void;
+    observeVisibility: () => void;
+    preserveScrollOnPrependRef: React.RefObject<boolean>;
+    scrollToEnd: (options?: MessageScrollerScrollOptions) => boolean;
+    scrollToMessage: (messageId: string, options?: MessageScrollerScrollOptions) => boolean;
+    scrollToStart: (options?: MessageScrollerScrollOptions) => boolean;
+    setContentElement: (element: HTMLDivElement | null) => void;
+    setRootElement: (element: HTMLDivElement | null) => void;
+    setSpacerElement: (element: HTMLDivElement | null) => void;
+    setViewportElement: (element: HTMLDivElement | null) => void;
+    pendingDefaultScrollStore: MessageScrollerStore<boolean>;
+    stateStore: MessageScrollerStore<MessageScrollerScrollable>;
+    syncAfterScroll: () => void;
+    unobserveVisibility: () => void;
+    userScrollIntent: () => void;
+    viewportRef: React.RefObject<HTMLDivElement | null>;
+    visibilityStore: MessageScrollerVisibilityStore;
+};
+declare const EMPTY_MESSAGE_SCROLLER_SCROLLABLE: MessageScrollerScrollable;
+declare const EMPTY_VISIBLE_MESSAGE_IDS: string[];
+declare const EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE: MessageScrollerVisibilityState;
+export { AUTOSCROLLING_CLEAR_DELAY, DEFAULT_SCROLL_EDGE_THRESHOLD, DEFAULT_SCROLL_MARGIN, DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK, EMPTY_MESSAGE_SCROLLER_SCROLLABLE, EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, EMPTY_VISIBLE_MESSAGE_IDS, SCROLL_POSITION_EPSILON, USER_SCROLL_KEYS, };
+export type { MessageScrollerButtonDirection, MessageScrollerButtonProps, MessageScrollerButtonRenderState, MessageScrollerContentProps, MessageScrollerContextValue, MessageScrollerDefaultScrollPosition, MessageScrollerItemProps, MessageScrollerMode, MessageScrollerProps, MessageScrollerProviderProps, MessageScrollerRegisterMessage, MessageScrollerScrollAlign, MessageScrollerScrollOptions, MessageScrollerScrollable, MessageScrollerStore, MessageScrollerViewportProps, MessageScrollerVisibilityState, MessageScrollerVisibilityStore, };

package/dist/components/ui/message-scroller/primitive/types.js

@@ -0,0 +1,24 @@
+const DEFAULT_SCROLL_EDGE_THRESHOLD = 8;
+const DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK = 64;
+const DEFAULT_SCROLL_MARGIN = 0;
+const SCROLL_POSITION_EPSILON = 0.5;
+const AUTOSCROLLING_CLEAR_DELAY = 180;
+const USER_SCROLL_KEYS = new Set([
+    'ArrowDown',
+    'ArrowUp',
+    'End',
+    'Home',
+    'PageDown',
+    'PageUp',
+    ' '
+]);
+const EMPTY_MESSAGE_SCROLLER_SCROLLABLE = {
+    start: false,
+    end: false
+};
+const EMPTY_VISIBLE_MESSAGE_IDS = [];
+const EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE = {
+    currentAnchorId: null,
+    visibleMessageIds: EMPTY_VISIBLE_MESSAGE_IDS
+};
+export { AUTOSCROLLING_CLEAR_DELAY, DEFAULT_SCROLL_EDGE_THRESHOLD, DEFAULT_SCROLL_MARGIN, DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK, EMPTY_MESSAGE_SCROLLER_SCROLLABLE, EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, EMPTY_VISIBLE_MESSAGE_IDS, SCROLL_POSITION_EPSILON, USER_SCROLL_KEYS };

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

@@ -0,0 +1,213 @@
+"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__, {
+    useMessageScrollerCommands: ()=>useMessageScrollerCommands
+});
+const external_react_namespaceObject = require("react");
+const external_geometry_cjs_namespaceObject = require("./geometry.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_use_message_scroller_refs_cjs_namespaceObject = require("./use-message-scroller-refs.cjs");
+function useMessageScrollerCommands({ refs, commitScrollState, scheduleStateCommit, scheduleVisibilitySync }) {
+    const { streamingTurnRef, autoScrollRef, autoscrollingRef, autoscrollingTimeoutRef, contentRef, itemCountRef, messageElementsRef, modeRef, pendingScrollToMessageRef, prependRestoreRef, scrollMarginRef, scrollPreviousItemPeekRef, spacerGapRef, spacerHeightRef, spacerRef, viewportRef } = refs;
+    const setAutoScrolling = external_react_namespaceObject.useCallback((autoscrolling)=>{
+        if (null !== autoscrollingTimeoutRef.current) {
+            window.clearTimeout(autoscrollingTimeoutRef.current);
+            autoscrollingTimeoutRef.current = null;
+        }
+        if (autoscrollingRef.current !== autoscrolling) {
+            autoscrollingRef.current = autoscrolling;
+            commitScrollState();
+        }
+        if (autoscrolling) autoscrollingTimeoutRef.current = window.setTimeout(()=>{
+            autoscrollingTimeoutRef.current = null;
+            autoscrollingRef.current = false;
+            commitScrollState();
+        }, external_types_cjs_namespaceObject.AUTOSCROLLING_CLEAR_DELAY);
+    }, [
+        commitScrollState
+    ]);
+    const setTailSpacerHeight = external_react_namespaceObject.useCallback((height)=>{
+        const spacer = spacerRef.current;
+        if (!spacer) return;
+        const nextHeight = Math.max(0, Math.ceil(height));
+        if (spacerHeightRef.current === nextHeight) return;
+        spacerHeightRef.current = nextHeight;
+        spacer.hidden = 0 === nextHeight;
+        spacer.style.height = `${nextHeight}px`;
+        spacer.style.marginTop = nextHeight > 0 ? `${-spacerGapRef.current}px` : '';
+    }, []);
+    const scrollToPosition = external_react_namespaceObject.useCallback((scrollTop, { behavior = 'auto', autoscrolling = false } = {})=>{
+        const viewport = viewportRef.current;
+        if (!viewport) return;
+        const nextScrollTop = Math.max(0, scrollTop);
+        if (Math.abs(viewport.scrollTop - nextScrollTop) <= external_types_cjs_namespaceObject.SCROLL_POSITION_EPSILON) {
+            viewport.scrollTop = nextScrollTop;
+            commitScrollState();
+            return;
+        }
+        if (autoscrolling) setAutoScrolling(true);
+        viewport.scrollTo({
+            top: nextScrollTop,
+            behavior
+        });
+        scheduleStateCommit();
+    }, [
+        commitScrollState,
+        scheduleStateCommit,
+        setAutoScrolling
+    ]);
+    const scrollToStart = external_react_namespaceObject.useCallback(({ behavior = 'auto' } = {})=>{
+        if (!viewportRef.current) return false;
+        setTailSpacerHeight(0);
+        streamingTurnRef.current = null;
+        modeRef.current = 'free-scrolling';
+        scrollToPosition(0, {
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const scrollToEnd = external_react_namespaceObject.useCallback(({ behavior = 'auto' } = {})=>{
+        const viewport = viewportRef.current;
+        if (!viewport) return false;
+        setTailSpacerHeight(0);
+        streamingTurnRef.current = null;
+        modeRef.current = autoScrollRef.current ? 'following-bottom' : 'free-scrolling';
+        scrollToPosition((0, external_geometry_cjs_namespaceObject.getMaxScrollTop)(viewport), {
+            autoscrolling: true,
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const scrollToElement = external_react_namespaceObject.useCallback((element, { align = 'start', behavior = 'auto', scrollMargin = scrollMarginRef.current } = {}, { keepPreviousPeek = false } = {})=>{
+        const content = contentRef.current;
+        const viewport = viewportRef.current;
+        if (!content || !viewport || !content.contains(element)) return false;
+        const scrollTop = (0, external_geometry_cjs_namespaceObject.getElementScrollTop)({
+            align,
+            element,
+            scrollMargin: keepPreviousPeek ? scrollMargin + scrollPreviousItemPeekRef.current : scrollMargin,
+            spacer: spacerRef.current,
+            viewport
+        });
+        const nextSpacerHeight = (0, external_geometry_cjs_namespaceObject.getTailSpacerHeight)({
+            content,
+            scrollTop,
+            spacer: spacerRef.current,
+            viewport
+        });
+        setTailSpacerHeight(nextSpacerHeight);
+        prependRestoreRef.current = {
+            element,
+            viewportTop: (0, external_geometry_cjs_namespaceObject.getElementViewportTop)(element, viewport)
+        };
+        modeRef.current = keepPreviousPeek ? 'anchored-to-message' : 'settling-jump';
+        streamingTurnRef.current = keepPreviousPeek ? element : null;
+        scrollToPosition(scrollTop, {
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const reanchorToAnchoredMessage = external_react_namespaceObject.useCallback(()=>{
+        const element = streamingTurnRef.current;
+        if (!element || !element.isConnected || 'anchored-to-message' !== modeRef.current) return false;
+        return scrollToElement(element, {
+            align: 'start'
+        }, {
+            keepPreviousPeek: true
+        });
+    }, [
+        scrollToElement
+    ]);
+    const scrollToMessage = external_react_namespaceObject.useCallback((messageId, options)=>{
+        const element = messageElementsRef.current.get(messageId);
+        if (!element) {
+            if (0 === itemCountRef.current) {
+                pendingScrollToMessageRef.current = {
+                    messageId,
+                    options
+                };
+                (0, external_use_message_scroller_refs_cjs_namespaceObject.markDefaultScrollPositionApplied)(refs);
+                return true;
+            }
+            return false;
+        }
+        (0, external_use_message_scroller_refs_cjs_namespaceObject.markDefaultScrollPositionApplied)(refs);
+        if (scrollToElement(element, options)) {
+            pendingScrollToMessageRef.current = null;
+            return true;
+        }
+        pendingScrollToMessageRef.current = {
+            messageId,
+            options
+        };
+        return true;
+    }, [
+        scrollToElement
+    ]);
+    const flushPendingScrollToMessage = external_react_namespaceObject.useCallback(()=>{
+        const pending = pendingScrollToMessageRef.current;
+        if (!pending) return false;
+        const element = messageElementsRef.current.get(pending.messageId);
+        if (!element) return false;
+        const handled = scrollToElement(element, pending.options);
+        if (!handled) return false;
+        pendingScrollToMessageRef.current = null;
+        (0, external_use_message_scroller_refs_cjs_namespaceObject.markDefaultScrollPositionApplied)(refs);
+        return true;
+    }, [
+        scrollToElement
+    ]);
+    return {
+        flushPendingScrollToMessage,
+        reanchorToAnchoredMessage,
+        scrollToElement,
+        scrollToEnd,
+        scrollToMessage,
+        scrollToStart
+    };
+}
+exports.useMessageScrollerCommands = __webpack_exports__.useMessageScrollerCommands;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useMessageScrollerCommands"
+].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-commands.d.ts

@@ -0,0 +1,18 @@
+import type { MessageScrollerScrollOptions } from './types';
+import { type MessageScrollerRefs } from './use-message-scroller-refs';
+declare function useMessageScrollerCommands({ refs, commitScrollState, scheduleStateCommit, scheduleVisibilitySync, }: {
+    refs: MessageScrollerRefs;
+    commitScrollState: () => void;
+    scheduleStateCommit: () => void;
+    scheduleVisibilitySync: () => void;
+}): {
+    flushPendingScrollToMessage: () => boolean;
+    reanchorToAnchoredMessage: () => boolean;
+    scrollToElement: (element: HTMLElement, { align, behavior, scrollMargin, }?: MessageScrollerScrollOptions, { keepPreviousPeek, }?: {
+        keepPreviousPeek?: boolean;
+    }) => boolean;
+    scrollToEnd: ({ behavior }?: MessageScrollerScrollOptions) => boolean;
+    scrollToMessage: (messageId: string, options?: MessageScrollerScrollOptions) => boolean;
+    scrollToStart: ({ behavior }?: MessageScrollerScrollOptions) => boolean;
+};
+export { useMessageScrollerCommands };

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

@@ -0,0 +1,179 @@
+import { useCallback } from "react";
+import { getElementScrollTop, getElementViewportTop, getMaxScrollTop, getTailSpacerHeight } from "./geometry.js";
+import { AUTOSCROLLING_CLEAR_DELAY, SCROLL_POSITION_EPSILON } from "./types.js";
+import { markDefaultScrollPositionApplied } from "./use-message-scroller-refs.js";
+function useMessageScrollerCommands({ refs, commitScrollState, scheduleStateCommit, scheduleVisibilitySync }) {
+    const { streamingTurnRef, autoScrollRef, autoscrollingRef, autoscrollingTimeoutRef, contentRef, itemCountRef, messageElementsRef, modeRef, pendingScrollToMessageRef, prependRestoreRef, scrollMarginRef, scrollPreviousItemPeekRef, spacerGapRef, spacerHeightRef, spacerRef, viewportRef } = refs;
+    const setAutoScrolling = useCallback((autoscrolling)=>{
+        if (null !== autoscrollingTimeoutRef.current) {
+            window.clearTimeout(autoscrollingTimeoutRef.current);
+            autoscrollingTimeoutRef.current = null;
+        }
+        if (autoscrollingRef.current !== autoscrolling) {
+            autoscrollingRef.current = autoscrolling;
+            commitScrollState();
+        }
+        if (autoscrolling) autoscrollingTimeoutRef.current = window.setTimeout(()=>{
+            autoscrollingTimeoutRef.current = null;
+            autoscrollingRef.current = false;
+            commitScrollState();
+        }, AUTOSCROLLING_CLEAR_DELAY);
+    }, [
+        commitScrollState
+    ]);
+    const setTailSpacerHeight = useCallback((height)=>{
+        const spacer = spacerRef.current;
+        if (!spacer) return;
+        const nextHeight = Math.max(0, Math.ceil(height));
+        if (spacerHeightRef.current === nextHeight) return;
+        spacerHeightRef.current = nextHeight;
+        spacer.hidden = 0 === nextHeight;
+        spacer.style.height = `${nextHeight}px`;
+        spacer.style.marginTop = nextHeight > 0 ? `${-spacerGapRef.current}px` : '';
+    }, []);
+    const scrollToPosition = useCallback((scrollTop, { behavior = 'auto', autoscrolling = false } = {})=>{
+        const viewport = viewportRef.current;
+        if (!viewport) return;
+        const nextScrollTop = Math.max(0, scrollTop);
+        if (Math.abs(viewport.scrollTop - nextScrollTop) <= SCROLL_POSITION_EPSILON) {
+            viewport.scrollTop = nextScrollTop;
+            commitScrollState();
+            return;
+        }
+        if (autoscrolling) setAutoScrolling(true);
+        viewport.scrollTo({
+            top: nextScrollTop,
+            behavior
+        });
+        scheduleStateCommit();
+    }, [
+        commitScrollState,
+        scheduleStateCommit,
+        setAutoScrolling
+    ]);
+    const scrollToStart = useCallback(({ behavior = 'auto' } = {})=>{
+        if (!viewportRef.current) return false;
+        setTailSpacerHeight(0);
+        streamingTurnRef.current = null;
+        modeRef.current = 'free-scrolling';
+        scrollToPosition(0, {
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const scrollToEnd = useCallback(({ behavior = 'auto' } = {})=>{
+        const viewport = viewportRef.current;
+        if (!viewport) return false;
+        setTailSpacerHeight(0);
+        streamingTurnRef.current = null;
+        modeRef.current = autoScrollRef.current ? 'following-bottom' : 'free-scrolling';
+        scrollToPosition(getMaxScrollTop(viewport), {
+            autoscrolling: true,
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const scrollToElement = useCallback((element, { align = 'start', behavior = 'auto', scrollMargin = scrollMarginRef.current } = {}, { keepPreviousPeek = false } = {})=>{
+        const content = contentRef.current;
+        const viewport = viewportRef.current;
+        if (!content || !viewport || !content.contains(element)) return false;
+        const scrollTop = getElementScrollTop({
+            align,
+            element,
+            scrollMargin: keepPreviousPeek ? scrollMargin + scrollPreviousItemPeekRef.current : scrollMargin,
+            spacer: spacerRef.current,
+            viewport
+        });
+        const nextSpacerHeight = getTailSpacerHeight({
+            content,
+            scrollTop,
+            spacer: spacerRef.current,
+            viewport
+        });
+        setTailSpacerHeight(nextSpacerHeight);
+        prependRestoreRef.current = {
+            element,
+            viewportTop: getElementViewportTop(element, viewport)
+        };
+        modeRef.current = keepPreviousPeek ? 'anchored-to-message' : 'settling-jump';
+        streamingTurnRef.current = keepPreviousPeek ? element : null;
+        scrollToPosition(scrollTop, {
+            behavior
+        });
+        scheduleVisibilitySync();
+        return true;
+    }, [
+        scheduleVisibilitySync,
+        scrollToPosition,
+        setTailSpacerHeight
+    ]);
+    const reanchorToAnchoredMessage = useCallback(()=>{
+        const element = streamingTurnRef.current;
+        if (!element || !element.isConnected || 'anchored-to-message' !== modeRef.current) return false;
+        return scrollToElement(element, {
+            align: 'start'
+        }, {
+            keepPreviousPeek: true
+        });
+    }, [
+        scrollToElement
+    ]);
+    const scrollToMessage = useCallback((messageId, options)=>{
+        const element = messageElementsRef.current.get(messageId);
+        if (!element) {
+            if (0 === itemCountRef.current) {
+                pendingScrollToMessageRef.current = {
+                    messageId,
+                    options
+                };
+                markDefaultScrollPositionApplied(refs);
+                return true;
+            }
+            return false;
+        }
+        markDefaultScrollPositionApplied(refs);
+        if (scrollToElement(element, options)) {
+            pendingScrollToMessageRef.current = null;
+            return true;
+        }
+        pendingScrollToMessageRef.current = {
+            messageId,
+            options
+        };
+        return true;
+    }, [
+        scrollToElement
+    ]);
+    const flushPendingScrollToMessage = useCallback(()=>{
+        const pending = pendingScrollToMessageRef.current;
+        if (!pending) return false;
+        const element = messageElementsRef.current.get(pending.messageId);
+        if (!element) return false;
+        const handled = scrollToElement(element, pending.options);
+        if (!handled) return false;
+        pendingScrollToMessageRef.current = null;
+        markDefaultScrollPositionApplied(refs);
+        return true;
+    }, [
+        scrollToElement
+    ]);
+    return {
+        flushPendingScrollToMessage,
+        reanchorToAnchoredMessage,
+        scrollToElement,
+        scrollToEnd,
+        scrollToMessage,
+        scrollToStart
+    };
+}
+export { useMessageScrollerCommands };