amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/withBadge.js

@@ -0,0 +1,7 @@
+/**
+ * amis-ui v6.13.0
+ * 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
+ * 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
+ * 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
+ * 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
+ * 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;

package/esm/hooks/use-touch.js

@@ -0,0 +1,77 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __assign, __read } from 'tslib';
+import { useRef, useCallback } from 'react';
+
+var MIN_DISTANCE = 10;
+function getDirection(x, y) {
+    if (x > y && x > MIN_DISTANCE) {
+        return 'horizontal';
+    }
+    if (y > x && y > MIN_DISTANCE) {
+        return 'vertical';
+    }
+    return '';
+}
+var INITIAL_STATE = {
+    startX: 0,
+    startY: 0,
+    deltaX: 0,
+    deltaY: 0,
+    offsetX: 0,
+    offsetY: 0,
+    direction: ''
+};
+var useTouch = function () {
+    var refState = useRef(INITIAL_STATE);
+    var innerState = refState.current;
+    var update = function (value) {
+        if (typeof value === 'function') {
+            value = value(refState.current);
+        }
+        Object.entries(value).forEach(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            //@ts-ignore
+            refState.current[k] = v;
+        });
+    };
+    var isVertical = useCallback(function () { return innerState.direction === 'vertical'; }, [innerState.direction]);
+    var isHorizontal = useCallback(function () { return innerState.direction === 'horizontal'; }, [innerState.direction]);
+    var reset = function () {
+        update({
+            deltaX: 0,
+            deltaY: 0,
+            offsetX: 0,
+            offsetY: 0,
+            direction: ''
+        });
+    };
+    var start = (function (event) {
+        reset();
+        update({
+            startX: event.touches[0].clientX,
+            startY: event.touches[0].clientY
+        });
+    });
+    var move = (function (event) {
+        var touch = event.touches[0];
+        update(function (value) {
+            // Fix: Safari back will set clientX to negative number
+            var newState = __assign({}, value);
+            newState.deltaX = touch.clientX < 0 ? 0 : touch.clientX - newState.startX;
+            newState.deltaY = touch.clientY - newState.startY;
+            newState.offsetX = Math.abs(newState.deltaX);
+            newState.offsetY = Math.abs(newState.deltaY);
+            if (!newState.direction) {
+                newState.direction = getDirection(newState.offsetX, newState.offsetY);
+            }
+            return newState;
+        });
+    });
+    return __assign(__assign({}, innerState), { move: move, start: start, reset: reset, isVertical: isVertical, isHorizontal: isHorizontal });
+};
+
+export { useTouch as default };

package/esm/hooks/use-update-effect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useUpdateEffect: typeof useEffect;
+export default useUpdateEffect;

package/esm/hooks/use-update-effect.js

@@ -0,0 +1,21 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { useRef, useEffect } from 'react';
+
+var useUpdateEffect = function (effect, deps) {
+    var isMounted = useRef(false);
+    useEffect(function () {
+        if (!isMounted.current) {
+            isMounted.current = true;
+        }
+        else {
+            return effect();
+        }
+        return undefined;
+    }, deps);
+};
+
+export { useUpdateEffect as default };

package/esm/hooks/use-validation-resolver.d.ts

@@ -0,0 +1,7 @@
+export declare function useValidationResolver(__?: (str: string) => string, validate?: (error: {
+    [propName: string]: {
+        rule: string;
+        msg: string;
+    }[];
+}, values: Record<string, any>, context: any, config: any) => Promise<void>): any;
+export default useValidationResolver;

package/esm/hooks/use-validation-resolver.js

@@ -0,0 +1,115 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __awaiter, __generator, __values } from 'tslib';
+import pick from 'lodash/pick';
+import React__default from 'react';
+import { validateObject, validations } from 'amis-core';
+
+function formatErrors(errors) {
+    var formated = {};
+    Object.keys(errors).forEach(function (key) {
+        var origin = errors[key][0];
+        if (origin) {
+            formated[key] = {
+                type: origin.rule,
+                message: origin.msg
+            };
+        }
+    });
+    return formated;
+}
+function useValidationResolver(__, validate) {
+    var _this = this;
+    if (__ === void 0) { __ = function (str) { return str; }; }
+    return React__default.useCallback(function (values, context, config) { return __awaiter(_this, void 0, void 0, function () {
+        var rules, customValidator, ruleKeys, _a, _b, key, field, errors, _c, _d, key, validate_1, result, e_1_1, e_2;
+        var e_3, _e, e_1, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    rules = {};
+                    customValidator = {};
+                    ruleKeys = Object.keys(validations);
+                    try {
+                        for (_a = __values(Object.keys(config.fields)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            key = _b.value;
+                            field = config.fields[key];
+                            rules[key] = pick(field, ruleKeys);
+                            if (field.required) {
+                                rules[key].isRequired = true;
+                            }
+                            if (typeof field.validate === 'function') {
+                                customValidator[key] = field.validate;
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    errors = validateObject(values, rules, undefined, __);
+                    _g.label = 1;
+                case 1:
+                    _g.trys.push([1, 6, 7, 8]);
+                    _c = __values(Object.keys(customValidator)), _d = _c.next();
+                    _g.label = 2;
+                case 2:
+                    if (!!_d.done) return [3 /*break*/, 5];
+                    key = _d.value;
+                    validate_1 = customValidator[key];
+                    return [4 /*yield*/, validate_1(values[key])];
+                case 3:
+                    result = _g.sent();
+                    if (typeof result === 'string') {
+                        errors[key] = errors[key] || [];
+                        errors[key].push({
+                            rule: 'custom',
+                            msg: result
+                        });
+                    }
+                    _g.label = 4;
+                case 4:
+                    _d = _c.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _g.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8:
+                    _g.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, (validate === null || validate === void 0 ? void 0 : validate(errors, values, context, config))];
+                case 9:
+                    _g.sent();
+                    return [3 /*break*/, 11];
+                case 10:
+                    e_2 = _g.sent();
+                    errors.customValidate = [
+                        {
+                            rule: 'custom',
+                            msg: e_2.message || e_2
+                        }
+                    ];
+                    return [3 /*break*/, 11];
+                case 11: return [2 /*return*/, {
+                        values: values,
+                        errors: formatErrors(errors)
+                    }];
+            }
+        });
+    }); }, [__, validate]);
+}
+
+export { useValidationResolver as default, useValidationResolver };

