@uipath/apollo-wind 2.66.1 → 2.67.0

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

@@ -0,0 +1,232 @@
+"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__, {
+    hasMultipleNewScrollAnchors: ()=>hasMultipleNewScrollAnchors,
+    getMessageScrollerVisibilityState: ()=>getMessageScrollerVisibilityState,
+    getUnanchoredScrollAnchor: ()=>getUnanchoredScrollAnchor,
+    getContentBottom: ()=>getContentBottom,
+    getFirstVisibleMessageItem: ()=>getFirstVisibleMessageItem,
+    getMessageScrollerItems: ()=>getMessageScrollerItems,
+    getElementScrollTop: ()=>getElementScrollTop,
+    getFlexGap: ()=>getFlexGap,
+    getElementTop: ()=>getElementTop,
+    getLastScrollAnchor: ()=>getLastScrollAnchor,
+    getTailSpacerHeight: ()=>getTailSpacerHeight,
+    getElementViewportTop: ()=>getElementViewportTop,
+    getContentBlockPadding: ()=>getContentBlockPadding,
+    getMaxScrollTop: ()=>getMaxScrollTop,
+    getMessageScrollerScrollable: ()=>getMessageScrollerScrollable,
+    getNewScrollAnchor: ()=>getNewScrollAnchor
+});
+const external_types_cjs_namespaceObject = require("./types.cjs");
+function getMessageScrollerScrollable({ content, scrollEdgeThreshold, spacer, viewport }) {
+    if (!viewport || !content) return external_types_cjs_namespaceObject.EMPTY_MESSAGE_SCROLLER_SCROLLABLE;
+    const contentBottom = getContentBottom({
+        content,
+        spacer,
+        viewport
+    });
+    return {
+        start: viewport.scrollTop > scrollEdgeThreshold,
+        end: contentBottom - viewport.scrollTop - viewport.clientHeight > scrollEdgeThreshold
+    };
+}
+function getMessageScrollerVisibilityState({ content, scrollMargin, scrollPreviousItemPeek, spacer, viewport, visibleMessageIds }) {
+    if (!content || !viewport) return external_types_cjs_namespaceObject.EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE;
+    const viewportRect = viewport.getBoundingClientRect();
+    const lineTop = viewportRect.top + scrollMargin + scrollPreviousItemPeek;
+    const trackByLayout = "u" < typeof IntersectionObserver;
+    const visible = [];
+    let currentAnchorId = null;
+    for (const item of getMessageScrollerItems(content, spacer)){
+        const messageId = item.dataset.messageId;
+        if (!messageId) continue;
+        const isAnchor = 'true' === item.dataset.scrollAnchor;
+        const rect = isAnchor || trackByLayout ? item.getBoundingClientRect() : null;
+        const isVisible = trackByLayout && rect ? rect.bottom > lineTop && rect.top < viewportRect.bottom : visibleMessageIds.has(messageId);
+        if (isVisible) visible.push(messageId);
+        if (isAnchor && rect && rect.top <= lineTop + external_types_cjs_namespaceObject.SCROLL_POSITION_EPSILON) currentAnchorId = messageId;
+    }
+    if (0 === visible.length && null === currentAnchorId) return external_types_cjs_namespaceObject.EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE;
+    return {
+        currentAnchorId,
+        visibleMessageIds: visible
+    };
+}
+function getMessageScrollerItems(content, spacer) {
+    return Array.from(content.children).filter((child)=>child instanceof HTMLElement && child !== spacer);
+}
+function getNewScrollAnchor(items, previousItemCount) {
+    for(let index = previousItemCount; index < items.length; index++){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') return item;
+    }
+    return null;
+}
+function getUnanchoredScrollAnchor(items, handledAnchors) {
+    for (const item of items)if ('true' === item.dataset.scrollAnchor && !handledAnchors.has(item)) return item;
+    return null;
+}
+function hasMultipleNewScrollAnchors(items, previousItemCount) {
+    let count = 0;
+    for(let index = previousItemCount; index < items.length; index++){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') {
+            count += 1;
+            if (count > 1) return true;
+        }
+    }
+    return false;
+}
+function getLastScrollAnchor(items) {
+    for(let index = items.length - 1; index >= 0; index--){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') return item;
+    }
+    return null;
+}
+function getFirstVisibleMessageItem({ content, spacer, viewport }) {
+    const viewportRect = viewport.getBoundingClientRect();
+    for (const item of getMessageScrollerItems(content, spacer)){
+        if (!item.dataset.messageId) continue;
+        const rect = item.getBoundingClientRect();
+        if (rect.bottom > viewportRect.top && rect.top < viewportRect.bottom) return item;
+    }
+    return null;
+}
+function getElementScrollTop({ align, element, scrollMargin, spacer, viewport }) {
+    const elementTop = getElementTop(element, viewport);
+    const elementHeight = element.getBoundingClientRect().height;
+    const contentPadding = getContentBlockPadding(spacer);
+    if ('center' === align) {
+        const insetHeight = Math.max(0, viewport.clientHeight - contentPadding.start - contentPadding.end);
+        return elementTop - contentPadding.start - (insetHeight - elementHeight) / 2 - scrollMargin;
+    }
+    if ('end' === align) return elementTop - viewport.clientHeight + elementHeight + contentPadding.end + scrollMargin;
+    if ('nearest' === align) {
+        const elementBottom = elementTop + elementHeight;
+        const viewportTop = viewport.scrollTop + contentPadding.start;
+        const viewportBottom = viewport.scrollTop + viewport.clientHeight - contentPadding.end;
+        if (elementTop >= viewportTop && elementBottom <= viewportBottom) return viewport.scrollTop;
+        if (elementTop < viewportTop) return elementTop - contentPadding.start - scrollMargin;
+        return elementBottom - viewport.clientHeight + contentPadding.end + scrollMargin;
+    }
+    return elementTop - contentPadding.start - scrollMargin;
+}
+function getElementTop(element, viewport) {
+    const elementRect = element.getBoundingClientRect();
+    const viewportRect = viewport.getBoundingClientRect();
+    return elementRect.top - viewportRect.top + viewport.scrollTop;
+}
+function getElementViewportTop(element, viewport) {
+    return element.getBoundingClientRect().top - viewport.getBoundingClientRect().top;
+}
+function getTailSpacerHeight({ content, scrollTop, spacer, viewport }) {
+    const contentBottom = getContentBottom({
+        content,
+        spacer,
+        viewport
+    });
+    return scrollTop + viewport.clientHeight - contentBottom;
+}
+function getContentBottom({ content, spacer, viewport }) {
+    const items = getMessageScrollerItems(content, spacer);
+    const padding = getBlockPadding(content);
+    const viewportRect = viewport.getBoundingClientRect();
+    const scrollTop = viewport.scrollTop;
+    let contentBottom = padding.start + padding.end;
+    for (const item of items){
+        const rect = item.getBoundingClientRect();
+        contentBottom = Math.max(contentBottom, rect.bottom - viewportRect.top + scrollTop + padding.end);
+    }
+    return contentBottom;
+}
+function getMaxScrollTop(viewport) {
+    return Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+}
+function getBlockPadding(element) {
+    const style = window.getComputedStyle(element);
+    return {
+        end: readCssPixel(style.paddingBlockEnd || style.paddingBottom),
+        start: readCssPixel(style.paddingBlockStart || style.paddingTop)
+    };
+}
+function getContentBlockPadding(spacer) {
+    const content = spacer?.parentElement;
+    if (!content) return {
+        end: 0,
+        start: 0
+    };
+    return getBlockPadding(content);
+}
+function getFlexGap(element) {
+    if (!element) return 0;
+    const style = window.getComputedStyle(element);
+    const gap = 'normal' === style.rowGap ? style.gap : style.rowGap;
+    return readCssPixel(gap);
+}
+function readCssPixel(value) {
+    if (!value) return 0;
+    const number = Number.parseFloat(value);
+    return Number.isFinite(number) ? number : 0;
+}
+exports.getContentBlockPadding = __webpack_exports__.getContentBlockPadding;
+exports.getContentBottom = __webpack_exports__.getContentBottom;
+exports.getElementScrollTop = __webpack_exports__.getElementScrollTop;
+exports.getElementTop = __webpack_exports__.getElementTop;
+exports.getElementViewportTop = __webpack_exports__.getElementViewportTop;
+exports.getFirstVisibleMessageItem = __webpack_exports__.getFirstVisibleMessageItem;
+exports.getFlexGap = __webpack_exports__.getFlexGap;
+exports.getLastScrollAnchor = __webpack_exports__.getLastScrollAnchor;
+exports.getMaxScrollTop = __webpack_exports__.getMaxScrollTop;
+exports.getMessageScrollerItems = __webpack_exports__.getMessageScrollerItems;
+exports.getMessageScrollerScrollable = __webpack_exports__.getMessageScrollerScrollable;
+exports.getMessageScrollerVisibilityState = __webpack_exports__.getMessageScrollerVisibilityState;
+exports.getNewScrollAnchor = __webpack_exports__.getNewScrollAnchor;
+exports.getTailSpacerHeight = __webpack_exports__.getTailSpacerHeight;
+exports.getUnanchoredScrollAnchor = __webpack_exports__.getUnanchoredScrollAnchor;
+exports.hasMultipleNewScrollAnchors = __webpack_exports__.hasMultipleNewScrollAnchors;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getContentBlockPadding",
+    "getContentBottom",
+    "getElementScrollTop",
+    "getElementTop",
+    "getElementViewportTop",
+    "getFirstVisibleMessageItem",
+    "getFlexGap",
+    "getLastScrollAnchor",
+    "getMaxScrollTop",
+    "getMessageScrollerItems",
+    "getMessageScrollerScrollable",
+    "getMessageScrollerVisibilityState",
+    "getNewScrollAnchor",
+    "getTailSpacerHeight",
+    "getUnanchoredScrollAnchor",
+    "hasMultipleNewScrollAnchors"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,54 @@
+import type { MessageScrollerScrollAlign, MessageScrollerScrollable, MessageScrollerVisibilityState } from './types';
+declare function getMessageScrollerScrollable({ content, scrollEdgeThreshold, spacer, viewport, }: {
+    content: HTMLElement | null;
+    scrollEdgeThreshold: number;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement | null;
+}): MessageScrollerScrollable;
+declare function getMessageScrollerVisibilityState({ content, scrollMargin, scrollPreviousItemPeek, spacer, viewport, visibleMessageIds, }: {
+    content: HTMLElement | null;
+    scrollMargin: number;
+    scrollPreviousItemPeek: number;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement | null;
+    visibleMessageIds: Set<string>;
+}): MessageScrollerVisibilityState;
+declare function getMessageScrollerItems(content: HTMLElement, spacer: HTMLElement | null): HTMLElement[];
+declare function getNewScrollAnchor(items: HTMLElement[], previousItemCount: number): HTMLElement | null;
+declare function getUnanchoredScrollAnchor(items: HTMLElement[], handledAnchors: {
+    has(element: HTMLElement): boolean;
+}): HTMLElement | null;
+declare function hasMultipleNewScrollAnchors(items: HTMLElement[], previousItemCount: number): boolean;
+declare function getLastScrollAnchor(items: HTMLElement[]): HTMLElement | null;
+declare function getFirstVisibleMessageItem({ content, spacer, viewport, }: {
+    content: HTMLElement;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement;
+}): HTMLElement | null;
+declare function getElementScrollTop({ align, element, scrollMargin, spacer, viewport, }: {
+    align: MessageScrollerScrollAlign;
+    element: HTMLElement;
+    scrollMargin: number;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement;
+}): number;
+declare function getElementTop(element: HTMLElement, viewport: HTMLElement): number;
+declare function getElementViewportTop(element: HTMLElement, viewport: HTMLElement): number;
+declare function getTailSpacerHeight({ content, scrollTop, spacer, viewport, }: {
+    content: HTMLElement;
+    scrollTop: number;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement;
+}): number;
+declare function getContentBottom({ content, spacer, viewport, }: {
+    content: HTMLElement;
+    spacer: HTMLElement | null;
+    viewport: HTMLElement;
+}): number;
+declare function getMaxScrollTop(viewport: HTMLElement): number;
+declare function getContentBlockPadding(spacer: HTMLElement | null): {
+    end: number;
+    start: number;
+};
+declare function getFlexGap(element: HTMLElement | null): number;
+export { getContentBlockPadding, getContentBottom, getElementScrollTop, getElementTop, getElementViewportTop, getFirstVisibleMessageItem, getFlexGap, getLastScrollAnchor, getMaxScrollTop, getMessageScrollerItems, getMessageScrollerScrollable, getMessageScrollerVisibilityState, getNewScrollAnchor, getTailSpacerHeight, getUnanchoredScrollAnchor, hasMultipleNewScrollAnchors, };

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

