@zykj2024/much-library 1.1.7-beta.3 → 1.1.7-beta.5

package/dist/Utils/lib/Queue/TaskQueue.js

@@ -0,0 +1,199 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// 任务队列（顺序队列）
+import { asyncWrap } from "./tools/publicDependencyMethod";
+import { BaseTaskQueue } from "./types/baseTaskQueue";
+var TaskQueue = /*#__PURE__*/function (_BaseTaskQueue) {
+  _inherits(TaskQueue, _BaseTaskQueue);
+  var _super = _createSuper(TaskQueue);
+  function TaskQueue() {
+    var _this;
+    var maxConcurrency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    var tasks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, TaskQueue);
+    _this = _super.call(this);
+    // 任务队列
+    _defineProperty(_assertThisInitialized(_this), "queue", []);
+    // 正在执行的任务队列
+    _defineProperty(_assertThisInitialized(_this), "runningTasks", []);
+    // 运行中被暂停的任务队列
+    _defineProperty(_assertThisInitialized(_this), "pausedTasks", []);
+    // 是否暂停任务
+    _defineProperty(_assertThisInitialized(_this), "isPaused", false);
+    // 最大并发数
+    _defineProperty(_assertThisInitialized(_this), "maxConcurrency", 1);
+    _this.maxConcurrency = maxConcurrency;
+    _this.queue = tasks === null || tasks === void 0 ? void 0 : tasks.map(function (item) {
+      return _objectSpread(_objectSpread({}, item), {}, {
+        task: asyncWrap(item.task),
+        isPaused: _this.isPaused
+      });
+    });
+    return _this;
+  }
+
+  // 添加任务到队列
+  _createClass(TaskQueue, [{
+    key: "addTask",
+    value: function addTask(taskConfig) {
+      var _this2 = this;
+      if (Array.isArray(taskConfig)) {
+        taskConfig.forEach(function (taskItem) {
+          _this2.queue.push(_objectSpread(_objectSpread({}, taskItem), {}, {
+            task: asyncWrap(taskItem.task),
+            isPaused: _this2.isPaused
+          }));
+        });
+      } else {
+        this.queue.push(_objectSpread(_objectSpread({}, taskConfig), {}, {
+          task: asyncWrap(taskConfig.task),
+          isPaused: this.isPaused
+        }));
+      }
+      this.runTasks();
+    }
+
+    // 暂停指定任务
+  }, {
+    key: "pauseTask",
+    value: function pauseTask(taskFilter) {
+      var _this3 = this;
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = true;
+        }
+      });
+      this.runningTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$pause;
+          task === null || task === void 0 || (_task$pause = task.pause) === null || _task$pause === void 0 || _task$pause.call(task);
+          task.isPaused = true;
+          _this3.pausedTasks.push(task);
+        }
+      });
+      this.runningTasks = this.runningTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      this.runTasks();
+    }
+
+    // 恢复任务
+  }, {
+    key: "resumeTask",
+    value: function resumeTask(taskFilter) {
+      this.queue.forEach(function (task) {
+        if (taskFilter(task)) {
+          task.isPaused = false;
+        }
+      });
+      this.pausedTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          //  变为可执行任务等待任务队列取出执行
+          task.isPaused = false;
+        }
+      });
+      this.runTasks();
+    }
+
+    // 取消任务
+  }, {
+    key: "cancelTask",
+    value: function cancelTask(taskFilter) {
+      this.queue = this.queue.filter(function (task) {
+        return !taskFilter(task);
+      });
+      var cancelTasks = this.runningTasks.filter(taskFilter);
+      cancelTasks === null || cancelTasks === void 0 || cancelTasks.forEach(function (task) {
+        if (taskFilter(task)) {
+          var _task$cancel;
+          task === null || task === void 0 || (_task$cancel = task.cancel) === null || _task$cancel === void 0 || _task$cancel.call(task);
+        }
+      });
+      this.runningTasks = this.runningTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      // 从暂停队列中移除
+      this.pausedTasks = this.pausedTasks.filter(function (task) {
+        return !taskFilter(task);
+      });
+      this.runTasks();
+    }
+
+    // 运行任务
+  }, {
+    key: "runTasks",
+    value: function runTasks() {
+      var _this4 = this;
+      if (this.isPaused || this.runningTasks.length >= this.maxConcurrency || this.queue.length === 0 && this.pausedTasks.length === 0) {
+        return;
+      }
+      var _loop = function _loop() {
+        // 查看暂停的任务队列中有没有被激活的任务
+        var pauseIndex = _this4.pausedTasks.findIndex(function (task) {
+          return !task.isPaused;
+        });
+        if (pauseIndex > -1) {
+          var _task$resume;
+          var _task = _this4.pausedTasks[pauseIndex];
+          _this4.pausedTasks = _this4.pausedTasks.slice(0, pauseIndex).concat(_this4.pausedTasks.slice(pauseIndex + 1));
+          // 恢复执行
+          _task === null || _task === void 0 || (_task$resume = _task.resume) === null || _task$resume === void 0 || _task$resume.call(_task);
+          _this4.runningTasks.push(_task);
+        } else {
+          var indx = _this4.queue.findIndex(function (task) {
+            return !task.isPaused;
+          });
+          if (indx > -1) {
+            var _task2 = _this4.queue[indx];
+            _this4.queue = _this4.queue.slice(0, indx).concat(_this4.queue.slice(indx + 1));
+            _this4.runningTasks.push(_task2);
+            _task2 === null || _task2 === void 0 || _task2.task().then(function (res) {
+              var _task2$onFinished;
+              _task2 === null || _task2 === void 0 || (_task2$onFinished = _task2.onFinished) === null || _task2$onFinished === void 0 || _task2$onFinished.call(_task2, [null, res]);
+            }).catch(function (err) {
+              var _task2$onFinished2;
+              _task2 === null || _task2 === void 0 || (_task2$onFinished2 = _task2.onFinished) === null || _task2$onFinished2 === void 0 || _task2$onFinished2.call(_task2, [err, null]);
+            }).finally(function () {
+              _this4.runningTasks = _this4.runningTasks.filter(function (t) {
+                return t.id !== _task2.id;
+              });
+              _task2.isPaused = false;
+              _this4.runTasks();
+            });
+          }
+        }
+      };
+      while ((this.queue.length > 0 && (_this$queue = this.queue) !== null && _this$queue !== void 0 && _this$queue.some(function (task) {
+        return !task.isPaused;
+      }) || this.pausedTasks.length > 0 && (_this$pausedTasks = this.pausedTasks) !== null && _this$pausedTasks !== void 0 && _this$pausedTasks.some(function (task) {
+        return !task.isPaused;
+      })) && this.runningTasks.length < this.maxConcurrency && !this.isPaused) {
+        var _this$queue, _this$pausedTasks;
+        _loop();
+      }
+    }
+
+    // 获取当前指定状态的任务数数量
+  }, {
+    key: "getTaskCount",
+    value: function getTaskCount(type) {
+      switch (type) {
+        case 'all':
+          return this.queue.length + this.runningTasks.length;
+        case 'running':
+          return this.runningTasks.length;
+        case 'notRunning':
+          return this.queue.length;
+        default:
+          return 0;
+      }
+    }
+  }]);
+  return TaskQueue;
+}(BaseTaskQueue);
+export default TaskQueue;