package/esm/icons/alert-danger.svg.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgAlertDanger = function SvgAlertDanger(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M667.904 704.32 508.992 546.56 351.104 705.472l-45.376-45.056L463.552 501.44 304.64 343.488l45.12-45.376 158.912 157.824L666.56 297.088 712 342.144 553.984 501.12 712.96 659.008l-45.12 45.44zM510.528 64a448 448 0 1 0 2.944 896 448 448 0 0 0-2.944-896z",
+    fill: "#F33E3E"
+  })));
+};
+
+export { SvgAlertDanger as default };

package/esm/icons/alert-info.svg.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgAlertInfo = function SvgAlertInfo(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm32 354.944h-64V768h64V418.944zM512 256a38.4 38.4 0 1 0-.128 76.672A38.4 38.4 0 0 0 512 256z",
+    fill: "#2468F2"
+  })));
+};
+
+export { SvgAlertInfo as default };

package/esm/icons/alert-success.svg.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgAlertSuccess = function SvgAlertSuccess(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "m449.856 706.56-45.44-45.056.128-.064L268.16 526.016l45.12-45.44L449.6 616.064 720.192 343.68l45.376 45.056-315.712 317.888zM510.528 64A448 448 0 1 0 960 510.528 448 448 0 0 0 510.528 64z",
+    fill: "#30BF13"
+  })));
+};
+
+export { SvgAlertSuccess as default };

package/esm/icons/alert-warning.svg.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgAlertWarning = function SvgAlertWarning(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    fill: "currentColor",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm0 627.2a38.4 38.4 0 1 0 0 76.8 38.4 38.4 0 0 0 0-76.8zM544 256h-64v349.12h64V256z",
+    fill: "#FF9326"
+  })));
+};
+
+export { SvgAlertWarning as default };

package/esm/icons/arrow-double-left.svg.js

