zmdms-webui 3.1.2 → 3.1.3

package/dist/es/asyncdynamicsetting/storage/index.js

@@ -0,0 +1,21 @@
+import { LocalStorageAdapter } from './localStorageAdapter.js';
+import { IndexedDBAdapter } from './indexedDBAdapter.js';
+
+/**
+ * 创建存储适配器
+ * @param config 存储配置
+ * @returns 存储适配器实例
+ */
+function createStorageAdapter(config) {
+    var type = (config === null || config === void 0 ? void 0 : config.type) || "localStorage";
+    if (type === "indexedDB") {
+        return new IndexedDBAdapter({
+            dbName: config === null || config === void 0 ? void 0 : config.dbName,
+            storeName: config === null || config === void 0 ? void 0 : config.storeName,
+        });
+    }
+    // 默认使用 localStorage
+    return new LocalStorageAdapter();
+}
+
+export { IndexedDBAdapter, LocalStorageAdapter, createStorageAdapter };

package/dist/es/asyncdynamicsetting/storage/indexedDBAdapter.js

@@ -0,0 +1,79 @@
+import { __awaiter, __generator } from '../../_virtual/_tslib.js';
+import localforage from '../../node_modules/localforage/dist/localforage.js';
+
+/**
+ * IndexedDB 存储适配器
+ * 使用 localforage 库实现异步操作
+ */
+var IndexedDBAdapter = /** @class */ (function () {
+    function IndexedDBAdapter(config) {
+        this.instance = localforage.createInstance({
+            name: (config === null || config === void 0 ? void 0 : config.dbName) || "zmdms_dynamic_setting",
+            storeName: (config === null || config === void 0 ? void 0 : config.storeName) || "dynamic_settings",
+            driver: localforage.INDEXEDDB,
+        });
+    }
+    IndexedDBAdapter.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var value, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.instance.getItem(key)];
+                    case 1:
+                        value = _a.sent();
+                        return [2 /*return*/, value !== null && value !== void 0 ? value : null];
+                    case 2:
+                        err_1 = _a.sent();
+                        console.error("IndexedDB.getItem error:", err_1);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IndexedDBAdapter.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.instance.setItem(key, value)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_2 = _a.sent();
+                        console.error("IndexedDB.setItem error:", err_2);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    IndexedDBAdapter.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.instance.removeItem(key)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_3 = _a.sent();
+                        console.error("IndexedDB.removeItem error:", err_3);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return IndexedDBAdapter;
+}());
+
+export { IndexedDBAdapter };

package/dist/es/asyncdynamicsetting/storage/localStorageAdapter.js

@@ -0,0 +1,53 @@
+import { __awaiter, __generator } from '../../_virtual/_tslib.js';
+
+/**
+ * localStorage 存储适配器
+ * 将同步的 localStorage API 封装为异步 API
+ */
+var LocalStorageAdapter = /** @class */ (function () {
+    function LocalStorageAdapter() {
+    }
+    LocalStorageAdapter.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    return [2 /*return*/, localStorage.getItem(key)];
+                }
+                catch (err) {
+                    console.error("localStorage.getItem error:", err);
+                    return [2 /*return*/, null];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    LocalStorageAdapter.prototype.setItem = function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    localStorage.setItem(key, value);
+                }
+                catch (err) {
+                    console.error("localStorage.setItem error:", err);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    LocalStorageAdapter.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    localStorage.removeItem(key);
+                }
+                catch (err) {
+                    console.error("localStorage.removeItem error:", err);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return LocalStorageAdapter;
+}());
+
+export { LocalStorageAdapter };

package/dist/es/asyncdynamicsetting/useAsyncDrawer.js

