@king-design/vue 3.7.0 → 3.8.0-beta.0

package/components/bubbleList/item.d.ts

@@ -0,0 +1,16 @@
+import { Component, TypeDefs } from 'intact-vue-next';
+import type { BubbleRenderSlots } from '../bubble';
+import type { BubbleList, BubbleListItem as BubbleListItemData } from './bubbleList';
+export interface BubbleListItemProps {
+    item: BubbleListItemData;
+    index: number;
+    list: BubbleList;
+    slotRenderers?: BubbleRenderSlots;
+}
+export interface BubbleListItemBlocks {
+}
+export declare class BubbleListItem extends Component<BubbleListItemProps, {}, BubbleListItemBlocks> {
+    static template: string | import('intact-vue-next').Template<any>;
+    static typeDefs: Required<TypeDefs<BubbleListItemProps>>;
+    private config;
+}

package/components/bubbleList/item.js

@@ -0,0 +1,27 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { Component } from 'intact-vue-next';
+import template from './item.vdt';
+import { useConfigContext } from '../config';
+var typeDefs = {
+  item: Object,
+  index: Number,
+  list: Object,
+  slotRenderers: Object
+};
+export var BubbleListItem = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(BubbleListItem, _Component);
+  function BubbleListItem() {
+    var _context;
+    var _this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.config = useConfigContext();
+    return _this;
+  }
+  return BubbleListItem;
+}(Component);
+BubbleListItem.template = template;
+BubbleListItem.typeDefs = typeDefs;

package/components/bubbleList/item.vdt.js

@@ -0,0 +1,36 @@
+import { createElementVNode as _$ce, createUnknownComponentVNode as _$cc, className as _$cn } from 'intact-vue-next';
+import { Bubble } from '../bubble';
+export default function ($props, $blocks, $__proto__) {
+  $blocks || ($blocks = {});
+  $props || ($props = {});
+  var $this = this;
+  var _this$get = this.get(),
+    item = _this$get.item,
+    index = _this$get.index,
+    list = _this$get.list,
+    slotRenderers = _this$get.slotRenderers;
+  var _list$bubbleList = list.bubbleList,
+    getBubbleProps = _list$bubbleList.getBubbleProps,
+    getBubbleTypingHandler = _list$bubbleList.getBubbleTypingHandler,
+    getBubbleTypingCompleteHandler = _list$bubbleList.getBubbleTypingCompleteHandler;
+  var k = this.config.k;
+  var bubbleProps = getBubbleProps(item, index);
+  return _$ce(2, 'div', _$cc(Bubble, {
+    'className': _$cn(bubbleProps.className),
+    'style': bubbleProps.style,
+    'content': bubbleProps.content,
+    'placement': bubbleProps.placement,
+    'avatar': bubbleProps.avatar,
+    'roleName': bubbleProps.roleName,
+    'loading': bubbleProps.loading,
+    'streaming': bubbleProps.streaming,
+    'variant': bubbleProps.variant,
+    'shape': bubbleProps.shape,
+    'maxWidthString': bubbleProps.maxWidthString,
+    'typing': bubbleProps.typing,
+    'slotRenderers': slotRenderers,
+    'ev-typing': getBubbleTypingHandler(item, index),
+    'ev-typingComplete': getBubbleTypingCompleteHandler(item, index)
+  }), 2, _$cn(k + "-bubble-list-item"));
+}
+;

package/components/bubbleList/styles.d.ts

@@ -0,0 +1,5 @@
+import '../../styles/global';
+export declare const makeStyles: {
+    (k: string): string;
+    clearCache(): {};
+};

package/components/bubbleList/styles.js