@@ -0,0 +1,24 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path, _path2;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgArrowDoubleLeft = function SvgArrowDoubleLeft(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    className: "icon",
+    viewBox: "0 0 1024 1024",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M842.667 864c-8.534 0-14.934-2.133-21.334-8.533L480 546.133c-6.4-6.4-10.667-14.933-10.667-23.466 0-8.534 4.267-17.067 10.667-23.467l341.333-309.333c12.8-12.8 34.134-10.667 44.8 2.133 12.8 12.8 10.667 34.133-2.133 44.8L548.267 522.667 864 808.533c12.8 10.667 14.933 32 2.133 44.8-6.4 6.4-14.933 10.667-23.466 10.667z",
+    fill: "#1677ff"
+  })), _path2 || (_path2 = /*#__PURE__*/React.createElement("path", {
+    d: "M512 864c-8.533 0-14.933-2.133-21.333-8.533L149.333 546.133c-6.4-6.4-10.666-14.933-10.666-23.466 0-8.534 4.266-17.067 10.666-23.467l341.334-309.333c12.8-12.8 34.133-10.667 44.8 2.133 12.8 12.8 10.666 34.133-2.134 44.8L217.6 522.667l315.733 285.866c12.8 12.8 14.934 32 2.134 44.8-6.4 6.4-14.934 10.667-23.467 10.667z",
+    fill: "#1677ff"
+  })));
+};
+
+export { SvgArrowDoubleLeft as default };

package/esm/icons/arrow-double-right.svg.js

@@ -0,0 +1,24 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path, _path2;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgArrowDoubleRight = function SvgArrowDoubleRight(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    className: "icon",
+    viewBox: "0 0 1024 1024",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M544 522.667c0-8.534-4.267-17.067-10.667-23.467L192 189.867c-12.8-12.8-34.133-10.667-44.8 2.133-12.8 12.8-10.667 34.133 2.133 44.8l315.734 285.867-315.734 285.866c-12.8 12.8-14.933 32-2.133 44.8 6.4 6.4 14.933 10.667 23.467 10.667 8.533 0 14.933-2.133 21.333-8.533l341.333-309.334c6.4-6.4 10.667-14.933 10.667-23.466z",
+    fill: "#1677ff"
+  })), _path2 || (_path2 = /*#__PURE__*/React.createElement("path", {
+    d: "M864 499.2 522.667 189.867c-12.8-12.8-34.134-10.667-44.8 2.133-12.8 12.8-10.667 34.133 2.133 44.8l315.733 285.867L480 808.533c-12.8 12.8-14.933 32-2.133 44.8 6.4 6.4 14.933 10.667 23.466 10.667 8.534 0 14.934-2.133 21.334-8.533L864 546.133c6.4-6.4 10.667-14.933 10.667-23.466 0-8.534-4.267-17.067-10.667-23.467z",
+    fill: "#1677ff"
+  })));
+};
+
+export { SvgArrowDoubleRight as default };

package/esm/icons/back.svg.js

@@ -0,0 +1,21 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgBack = function SvgBack(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    viewBox: "0 0 9 12",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    d: "M8.294 10.473 3.494 6l4.8-4.473L6.694 0l-6.4 6 6.4 6z",
+    fill: "currentColor"
+  })));
+};
+
+export { SvgBack as default };

package/esm/icons/calendar.svg.js

@@ -0,0 +1,31 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _g;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgCalendar = function SvgCalendar(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    viewBox: "0 0 14 14",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: "icon"
+  }, props), _g || (_g = /*#__PURE__*/React.createElement("g", {
+    fill: "none",
+    fillRule: "evenodd"
+  }, /*#__PURE__*/React.createElement("path", {
+    d: "M23.5-7.5h-159v29h159v-29Z",
+    stroke: "currentColor"
+  }), /*#__PURE__*/React.createElement("g", {
+    fill: "currentColor",
+    fillRule: "nonzero"
+  }, /*#__PURE__*/React.createElement("path", {
+    d: "M0 14h14V3H0v11Zm2-9h10v7H2V5ZM0 0h14v2H0z"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M9 6h2v2H9zm0 3h2v2H9zM6 6h2v2H6zm0 3h2v2H6zM3 6h2v2H3zm0 3h2v2H3z"
+  })))));
+};
+
+export { SvgCalendar as default };

package/esm/icons/caret.svg.js

@@ -0,0 +1,21 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import * as React from 'react';
+
+var _path;
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+var SvgCaret = function SvgCaret(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    viewBox: "0 0 12 8",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: "icon"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    d: "M10.473 0 6 4.8 1.527 0 0 1.6 6 8l6-6.4z"
+  })));
+};
+
+export { SvgCaret as default };