@@ -0,0 +1,153 @@
+import { EMPTY_MESSAGE_SCROLLER_SCROLLABLE, EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, SCROLL_POSITION_EPSILON } from "./types.js";
+function getMessageScrollerScrollable({ content, scrollEdgeThreshold, spacer, viewport }) {
+    if (!viewport || !content) return EMPTY_MESSAGE_SCROLLER_SCROLLABLE;
+    const contentBottom = getContentBottom({
+        content,
+        spacer,
+        viewport
+    });
+    return {
+        start: viewport.scrollTop > scrollEdgeThreshold,
+        end: contentBottom - viewport.scrollTop - viewport.clientHeight > scrollEdgeThreshold
+    };
+}
+function getMessageScrollerVisibilityState({ content, scrollMargin, scrollPreviousItemPeek, spacer, viewport, visibleMessageIds }) {
+    if (!content || !viewport) return EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE;
+    const viewportRect = viewport.getBoundingClientRect();
+    const lineTop = viewportRect.top + scrollMargin + scrollPreviousItemPeek;
+    const trackByLayout = "u" < typeof IntersectionObserver;
+    const visible = [];
+    let currentAnchorId = null;
+    for (const item of getMessageScrollerItems(content, spacer)){
+        const messageId = item.dataset.messageId;
+        if (!messageId) continue;
+        const isAnchor = 'true' === item.dataset.scrollAnchor;
+        const rect = isAnchor || trackByLayout ? item.getBoundingClientRect() : null;
+        const isVisible = trackByLayout && rect ? rect.bottom > lineTop && rect.top < viewportRect.bottom : visibleMessageIds.has(messageId);
+        if (isVisible) visible.push(messageId);
+        if (isAnchor && rect && rect.top <= lineTop + SCROLL_POSITION_EPSILON) currentAnchorId = messageId;
+    }
+    if (0 === visible.length && null === currentAnchorId) return EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE;
+    return {
+        currentAnchorId,
+        visibleMessageIds: visible
+    };
+}
+function getMessageScrollerItems(content, spacer) {
+    return Array.from(content.children).filter((child)=>child instanceof HTMLElement && child !== spacer);
+}
+function getNewScrollAnchor(items, previousItemCount) {
+    for(let index = previousItemCount; index < items.length; index++){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') return item;
+    }
+    return null;
+}
+function getUnanchoredScrollAnchor(items, handledAnchors) {
+    for (const item of items)if ('true' === item.dataset.scrollAnchor && !handledAnchors.has(item)) return item;
+    return null;
+}
+function hasMultipleNewScrollAnchors(items, previousItemCount) {
+    let count = 0;
+    for(let index = previousItemCount; index < items.length; index++){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') {
+            count += 1;
+            if (count > 1) return true;
+        }
+    }
+    return false;
+}
+function getLastScrollAnchor(items) {
+    for(let index = items.length - 1; index >= 0; index--){
+        const item = items[index];
+        if (item?.dataset.scrollAnchor === 'true') return item;
+    }
+    return null;
+}
+function getFirstVisibleMessageItem({ content, spacer, viewport }) {
+    const viewportRect = viewport.getBoundingClientRect();
+    for (const item of getMessageScrollerItems(content, spacer)){
+        if (!item.dataset.messageId) continue;
+        const rect = item.getBoundingClientRect();
+        if (rect.bottom > viewportRect.top && rect.top < viewportRect.bottom) return item;
+    }
+    return null;
+}
+function getElementScrollTop({ align, element, scrollMargin, spacer, viewport }) {
+    const elementTop = getElementTop(element, viewport);
+    const elementHeight = element.getBoundingClientRect().height;
+    const contentPadding = getContentBlockPadding(spacer);
+    if ('center' === align) {
+        const insetHeight = Math.max(0, viewport.clientHeight - contentPadding.start - contentPadding.end);
+        return elementTop - contentPadding.start - (insetHeight - elementHeight) / 2 - scrollMargin;
+    }
+    if ('end' === align) return elementTop - viewport.clientHeight + elementHeight + contentPadding.end + scrollMargin;
+    if ('nearest' === align) {
+        const elementBottom = elementTop + elementHeight;
+        const viewportTop = viewport.scrollTop + contentPadding.start;
+        const viewportBottom = viewport.scrollTop + viewport.clientHeight - contentPadding.end;
+        if (elementTop >= viewportTop && elementBottom <= viewportBottom) return viewport.scrollTop;
+        if (elementTop < viewportTop) return elementTop - contentPadding.start - scrollMargin;
+        return elementBottom - viewport.clientHeight + contentPadding.end + scrollMargin;
+    }
+    return elementTop - contentPadding.start - scrollMargin;
+}
+function getElementTop(element, viewport) {
+    const elementRect = element.getBoundingClientRect();
+    const viewportRect = viewport.getBoundingClientRect();
+    return elementRect.top - viewportRect.top + viewport.scrollTop;
+}
+function getElementViewportTop(element, viewport) {
+    return element.getBoundingClientRect().top - viewport.getBoundingClientRect().top;
+}
+function getTailSpacerHeight({ content, scrollTop, spacer, viewport }) {
+    const contentBottom = getContentBottom({
+        content,
+        spacer,
+        viewport
+    });
+    return scrollTop + viewport.clientHeight - contentBottom;
+}
+function getContentBottom({ content, spacer, viewport }) {
+    const items = getMessageScrollerItems(content, spacer);
+    const padding = getBlockPadding(content);
+    const viewportRect = viewport.getBoundingClientRect();
+    const scrollTop = viewport.scrollTop;
+    let contentBottom = padding.start + padding.end;
+    for (const item of items){
+        const rect = item.getBoundingClientRect();
+        contentBottom = Math.max(contentBottom, rect.bottom - viewportRect.top + scrollTop + padding.end);
+    }
+    return contentBottom;
+}
+function getMaxScrollTop(viewport) {
+    return Math.max(0, viewport.scrollHeight - viewport.clientHeight);
+}
+function getBlockPadding(element) {
+    const style = window.getComputedStyle(element);
+    return {
+        end: readCssPixel(style.paddingBlockEnd || style.paddingBottom),
+        start: readCssPixel(style.paddingBlockStart || style.paddingTop)
+    };
+}
+function getContentBlockPadding(spacer) {
+    const content = spacer?.parentElement;
+    if (!content) return {
+        end: 0,
+        start: 0
+    };
+    return getBlockPadding(content);
+}
+function getFlexGap(element) {
+    if (!element) return 0;
+    const style = window.getComputedStyle(element);
+    const gap = 'normal' === style.rowGap ? style.gap : style.rowGap;
+    return readCssPixel(gap);
+}
+function readCssPixel(value) {
+    if (!value) return 0;
+    const number = Number.parseFloat(value);
+    return Number.isFinite(number) ? number : 0;
+}
+export { getContentBlockPadding, getContentBottom, getElementScrollTop, getElementTop, getElementViewportTop, getFirstVisibleMessageItem, getFlexGap, getLastScrollAnchor, getMaxScrollTop, getMessageScrollerItems, getMessageScrollerScrollable, getMessageScrollerVisibilityState, getNewScrollAnchor, getTailSpacerHeight, getUnanchoredScrollAnchor, hasMultipleNewScrollAnchors };

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