@@ -0,0 +1,56 @@
+import { useState, useCallback } from 'react';
+import { getSetDynamicKey } from './useAsyncDynamic.js';
+import '../config/ZtxkContext.js';
+import useBaseContext from '../config/useBaseContext.js';
+import '../config/MyStorage.js';
+
+function useAsyncDrawer(currentDynamicList, setCurrentDynamicList, dynamicKey, parentDynamicKey, setTempDynamicList, list, onCurrentListChange, adapter) {
+    // 控制抽屉显示隐藏
+    var _a = useState(false), visible = _a[0], setVisible = _a[1];
+    var customConfigFetch = useBaseContext().customConfigFetch;
+    // 设置缓存数据的方法
+    var setDynamicKey = useCallback(function () {
+        return getSetDynamicKey(adapter, parentDynamicKey, "".concat(parentDynamicKey, "_lru_key"), customConfigFetch);
+    }, [parentDynamicKey, adapter, customConfigFetch]);
+    // 关闭
+    var onClose = useCallback(function () {
+        setVisible(false);
+        setTempDynamicList(currentDynamicList);
+    }, [setTempDynamicList, currentDynamicList]);
+    // 重置 (回到用户配置状态)
+    var onReset = useCallback(function () {
+        setVisible(false);
+        setCurrentDynamicList(list);
+        onCurrentListChange(list);
+        setTempDynamicList(list);
+        // 异步保存
+        setDynamicKey()(dynamicKey, list);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        list,
+        setCurrentDynamicList,
+        dynamicKey,
+        setDynamicKey,
+        setTempDynamicList,
+    ]);
+    // 确认修改
+    var onSure = useCallback(function (newList) {
+        setVisible(false);
+        setCurrentDynamicList(newList);
+        setTempDynamicList(newList);
+        onCurrentListChange(newList);
+        // 异步保存
+        setDynamicKey()(dynamicKey, newList);
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [setCurrentDynamicList, dynamicKey, setDynamicKey, setTempDynamicList]);
+    return {
+        visible: visible,
+        setVisible: setVisible,
+        onClose: onClose,
+        onReset: onReset,
+        onSure: onSure,
+    };
+}
+
+export { useAsyncDrawer };

package/dist/es/asyncdynamicsetting/useAsyncDynamic.js

@@ -0,0 +1,254 @@
+import { __awaiter, __generator, __assign } from '../_virtual/_tslib.js';
+import { useState, useEffect } from 'react';
+
+var LRU_MAX_SIZE = 1000;
+/**
+ * 递归处理动态配置项 - 将缓存数据合并到配置列表中
+ */
+function recursionDynamicItems(list, currentDynamicList) {
+    list.forEach(function (item, index) {
+        var _a;
+        var result = __assign({ checked: true }, item);
+        var currentData = (_a = currentDynamicList === null || currentDynamicList === void 0 ? void 0 : currentDynamicList.find) === null || _a === void 0 ? void 0 : _a.call(currentDynamicList, function (currentDynamic) { return currentDynamic.key === result.key; });
+        if (currentData) {
+            currentData.label = result.label;
+            currentData.isFind = true;
+            currentData.disabled = result.disabled;
+            currentData.isDimension = result.isDimension;
+            currentData.dimensionPriority = result.dimensionPriority;
+            currentData.dimensionGroup = result.dimensionGroup;
+            currentData.dimensionExclusive = result.dimensionExclusive;
+            if (item.children) {
+                var children = item.children;
+                if (!currentData.children) {
+                    currentData.children = [];
+                }
+                var dynamicChildren = currentData.children;
+                recursionDynamicItems(children, dynamicChildren);
+            }
+        }
+        else {
+            var resultChildren = null;
+            if (Array.isArray(result.children) && result.children.length > 0) {
+                resultChildren = recursionAddFind(result.children);
+            }
+            if (resultChildren) {
+                result.children = resultChildren;
+            }
+            if (index <= currentDynamicList.length - 1) {
+                currentDynamicList.splice(index, 0, __assign(__assign({}, result), { isFind: true }));
+                if (result.indexs) {
+                    var recursionIndexs_1 = function (dynamicList, indexs, parentIndex) {
+                        if (Array.isArray(dynamicList)) {
+                            dynamicList.forEach(function (item, index) {
+                                var newIndexs = indexs ? indexs.slice() : [];
+                                newIndexs.push(parentIndex ? parentIndex + index : index);
+                                item.indexs = newIndexs;
+                                if (Array.isArray(item.children)) {
+                                    recursionIndexs_1(item.children, indexs);
+                                }
+                            });
+                        }
+                    };
+                    recursionIndexs_1(currentDynamicList.slice(index + 1), [], index + 1);
+                }
+            }
+            else {
+                currentDynamicList.push(__assign(__assign({}, result), { isFind: true }));
+            }
+        }
+    });
+}
+function recursionAddFind(list) {
+    var newList = [];
+    list.forEach(function (item) {
+        var newItem = __assign(__assign({}, item), { checked: item.checked !== undefined ? item.checked : true });
+        if (newItem.children) {
+            newItem.children = recursionAddFind(newItem.children);
+        }
+        newList.push(__assign(__assign({}, newItem), { isFind: true }));
+    });
+    return newList;
+}
+function recursionDeleteDynamicItems(currentDynamicList) {
+    return currentDynamicList
+        .filter(function (item) {
+        if (item.isFind) {
+            if (Array.isArray(item.children)) {
+                item.children = recursionDeleteDynamicItems(item.children);
+            }
+            return true;
+        }
+        return false;
+    })
+        .map(function (item) {
+        var result = __assign({}, item);
+        Reflect.deleteProperty(result, "isFind");
+        return result;
+    });
+}
+/**
+ * 异步获取动态配置项
+ */
+function getDynamicItems(adapter, dynamicKey, parentDynamicKey, list) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dynamicList, objStr, obj, err_1, currentDynamicList;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!parentDynamicKey || !Array.isArray(list)) {
+                        return [2 /*return*/, []];
+                    }
+                    dynamicList = [];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, adapter.getItem(parentDynamicKey)];
+                case 2:
+                    objStr = _a.sent();
+                    obj = objStr ? JSON.parse(objStr) : {};
+                    dynamicList = dynamicKey ? obj[dynamicKey] : [];
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _a.sent();
+                    console.log("getDynamicItems error:", err_1);
+                    return [3 /*break*/, 4];
+                case 4:
+                    currentDynamicList = Array.isArray(dynamicList) && dynamicList.length > 0 ? dynamicList : [];
+                    if (!dynamicList || dynamicList.length === 0) {
+                        list.forEach(function (item) {
+                            var result = __assign(__assign({}, item), { checked: item.checked !== undefined ? item.checked : true });
+                            if (result.children) {
+                                result.children = recursionAddFind(result.children);
+                            }
+                            currentDynamicList.push(__assign(__assign({}, result), { isFind: true }));
+                        });
+                    }
+                    else {
+                        recursionDynamicItems(list, currentDynamicList);
+                    }
+                    return [2 /*return*/, recursionDeleteDynamicItems(currentDynamicList)];
+            }
+        });
+    });
+}
+/**
+ * 获取设置动态键的函数
+ */
+function getSetDynamicKey(adapter, LOCAL_STORAGE_KEY, LOCAL_STORAGE_LRU_KEY, customConfigFetch) {
+    var _this = this;
+    return function (dynamicStorageKey, value) { return __awaiter(_this, void 0, void 0, function () {
+        var obj, lruKeys, objStr, lruStr, err_2, currentKeyIndex, length, oldKey, data, lruData;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    obj = {};
+                    lruKeys = [];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, adapter.getItem(LOCAL_STORAGE_KEY)];
+                case 2:
+                    objStr = _a.sent();
+                    return [4 /*yield*/, adapter.getItem(LOCAL_STORAGE_LRU_KEY)];
+                case 3:
+                    lruStr = _a.sent();
+                    obj = objStr ? JSON.parse(objStr) : {};
+                    lruKeys = lruStr ? JSON.parse(lruStr) : [];
+                    return [3 /*break*/, 5];
+                case 4:
+                    err_2 = _a.sent();
+                    console.error("getSetDynamicKey error:", err_2);
+                    return [3 /*break*/, 5];
+                case 5:
+                    if (lruKeys.length !== Object.keys(obj).length) {
+                        lruKeys = Object.keys(obj);
+                    }
+                    currentKeyIndex = lruKeys.findIndex(function (lruKey) { return lruKey === dynamicStorageKey; });
+                    if (currentKeyIndex !== -1) {
+                        lruKeys.splice(currentKeyIndex, 1);
+                        lruKeys.push(dynamicStorageKey);
+                    }
+                    else {
+                        lruKeys.push(dynamicStorageKey);
+                    }
+                    length = lruKeys.length;
+                    if (length > LRU_MAX_SIZE) {
+                        oldKey = lruKeys.shift();
+                        try {
+                            delete obj[oldKey];
+                        }
+                        catch (err) {
+                            //
+                        }
+                    }
+                    obj[dynamicStorageKey] = value;
+                    data = JSON.stringify(obj);
+                    lruData = JSON.stringify(lruKeys);
+                    return [4 /*yield*/, adapter.setItem(LOCAL_STORAGE_KEY, data)];
+                case 6:
+                    _a.sent();
+                    return [4 /*yield*/, adapter.setItem(LOCAL_STORAGE_LRU_KEY, lruData)];
+                case 7:
+                    _a.sent();
+                    try {
+                        customConfigFetch === null || customConfigFetch === void 0 ? void 0 : customConfigFetch({
+                            customKey: LOCAL_STORAGE_KEY,
+                            customValue: data,
+                            mark: "表单动态列配置缓存数据-新版组件库",
+                        });
+                        customConfigFetch === null || customConfigFetch === void 0 ? void 0 : customConfigFetch({
+                            customKey: LOCAL_STORAGE_LRU_KEY,
+                            customValue: lruData,
+                            mark: "表单动态列配置缓存LRUKey数据-新版组件库",
+                        });
+                    }
+                    catch (err) {
+                        console.error("\u8BBE\u7F6E\u52A8\u6001\u5217\u7F13\u5B58\u6570\u636E\u5931\u8D25!", err);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+}
+/**
+ * 获取当前动态配置项
+ */
+function getCurrentDynamicItems(adapter, dynamicKey, parentDynamicKey, list) {
+    return getDynamicItems(adapter, dynamicKey, parentDynamicKey, list || []);
+}
+/**
+ * useAsyncDynamic Hook
+ * 统一异步存储的动态配置
+ */
+function useAsyncDynamic(dynamicKey, parentDynamicKey, list, adapter) {
+    // 初始状态使用传入的 list，避免闪烁
+    var _a = useState(list), currentDynamicList = _a[0], setCurrentDynamicList = _a[1];
+    var _b = useState(list), tempDynamicList = _b[0], setTempDynamicList = _b[1];
+    var _c = useState(false), isReady = _c[0], setIsReady = _c[1];
+    // 异步加载存储数据
+    useEffect(function () {
+        var cancelled = false;
+        getDynamicItems(adapter, dynamicKey, parentDynamicKey, list).then(function (result) {
+            if (!cancelled) {
+                setCurrentDynamicList(result);
+                setTempDynamicList(result);
+                setIsReady(true);
+            }
+        });
+        return function () {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [dynamicKey, parentDynamicKey, adapter, list]);
+    return {
+        currentDynamicList: currentDynamicList,
+        setCurrentDynamicList: setCurrentDynamicList,
+        tempDynamicList: tempDynamicList,
+        setTempDynamicList: setTempDynamicList,
+        isReady: isReady,
+        adapter: adapter,
+    };
+}
+
+export { getCurrentDynamicItems, getSetDynamicKey, useAsyncDynamic };

package/dist/es/asyncdynamicsetting/useSearch.js

@@ -0,0 +1,98 @@
+import { __spreadArray } from '../_virtual/_tslib.js';
+import { useState } from 'react';
+import myMessage from '../message/index.js';
+
+function useSearch(dynamicList, checkedValues, isDimensionDynamic) {
+    // 过滤后的可见列集合（仅操作此集合中的列）
+    var _a = useState(null), filterDynamicColumns = _a[0], setFilterDynamicColumns = _a[1];
+    // 未参与过滤的列，但是选中了的值
+    var _b = useState([]), filterCheckedValues = _b[0], setFilterCheckedValues = _b[1];
+    /**
+     * @description 表格列动态显示/隐藏 - 全选/反选按钮点击回调
+     * @author （可补充作者姓名）
+     * @param {('all' | 'inverse')} type - 操作类型：'all' 全选（仅对「过滤后可见+可动态操作」列生效），'inverse' 反选（同上）
+     * @see dynamicColumns - 原始完整表格列集合（包含所有列）
+     * @see filterDynamicColumns - 过滤后的可见列集合（仅操作此集合中的列）
+     * @see checkedValues - 已选中的列 key 集合（状态变量）
+     * @see setCheckedValues - 更新选中列的状态函数
+     * @note 核心规则（解决「过滤后操作不影响过滤前数据」的核心诉求）：
+     *  1. 操作范围严格限制：仅对「过滤后可见列（filterDynamicColumns 优先，无则 dynamicColumns）+ 可动态操作（isNoDynamicHide: false）」的列生效
+     *  2. 过滤后隐藏的列（未在 targetColumns 中）：无论是否可动态，均不参与全选/反选，保持其原始选中状态不变
+     *  3. 禁止动态隐藏的列（isNoDynamicHide: true）：即使在过滤后可见，也不参与全选/反选，保持原始选中状态
+     *  4. 仅当操作后选中状态发生变化时才更新，避免无效渲染
+     */
+    var onCheckBtn = function (type, onCheckboxChange) {
+        if (isDimensionDynamic) {
+            myMessage.warn("维度列不支持全选/反选");
+            return;
+        }
+        // 1. 确定操作的目标列集合：仅对「过滤后可见列」操作（优先 filterDynamicColumns，无则用 dynamicColumns）
+        var targetColumns = filterDynamicColumns !== null && filterDynamicColumns !== void 0 ? filterDynamicColumns : dynamicList;
+        // 2. 拆分目标列中的两类列（仅在可见列范围内处理）
+        // 2.1 「可操作列」：过滤后可见 + 允许动态隐藏（isNoDynamicHide: false）→ 参与全选/反选
+        var operableKeys = targetColumns
+            .filter(function (column) { return !column.disabled; })
+            .map(function (column) { return column.key; });
+        var operableLen = operableKeys.length;
+        // 2.2 「不可操作列」：过滤后可见 + 禁止动态隐藏（isNoDynamicHide: true）→ 不参与操作，保留原选中状态
+        var visibleNonOperableKeys = targetColumns
+            .filter(function (column) { return column.disabled; })
+            .map(function (column) { return column.key; });
+        // 3. 拆分当前已选中的 keys（确保「过滤后隐藏的列」状态不变）
+        // 3.1 已选中的「过滤后隐藏的列」：无论是否可动态，均保留原状态（不参与本次操作）
+        var hiddenCheckedKeys = checkedValues.filter(function (key) { return !targetColumns.some(function (column) { return column.key === key; }); } // 不在目标列（过滤后隐藏）的选中项
+        );
+        // 3.2 已选中的「可见不可操作列」：保留原选中状态
+        var visibleNonOperableCheckedKeys = checkedValues.filter(function (key) {
+            return visibleNonOperableKeys.includes(key);
+        });
+        // 3.3 已选中的「可见可操作列」：参与本次全选/反选
+        var operableCheckedKeys = checkedValues.filter(function (key) {
+            return operableKeys.includes(key);
+        });
+        // 4. 全选逻辑：仅选中「可见可操作列」，其他列（隐藏列、可见不可操作列）保持原状态
+        if (type === "all") {
+            // 边界判断：仅当「已选中的可操作列数 ≠ 可操作列总数」时才更新（避免无效渲染）
+            if (operableCheckedKeys.length !== operableLen) {
+                onCheckboxChange(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], filterCheckedValues, true), operableKeys, true), visibleNonOperableCheckedKeys, true), hiddenCheckedKeys, true));
+            }
+            return;
+        }
+        // 5. 反选逻辑：仅反选「可见可操作列」，其他列保持原状态
+        var inversedOperableKeys = operableKeys.filter(function (key) { return !operableCheckedKeys.includes(key); });
+        onCheckboxChange(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], filterCheckedValues, true), inversedOperableKeys, true), visibleNonOperableCheckedKeys, true), hiddenCheckedKeys, true));
+    };
+    /**
+     * @description 搜索过滤触发的回调
+     * @param value 搜索值
+     */
+    var onSearchHandle = function (value) {
+        if (!value) {
+            setFilterCheckedValues([]);
+            setFilterDynamicColumns(null);
+            return;
+        }
+        var filterColumns = dynamicList.filter(function (column) {
+            var _a, _b, _c;
+            var title = column.label || column.key;
+            return (_c = (_b = (_a = title === null || title === void 0 ? void 0 : title.toLowerCase) === null || _a === void 0 ? void 0 : _a.call(title)) === null || _b === void 0 ? void 0 : _b.includes) === null || _c === void 0 ? void 0 : _c.call(_b, value.toLowerCase());
+        });
+        // 未参与过滤的列，单独缓存起来
+        setFilterCheckedValues(checkedValues.filter(function (key) { return !filterColumns.find(function (column) { return column.key === key; }); }));
+        setFilterDynamicColumns(filterColumns);
+    };
+    return {
+        onSearchHandle: onSearchHandle,
+        onCheckBtn: onCheckBtn,
+        /** 未参与过滤的列，但是选中了的值 */
+        filterCheckedValues: filterCheckedValues,
+        /** 设置未参与过滤的列，但是选中了的值 */
+        setFilterCheckedValues: setFilterCheckedValues,
+        /** 过滤后的列 */
+        filterDynamicColumns: filterDynamicColumns,
+        /** 设置过滤后的列 */
+        setFilterDynamicColumns: setFilterDynamicColumns,
+    };
+}
+
+export { useSearch as default };

package/dist/index.build.d.ts

@@ -11,6 +11,9 @@ export { ILoginChildrenProps, default as Login } from './es/login/index.js';
 export { default as Icon } from './es/icon/index.js';
 export { default as IconOss } from './es/icon/icon-oss.js';
 export { default as DynamicSetting } from './es/dynamicsetting/dynamicSetting.js';
+export { default as AsyncDynamicSetting } from './es/asyncdynamicsetting/asyncDynamicSetting.js';
+export { IAsyncDynamicDrawerProps, IDynamicItem as IAsyncDynamicItem, IRef as IAsyncDynamicRef, IAsyncDynamicSettingProps, IFilter as IAsyncFilter, IStorageConfig, StorageType } from './es/asyncdynamicsetting/interface.js';
+export { IStorageAdapter } from './es/asyncdynamicsetting/storage/IStorageAdapter.js';
 export { default as Form } from './es/form/form.js';
 export { default as FormItem } from './es/formitem/formItem.js';
 export { default as Container } from './es/container/container.js';