amis-ui 6.13.0-beta.8 → 6.13.0-beta.9

package/esm/components/virtual-list/constants.d.ts

@@ -0,0 +1,34 @@
+export declare enum ALIGNMENT {
+    AUTO = "auto",
+    START = "start",
+    CENTER = "center",
+    END = "end"
+}
+export declare enum DIRECTION {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+export declare enum SCROLL_CHANGE_REASON {
+    OBSERVED = "observed",
+    REQUESTED = "requested"
+}
+export declare const scrollProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const sizeProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const positionProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const marginProp: {
+    vertical: string;
+    horizontal: string;
+};
+export declare const oppositeMarginProp: {
+    vertical: string;
+    horizontal: string;
+};

package/esm/components/virtual-list/constants.js

@@ -0,0 +1,45 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+var _a, _b, _c, _d, _e;
+var ALIGNMENT;
+(function (ALIGNMENT) {
+    ALIGNMENT["AUTO"] = "auto";
+    ALIGNMENT["START"] = "start";
+    ALIGNMENT["CENTER"] = "center";
+    ALIGNMENT["END"] = "end";
+})(ALIGNMENT || (ALIGNMENT = {}));
+var DIRECTION;
+(function (DIRECTION) {
+    DIRECTION["HORIZONTAL"] = "horizontal";
+    DIRECTION["VERTICAL"] = "vertical";
+})(DIRECTION || (DIRECTION = {}));
+var SCROLL_CHANGE_REASON;
+(function (SCROLL_CHANGE_REASON) {
+    SCROLL_CHANGE_REASON["OBSERVED"] = "observed";
+    SCROLL_CHANGE_REASON["REQUESTED"] = "requested";
+})(SCROLL_CHANGE_REASON || (SCROLL_CHANGE_REASON = {}));
+var scrollProp = (_a = {},
+    _a[DIRECTION.VERTICAL] = 'scrollTop',
+    _a[DIRECTION.HORIZONTAL] = 'scrollLeft',
+    _a);
+var sizeProp = (_b = {},
+    _b[DIRECTION.VERTICAL] = 'height',
+    _b[DIRECTION.HORIZONTAL] = 'width',
+    _b);
+var positionProp = (_c = {},
+    _c[DIRECTION.VERTICAL] = 'top',
+    _c[DIRECTION.HORIZONTAL] = 'left',
+    _c);
+var marginProp = (_d = {},
+    _d[DIRECTION.VERTICAL] = 'marginTop',
+    _d[DIRECTION.HORIZONTAL] = 'marginLeft',
+    _d);
+var oppositeMarginProp = (_e = {},
+    _e[DIRECTION.VERTICAL] = 'marginBottom',
+    _e[DIRECTION.HORIZONTAL] = 'marginRight',
+    _e);
+
+export { ALIGNMENT, DIRECTION, SCROLL_CHANGE_REASON, marginProp, oppositeMarginProp, positionProp, scrollProp, sizeProp };

package/esm/components/virtual-list/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 基于 https://github.com/clauderic/react-tiny-virtual-list 改造，主要是加了宽度自适应
+ */
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import SizeAndPositionManager, { ItemSize } from './SizeAndPositionManager';
+import { ALIGNMENT, DIRECTION, SCROLL_CHANGE_REASON } from './constants';
+export { DIRECTION as ScrollDirection } from './constants';
+export type ItemPosition = 'absolute' | 'sticky';
+export interface ItemStyle {
+    position: ItemPosition;
+    top?: number;
+    left: number;
+    width: string | number;
+    height?: number;
+    marginTop?: number;
+    marginLeft?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    zIndex?: number;
+}
+export interface ItemInfo {
+    index: number;
+    style: ItemStyle;
+}
+export interface RenderedRows {
+    startIndex: number;
+    stopIndex: number;
+}
+export interface Props {
+    className?: string;
+    estimatedItemSize?: number;
+    height: number | string;
+    itemCount: number;
+    itemSize: ItemSize;
+    overscanCount?: number;
+    scrollOffset?: number;
+    scrollToIndex?: number;
+    scrollToAlignment?: ALIGNMENT;
+    scrollDirection?: DIRECTION;
+    stickyIndices?: number[];
+    style?: React.CSSProperties;
+    width?: number | string;
+    WrapperComponent?: React.ElementType;
+    InnerComponent?: React.ElementType;
+    innerStyleFilter?: (styles: object) => object;
+    prefix?: React.ReactNode | null;
+    onItemsRendered?({ startIndex, stopIndex }: RenderedRows): void;
+    onScroll?(offset: number, event: UIEvent): void;
+    renderItem(itemInfo: ItemInfo): React.ReactNode;
+}
+export interface State {
+    offset: number;
+    scrollChangeReason: SCROLL_CHANGE_REASON;
+}
+export default class VirtualList extends React.PureComponent<Props, State> {
+    static defaultProps: {
+        overscanCount: number;
+        scrollDirection: DIRECTION;
+        width: string;
+    };
+    static propTypes: {
+        estimatedItemSize: PropTypes.Requireable<number>;
+        height: PropTypes.Validator<NonNullable<NonNullable<string | number | null | undefined>>>;
+        itemCount: PropTypes.Validator<number>;
+        itemSize: PropTypes.Validator<NonNullable<NonNullable<number | any[] | ((...args: any[]) => any) | null | undefined>>>;
+        onScroll: PropTypes.Requireable<(...args: any[]) => any>;
+        onItemsRendered: PropTypes.Requireable<(...args: any[]) => any>;
+        overscanCount: PropTypes.Requireable<number>;
+        renderItem: PropTypes.Validator<(...args: any[]) => any>;
+        scrollOffset: PropTypes.Requireable<number>;
+        scrollToIndex: PropTypes.Requireable<number>;
+        scrollToAlignment: PropTypes.Requireable<ALIGNMENT>;
+        scrollDirection: PropTypes.Requireable<DIRECTION>;
+        stickyIndices: PropTypes.Requireable<(number | null | undefined)[]>;
+        style: PropTypes.Requireable<object>;
+        width: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+    };
+    itemSizeGetter: (itemSize: Props['itemSize']) => (index: any) => any;
+    sizeAndPositionManager: SizeAndPositionManager;
+    readonly state: State;
+    private rootNode;
+    private styleCache;
+    componentDidMount(): void;
+    updateRootWidth(): void;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    componentWillUnmount(): void;
+    scrollTo(value: number): void;
+    getOffsetForIndex(index: number, scrollToAlignment?: ALIGNMENT | undefined, itemCount?: number): number;
+    recomputeSizes(startIndex?: number): void;
+    render(): React.JSX.Element;
+    private getRef;
+    private handleScroll;
+    private getNodeOffset;
+    private getEstimatedItemSize;
+    private getSize;
+    private getStyle;
+}
+export { default as AutoSizer } from './AutoSizer';

package/esm/components/virtual-list/index.js

@@ -0,0 +1,288 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { __assign, __extends, __rest } from 'tslib';
+import * as React from 'react';
+import * as PropTypes from 'prop-types';
+import SizeAndPositionManager from './SizeAndPositionManager.js';
+import { SCROLL_CHANGE_REASON, DIRECTION, scrollProp, sizeProp, marginProp, oppositeMarginProp, positionProp, ALIGNMENT } from './constants.js';
+export { DIRECTION as ScrollDirection } from './constants.js';
+export { default as AutoSizer } from './AutoSizer.js';
+
+/**
+ * 基于 https://github.com/clauderic/react-tiny-virtual-list 改造，主要是加了宽度自适应
+ */
+var STYLE_WRAPPER = {
+    overflow: 'auto',
+    willChange: 'transform',
+    WebkitOverflowScrolling: 'touch'
+};
+var STYLE_INNER = {
+    position: 'relative',
+    width: 'auto',
+    whiteSpace: 'nowrap',
+    minHeight: '100%'
+};
+var STYLE_ITEM = {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    width: '100%'
+};
+var STYLE_STICKY_ITEM = __assign(__assign({}, STYLE_ITEM), { position: 'sticky' });
+var VirtualList = /** @class */ (function (_super) {
+    __extends(VirtualList, _super);
+    function VirtualList() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.itemSizeGetter = function (itemSize) {
+            return function (index) { return _this.getSize(index, itemSize); };
+        };
+        _this.sizeAndPositionManager = new SizeAndPositionManager({
+            itemCount: _this.props.itemCount,
+            itemSizeGetter: _this.itemSizeGetter(_this.props.itemSize),
+            estimatedItemSize: _this.getEstimatedItemSize()
+        });
+        _this.state = {
+            offset: _this.props.scrollOffset ||
+                (_this.props.scrollToIndex != null &&
+                    _this.getOffsetForIndex(_this.props.scrollToIndex)) ||
+                0,
+            scrollChangeReason: SCROLL_CHANGE_REASON.REQUESTED
+        };
+        _this.styleCache = {};
+        _this.getRef = function (node) {
+            node && (_this.rootNode = node);
+        };
+        _this.handleScroll = function (event) {
+            var onScroll = _this.props.onScroll;
+            var offset = _this.getNodeOffset();
+            if (offset < 0 ||
+                _this.state.offset === offset ||
+                event.target !== _this.rootNode) {
+                return;
+            }
+            _this.setState({
+                offset: offset,
+                scrollChangeReason: SCROLL_CHANGE_REASON.OBSERVED
+            });
+            if (typeof onScroll === 'function') {
+                onScroll(offset, event);
+            }
+        };
+        return _this;
+    }
+    VirtualList.prototype.componentDidMount = function () {
+        var _a = this.props, scrollOffset = _a.scrollOffset, scrollToIndex = _a.scrollToIndex;
+        this.rootNode.addEventListener('scroll', this.handleScroll, {
+            passive: true
+        });
+        this.updateRootWidth();
+        if (scrollOffset != null) {
+            this.scrollTo(scrollOffset);
+        }
+        else if (scrollToIndex != null) {
+            this.scrollTo(this.getOffsetForIndex(scrollToIndex));
+        }
+    };
+    // 自适应宽度
+    VirtualList.prototype.updateRootWidth = function () {
+        var itemsDom = this.rootNode.children[0].children;
+        var scrollbarWidth = window.innerWidth - document.documentElement.clientWidth || 15;
+        var containerWidth = this.rootNode.parentElement.getBoundingClientRect().width;
+        var maxItemWidth = 0;
+        for (var i = 0; i < itemsDom.length; i++) {
+            var itemWidth = itemsDom[i].getBoundingClientRect().width;
+            if (itemWidth > maxItemWidth) {
+                maxItemWidth = itemWidth;
+            }
+        }
+        if (maxItemWidth > containerWidth) {
+            this.rootNode.style.width = maxItemWidth + scrollbarWidth + 'px';
+        }
+    };
+    VirtualList.prototype.componentDidUpdate = function (prevProps, prevState) {
+        var props = this.props;
+        var estimatedItemSize = prevProps.estimatedItemSize, itemCount = prevProps.itemCount, itemSize = prevProps.itemSize, scrollOffset = prevProps.scrollOffset, scrollToAlignment = prevProps.scrollToAlignment, scrollToIndex = prevProps.scrollToIndex;
+        var scrollPropsHaveChanged = props.scrollToIndex !== scrollToIndex ||
+            props.scrollToAlignment !== scrollToAlignment;
+        var itemPropsHaveChanged = props.itemCount !== itemCount ||
+            props.itemSize !== itemSize ||
+            props.estimatedItemSize !== estimatedItemSize;
+        if (props.itemSize !== itemSize) {
+            this.sizeAndPositionManager.updateConfig({
+                itemSizeGetter: this.itemSizeGetter(props.itemSize)
+            });
+        }
+        if (props.itemCount !== itemCount ||
+            props.estimatedItemSize !== estimatedItemSize) {
+            this.sizeAndPositionManager.updateConfig({
+                itemCount: props.itemCount,
+                estimatedItemSize: this.getEstimatedItemSize(props)
+            });
+        }
+        if (itemPropsHaveChanged) {
+            this.recomputeSizes();
+        }
+        if (props.scrollOffset !== scrollOffset) {
+            this.setState({
+                offset: props.scrollOffset || 0,
+                scrollChangeReason: SCROLL_CHANGE_REASON.REQUESTED
+            });
+        }
+        else if (typeof props.scrollToIndex === 'number' &&
+            (scrollPropsHaveChanged || itemPropsHaveChanged)) {
+            this.setState({
+                offset: this.getOffsetForIndex(props.scrollToIndex, props.scrollToAlignment, props.itemCount),
+                scrollChangeReason: SCROLL_CHANGE_REASON.REQUESTED
+            });
+        }
+        var _a = this.state, offset = _a.offset, scrollChangeReason = _a.scrollChangeReason;
+        if (prevState.offset !== offset &&
+            scrollChangeReason === SCROLL_CHANGE_REASON.REQUESTED) {
+            this.scrollTo(offset);
+        }
+        if (props.itemCount !== itemCount) {
+            // 长度发生变化时重新渲染
+            this.forceUpdate();
+        }
+    };
+    VirtualList.prototype.componentWillUnmount = function () {
+        this.rootNode.removeEventListener('scroll', this.handleScroll);
+    };
+    VirtualList.prototype.scrollTo = function (value) {
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? DIRECTION.VERTICAL : _a;
+        this.rootNode[scrollProp[scrollDirection]] = value;
+    };
+    VirtualList.prototype.getOffsetForIndex = function (index, scrollToAlignment, itemCount) {
+        if (scrollToAlignment === void 0) { scrollToAlignment = this.props.scrollToAlignment; }
+        if (itemCount === void 0) { itemCount = this.props.itemCount; }
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? DIRECTION.VERTICAL : _a;
+        if (index < 0 || index >= itemCount) {
+            index = 0;
+        }
+        return this.sizeAndPositionManager.getUpdatedOffsetForIndex({
+            align: scrollToAlignment,
+            containerSize: this.props[sizeProp[scrollDirection]],
+            currentOffset: (this.state && this.state.offset) || 0,
+            targetIndex: index
+        });
+    };
+    VirtualList.prototype.recomputeSizes = function (startIndex) {
+        if (startIndex === void 0) { startIndex = 0; }
+        this.styleCache = {};
+        this.sizeAndPositionManager.resetItem(startIndex);
+    };
+    VirtualList.prototype.render = function () {
+        var _a;
+        var _this = this;
+        var _b = this.props; _b.estimatedItemSize; var height = _b.height, _c = _b.overscanCount, overscanCount = _c === void 0 ? 3 : _c, renderItem = _b.renderItem; _b.itemCount; _b.itemSize; var onItemsRendered = _b.onItemsRendered; _b.onScroll; var _d = _b.scrollDirection, scrollDirection = _d === void 0 ? DIRECTION.VERTICAL : _d; _b.scrollOffset; _b.scrollToIndex; _b.scrollToAlignment; var stickyIndices = _b.stickyIndices, style = _b.style, width = _b.width, WrapperComponent = _b.WrapperComponent, InnerComponent = _b.InnerComponent, prefix = _b.prefix, innerStyleFilter = _b.innerStyleFilter, props = __rest(_b, ["estimatedItemSize", "height", "overscanCount", "renderItem", "itemCount", "itemSize", "onItemsRendered", "onScroll", "scrollDirection", "scrollOffset", "scrollToIndex", "scrollToAlignment", "stickyIndices", "style", "width", "WrapperComponent", "InnerComponent", "prefix", "innerStyleFilter"]);
+        var offset = this.state.offset;
+        var _e = this.sizeAndPositionManager.getVisibleRange({
+            containerSize: this.props[sizeProp[scrollDirection]] || 0,
+            offset: offset,
+            overscanCount: overscanCount
+        }), start = _e.start, stop = _e.stop;
+        var items = [];
+        var wrapperStyle = __assign(__assign(__assign({}, STYLE_WRAPPER), style), { height: height, width: width });
+        var innerStyle = __assign(__assign({}, STYLE_INNER), (_a = {}, _a[sizeProp[scrollDirection]] = this.sizeAndPositionManager.getTotalSize(), _a));
+        if (stickyIndices != null && stickyIndices.length !== 0) {
+            stickyIndices.forEach(function (index) {
+                return items.push(renderItem({
+                    index: index,
+                    style: _this.getStyle(index, true)
+                }));
+            });
+            if (scrollDirection === DIRECTION.HORIZONTAL) {
+                innerStyle.display = 'flex';
+            }
+        }
+        if (typeof start !== 'undefined' && typeof stop !== 'undefined') {
+            for (var index = start; index <= stop; index++) {
+                if (stickyIndices != null && ~stickyIndices.indexOf(index)) {
+                    continue;
+                }
+                items.push(renderItem({
+                    index: index,
+                    style: this.getStyle(index, false)
+                }));
+            }
+            if (typeof onItemsRendered === 'function') {
+                onItemsRendered({
+                    startIndex: start,
+                    stopIndex: stop
+                });
+            }
+        }
+        var WrapperCmpt = WrapperComponent || 'div';
+        var InnerCmpt = InnerComponent || 'div';
+        return (React.createElement(WrapperCmpt, __assign({ ref: this.getRef }, props, { style: wrapperStyle }), prefix !== null && prefix !== void 0 ? prefix : null,
+            React.createElement(InnerCmpt, { style: innerStyleFilter ? innerStyleFilter(innerStyle) : innerStyle }, items)));
+    };
+    VirtualList.prototype.getNodeOffset = function () {
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? DIRECTION.VERTICAL : _a;
+        return this.rootNode[scrollProp[scrollDirection]];
+    };
+    VirtualList.prototype.getEstimatedItemSize = function (props) {
+        if (props === void 0) { props = this.props; }
+        return (props.estimatedItemSize ||
+            (typeof props.itemSize === 'number' && props.itemSize) ||
+            50);
+    };
+    VirtualList.prototype.getSize = function (index, itemSize) {
+        if (typeof itemSize === 'function') {
+            return itemSize(index);
+        }
+        return Array.isArray(itemSize) ? itemSize[index] : itemSize;
+    };
+    VirtualList.prototype.getStyle = function (index, sticky) {
+        var _a, _b;
+        var style = this.styleCache[index];
+        if (style) {
+            return style;
+        }
+        var _c = this.props.scrollDirection, scrollDirection = _c === void 0 ? DIRECTION.VERTICAL : _c;
+        var _d = this.sizeAndPositionManager.getSizeAndPositionForIndex(index), size = _d.size, offset = _d.offset;
+        return (this.styleCache[index] = sticky
+            ? __assign(__assign({}, STYLE_STICKY_ITEM), (_a = {}, _a[sizeProp[scrollDirection]] = size, _a[marginProp[scrollDirection]] = offset, _a[oppositeMarginProp[scrollDirection]] = -(offset + size), _a.zIndex = 1, _a)) : __assign(__assign({}, STYLE_ITEM), (_b = {}, _b[sizeProp[scrollDirection]] = size, _b[positionProp[scrollDirection]] = offset, _b)));
+    };
+    VirtualList.defaultProps = {
+        overscanCount: 3,
+        scrollDirection: DIRECTION.VERTICAL,
+        width: '100%'
+    };
+    VirtualList.propTypes = {
+        estimatedItemSize: PropTypes.number,
+        height: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+            .isRequired,
+        itemCount: PropTypes.number.isRequired,
+        itemSize: PropTypes.oneOfType([
+            PropTypes.number,
+            PropTypes.array,
+            PropTypes.func
+        ]).isRequired,
+        onScroll: PropTypes.func,
+        onItemsRendered: PropTypes.func,
+        overscanCount: PropTypes.number,
+        renderItem: PropTypes.func.isRequired,
+        scrollOffset: PropTypes.number,
+        scrollToIndex: PropTypes.number,
+        scrollToAlignment: PropTypes.oneOf([
+            ALIGNMENT.AUTO,
+            ALIGNMENT.START,
+            ALIGNMENT.CENTER,
+            ALIGNMENT.END
+        ]),
+        scrollDirection: PropTypes.oneOf([
+            DIRECTION.HORIZONTAL,
+            DIRECTION.VERTICAL
+        ]),
+        stickyIndices: PropTypes.arrayOf(PropTypes.number),
+        style: PropTypes.object,
+        width: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+    };
+    return VirtualList;
+}(React.PureComponent));
+
+export { VirtualList as default };