@@ -0,0 +1,33 @@
+import { css } from '@emotion/css';
+import { theme, setDefault } from '../../styles/theme';
+import { deepDefaults, setAlpha } from '../../styles/utils';
+import '../../styles/global';
+import { cache } from '../utils';
+var defaults = {
+  gap: '12px',
+  paddingInline: '8px',
+  scrollToBottomBg: '#fff',
+  scrollToBottomColor: '#97A3B6',
+  scrollToBottomBorder: "1px solid " + setAlpha(theme.color.border, 0.72),
+  scrollToBottomShadow: "0 10px 28px " + setAlpha('#000', 0.12),
+  scrollToBottomHoverBg: '#fff',
+  scrollToBottomHoverColor: theme.color.primary,
+  scrollToBottomHoverBorder: "1px solid " + setAlpha(theme.color.primary, 0.22),
+  scrollToBottomSize: '32px',
+  scrollToBottomIconSize: '20px',
+  scrollbarTrack: 'transparent',
+  scrollThumb: 'rgba(90, 108, 129, 0.34)',
+  scrollThumbHover: 'rgba(90, 108, 129, 0.5)',
+  auxiliaryColor: theme.color.placeholder,
+  auxiliaryBg: 'transparent'
+};
+var bubbleList;
+setDefault(function () {
+  bubbleList = deepDefaults(theme, {
+    bubbleList: defaults
+  }).bubbleList;
+  makeStyles == null || makeStyles.clearCache();
+});
+export var makeStyles = cache(function makeStyles(k) {
+  return /*#__PURE__*/css("position:relative;display:flex;flex-direction:column;gap:", bubbleList.gap, ";width:100%;min-height:0;.", k, "-bubble-list-scroll{position:relative;flex:1 1 auto;min-height:0;overflow-y:auto;overflow-x:hidden;width:100%;box-sizing:border-box;scrollbar-width:thin;scrollbar-color:", bubbleList.scrollThumb, " ", bubbleList.scrollbarTrack, ";}.", k, "-bubble-list-scroll::-webkit-scrollbar{width:10px;height:10px;}.", k, "-bubble-list-scroll::-webkit-scrollbar-track{background:", bubbleList.scrollbarTrack, ";}.", k, "-bubble-list-scroll::-webkit-scrollbar-thumb{background:", bubbleList.scrollThumb, ";border-radius:999px;border:2px solid transparent;background-clip:content-box;transition:background ", theme.transition.small, ";}.", k, "-bubble-list-scroll::-webkit-scrollbar-thumb:hover{background:", bubbleList.scrollThumbHover, ";background-clip:content-box;}.", k, "-bubble-list-scroll-content{min-height:100%;display:flex;flex-direction:column;box-sizing:border-box;padding-inline:", bubbleList.paddingInline, ";}.", k, "-bubble-list-history{display:flex;justify-content:center;color:", bubbleList.auxiliaryColor, ";font-size:12px;line-height:1.5;padding:4px 0 8px;flex:0 0 auto;}.", k, "-bubble-list-items{display:flex;flex-direction:column;gap:", bubbleList.gap, ";width:100%;}.", k, "-bubble-list-item{width:100%;min-width:0;}.", k, "-bubble-list-empty{min-height:100%;display:flex;align-items:center;justify-content:center;color:", bubbleList.auxiliaryColor, ";padding:24px 16px;text-align:center;box-sizing:border-box;}.", k, "-bubble-list-scroll-to-bottom{position:absolute;right:16px;bottom:16px;z-index:1;}.", k, "-bubble-list-scroll-to-bottom-button{border:", bubbleList.scrollToBottomBorder, ";background:", bubbleList.scrollToBottomBg, ";color:", bubbleList.scrollToBottomColor, ";border-radius:999px;box-shadow:", bubbleList.scrollToBottomShadow, ";width:", bubbleList.scrollToBottomSize, ";height:", bubbleList.scrollToBottomSize, ";display:inline-flex;align-items:center;justify-content:center;padding:0;font-size:18px;line-height:1;cursor:pointer;transition:background ", theme.transition.small, ",border-color ", theme.transition.small, ",color ", theme.transition.small, ",transform ", theme.transition.small, ",box-shadow ", theme.transition.small, ";}.", k, "-bubble-list-scroll-to-bottom-button:hover{background:", bubbleList.scrollToBottomHoverBg, ";color:", bubbleList.scrollToBottomHoverColor, ";border:", bubbleList.scrollToBottomHoverBorder, ";transform:translateY(-1px);box-shadow:0 14px 30px ", setAlpha('#000', 0.16), ";}.", k, "-bubble-list-scroll-to-bottom-button:focus-visible{outline:0;color:", bubbleList.scrollToBottomHoverColor, ";border:", bubbleList.scrollToBottomHoverBorder, ";box-shadow:0 0 0 4px ", setAlpha(theme.color.primary, 0.14), ",0 10px 28px ", setAlpha('#000', 0.12), ";}.", k, "-bubble-list-scroll-to-bottom-icon{pointer-events:none;font-size:", bubbleList.scrollToBottomIconSize, ";}");
+});