package/dist/Utils/lib/Queue/tools/BinaryHeap.d.ts

@@ -0,0 +1,25 @@
+export declare class BinaryHeap<T> {
+    private compare;
+    private heap;
+    constructor(compare: (a: T, b: T) => number);
+    private parentIndex;
+    private leftChildIndex;
+    private rightChildIndex;
+    private swap;
+    private siftUp;
+    private siftDown;
+    insert(item: T): void;
+    insertMany(items: T[]): void;
+    extractMin(): T | undefined;
+    deleteByIndex(index: number): T | undefined;
+    find(taskFilter: (task: T) => boolean): T | undefined;
+    findIndex(taskFilter: (task: T) => boolean): number;
+    peek(): T | undefined;
+    size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    forEach(callback: (item: T) => void): void;
+    filter(taskFilter: (task: T) => boolean): BinaryHeap<T>;
+    some(taskFilter: (task: T) => boolean): boolean;
+    every(taskFilter: (task: T) => boolean): boolean;
+}

package/dist/Utils/lib/Queue/tools/BinaryHeap.js

@@ -0,0 +1,184 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// 二叉堆，每次传入任务，会自动按照优先级排序
+export var BinaryHeap = /*#__PURE__*/function () {
+  function BinaryHeap(compare) {
+    _classCallCheck(this, BinaryHeap);
+    _defineProperty(this, "heap", void 0);
+    this.compare = compare;
+    this.heap = [];
+  }
+
+  // 获取父节点元素索引
+  _createClass(BinaryHeap, [{
+    key: "parentIndex",
+    value: function parentIndex(index) {
+      return Math.floor((index - 1) / 2);
+    }
+
+    // 获取左子节点元素索引
+  }, {
+    key: "leftChildIndex",
+    value: function leftChildIndex(index) {
+      return 2 * index + 1;
+    }
+
+    // 获取右子节点元素索引
+  }, {
+    key: "rightChildIndex",
+    value: function rightChildIndex(index) {
+      return 2 * index + 2;
+    }
+
+    // 交换节点
+  }, {
+    key: "swap",
+    value: function swap(originIndex, targetIndex) {
+      var _ref = [this.heap[targetIndex], this.heap[originIndex]];
+      this.heap[originIndex] = _ref[0];
+      this.heap[targetIndex] = _ref[1];
+    }
+
+    // 元素上浮
+  }, {
+    key: "siftUp",
+    value: function siftUp(index) {
+      var i = index;
+      var parent = this.parentIndex(i);
+      while (i > 0 && this.compare(this.heap[i], this.heap[parent]) < 0) {
+        this.swap(i, parent);
+        i = parent;
+        parent = this.parentIndex(i);
+      }
+    }
+
+    // 元素下沉
+  }, {
+    key: "siftDown",
+    value: function siftDown(index) {
+      var left = this.leftChildIndex(index);
+      var right = this.rightChildIndex(index);
+      var smallest = index;
+      if (left < this.heap.length && this.compare(this.heap[left], this.heap[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < this.heap.length && this.compare(this.heap[right], this.heap[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest !== index) {
+        this.swap(index, smallest);
+        this.siftDown(smallest);
+      }
+    }
+
+    // 插入元素
+  }, {
+    key: "insert",
+    value: function insert(item) {
+      this.heap.push(item);
+      this.siftUp(this.heap.length - 1);
+    }
+
+    // 批量插入元素
+  }, {
+    key: "insertMany",
+    value: function insertMany(items) {
+      var _this = this;
+      items.forEach(function (item) {
+        _this.insert(item);
+      });
+    }
+
+    // 取堆顶元素并删除
+  }, {
+    key: "extractMin",
+    value: function extractMin() {
+      if (this.heap.length === 0) {
+        return undefined;
+      }
+      if (this.heap.length === 1) {
+        return this.heap.pop();
+      }
+      var min = this.heap[0];
+      this.heap[0] = this.heap.pop();
+      this.siftDown(0);
+      return min;
+    }
+
+    // 删除指定索引元素
+  }, {
+    key: "deleteByIndex",
+    value: function deleteByIndex(index) {
+      if (index < 0 || index >= this.heap.length) {
+        return undefined;
+      }
+      if (index === 0) {
+        return this.heap.pop();
+      }
+      var item = this.heap[index];
+      this.swap(index, this.heap.length - 1);
+      this.heap.pop();
+      this.siftDown(index);
+      return item;
+    }
+  }, {
+    key: "find",
+    value: function find(taskFilter) {
+      return this.heap.find(taskFilter);
+    }
+  }, {
+    key: "findIndex",
+    value: function findIndex(taskFilter) {
+      return this.heap.findIndex(taskFilter);
+    }
+
+    // 查看堆顶元素
+  }, {
+    key: "peek",
+    value: function peek() {
+      return this.heap.length > 0 ? this.heap[0] : undefined;
+    }
+  }, {
+    key: "size",
+    value: function size() {
+      return this.heap.length;
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.heap.length === 0;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.heap = [];
+    }
+
+    // 为每个元素运行一个函数
+  }, {
+    key: "forEach",
+    value: function forEach(callback) {
+      this.heap.forEach(callback);
+    }
+  }, {
+    key: "filter",
+    value: function filter(taskFilter) {
+      var filteredTasks = this.heap.filter(taskFilter);
+      var newHeap = new BinaryHeap(this.compare);
+      newHeap.insertMany(filteredTasks);
+      return newHeap;
+    }
+  }, {
+    key: "some",
+    value: function some(taskFilter) {
+      return this.heap.some(taskFilter);
+    }
+  }, {
+    key: "every",
+    value: function every(taskFilter) {
+      return this.heap.every(taskFilter);
+    }
+  }]);
+  return BinaryHeap;
+}();

package/dist/Utils/lib/Queue/tools/publicDependencyMethod.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param fn 需要包装的函数
+ * @returns 包装后的异步函数
+ */
+export declare function asyncWrap(fn: (...args: any[]) => any): (...args: any[]) => Promise<unknown>;

package/dist/Utils/lib/Queue/tools/publicDependencyMethod.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * @param fn 需要包装的函数
+ * @returns 包装后的异步函数
+ */
+export function asyncWrap(fn) {
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return new Promise(function (resolve) {
+      try {
+        var res = fn(args);
+        if (res instanceof Promise) {
+          res.then(function (data) {
+            resolve(data);
+          });
+        } else {
+          resolve(res);
+        }
+      } catch (error) {
+        resolve(error);
+      }
+    });
+  };
+}

package/dist/Utils/lib/Queue/types/baseTaskQueue.d.ts

@@ -0,0 +1,23 @@
+export declare abstract class BaseTaskQueue<T, U> {
+    queue: T | undefined;
+    constructor(queue?: T);
+    abstract addTask(task: U | U[]): any;
+    abstract runTasks(): any;
+    abstract pauseTask(taskFilter: (task: U) => boolean): any;
+    abstract resumeTask(taskFilter: (task: U) => boolean): any;
+    abstract cancelTask(taskFilter: (task: U) => boolean): any;
+    abstract getTaskCount(type: 'all' | 'running' | 'notRunning'): number;
+}
+export interface Task {
+    id: any;
+    task: () => any;
+    pause?: () => any;
+    resume?: () => any;
+    cancel?: () => any;
+    isPaused?: boolean;
+    onFinished?: (result: [null, any] | [any, null]) => any;
+    [key: string | symbol]: any;
+}
+export type TaskConfig = {
+    [P in keyof Task]: P extends 'task' ? () => Promise<any> : Task[P];
+};

package/dist/Utils/lib/Queue/types/baseTaskQueue.js

@@ -0,0 +1,10 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export var BaseTaskQueue = /*#__PURE__*/_createClass(function BaseTaskQueue(queue) {
+  _classCallCheck(this, BaseTaskQueue);
+  _defineProperty(this, "queue", void 0);
+  this.queue = queue;
+}
+// 添加任务
+);

package/dist/Utils/lib/copyToClipboard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @name 复制粘贴内容
+ * @description 尝试将给定的文本复制到剪切板
+ * @param text 要复制的文本
+ * @param successStr 成功提示
+ * @param failedStr 失败提示
+ */
+export default function copyToClipboard(text: string, onSuccess?: () => void, onFail?: () => void): Promise<void>;

package/dist/Utils/lib/copyToClipboard.js

@@ -0,0 +1,54 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+/**
+ * @name 复制粘贴内容
+ * @description 尝试将给定的文本复制到剪切板
+ * @param text 要复制的文本
+ * @param successStr 成功提示
+ * @param failedStr 失败提示
+ */
+export default function copyToClipboard(_x, _x2, _x3) {
+  return _copyToClipboard.apply(this, arguments);
+}
+function _copyToClipboard() {
+  _copyToClipboard = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(text, onSuccess, onFail) {
+    var textarea;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return navigator.clipboard.writeText(text);
+        case 3:
+          onSuccess === null || onSuccess === void 0 || onSuccess();
+          _context.next = 9;
+          break;
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](0);
+          // 在某些浏览器中，可能需要回退到使用document.execCommand
+          // 但请注意，document.execCommand已被废弃，不推荐使用
+          if (typeof document !== 'undefined' && document.queryCommandSupported && document.queryCommandSupported('copy')) {
+            textarea = document.createElement('textarea');
+            textarea.textContent = text;
+            textarea.style.position = 'fixed'; // 防止滚动
+            document.body.appendChild(textarea);
+            textarea.select();
+            try {
+              if (document.execCommand('copy')) {
+                onSuccess === null || onSuccess === void 0 || onSuccess();
+              }
+            } catch (err) {
+              console.error(err);
+              onFail === null || onFail === void 0 || onFail();
+            }
+            document.body.removeChild(textarea);
+          }
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return _copyToClipboard.apply(this, arguments);
+}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import McFonts from './McFonts';
+import McGroupPanel from './McGroupPanel';
+import McIconFont from './McIconFont';
+import McInputNumber from './McInputNumber';
+import McLazyLoader from './McLazyLoader';
+import McModalProvider from './McModalProvider';
+import McPeriodSelect from './McPeriodSelect';
+import McPopoverButton from './McPopoverButton';
+import McPopoverForm from './McPopoverForm';
+import McProSelect from './McProSelect';
+import McResult from './McResult';
+import McTag from './McTag';
+import McThemeConfig from './McThemeConfig';
+import McTreePanel from './McTreePanel';
+import McTreeSelect from './McTreeSelect';
+import McUpload from './McUpload';
+import * as Utils from './Utils';
+export * from './McCascader';
+export { default as McCascader } from './McCascader';
+export * from './McContainer';
+export { default as McContainer } from './McContainer';
+export * from './McDateRange';
+export { default as McDateRange } from './McDateRange';
+export * from './McEllipsis';
+export * from './McEllipsisMiddle';
+export * from './McInput';
+export { default as McInput } from './McInput';
+export * from './McListSelect';
+export { default as McListSelect } from './McListSelect';
+export * from './McSelect';
+export { default as McSelect } from './McSelect';
+export * from './McUpload';
+export type { Task, TaskConfig } from './Utils/lib/Queue/types/baseTaskQueue';
+export { McFonts, McGroupPanel, McIconFont, McInputNumber, McLazyLoader, McModalProvider, McPeriodSelect, McPopoverButton, McPopoverForm, McProSelect, McResult, McTag, McThemeConfig, McTreePanel, McTreeSelect, McUpload, Utils, };

package/dist/index.js

@@ -0,0 +1,33 @@
+import McFonts from "./McFonts";
+import McGroupPanel from "./McGroupPanel";
+import McIconFont from "./McIconFont";
+import McInputNumber from "./McInputNumber";
+import McLazyLoader from "./McLazyLoader";
+import McModalProvider from "./McModalProvider";
+import McPeriodSelect from "./McPeriodSelect";
+import McPopoverButton from "./McPopoverButton";
+import McPopoverForm from "./McPopoverForm";
+import McProSelect from "./McProSelect";
+import McResult from "./McResult";
+import McTag from "./McTag";
+import McThemeConfig from "./McThemeConfig";
+import McTreePanel from "./McTreePanel";
+import McTreeSelect from "./McTreeSelect";
+import McUpload from "./McUpload";
+import * as Utils from "./Utils";
+export * from "./McCascader";
+export { default as McCascader } from "./McCascader";
+export * from "./McContainer";
+export { default as McContainer } from "./McContainer";
+export * from "./McDateRange";
+export { default as McDateRange } from "./McDateRange";
+export * from "./McEllipsis";
+export * from "./McEllipsisMiddle";
+export * from "./McInput";
+export { default as McInput } from "./McInput";
+export * from "./McListSelect";
+export { default as McListSelect } from "./McListSelect";
+export * from "./McSelect";
+export { default as McSelect } from "./McSelect";
+export * from "./McUpload";
+export { McFonts, McGroupPanel, McIconFont, McInputNumber, McLazyLoader, McModalProvider, McPeriodSelect, McPopoverButton, McPopoverForm, McProSelect, McResult, McTag, McThemeConfig, McTreePanel, McTreeSelect, McUpload, Utils };

package/dist/styles/demo/basic.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/styles/demo/basic.js

@@ -0,0 +1,44 @@
+import { Form, Radio } from 'antd';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export default (function () {
+  return /*#__PURE__*/_jsxs("div", {
+    children: [/*#__PURE__*/_jsx(Form.Item, {
+      label: ".text-center",
+      children: /*#__PURE__*/_jsx("div", {
+        style: {
+          width: 100,
+          border: '1px solid grey'
+        },
+        className: "text-center",
+        children: "\u6587\u5B57\u5C45\u4E2D"
+      })
+    }), /*#__PURE__*/_jsx(Form.Item, {
+      label: ".text-ellipsis",
+      children: /*#__PURE__*/_jsx("div", {
+        style: {
+          width: 100,
+          border: '1px solid grey'
+        },
+        className: "text-ellipsis",
+        children: "\u5C3E\u90E8\u8D85\u51FA\u7701\u7565\u5C3E\u90E8\u8D85\u51FA\u7701\u7565\u5C3E\u90E8\u8D85\u51FA\u7701\u7565\u5C3E\u90E8\u8D85\u51FA\u7701\u7565"
+      })
+    }), /*#__PURE__*/_jsx(Form.Item, {
+      label: "\u7B49\u5BBDRadioButton .equal-radio-group",
+      children: /*#__PURE__*/_jsxs(Radio.Group, {
+        className: "equal-radio-group",
+        value: "a",
+        children: [/*#__PURE__*/_jsx(Radio.Button, {
+          value: "a",
+          children: "A"
+        }), /*#__PURE__*/_jsx(Radio.Button, {
+          value: "b",
+          children: "B"
+        }), /*#__PURE__*/_jsx(Radio.Button, {
+          value: "c",
+          children: "C\u5F88\u957F\u5F88\u957F"
+        })]
+      })
+    })]
+  });
+});

package/dist/styles/demo/delete-icon.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("react/jsx-runtime").JSX.Element;
+export default _default;