package/esm/components/withBadge.d.ts

@@ -0,0 +1,2 @@
+import { withBadge } from './Badge';
+export default withBadge;

package/esm/components/withBadge.js

@@ -0,0 +1,7 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { withBadge } from './Badge.js';
+export { withBadge as default } from './Badge.js';

package/esm/hooks/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file 常用 hooks
+ */
+export { default as useSetState } from './use-set-state';
+export { default as useUpdateEffect } from './use-update-effect';
+export { default as useTouch } from './use-touch';
+export { default as useValidationResolver } from './use-validation-resolver';
+export { default as useOnScreen } from './use-on-screen';

package/esm/hooks/use-click-away.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+/**
+ * 自定义 Hook：useClickAway
+ * 当点击事件发生在指定元素外部时，触发回调函数
+ *
+ * @param ref - 目标元素的引用
+ * @param onClickAway - 点击外部时的回调函数
+ * @param doc - Document 对象，默认为当前文档
+ * @param events - 监听的事件类型，默认为 ['mousedown', 'touchstart']
+ */
+declare const useClickAway: (ref: RefObject<HTMLElement | null>, onClickAway: (e: Event) => void, doc?: Document, events?: string[]) => void;
+export default useClickAway;

package/esm/hooks/use-click-away.js

@@ -0,0 +1,55 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { useCallback, useEffect } from 'react';
+
+// 存储所有点击事件监听器的集合
+var listeners = new Set();
+// 添加点击事件监听器
+var addClickListener = function (callback) {
+    return listeners.add(callback);
+};
+// 移除点击事件监听器
+var removeClickListener = function (callback) {
+    return listeners.delete(callback);
+};
+// 处理点击事件，调用所有监听器
+function handleEvent(e) {
+    listeners.forEach(function (listener) { return listener(e); });
+}
+// 默认的事件类型
+var defaultEvents = ['mousedown', 'touchstart'];
+/**
+ * 自定义 Hook：useClickAway
+ * 当点击事件发生在指定元素外部时，触发回调函数
+ *
+ * @param ref - 目标元素的引用
+ * @param onClickAway - 点击外部时的回调函数
+ * @param doc - Document 对象，默认为当前文档
+ * @param events - 监听的事件类型，默认为 ['mousedown', 'touchstart']
+ */
+var useClickAway = function (ref, onClickAway, doc, events) {
+    if (doc === void 0) { doc = document; }
+    if (events === void 0) { events = defaultEvents; }
+    // 事件处理函数
+    var handler = useCallback(function (e) {
+        var el = ref.current;
+        el && !el.contains(e.target) && onClickAway(e);
+    }, [ref]);
+    useEffect(function () {
+        // 添加事件监听器
+        if (!listeners.has(handler)) {
+            addClickListener(handler);
+        }
+        events.forEach(function (event) { return doc.addEventListener(event, handleEvent); });
+        // 清理函数，移除事件监听器
+        return function () {
+            removeClickListener(handler);
+            events.forEach(function (event) { return doc.removeEventListener(event, handleEvent); });
+        };
+    }, [events, ref, doc]);
+};
+
+export { useClickAway as default };

