@nadicodeai/ui 0.6.0 → 0.8.0

package/dist/lib/message-scroller-primitive/types.js

@@ -0,0 +1,40 @@
+// 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.
+// Default scrollEdgeThreshold. Sub-pixel tolerance so edge detection does not
+// flicker across engines that round scrollTop differently.
+const DEFAULT_SCROLL_EDGE_THRESHOLD = 8;
+// Default scrollPreviousItemPeek. Pixels of the previous item kept visible above
+// a newly anchored row.
+const DEFAULT_SCROLL_PREVIOUS_ITEM_PEEK = 64;
+// Default scrollMargin for scrollToMessage and programmatic targets.
+const DEFAULT_SCROLL_MARGIN = 0;
+// Two fractional scrollTop values within this range are treated as equal, to
+// absorb zoom and HiDPI rounding drift.
+const SCROLL_POSITION_EPSILON = 0.5;
+// How long (ms) data-autoscrolling stays set during a programmatic smooth scroll
+// before clearing.
+const AUTOSCROLLING_CLEAR_DELAY = 180;
+// Viewport keys that count as deliberate scroll intent and release follow-bottom.
+const USER_SCROLL_KEYS = new Set([
+    "ArrowDown",
+    "ArrowUp",
+    "End",
+    "Home",
+    "PageDown",
+    "PageUp",
+    " ", // Space key.
+]);
+// Initial MessageScrollerScrollable before measurement. Stable reference for the
+// server and first-render snapshot.
+const EMPTY_MESSAGE_SCROLLER_SCROLLABLE = {
+    start: false,
+    end: false,
+};
+// Shared empty array so empty visibility snapshots stay referentially stable.
+const EMPTY_VISIBLE_MESSAGE_IDS = [];
+// Initial MessageScrollerVisibilityState. Nothing tracked, no current anchor.
+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/lib/message-scroller-primitive/use-message-scroller-commands.d.ts

@@ -0,0 +1,19 @@
+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 };
+//# sourceMappingURL=use-message-scroller-commands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-message-scroller-commands.d.ts","sourceRoot":"","sources":["../../../src/lib/message-scroller-primitive/use-message-scroller-commands.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAKvE,iBAAS,0BAA0B,CAAC,EAClC,IAAI,EACJ,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,GACvB,EAAE;IACD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,mBAAmB,EAAE,MAAM,IAAI,CAAC;IAChC,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACpC;;;+BA8Ic,WAAW,uCAKjB,4BAA4B,0BAG5B;QACD,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B;iCAjCqB,4BAA4B;iCAkGxC,MAAM,YAAY,4BAA4B;mCAnHlC,4BAA4B;EAsLvD;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,188 @@
+// 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 { getElementScrollTop, getElementViewportTop, getMaxScrollTop, getTailSpacerHeight, } from "./geometry.js";
+import { AUTOSCROLLING_CLEAR_DELAY, SCROLL_POSITION_EPSILON } from "./types.js";
+// Imperative scroll primitives, split from the controller so the move mechanics
+// live apart from the policy that decides when to run them. Each command resolves
+// a target scrollTop and returns false when the viewport is not mounted yet.
+function useMessageScrollerCommands({ refs, commitScrollState, scheduleStateCommit, scheduleVisibilitySync, }) {
+    const { streamingTurnRef, autoScrollRef, autoscrollingRef, autoscrollingTimeoutRef, contentRef, defaultScrollPositionAppliedRef, itemCountRef, messageElementsRef, modeRef, pendingScrollToMessageRef, prependRestoreRef, scrollMarginRef, scrollPreviousItemPeekRef, spacerGapRef, spacerHeightRef, spacerRef, viewportRef, } = refs;
+    const setAutoScrolling = React.useCallback((autoscrolling) => {
+        if (autoscrollingTimeoutRef.current !== null) {
+            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 = React.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 = nextHeight === 0;
+        spacer.style.height = `${nextHeight}px`;
+        spacer.style.marginTop = nextHeight > 0 ? `${-spacerGapRef.current}px` : "";
+    }, []);
+    const scrollToPosition = React.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 = React.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 = React.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 = React.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);
+        // Seed the prepend anchor with the jump target so a prepend that lands
+        // before this scroll settles still preserves the jumped-to row; once it
+        // settles, syncAfterScroll's capturePrependAnchor re-captures it from the
+        // first visible row.
+        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 = React.useCallback(() => {
+        const element = streamingTurnRef.current;
+        if (!element || !element.isConnected || modeRef.current !== "anchored-to-message") {
+            return false;
+        }
+        // Re-run the placement so the tail spacer is recomputed for the new content
+        // height and the turn is held at the reading line.
+        return scrollToElement(element, { align: "start" }, { keepPreviousPeek: true });
+    }, [scrollToElement]);
+    // The target row may not be mounted yet (e.g. an async-loaded transcript).
+    // When it is missing the request is queued in pendingScrollToMessageRef and
+    // flushed later — on registerMessage for that id, or on the next content
+    // change. An explicit jump also marks the mount default as applied, so
+    // defaultScrollPosition does not override it.
+    const scrollToMessage = React.useCallback((messageId, options) => {
+        const element = messageElementsRef.current.get(messageId);
+        if (!element) {
+            if (itemCountRef.current === 0) {
+                pendingScrollToMessageRef.current = {
+                    messageId,
+                    options,
+                };
+                defaultScrollPositionAppliedRef.current = true;
+                return true;
+            }
+            return false;
+        }
+        defaultScrollPositionAppliedRef.current = true;
+        if (scrollToElement(element, options)) {
+            pendingScrollToMessageRef.current = null;
+            return true;
+        }
+        pendingScrollToMessageRef.current = {
+            messageId,
+            options,
+        };
+        return true;
+    }, [scrollToElement]);
+    const flushPendingScrollToMessage = React.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;
+        defaultScrollPositionAppliedRef.current = true;
+        return true;
+    }, [scrollToElement]);
+    return {
+        flushPendingScrollToMessage,
+        reanchorToAnchoredMessage,
+        scrollToElement,
+        scrollToEnd,
+        scrollToMessage,
+        scrollToStart,
+    };
+}
+export { useMessageScrollerCommands };

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

@@ -0,0 +1,7 @@
+import type { MessageScrollerContextValue, MessageScrollerProviderProps, MessageScrollerRegisterMessage } from "./types";
+declare function useMessageScrollerController({ autoScroll, defaultScrollPosition, scrollEdgeThreshold, scrollPreviousItemPeek, scrollMargin, }: MessageScrollerProviderProps): {
+    context: MessageScrollerContextValue;
+    registerMessage: MessageScrollerRegisterMessage;
+};
+export { useMessageScrollerController };
+//# sourceMappingURL=use-message-scroller-controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-message-scroller-controller.d.ts","sourceRoot":"","sources":["../../../src/lib/message-scroller-primitive/use-message-scroller-controller.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,2BAA2B,EAC3B,4BAA4B,EAC5B,8BAA8B,EAE/B,MAAM,SAAS,CAAC;AAqBjB,iBAAS,4BAA4B,CAAC,EACpC,UAAkB,EAClB,qBAA6B,EAC7B,mBAAmD,EACnD,sBAA0D,EAC1D,YAAoC,GACrC,EAAE,4BAA4B;;;EA8nB9B;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAC"}