@@ -0,0 +1,53 @@
+"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__, {
+    useMessageScrollerVisibility: ()=>external_components_cjs_namespaceObject.useMessageScrollerVisibility,
+    MessageScroller: ()=>MessageScroller,
+    useMessageScroller: ()=>external_components_cjs_namespaceObject.useMessageScroller,
+    useMessageScrollerScrollable: ()=>external_components_cjs_namespaceObject.useMessageScrollerScrollable
+});
+const external_components_cjs_namespaceObject = require("./components.cjs");
+const MessageScroller = {
+    Provider: external_components_cjs_namespaceObject.MessageScrollerProvider,
+    Root: external_components_cjs_namespaceObject.MessageScroller,
+    Viewport: external_components_cjs_namespaceObject.MessageScrollerViewport,
+    Content: external_components_cjs_namespaceObject.MessageScrollerContent,
+    Item: external_components_cjs_namespaceObject.MessageScrollerItem,
+    Button: external_components_cjs_namespaceObject.MessageScrollerButton
+};
+exports.MessageScroller = __webpack_exports__.MessageScroller;
+exports.useMessageScroller = __webpack_exports__.useMessageScroller;
+exports.useMessageScrollerScrollable = __webpack_exports__.useMessageScrollerScrollable;
+exports.useMessageScrollerVisibility = __webpack_exports__.useMessageScrollerVisibility;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "MessageScroller",
+    "useMessageScroller",
+    "useMessageScrollerScrollable",
+    "useMessageScrollerVisibility"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,23 @@
+import { MessageScrollerProvider as Provider } from './components';
+export declare const MessageScroller: {
+    Provider: typeof Provider;
+    Root: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Viewport: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        preserveScrollOnPrepend?: boolean;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        spacerClassName?: string;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        messageId?: string;
+        scrollAnchor?: boolean;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    Button: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        render?: (import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | ((props: Record<string, unknown>, state: import("./types").MessageScrollerButtonRenderState) => React.ReactElement | null)) | undefined;
+    } & {
+        behavior?: ScrollBehavior;
+        direction?: import("./types").MessageScrollerButtonDirection;
+    } & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export { useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility, } from './components';
+export type { MessageScrollerDefaultScrollPosition, MessageScrollerScrollAlign, MessageScrollerScrollable, MessageScrollerScrollOptions, MessageScrollerVisibilityState, } from './types';

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