package/esm/hooks/use-on-screen.d.ts

@@ -0,0 +1,2 @@
+declare const useOnScreen: (ref: any) => boolean;
+export default useOnScreen;

package/esm/hooks/use-on-screen.js

@@ -0,0 +1,28 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { __read } from 'tslib';
+import { useState, useEffect } from 'react';
+
+var useOnScreen = function (ref) {
+    var _a = __read(useState(false), 2), isIntersecting = _a[0], setIsIntersecting = _a[1];
+    useEffect(function () {
+        var observer = new IntersectionObserver(function (_a) {
+            var _b = __read(_a, 1), entry = _b[0];
+            setIsIntersecting(entry.isIntersecting);
+        });
+        if (ref.current) {
+            observer.observe(ref.current);
+        }
+        return function () {
+            if (ref.current) {
+                observer.unobserve(ref.current);
+            }
+        };
+    }, [ref]);
+    return isIntersecting;
+};
+
+export { useOnScreen as default };

package/esm/hooks/use-set-state.d.ts

@@ -0,0 +1,2 @@
+declare const useSetState: <T extends object>(initialState?: T) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void];
+export default useSetState;

package/esm/hooks/use-set-state.js

@@ -0,0 +1,19 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { __read, __assign } from 'tslib';
+import { useState, useCallback } from 'react';
+import isFunction from 'lodash/isFunction';
+
+var useSetState = function (initialState) {
+    if (initialState === void 0) { initialState = {}; }
+    var _a = __read(useState(initialState), 2), state = _a[0], setState = _a[1];
+    var setMergeState = useCallback(function (patch) {
+        setState(function (prevState) { return (__assign(__assign({}, prevState), (isFunction(patch) ? patch(prevState) : patch))); });
+    }, []);
+    return [state, setMergeState];
+};
+
+export { useSetState as default };