package/components/bubbleList/useBubbleList.d.ts

@@ -0,0 +1,28 @@
+import type { BubbleProps } from '../bubble';
+import type { BubbleListItem, BubbleListKey, BubbleListSlotParams } from './bubbleList';
+export declare function useBubbleList(): {
+    scrollBoxRef: import('intact-vue-next').RefObject<HTMLDivElement>;
+    scrollContentRef: import('intact-vue-next').RefObject<HTMLDivElement>;
+    getItems: () => BubbleListItem[];
+    getItemKey: (item: BubbleListItem, index: number) => BubbleListKey;
+    getBubbleProps: (item: BubbleListItem, index: number) => Partial<BubbleProps> & {
+        className?: string | undefined;
+        style?: any;
+    };
+    getSlotParams: (item: BubbleListItem, index: number) => BubbleListSlotParams;
+    getItemRef: (item: BubbleListItem, index: number) => (element: HTMLDivElement | null) => void;
+    handleScroll: (e: Event) => void;
+    shouldShowEmpty: () => boolean;
+    shouldShowHistoryLoading: () => boolean;
+    shouldShowScrollToBottom: () => boolean;
+    getDefaultHistoryLoadingText: () => string;
+    onScrollToBottomClick: () => void;
+    onBubbleTyping: (item: BubbleListItem, index: number, renderedContent: string, currentContent: string) => void;
+    onBubbleTypingComplete: (item: BubbleListItem, index: number, content: string) => void;
+    getBubbleTypingHandler: (item: BubbleListItem, index: number) => (renderedContent: string, currentContent: string) => void;
+    getBubbleTypingCompleteHandler: (item: BubbleListItem, index: number) => (content: string) => void;
+    scrollToTop: (behavior?: ScrollBehavior) => void;
+    scrollToBottom: (behavior?: ScrollBehavior) => void;
+    scrollToKey: (key: BubbleListKey, behavior?: ScrollBehavior) => void;
+    isAtBottom: () => boolean;
+};

package/components/bubbleList/useBubbleList.js