@@ -0,0 +1,10 @@
+import { MessageScroller, MessageScrollerButton, MessageScrollerContent, MessageScrollerItem, MessageScrollerProvider, MessageScrollerViewport, useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility } from "./components.js";
+const primitive_MessageScroller = {
+    Provider: MessageScrollerProvider,
+    Root: MessageScroller,
+    Viewport: MessageScrollerViewport,
+    Content: MessageScrollerContent,
+    Item: MessageScrollerItem,
+    Button: MessageScrollerButton
+};
+export { primitive_MessageScroller as MessageScroller, useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility };

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

@@ -0,0 +1,81 @@
+"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__, {
+    createMessageScrollerVisibilityStore: ()=>createMessageScrollerVisibilityStore,
+    areVisibilityStatesEqual: ()=>areVisibilityStatesEqual,
+    areScrollStatesEqual: ()=>areScrollStatesEqual,
+    createMessageScrollerStore: ()=>createMessageScrollerStore
+});
+const external_types_cjs_namespaceObject = require("./types.cjs");
+function createExternalStore(initialSnapshot, isEqual) {
+    let snapshot = initialSnapshot;
+    const listeners = new Set();
+    return {
+        getSnapshot: ()=>snapshot,
+        hasListeners: ()=>listeners.size > 0,
+        setSnapshot: (nextSnapshot)=>{
+            if (isEqual(snapshot, nextSnapshot)) return;
+            snapshot = nextSnapshot;
+            for (const listener of listeners)listener();
+        },
+        subscribe: (listener, onFirstSubscribe, onLastUnsubscribe)=>{
+            const wasEmpty = 0 === listeners.size;
+            listeners.add(listener);
+            if (wasEmpty) onFirstSubscribe?.();
+            return ()=>{
+                listeners.delete(listener);
+                if (0 === listeners.size) onLastUnsubscribe?.();
+            };
+        }
+    };
+}
+function createMessageScrollerStore(initialSnapshot, isEqual) {
+    return createExternalStore(initialSnapshot, isEqual);
+}
+function createMessageScrollerVisibilityStore() {
+    return createExternalStore(external_types_cjs_namespaceObject.EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, areVisibilityStatesEqual);
+}
+function areScrollStatesEqual(current, next) {
+    return current.start === next.start && current.end === next.end;
+}
+function areVisibilityStatesEqual(current, next) {
+    if (current.currentAnchorId !== next.currentAnchorId) return false;
+    if (current.visibleMessageIds.length !== next.visibleMessageIds.length) return false;
+    return current.visibleMessageIds.every((messageId, index)=>messageId === next.visibleMessageIds[index]);
+}
+exports.areScrollStatesEqual = __webpack_exports__.areScrollStatesEqual;
+exports.areVisibilityStatesEqual = __webpack_exports__.areVisibilityStatesEqual;
+exports.createMessageScrollerStore = __webpack_exports__.createMessageScrollerStore;
+exports.createMessageScrollerVisibilityStore = __webpack_exports__.createMessageScrollerVisibilityStore;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "areScrollStatesEqual",
+    "areVisibilityStatesEqual",
+    "createMessageScrollerStore",
+    "createMessageScrollerVisibilityStore"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,6 @@
+import type { MessageScrollerScrollable, MessageScrollerStore, MessageScrollerVisibilityState, MessageScrollerVisibilityStore } from './types';
+declare function createMessageScrollerStore<T>(initialSnapshot: T, isEqual: (a: T, b: T) => boolean): MessageScrollerStore<T>;
+declare function createMessageScrollerVisibilityStore(): MessageScrollerVisibilityStore;
+declare function areScrollStatesEqual(current: MessageScrollerScrollable, next: MessageScrollerScrollable): boolean;
+declare function areVisibilityStatesEqual(current: MessageScrollerVisibilityState, next: MessageScrollerVisibilityState): boolean;
+export { areScrollStatesEqual, areVisibilityStatesEqual, createMessageScrollerStore, createMessageScrollerVisibilityStore, };

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