package/esm/hooks/use-sub-form.d.ts

@@ -0,0 +1,4 @@
+import { TranslateFn } from 'amis-core';
+import { UseFormReturn } from 'react-hook-form';
+declare const useSubForm: (defaultValue: any, translate: TranslateFn, onUpdate: (data: any) => void) => UseFormReturn;
+export default useSubForm;

package/esm/hooks/use-sub-form.js

@@ -0,0 +1,39 @@
+/**
+ * amis-ui v6.13.0-beta.9
+ * Copyright 2018-2025 fex
+ */
+
+import { __assign } from 'tslib';
+import { useForm } from 'react-hook-form';
+import debounce from 'lodash/debounce';
+import React__default from 'react';
+import { useValidationResolver } from './use-validation-resolver.js';
+
+var useSubForm = function (defaultValue, translate, onUpdate) {
+    var methods = useForm({
+        defaultValues: defaultValue,
+        mode: 'onChange',
+        shouldUnregister: true,
+        resolver: useValidationResolver(translate)
+    });
+    // 数据修改后，自动提交更新到上层
+    var lazyUpdate = React__default.useRef(debounce(onUpdate, 250, {
+        leading: false,
+        trailing: true
+    }));
+    // 销毁的时候要 cancel
+    React__default.useEffect(function () {
+        return function () { return lazyUpdate.current.cancel(); };
+    }, []);
+    // 监控数值变化，自动同步到上层
+    React__default.useEffect(function () {
+        var subscriber = methods.watch(function (data) {
+            // 因为 watch 只会触发有表单项的数值，而原始数据中可能包含其他属性，所以要合并一下
+            lazyUpdate.current(__assign(__assign({}, defaultValue), data));
+        });
+        return function () { return subscriber.unsubscribe(); };
+    }, [methods.watch]);
+    return methods;
+};
+
+export { useSubForm as default };

package/esm/hooks/use-touch.d.ts

@@ -0,0 +1,16 @@
+type Direction = '' | 'vertical' | 'horizontal';
+declare const useTouch: () => {
+    move: EventListener;
+    start: EventListener;
+    reset: () => void;
+    isVertical: () => boolean;
+    isHorizontal: () => boolean;
+    startX: number;
+    startY: number;
+    deltaX: number;
+    deltaY: number;
+    offsetX: number;
+    offsetY: number;
+    direction: Direction;
+};
+export default useTouch;