@@ -0,0 +1,455 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _Map from "@babel/runtime-corejs3/core-js/map";
+import _WeakMap from "@babel/runtime-corejs3/core-js/weak-map";
+import { createRef, nextTick, onBeforeUnmount, onMounted, useInstance } from 'intact-vue-next';
+import ResizeObserver from 'resize-observer-polyfill';
+var BUBBLE_PROP_KEYS = ['content', 'placement', 'avatar', 'roleName', 'loading', 'streaming', 'variant', 'shape', 'maxWidthString', 'typing'];
+function toItemArray(items) {
+  return Array.isArray(items) ? items : [];
+}
+// 管理列表数据到 DOM 滚动的协作：key、角色合并、贴底、历史前插和滚动方法都依赖同一组状态。
+export function useBubbleList() {
+  var instance = useInstance();
+  var scrollBoxRef = createRef();
+  var scrollContentRef = createRef();
+  var itemElements = new _Map();
+  var internalItemKeys = new _WeakMap();
+  var resizeObserver = null;
+  var resizeFrame = 0;
+  var historyRequestLocked = false;
+  var anchorSnapshot = null;
+  var internalItemKeySeed = 0;
+  var warnedMissingItemKey = false;
+  function getItems() {
+    return toItemArray(instance.get('items'));
+  }
+  function warnMissingItemKey() {
+    if (process.env.NODE_ENV === 'production' || warnedMissingItemKey) return;
+    warnedMissingItemKey = true;
+    console.warn('BubbleList: each item should provide a stable `key`, or configure `itemKey`. ' + 'The component is falling back to an internal temporary key, which is only suitable ' + 'for basic rendering and may be unstable across recreated item objects.');
+  }
+  function getInternalItemKey(item) {
+    warnMissingItemKey();
+    if (item && typeof item === 'object') {
+      var cachedKey = internalItemKeys.get(item);
+      if (cachedKey !== undefined) return cachedKey;
+      internalItemKeySeed += 1;
+      var internalKey = "__bubble_list_internal_" + internalItemKeySeed;
+      internalItemKeys.set(item, internalKey);
+      return internalKey;
+    }
+    internalItemKeySeed += 1;
+    return "__bubble_list_internal_" + internalItemKeySeed;
+  }
+  // 优先使用业务稳定 key；内部 key 只保证同一对象引用下的基础渲染稳定。
+  function getItemKey(item, index) {
+    var itemKey = instance.get('itemKey');
+    if (typeof itemKey === 'function') {
+      return itemKey(item, index);
+    }
+    if (typeof itemKey === 'string' && itemKey) {
+      var fromField = item[itemKey];
+      if (fromField !== undefined && fromField !== null) return fromField;
+    }
+    if (item.key !== undefined && item.key !== null) return item.key;
+    return getInternalItemKey(item);
+  }
+  function getAutoScrollThreshold() {
+    return Math.max(instance.get('autoScrollThreshold') || 0, 0);
+  }
+  function getHistoryTriggerOffset() {
+    return Math.max(instance.get('historyTriggerOffset') || 0, 0);
+  }
+  function isAutoScrollEnabled() {
+    return !!instance.get('autoScroll');
+  }
+  function getScrollBehavior() {
+    return instance.get('scrollBehavior') || 'auto';
+  }
+  function getScrollBox() {
+    return scrollBoxRef.value || null;
+  }
+  function getScrollContent() {
+    return scrollContentRef.value || null;
+  }
+  function setInternalState(key, value) {
+    if (instance.get(key) === value) return;
+    instance.set(key, value);
+  }
+  function setIsAtBottom(value) {
+    if (instance.get('$isAtBottom') === value) return;
+    setInternalState('$isAtBottom', value);
+    instance.trigger('scrollBottomChange', value);
+  }
+  function setAutoScrollActive(value) {
+    var nextValue = isAutoScrollEnabled() ? value : false;
+    if (instance.get('$autoScrollActive') === nextValue) return;
+    setInternalState('$autoScrollActive', nextValue);
+    instance.trigger('autoScrollChange', nextValue);
+  }
+  function isAtBottom() {
+    var scrollBox = getScrollBox();
+    if (!scrollBox) return true;
+    return scrollBox.scrollHeight - scrollBox.scrollTop - scrollBox.clientHeight <= getAutoScrollThreshold();
+  }
+  function isAutoScrollActive() {
+    return !!instance.get('$autoScrollActive');
+  }
+  function shouldStickToBottom() {
+    return isAutoScrollEnabled() && isAutoScrollActive();
+  }
+  function getRoleConfig(item, index) {
+    var roles = instance.get('roles');
+    var role = item.role;
+    if (!roles || !role) return;
+    var roleConfig = roles[role];
+    if (!roleConfig) return;
+    return typeof roleConfig === 'function' ? roleConfig(item, index) : roleConfig;
+  }
+  // 单条消息配置覆盖角色默认配置，保持 role 只负责默认值。
+  function getMergedItem(item, index) {
+    var roleConfig = getRoleConfig(item, index);
+    if (!roleConfig) return item;
+    return _extends({}, roleConfig, item);
+  }
+  function getBubbleProps(item, index) {
+    var mergedItem = getMergedItem(item, index);
+    var bubbleProps = {};
+    BUBBLE_PROP_KEYS.forEach(function (key) {
+      if (mergedItem[key] !== undefined) {
+        bubbleProps[key] = mergedItem[key];
+      }
+    });
+    if (mergedItem.className !== undefined) {
+      bubbleProps.className = mergedItem.className;
+    }
+    if (mergedItem.style !== undefined) {
+      bubbleProps.style = mergedItem.style;
+    }
+    return bubbleProps;
+  }
+  function getSlotParams(item, index) {
+    var key = getItemKey(item, index);
+    var mergedItem = getMergedItem(item, index);
+    return {
+      item: item,
+      mergedItem: mergedItem,
+      index: index,
+      key: key,
+      isFirst: index === 0,
+      isLast: index === getItems().length - 1,
+      isAtBottom: isAtBottom()
+    };
+  }
+  function setItemElement(key, element) {
+    if (!element) {
+      itemElements.delete(key);
+      return;
+    }
+    itemElements.set(key, element);
+  }
+  function getItemRef(item, index) {
+    var key = getItemKey(item, index);
+    return function (element) {
+      setItemElement(key, element);
+    };
+  }
+  function getContentTop() {
+    var scrollBox = getScrollBox();
+    var scrollContent = getScrollContent();
+    if (!scrollBox || !scrollContent) return 0;
+    var scrollBoxRect = scrollBox.getBoundingClientRect();
+    var scrollContentRect = scrollContent.getBoundingClientRect();
+    return scrollContentRect.top - scrollBoxRect.top;
+  }
+  // 记录当前视口顶部的首个可见项，用于历史消息前插后恢复阅读位置。
+  function updateAnchorSnapshot() {
+    var scrollBox = getScrollBox();
+    if (!scrollBox) {
+      anchorSnapshot = null;
+      return;
+    }
+    var scrollBoxRect = scrollBox.getBoundingClientRect();
+    var topBoundary = scrollBoxRect.top + getContentTop();
+    var items = getItems();
+    for (var i = 0; i < items.length; i++) {
+      var key = getItemKey(items[i], i);
+      var element = itemElements.get(key);
+      if (!element) continue;
+      var rect = element.getBoundingClientRect();
+      if (rect.bottom > topBoundary) {
+        anchorSnapshot = {
+          key: key,
+          top: rect.top - scrollBoxRect.top
+        };
+        return;
+      }
+    }
+    anchorSnapshot = null;
+  }
+  // prepend 或内容高度变化后，把锚点项拉回原来的视口位置。
+  function restoreAnchorSnapshot() {
+    if (!anchorSnapshot) return;
+    var scrollBox = getScrollBox();
+    if (!scrollBox) return;
+    var element = itemElements.get(anchorSnapshot.key);
+    if (!element) return;
+    var scrollBoxRect = scrollBox.getBoundingClientRect();
+    var currentTop = element.getBoundingClientRect().top - scrollBoxRect.top;
+    var delta = currentTop - anchorSnapshot.top;
+    if (Math.abs(delta) < 1) return;
+    scrollBox.scrollTop += delta;
+  }
+  function syncScrollState() {
+    var atBottom = isAtBottom();
+    setIsAtBottom(atBottom);
+    setAutoScrollActive(atBottom);
+    if (atBottom) {
+      anchorSnapshot = null;
+    } else {
+      updateAnchorSnapshot();
+    }
+  }
+  // 顶部触发历史加载时先锁住，等待 loadingHistory 结束或 items 更新后释放。
+  function triggerLoadHistory() {
+    if (!instance.get('hasMoreHistory')) return;
+    if (instance.get('loadingHistory')) return;
+    if (historyRequestLocked) return;
+    historyRequestLocked = true;
+    updateAnchorSnapshot();
+    instance.trigger('loadHistory');
+  }
+  function handleScroll(e) {
+    syncScrollState();
+    var scrollBox = getScrollBox();
+    if (scrollBox && scrollBox.scrollTop <= getHistoryTriggerOffset()) {
+      triggerLoadHistory();
+    }
+    instance.trigger('scroll', e);
+  }
+  function scrollTo(top, behavior) {
+    if (behavior === void 0) {
+      behavior = getScrollBehavior();
+    }
+    var scrollBox = getScrollBox();
+    if (!scrollBox) return;
+    // 兼容不支持 ScrollToOptions 的旧浏览器，smooth 会自动降级为即时滚动。
+    if (typeof scrollBox.scrollTo === 'function') {
+      try {
+        scrollBox.scrollTo({
+          top: top,
+          behavior: behavior
+        });
+        return;
+      } catch (e) {
+        scrollBox.scrollTo(0, top);
+        return;
+      }
+    }
+    scrollBox.scrollTop = top;
+  }
+  function scrollToTop(behavior) {
+    if (behavior === void 0) {
+      behavior = getScrollBehavior();
+    }
+    setAutoScrollActive(false);
+    scrollTo(0, behavior);
+    nextTick(syncScrollState);
+  }
+  function scrollToBottom(behavior) {
+    if (behavior === void 0) {
+      behavior = getScrollBehavior();
+    }
+    var scrollBox = getScrollBox();
+    if (!scrollBox) return;
+    setAutoScrollActive(true);
+    scrollTo(scrollBox.scrollHeight, behavior);
+    nextTick(syncScrollState);
+  }
+  function scrollToKey(key, behavior) {
+    if (behavior === void 0) {
+      behavior = getScrollBehavior();
+    }
+    var scrollBox = getScrollBox();
+    var element = itemElements.get(key);
+    if (!scrollBox || !element) return;
+    var scrollBoxRect = scrollBox.getBoundingClientRect();
+    var elementRect = element.getBoundingClientRect();
+    var currentTop = scrollBox.scrollTop + (elementRect.top - scrollBoxRect.top);
+    var targetTop = currentTop;
+    if (Math.abs(targetTop - (scrollBox.scrollHeight - scrollBox.clientHeight)) <= getAutoScrollThreshold()) {
+      setAutoScrollActive(true);
+    } else {
+      setAutoScrollActive(false);
+    }
+    scrollTo(Math.max(targetTop, 0), behavior);
+    nextTick(syncScrollState);
+  }
+  function shouldShowScrollToBottom() {
+    return !!instance.get('showScrollToBottom') && !instance.get('$isAtBottom') && getItems().length > 0;
+  }
+  function shouldShowEmpty() {
+    return getItems().length === 0;
+  }
+  function shouldShowHistoryLoading() {
+    var _instance$get = instance.get(),
+      blocks = _instance$get.$blocks;
+    // 自定义 historyLoading 时需在「没有更多」且非加载时仍保留区域，否则 slot 无法展示收尾文案
+    if (blocks && blocks.historyLoading && getItems().length > 0) {
+      return true;
+    }
+    return !!instance.get('loadingHistory');
+  }
+  function onBubbleTyping(item, index, renderedContent, currentContent) {
+    var mergedItem = getMergedItem(item, index);
+    mergedItem.onTyping == null || mergedItem.onTyping(renderedContent, currentContent, item, index);
+    instance.trigger('typing', item, renderedContent, currentContent, index);
+  }
+  function onBubbleTypingComplete(item, index, content) {
+    var mergedItem = getMergedItem(item, index);
+    mergedItem.onTypingComplete == null || mergedItem.onTypingComplete(content, item, index);
+    instance.trigger('typingComplete', item, content, index);
+  }
+  function getBubbleTypingHandler(item, index) {
+    return function (renderedContent, currentContent) {
+      onBubbleTyping(item, index, renderedContent, currentContent);
+    };
+  }
+  function getBubbleTypingCompleteHandler(item, index) {
+    return function (content) {
+      onBubbleTypingComplete(item, index, content);
+    };
+  }
+  function getDefaultHistoryLoadingText() {
+    return '加载历史中...';
+  }
+  function onScrollToBottomClick() {
+    scrollToBottom('smooth');
+  }
+  function watchItems() {
+    instance.watch('items', function () {
+      var shouldKeepBottom = shouldStickToBottom();
+      if (!shouldKeepBottom) {
+        updateAnchorSnapshot();
+      }
+      historyRequestLocked = false;
+      nextTick(function () {
+        if (instance.$unmounted) return;
+        // 新消息增长时贴底；用户离开底部时优先恢复锚点，避免阅读位置跳动。
+        if (shouldKeepBottom) {
+          scrollToBottom('auto');
+        } else {
+          restoreAnchorSnapshot();
+          syncScrollState();
+        }
+      });
+    }, {
+      inited: true
+    });
+  }
+  function watchLoadingHistory() {
+    instance.watch('loadingHistory', function (value, oldValue) {
+      if (!value && oldValue) {
+        historyRequestLocked = false;
+        nextTick(function () {
+          restoreAnchorSnapshot();
+          syncScrollState();
+        });
+      }
+    }, {
+      inited: true
+    });
+  }
+  function watchAutoScroll() {
+    instance.watch('autoScroll', function (value) {
+      if (!value) {
+        setAutoScrollActive(false);
+        syncScrollState();
+        return;
+      }
+      nextTick(function () {
+        setAutoScrollActive(isAtBottom());
+        if (isAtBottom()) {
+          scrollToBottom('auto');
+        } else {
+          syncScrollState();
+        }
+      });
+    }, {
+      inited: true
+    });
+  }
+  function mountResizeObserver() {
+    var scrollContent = getScrollContent();
+    if (!scrollContent) return;
+    resizeObserver = new ResizeObserver(function () {
+      if (resizeFrame) {
+        cancelAnimationFrame(resizeFrame);
+      }
+      resizeFrame = requestAnimationFrame(function () {
+        resizeFrame = 0;
+        if (instance.$unmounted) return;
+        // 图片、Markdown、typing 等高度变化也要参与贴底或锚点恢复。
+        if (shouldStickToBottom()) {
+          scrollToBottom('auto');
+          return;
+        }
+        restoreAnchorSnapshot();
+        syncScrollState();
+      });
+    });
+    resizeObserver.observe(scrollContent);
+  }
+  function onMountedCallback() {
+    nextTick(function () {
+      mountResizeObserver();
+      if (isAutoScrollEnabled()) {
+        scrollToBottom('auto');
+        requestAnimationFrame(function () {
+          if (instance.$unmounted) return;
+          scrollToBottom('auto');
+        });
+        return;
+      }
+      syncScrollState();
+    });
+  }
+  function onBeforeUnmountCallback() {
+    if (resizeFrame) {
+      cancelAnimationFrame(resizeFrame);
+      resizeFrame = 0;
+    }
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+      resizeObserver = null;
+    }
+  }
+  watchItems();
+  watchLoadingHistory();
+  watchAutoScroll();
+  onMounted(onMountedCallback);
+  onBeforeUnmount(onBeforeUnmountCallback);
+  return {
+    scrollBoxRef: scrollBoxRef,
+    scrollContentRef: scrollContentRef,
+    getItems: getItems,
+    getItemKey: getItemKey,
+    getBubbleProps: getBubbleProps,
+    getSlotParams: getSlotParams,
+    getItemRef: getItemRef,
+    handleScroll: handleScroll,
+    shouldShowEmpty: shouldShowEmpty,
+    shouldShowHistoryLoading: shouldShowHistoryLoading,
+    shouldShowScrollToBottom: shouldShowScrollToBottom,
+    getDefaultHistoryLoadingText: getDefaultHistoryLoadingText,
+    onScrollToBottomClick: onScrollToBottomClick,
+    onBubbleTyping: onBubbleTyping,
+    onBubbleTypingComplete: onBubbleTypingComplete,
+    getBubbleTypingHandler: getBubbleTypingHandler,
+    getBubbleTypingCompleteHandler: getBubbleTypingCompleteHandler,
+    scrollToTop: scrollToTop,
+    scrollToBottom: scrollToBottom,
+    scrollToKey: scrollToKey,
+    isAtBottom: isAtBottom
+  };
+}

package/components/checkbox/index.d.ts

@@ -1,6 +1,6 @@
 import { Component, TypeDefs } from 'intact-vue-next';
-import { CommonInputHTMLAttributes, Events } from '../types';
-export interface CheckboxProps<V = boolean> extends CommonInputHTMLAttributes {
+import { CommonFormElementAttributes, Events } from '../types';
+export interface CheckboxProps<V = boolean> extends CommonFormElementAttributes {
     disabled?: boolean;
     value?: V;
     trueValue?: any;
@@ -13,7 +13,7 @@ export interface CheckboxEvents<V = boolean> {
 }
 export declare class Checkbox<V = boolean> extends Component<CheckboxProps<V>, CheckboxEvents<V>> {
     static template: string | import('intact-vue-next').Template<any>;
-    static typeDefs: Required<TypeDefs<Omit<CheckboxProps<boolean>, keyof CommonInputHTMLAttributes>>>;
+    static typeDefs: Required<TypeDefs<Omit<CheckboxProps<boolean>, keyof CommonFormElementAttributes>>>;
     static defaults: () => Partial<CheckboxProps<boolean>>;
     static events: Events<CheckboxEvents<boolean>>;
     private inputRef;