@@ -0,0 +1,38 @@
+import { EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE } from "./types.js";
+function createExternalStore(initialSnapshot, isEqual) {
+    let snapshot = initialSnapshot;
+    const listeners = new Set();
+    return {
+        getSnapshot: ()=>snapshot,
+        hasListeners: ()=>listeners.size > 0,
+        setSnapshot: (nextSnapshot)=>{
+            if (isEqual(snapshot, nextSnapshot)) return;
+            snapshot = nextSnapshot;
+            for (const listener of listeners)listener();
+        },
+        subscribe: (listener, onFirstSubscribe, onLastUnsubscribe)=>{
+            const wasEmpty = 0 === listeners.size;
+            listeners.add(listener);
+            if (wasEmpty) onFirstSubscribe?.();
+            return ()=>{
+                listeners.delete(listener);
+                if (0 === listeners.size) onLastUnsubscribe?.();
+            };
+        }
+    };
+}
+function createMessageScrollerStore(initialSnapshot, isEqual) {
+    return createExternalStore(initialSnapshot, isEqual);
+}
+function createMessageScrollerVisibilityStore() {
+    return createExternalStore(EMPTY_MESSAGE_SCROLLER_VISIBILITY_STATE, areVisibilityStatesEqual);
+}
+function areScrollStatesEqual(current, next) {
+    return current.start === next.start && current.end === next.end;
+}
+function areVisibilityStatesEqual(current, next) {
+    if (current.currentAnchorId !== next.currentAnchorId) return false;
+    if (current.visibleMessageIds.length !== next.visibleMessageIds.length) return false;
+    return current.visibleMessageIds.every((messageId, index)=>messageId === next.visibleMessageIds[index]);
+}
+export { areScrollStatesEqual, areVisibilityStatesEqual, createMessageScrollerStore, createMessageScrollerVisibilityStore };