@nadicodeai/ui 0.20.0 → 0.22.0

package/dist/lib/message-scroller-primitive/use-message-scroller-controller.js

@@ -1,506 +0,0 @@
-// Vendored from @shadcn/react 0.2.1 (upstream github.com/shadcn-ui).
-// Adapted only for repo import paths and formatting; not added as an npm dependency.
-import * as React 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 { useMessageScrollerRefs } from "./use-message-scroller-refs.js";
-// Builds a ref callback that stores the node and runs onMount once it attaches.
-function useElementRef(elementRef, onMount) {
-    return React.useCallback((element) => {
-        elementRef.current = element;
-        if (element) {
-            onMount();
-        }
-    }, [elementRef, onMount]);
-}
-// Orchestrator hook. Decides when to scroll and delegates the moves to
-// useMessageScrollerCommands; state and visibility commits are coalesced on a
-// requestAnimationFrame and torn down on cleanup for StrictMode safety.
-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,
-        scrollEdgeThreshold,
-        scrollMargin,
-        scrollPreviousItemPeek,
-    });
-    const { streamingTurnRef, autoScrollRef, autoscrollingRef, autoscrollingTimeoutRef, contentRef, defaultScrollPositionAppliedRef, firstItemRef, itemCountRef, lastScrollTopRef, messageElementsRef, modeRef, pendingScrollFrameRef, pendingScrollToMessageRef, prependRestoreRef, preserveScrollOnPrependRef, rootRef, scrollEdgeThresholdRef, scrollMarginRef, scrollPreviousItemPeekRef, spacerGapRef, spacerHeightRef, spacerRef, stateFrameRef, stateStore, viewportRef, visibilityFrameRef, visibilityObserverRef, visibilityStore, visibleMessageIdsRef, handledScrollAnchorsRef, } = refs;
-    const previousDefaultScrollPositionRef = React.useRef(defaultScrollPosition);
-    if (previousDefaultScrollPositionRef.current !== defaultScrollPosition) {
-        previousDefaultScrollPositionRef.current = defaultScrollPosition;
-        defaultScrollPositionAppliedRef.current = false;
-    }
-    const writeStateAttributes = React.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) {
-                continue;
-            }
-            if (scrollable) {
-                element.setAttribute("data-scrollable", scrollable);
-            }
-            else {
-                element.removeAttribute("data-scrollable");
-            }
-            element.toggleAttribute("data-autoscrolling", autoScrolling);
-        }
-    }, []);
-    // Owns the one follow-bottom transition: arm at the bottom, release on any
-    // scroll away (including a scrollbar drag), suppressed during a programmatic
-    // scroll so the auto-scroll animation cannot release itself. Arming also
-    // skips the anchored-to-message hold: the tail spacer makes a freshly
-    // anchored turn read as "at the end", and re-arming there would let the
-    // first streamed chunk yank the reader off the anchor. The hold hands back
-    // to following in handleResize, once the reply consumes the tail spacer.
-    const reconcileFollowMode = React.useCallback((scrollable) => {
-        const scrollTop = viewportRef.current?.scrollTop ?? 0;
-        // Content growing past the live edge also reads as "not at the end", but
-        // only a scrollbar drag moves scrollTop up. Growth must not release
-        // follow-output: the resize handler is coalesced onto a frame, so a state
-        // commit can observe the grown content before follow catches up.
-        const scrolledUp = scrollTop < lastScrollTopRef.current - SCROLL_POSITION_EPSILON;
-        lastScrollTopRef.current = scrollTop;
-        if (autoScrollRef.current &&
-            !scrollable.end &&
-            modeRef.current !== "settling-jump" &&
-            modeRef.current !== "anchored-to-message") {
-            modeRef.current = "following-bottom";
-        }
-        else if (modeRef.current === "following-bottom" &&
-            scrollable.end &&
-            scrolledUp &&
-            !autoscrollingRef.current) {
-            modeRef.current = "free-scrolling";
-        }
-    }, []);
-    const commitScrollState = React.useCallback(() => {
-        const nextState = getMessageScrollerScrollable({
-            content: contentRef.current,
-            scrollEdgeThreshold: scrollEdgeThresholdRef.current,
-            spacer: spacerRef.current,
-            viewport: viewportRef.current,
-        });
-        reconcileFollowMode(nextState);
-        // While follow-output is engaged the scroller is already closing any gap a
-        // streamed chunk just opened, so publishing it as scrollable toward the
-        // end would strobe the scroll button once per chunk. Reconcile runs on the
-        // raw geometry first, so a commit that releases follow still publishes the
-        // gap it released over.
-        const publishedState = modeRef.current === "following-bottom" ? { ...nextState, end: false } : nextState;
-        writeStateAttributes(publishedState);
-        stateStore.setSnapshot(publishedState);
-    }, [reconcileFollowMode, stateStore, writeStateAttributes]);
-    const scheduleStateCommit = React.useCallback(() => {
-        if (stateFrameRef.current !== null) {
-            return;
-        }
-        stateFrameRef.current = window.requestAnimationFrame(() => {
-            stateFrameRef.current = null;
-            commitScrollState();
-        });
-    }, [commitScrollState]);
-    const scheduleVisibilitySync = React.useCallback(() => {
-        if (!visibilityStore.hasListeners()) {
-            return;
-        }
-        if (visibilityFrameRef.current !== null) {
-            return;
-        }
-        visibilityFrameRef.current = window.requestAnimationFrame(() => {
-            visibilityFrameRef.current = null;
-            // A frame can outlive the last unsubscribe. Recomputing here would
-            // overwrite the EMPTY snapshot that teardown just wrote, leaving a stale
-            // value for the next subscriber to read.
-            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 = React.useCallback(() => {
-        const anchor = prependRestoreRef.current;
-        const viewport = viewportRef.current;
-        if (!anchor || !viewport || !anchor.element.isConnected) {
-            return false;
-        }
-        // Compare the anchor relative to the viewport, not to the content. Native
-        // scroll anchoring leaves the viewport-relative position unchanged, so this
-        // is a no-op where the browser already handled the prepend and only corrects
-        // the scroll where it did not (e.g. Safari) — without trusting a capability
-        // flag, which some engines report incorrectly.
-        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 = React.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 = React.useCallback(() => {
-        if (pendingScrollFrameRef.current !== null) {
-            return;
-        }
-        pendingScrollFrameRef.current = window.requestAnimationFrame(() => {
-            pendingScrollFrameRef.current = null;
-            if (flushPendingScrollToMessage()) {
-                capturePrependAnchor();
-            }
-        });
-    }, [capturePrependAnchor, flushPendingScrollToMessage]);
-    const applyDefaultScrollPosition = React.useCallback(() => {
-        if (!defaultScrollPosition ||
-            defaultScrollPositionAppliedRef.current ||
-            itemCountRef.current === 0) {
-            return false;
-        }
-        let handled = false;
-        if (defaultScrollPosition === "last-anchor") {
-            const content = contentRef.current;
-            const viewport = viewportRef.current;
-            const anchor = content && viewport
-                ? getLastScrollAnchor(getMessageScrollerItems(content, spacerRef.current))
-                : null;
-            if (!content || !viewport || !anchor) {
-                handled = scrollToEnd({ behavior: "auto" });
-            }
-            else {
-                const anchorTop = getElementTop(anchor, viewport);
-                const contentBottom = getContentBottom({
-                    content,
-                    spacer: spacerRef.current,
-                    viewport,
-                });
-                // A short last turn already fits below the anchor, so opening at the end
-                // shows the whole turn without leaving a blank gap beneath it.
-                const lastTurnFits = contentBottom - anchorTop <= viewport.clientHeight;
-                handled = lastTurnFits
-                    ? scrollToEnd({ behavior: "auto" })
-                    : scrollToElement(anchor, { align: "start" }, { keepPreviousPeek: true });
-            }
-        }
-        else {
-            handled =
-                defaultScrollPosition === "end"
-                    ? scrollToEnd({ behavior: "auto" })
-                    : scrollToStart({ behavior: "auto" });
-        }
-        if (!handled) {
-            return false;
-        }
-        defaultScrollPositionAppliedRef.current = true;
-        return true;
-    }, [defaultScrollPosition, scrollToElement, scrollToEnd, scrollToStart]);
-    const handleContentChange = React.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;
-        // Reconcile the scroll position with the new content. Every path re-captures
-        // the prepend anchor afterward, so each branch just returns.
-        //
-        // Branch order is load-bearing: first-content, prepended, appended, updated.
-        const reconcileScrollPosition = () => {
-            if (flushPendingScrollToMessage()) {
-                return;
-            }
-            if (previousItemCount === 0) {
-                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) {
-                // Prepended rows are not new appends. Restore the prior scroll position.
-                // The restore is a no-op where native scroll anchoring already did it.
-                restorePrependedAnchor();
-                return;
-            }
-            if (items.length > previousItemCount) {
-                const anchor = getNewScrollAnchor(items, previousItemCount);
-                if (anchor) {
-                    // While the reader is following the live end, a batch of several
-                    // anchored turns arriving at once should keep following the end — not
-                    // yank back to anchor the first turn of the batch. A single new anchor
-                    // still moves to the top as usual.
-                    if (autoScrollRef.current &&
-                        modeRef.current === "following-bottom" &&
-                        hasMultipleNewScrollAnchors(items, previousItemCount)) {
-                        scrollToEnd({ behavior: "auto" });
-                        return;
-                    }
-                    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;
-                }
-            }
-            // Appends with no new anchor (and content-only updates) fall through here:
-            // keep following the end if we still are, otherwise just recommit state.
-            if (modeRef.current === "following-bottom" && autoScrollRef.current) {
-                scrollToEnd({ behavior: "auto" });
-            }
-            else {
-                commitScrollState();
-                scheduleVisibilitySync();
-            }
-        };
-        reconcileScrollPosition();
-        capturePrependAnchor();
-    }, [
-        applyDefaultScrollPosition,
-        capturePrependAnchor,
-        commitScrollState,
-        flushPendingScrollToMessage,
-        restorePrependedAnchor,
-        scheduleVisibilitySync,
-        scrollToElement,
-        scrollToEnd,
-    ]);
-    const handleResize = React.useCallback(() => {
-        if (modeRef.current === "following-bottom" && autoScrollRef.current) {
-            scrollToEnd({ behavior: "auto" });
-            return;
-        }
-        // Hold the anchored turn in place as content below it resizes (a reply
-        // streaming in, or a transient marker collapsing) — otherwise the shrinking
-        // content lets the browser clamp scrollTop and the turn drops.
-        const previousSpacerHeight = spacerHeightRef.current;
-        if (reanchorToAnchoredMessage()) {
-            // The reply streaming below the anchor consumes the tail spacer as it
-            // grows. Once the last of it is gone the reply has filled the viewport
-            // and the reader is genuinely at the live edge, so autoScroll hands off
-            // from the anchor hold to following the bottom. Requiring the >0 → 0
-            // transition keeps a turn taller than the viewport (placed with no
-            // spacer) held instead of yanked to the end.
-            if (autoScrollRef.current && previousSpacerHeight > 0 && spacerHeightRef.current === 0) {
-                scrollToEnd({ behavior: "auto" });
-            }
-            return;
-        }
-        scheduleStateCommit();
-        scheduleVisibilitySync();
-    }, [reanchorToAnchoredMessage, scheduleStateCommit, scheduleVisibilitySync, scrollToEnd]);
-    const observeVisibility = React.useCallback(() => {
-        const viewport = viewportRef.current;
-        if (!viewport || !visibilityStore.hasListeners()) {
-            return;
-        }
-        if (typeof IntersectionObserver === "undefined") {
-            scheduleVisibilitySync();
-            return;
-        }
-        if (!visibilityObserverRef.current) {
-            visibilityObserverRef.current = new IntersectionObserver((entries) => {
-                for (const entry of entries) {
-                    const messageId = entry.target.dataset.messageId;
-                    if (!messageId) {
-                        continue;
-                    }
-                    if (entry.isIntersecting) {
-                        visibleMessageIdsRef.current.add(messageId);
-                    }
-                    else {
-                        visibleMessageIdsRef.current.delete(messageId);
-                    }
-                }
-                scheduleVisibilitySync();
-            }, {
-                root: viewport,
-                // Shrink the root's top edge to the anchoring line so a previous turn
-                // peeking in the scrollMargin + peek band is not reported as visible,
-                // keeping visibleMessageIds consistent with currentAnchorId. Captured
-                // at observe time; a prop change rebuilds the observer on resubscribe.
-                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 = React.useCallback(() => {
-        if (visibilityFrameRef.current !== null) {
-            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 = React.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 = React.useCallback(() => {
-        if (modeRef.current === "following-bottom" ||
-            modeRef.current === "anchored-to-message" ||
-            modeRef.current === "settling-jump") {
-            // A deliberate gesture releases auto-follow, turn-anchoring, and an in-flight
-            // programmatic jump so re-pinning (and re-arming) never fights the reader.
-            streamingTurnRef.current = null;
-            modeRef.current = "free-scrolling";
-        }
-    }, []);
-    const mirrorStateAttributes = React.useCallback(() => writeStateAttributes(stateStore.getSnapshot()), [stateStore, writeStateAttributes]);
-    const setRootElement = useElementRef(rootRef, mirrorStateAttributes);
-    const setViewportElement = useElementRef(viewportRef, mirrorStateAttributes);
-    const setContentElement = React.useCallback((element) => {
-        contentRef.current = element;
-    }, []);
-    const setSpacerElement = React.useCallback((element) => {
-        spacerRef.current = element;
-        spacerGapRef.current = getFlexGap(element?.parentElement ?? null);
-    }, []);
-    const syncAfterScroll = React.useCallback(() => {
-        commitScrollState();
-        scheduleVisibilitySync();
-        capturePrependAnchor();
-    }, [capturePrependAnchor, commitScrollState, scheduleVisibilitySync]);
-    const context = React.useMemo(() => ({
-        handleContentChange,
-        handleResize,
-        observeVisibility,
-        preserveScrollOnPrependRef,
-        scrollToEnd,
-        scrollToMessage,
-        scrollToStart,
-        setContentElement,
-        setRootElement,
-        setSpacerElement,
-        setViewportElement,
-        stateStore,
-        syncAfterScroll,
-        unobserveVisibility,
-        userScrollIntent,
-        viewportRef,
-        visibilityStore,
-    }), [
-        handleContentChange,
-        handleResize,
-        observeVisibility,
-        scrollToEnd,
-        scrollToMessage,
-        scrollToStart,
-        setContentElement,
-        setRootElement,
-        setSpacerElement,
-        setViewportElement,
-        stateStore,
-        syncAfterScroll,
-        unobserveVisibility,
-        userScrollIntent,
-        visibilityStore,
-    ]);
-    React.useLayoutEffect(() => {
-        applyDefaultScrollPosition();
-    }, [applyDefaultScrollPosition]);
-    React.useEffect(() => {
-        return () => {
-            // Reset every ref after cancelling. StrictMode replays effects on the same
-            // refs (unmount then remount), so a frame id left non-null here makes the
-            // scheduler on remount think a frame is still pending and never reschedule.
-            if (stateFrameRef.current !== null) {
-                window.cancelAnimationFrame(stateFrameRef.current);
-                stateFrameRef.current = null;
-            }
-            if (visibilityFrameRef.current !== null) {
-                window.cancelAnimationFrame(visibilityFrameRef.current);
-                visibilityFrameRef.current = null;
-            }
-            if (autoscrollingTimeoutRef.current !== null) {
-                window.clearTimeout(autoscrollingTimeoutRef.current);
-                autoscrollingTimeoutRef.current = null;
-            }
-            if (pendingScrollFrameRef.current !== null) {
-                window.cancelAnimationFrame(pendingScrollFrameRef.current);
-                pendingScrollFrameRef.current = null;
-            }
-            visibilityObserverRef.current?.disconnect();
-            visibilityObserverRef.current = null;
-        };
-    }, []);
-    React.useLayoutEffect(() => {
-        if (autoScroll && modeRef.current === "following-bottom" && itemCountRef.current > 0) {
-            scrollToEnd({ behavior: "auto" });
-            return;
-        }
-        commitScrollState();
-    }, [autoScroll, commitScrollState, scrollToEnd]);
-    return {
-        context,
-        registerMessage,
-    };
-}
-export { useMessageScrollerController };

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

@@ -1,49 +0,0 @@
-import * as React from "react";
-import type { 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>;
-    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, scrollEdgeThreshold, scrollMargin, scrollPreviousItemPeek, }: {
-    autoScroll: boolean;
-    scrollEdgeThreshold: number;
-    scrollMargin: number;
-    scrollPreviousItemPeek: number;
-}): MessageScrollerRefs;
-export { useMessageScrollerRefs };
-export type { MessageScrollerRefs };
-//# sourceMappingURL=use-message-scroller-refs.d.ts.map

package/dist/lib/message-scroller-primitive/use-message-scroller-refs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-message-scroller-refs.d.ts","sourceRoot":"","sources":["../../../src/lib/message-scroller-primitive/use-message-scroller-refs.ts"],"names":[],"mappings":"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"}

package/dist/lib/message-scroller-primitive/use-message-scroller-refs.js

@@ -1,90 +0,0 @@
-// Vendored from @shadcn/react 0.2.1 (upstream github.com/shadcn-ui).
-// Adapted only for repo import paths and formatting; not added as an npm dependency.
-import * as React from "react";
-import { areScrollStatesEqual, createMessageScrollerStore, createMessageScrollerVisibilityStore, } from "./stores.js";
-import { EMPTY_MESSAGE_SCROLLER_SCROLLABLE } from "./types.js";
-// Builds the per-instance ref bag: the two external stores constructed once, and
-// the latest prop values mirrored onto refs each render so callbacks stay stable.
-function useMessageScrollerRefs({ autoScroll, scrollEdgeThreshold, scrollMargin, scrollPreviousItemPeek, }) {
-    const autoScrollRef = React.useRef(autoScroll);
-    const autoscrollingRef = React.useRef(false);
-    const contentRef = React.useRef(null);
-    const defaultScrollPositionAppliedRef = React.useRef(false);
-    const scrollEdgeThresholdRef = React.useRef(scrollEdgeThreshold);
-    const itemCountRef = React.useRef(0);
-    const firstItemRef = React.useRef(null);
-    // The scrollTop seen by the previous state commit, so follow-release can tell
-    // a reader scrolling up from content growing past the live edge.
-    const lastScrollTopRef = React.useRef(0);
-    const modeRef = React.useRef(autoScroll ? "following-bottom" : "free-scrolling");
-    const messageElementsRef = React.useRef(new Map());
-    const pendingScrollToMessageRef = React.useRef(null);
-    // The row to hold steady on the next prepend: the first visible row, or a jump
-    // target seeded by scrollToElement. restorePrependedAnchor reads only this.
-    const prependRestoreRef = React.useRef(null);
-    // The turn held at the reading line so a reply streaming in below it can re-pin
-    // it instead of letting scrollTop clamp it loose.
-    const streamingTurnRef = React.useRef(null);
-    const scrollPreviousItemPeekRef = React.useRef(scrollPreviousItemPeek);
-    const preserveScrollOnPrependRef = React.useRef(true);
-    const rootRef = React.useRef(null);
-    const scrollMarginRef = React.useRef(scrollMargin);
-    const pendingScrollFrameRef = React.useRef(null);
-    const spacerGapRef = React.useRef(0);
-    const spacerHeightRef = React.useRef(0);
-    const spacerRef = React.useRef(null);
-    const stateFrameRef = React.useRef(null);
-    const stateStoreRef = React.useRef(null);
-    const autoscrollingTimeoutRef = React.useRef(null);
-    const viewportRef = React.useRef(null);
-    const visibilityFrameRef = React.useRef(null);
-    const visibilityObserverRef = React.useRef(null);
-    const visibilityStoreRef = React.useRef(null);
-    const visibleMessageIdsRef = React.useRef(new Set());
-    const handledScrollAnchorsRef = React.useRef(new WeakSet());
-    if (stateStoreRef.current === null) {
-        stateStoreRef.current = createMessageScrollerStore(EMPTY_MESSAGE_SCROLLER_SCROLLABLE, areScrollStatesEqual);
-    }
-    if (visibilityStoreRef.current === null) {
-        visibilityStoreRef.current = createMessageScrollerVisibilityStore();
-    }
-    // Track the latest prop values on every render so callbacks read fresh values
-    // without being recreated (the useLatest pattern).
-    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,
-        rootRef,
-        scrollEdgeThresholdRef,
-        scrollMarginRef,
-        scrollPreviousItemPeekRef,
-        spacerGapRef,
-        spacerHeightRef,
-        spacerRef,
-        stateFrameRef,
-        stateStore: stateStoreRef.current,
-        viewportRef,
-        visibilityFrameRef,
-        visibilityObserverRef,
-        visibilityStore: visibilityStoreRef.current,
-        visibleMessageIdsRef,
-        handledScrollAnchorsRef,
-    };
-}
-export { useMessageScrollerRefs };

package/dist/lib/message-scroller-primitive/use-render.d.ts

@@ -1,22 +0,0 @@
-import * as React from "react";
-type RenderState = Record<string, unknown>;
-type RenderFunction<TState extends RenderState> = (props: Record<string, unknown>, state: TState) => React.ReactElement | null;
-type RenderProp<TState extends RenderState> = React.ReactElement | RenderFunction<TState>;
-type StateAttributesMapping<TState extends RenderState> = Partial<{
-    [K in keyof TState]: (value: TState[K]) => Record<string, string | undefined> | null | undefined;
-}>;
-type UseRenderComponentProps<TElement extends React.ElementType, TState extends RenderState = RenderState> = React.ComponentPropsWithRef<TElement> & {
-    render?: RenderProp<TState>;
-};
-type UseRenderOptions<TElement extends React.ElementType, TState extends RenderState> = {
-    defaultTagName: TElement;
-    props?: React.ComponentPropsWithRef<TElement>;
-    render?: RenderProp<TState>;
-    state?: TState;
-    stateAttributesMapping?: StateAttributesMapping<TState>;
-};
-declare function useRender<TElement extends React.ElementType, TState extends RenderState = RenderState>({ defaultTagName, props, render, state, stateAttributesMapping, }: UseRenderOptions<TElement, TState>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-declare function mergeProps<TElement extends React.ElementType>(...sources: Array<React.ComponentPropsWithRef<TElement> | Record<string, unknown> | undefined>): React.ComponentPropsWithRef<TElement>;
-declare function composeRefs<T>(...refs: Array<React.Ref<T> | undefined>): React.RefCallback<T> | undefined;
-export { composeRefs, mergeProps, useRender, type UseRenderComponentProps };
-//# sourceMappingURL=use-render.d.ts.map