bkui-vue 0.0.1-beta.74 → 0.0.1-beta.75

package/dist/index.esm.js

@@ -8888,7 +8888,7 @@ var Component$u = defineComponent({
         "mode": props.loadingMode,
         "theme": loadingTheme.value,
         "size": loadingSize.value
-      }, null), slots.default && createVNode("span", {
+      }, null), slots.default && !props.loading && createVNode("span", {
         "class": `${btnClsPrefix}-text`
       }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])]);
     };
@@ -16289,10 +16289,7 @@ const collapseMotion = () => ({
 });
 const menuProps = {
   activeKey: String,
-  collapse: {
-    type: Boolean,
-    default: false
-  },
+  collapse: Boolean,
   openedKeys: {
     type: Array
   },
@@ -16311,7 +16308,8 @@ var Component$6 = defineComponent({
   emits: ["update:activeKey", "update:openKeys", "click", "openChange"],
   setup(props, {
     slots,
-    emit
+    emit,
+    expose
   }) {
     const activeKey = ref("");
     const openedKeys = ref([]);
@@ -16319,11 +16317,6 @@ var Component$6 = defineComponent({
     const mode = computed(() => props.mode);
     const collapse2 = ref(props.collapse);
     const oldOpenKeys = ref([]);
-    watch(() => props.openedKeys, (keys = openedKeys.value) => {
-      openedKeys.value = keys;
-    }, {
-      immediate: true
-    });
     watchEffect(() => {
       if (props.activeKey !== void 0) {
         activeKey.value = props.activeKey;
@@ -16331,6 +16324,7 @@ var Component$6 = defineComponent({
     });
     watch(() => props.collapse, () => {
       collapse2.value = props.collapse;
+      console.info(props.collapse);
       const oldKeys = [...oldOpenKeys.value];
       const openKeys = [...openedKeys.value];
       openedKeys.value = collapse2.value ? [] : oldKeys;
@@ -16338,6 +16332,11 @@ var Component$6 = defineComponent({
     }, {
       immediate: true
     });
+    watch(() => props.openedKeys, (keys = openedKeys.value) => {
+      openedKeys.value = keys;
+    }, {
+      immediate: true
+    });
     const registerMenuInfo = (key, info2) => {
       menuStore.value = __spreadProps(__spreadValues({}, menuStore.value), {
         [key]: info2
@@ -16375,6 +16374,11 @@ var Component$6 = defineComponent({
       handleOpenChange,
       handleActiveChange
     });
+    expose({
+      activeKey,
+      openedKeys,
+      menuStore
+    });
     return () => {
       var _a;
       return createVNode("div", {
@@ -16382,7 +16386,7 @@ var Component$6 = defineComponent({
           "bk-menu": true,
           "is-collapse": collapse2.value
         }
-      }, [(_a = slots == null ? void 0 : slots.default) == null ? void 0 : _a.call(slots)]);
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
     };
   }
 });
@@ -21085,8 +21089,18 @@ var NODE_ATTRIBUTES = /* @__PURE__ */ ((NODE_ATTRIBUTES2) => {
   NODE_ATTRIBUTES2["IS_NULL"] = "__IS_NULL";
   NODE_ATTRIBUTES2["IS_CACHED"] = "__is_cached";
   NODE_ATTRIBUTES2["IS_ASYNC"] = "__is_async";
+  NODE_ATTRIBUTES2["IS_LOADING"] = "__is_loading";
   return NODE_ATTRIBUTES2;
 })(NODE_ATTRIBUTES || {});
+const NODE_SOURCE_ATTRS = {
+  ["__is_open"]: "isOpen",
+  ["__is_selected"]: "selected",
+  ["__is_match"]: "isMatch",
+  ["__has_child"]: "hasChild",
+  ["__is_checked"]: "checked",
+  ["__is_async"]: "async",
+  ["__is_loading"]: "loading"
+};
 const treeProps = {
   data: PropTypes.arrayOf(PropTypes.any).def([]),
   label: PropTypes.oneOfType([PropTypes.func.def(void 0), PropTypes.string.def("label")]),
@@ -21133,7 +21147,9 @@ const treeProps = {
   draggable: PropTypes.bool.def(false),
   dragSort: PropTypes.bool.def(false),
   selectable: PropTypes.bool.def(true),
-  selected: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.object]).def(null)
+  selected: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.object]).def(null),
+  autoCheckChildren: PropTypes.bool.def(true),
+  syncAction: PropTypes.bool.def(false)
 };
 var useEmpty = (props, {
   slots
@@ -21148,79 +21164,6 @@ var useEmpty = (props, {
     }
   })
 });
-var useNodeAttribute = (flatData, props) => {
-  const getSchemaVal2 = (key) => flatData.schema.get(key);
-  const getNodeAttr2 = (node, attr) => {
-    var _a;
-    return (_a = getSchemaVal2(node[NODE_ATTRIBUTES.UUID])) == null ? void 0 : _a[attr];
-  };
-  const setNodeAttr = (node, attr, val) => flatData.schema.set(node[NODE_ATTRIBUTES.UUID], __spreadProps(__spreadValues({}, getSchemaVal2(node[NODE_ATTRIBUTES.UUID])), {
-    [attr]: val
-  }));
-  const getNodePath = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.PATH);
-  const getNodeId = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.UUID);
-  const isRootNode = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_ROOT);
-  const isNodeOpened = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_OPENED);
-  const hasChildNode = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.HAS_CHILD);
-  const isNodeMatched = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_MATCH);
-  const isNodeChecked = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_CHECKED);
-  const getNodeParentId = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.PARENT_ID);
-  const getNodeParentIdById = (id) => getNodeAttr2({
-    [NODE_ATTRIBUTES.UUID]: id
-  }, NODE_ATTRIBUTES.PARENT_ID);
-  const deleteNodeSchema = (id) => flatData.schema.delete(id);
-  const isItemOpen = (item) => {
-    var _a;
-    if (typeof item === "object") {
-      return isNodeOpened(item);
-    }
-    if (typeof item === "string") {
-      return (_a = getSchemaVal2(item)) == null ? void 0 : _a[NODE_ATTRIBUTES.IS_OPENED];
-    }
-    return false;
-  };
-  const checkNodeIsOpen = (node) => isRootNode(node) || isItemOpen(node) || isItemOpen(getNodeAttr2(node, NODE_ATTRIBUTES.PARENT_ID));
-  const getSourceNodeByPath = (path) => {
-    const paths = path.split("-");
-    return paths.reduce((pre, nodeIndex) => {
-      const index = Number(nodeIndex);
-      return Array.isArray(pre) ? pre[index] : pre[props.children][index];
-    }, props.data);
-  };
-  const getSourceNodeByUID = (uid) => getSourceNodeByPath(getNodePath({
-    [NODE_ATTRIBUTES.UUID]: uid
-  }));
-  const getParentNodeData = (uid) => {
-    if (isRootNode({
-      [NODE_ATTRIBUTES.UUID]: uid
-    })) {
-      return {
-        [props.children]: props.data
-      };
-    }
-    return getSourceNodeByUID(getNodeParentIdById(uid));
-  };
-  return {
-    getSchemaVal: getSchemaVal2,
-    getNodeAttr: getNodeAttr2,
-    getNodeId,
-    getNodeParentId,
-    getNodeParentIdById,
-    getParentNodeData,
-    setNodeAttr,
-    getNodePath,
-    isRootNode,
-    isNodeOpened,
-    hasChildNode,
-    isItemOpen,
-    isNodeChecked,
-    isNodeMatched,
-    checkNodeIsOpen,
-    getSourceNodeByPath,
-    getSourceNodeByUID,
-    deleteNodeSchema
-  };
-};
 const DEFAULT_LEVLE_LINE = "1px dashed #c3cdd7";
 const getPropsOneOfBoolValueWithDefault = (props, key, item = null, defaultTrueValue = null, defaultFalseValue = null, args = []) => {
   const prop = props[key];
@@ -21318,12 +21261,114 @@ const resolveNodeItem = (node) => {
   console.error("setNodeAction Error: node id cannot found");
   return node;
 };
+var useNodeAttribute = (flatData, props) => {
+  const getSchemaVal2 = (key) => flatData.schema.get(key);
+  const getNodeAttr2 = (node, attr) => {
+    var _a;
+    return (_a = getSchemaVal2(node[NODE_ATTRIBUTES.UUID])) == null ? void 0 : _a[attr];
+  };
+  const setNodeAttr = (node, attr, val) => {
+    if (props.syncAction && NODE_SOURCE_ATTRS[attr] !== void 0) {
+      updateTreeNode(getNodePath(node), props.data, props.children, NODE_SOURCE_ATTRS[attr], val);
+    }
+    flatData.schema.set(node[NODE_ATTRIBUTES.UUID], __spreadProps(__spreadValues({}, getSchemaVal2(node[NODE_ATTRIBUTES.UUID])), {
+      [attr]: val
+    }));
+  };
+  const getNodePath = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.PATH);
+  const getNodeId = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.UUID);
+  const isRootNode = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_ROOT);
+  const isNodeOpened = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_OPENED);
+  const hasChildNode = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.HAS_CHILD);
+  const isNodeMatched = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_MATCH);
+  const isNodeChecked = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_CHECKED);
+  const getNodeParentId = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.PARENT_ID);
+  const getNodeParentIdById = (id) => getNodeAttr2({
+    [NODE_ATTRIBUTES.UUID]: id
+  }, NODE_ATTRIBUTES.PARENT_ID);
+  const isNodeLoading = (node) => getNodeAttr2(node, NODE_ATTRIBUTES.IS_LOADING);
+  const setTreeNodeLoading = (node, value) => {
+    setNodeAttr(node, NODE_ATTRIBUTES.IS_LOADING, value);
+    if (!props.syncAction) {
+      updateTreeNode(getNodePath(node), props.data, props.children, NODE_ATTRIBUTES.IS_LOADING, value);
+    }
+  };
+  const deleteNodeSchema = (id) => flatData.schema.delete(id);
+  const isItemOpen = (item) => {
+    var _a;
+    if (typeof item === "object") {
+      return isNodeOpened(item);
+    }
+    if (typeof item === "string") {
+      return (_a = getSchemaVal2(item)) == null ? void 0 : _a[NODE_ATTRIBUTES.IS_OPENED];
+    }
+    return false;
+  };
+  const checkNodeIsOpen = (node) => isRootNode(node) || isItemOpen(node) || isItemOpen(getNodeAttr2(node, NODE_ATTRIBUTES.PARENT_ID));
+  const getSourceNodeByPath = (path) => {
+    const paths = path.split("-");
+    return paths.reduce((pre, nodeIndex) => {
+      const index = Number(nodeIndex);
+      return Array.isArray(pre) ? pre[index] : pre[props.children][index];
+    }, props.data);
+  };
+  const getSourceNodeByUID = (uid) => getSourceNodeByPath(getNodePath({
+    [NODE_ATTRIBUTES.UUID]: uid
+  }));
+  const getParentNodeData = (uid) => {
+    if (isRootNode({
+      [NODE_ATTRIBUTES.UUID]: uid
+    })) {
+      return {
+        [props.children]: props.data
+      };
+    }
+    return getSourceNodeByUID(getNodeParentIdById(uid));
+  };
+  const resolveScopedSlotParam = (item) => __spreadProps(__spreadValues({}, item), {
+    loading: getNodeAttr2(item, NODE_ATTRIBUTES.IS_LOADING),
+    hasChildNode: hasChildNode(item),
+    isMatched: isNodeMatched(item),
+    isChecked: isNodeChecked(item),
+    isOpened: isNodeOpened(item),
+    isRoot: isRootNode(item),
+    fullPath: getNodeAttr2(item, NODE_ATTRIBUTES.PATH),
+    uuid: getNodeId(item),
+    parentId: getNodeAttr2(item, NODE_ATTRIBUTES.PARENT_ID)
+  });
+  return {
+    getSchemaVal: getSchemaVal2,
+    getNodeAttr: getNodeAttr2,
+    getNodeId,
+    getNodeParentId,
+    getNodeParentIdById,
+    getParentNodeData,
+    setNodeAttr,
+    getNodePath,
+    isRootNode,
+    isNodeOpened,
+    hasChildNode,
+    isItemOpen,
+    isNodeChecked,
+    isNodeMatched,
+    isNodeLoading,
+    checkNodeIsOpen,
+    getSourceNodeByPath,
+    getSourceNodeByUID,
+    deleteNodeSchema,
+    resolveScopedSlotParam,
+    setTreeNodeLoading
+  };
+};
 var useNodeAsync = (props, flatData) => {
   const {
     setNodeAttr,
     getNodePath,
-    getNodeAttr: getNodeAttr2
-  } = useNodeAttribute(flatData);
+    getNodeAttr: getNodeAttr2,
+    isNodeOpened,
+    resolveScopedSlotParam,
+    setTreeNodeLoading
+  } = useNodeAttribute(flatData, props);
   const setNodeRemoteLoad = (resp, item) => {
     if (typeof resp === "object" && resp !== null) {
       setNodeAttr(item, NODE_ATTRIBUTES.IS_OPENED, true);
@@ -21334,34 +21379,39 @@ var useNodeAsync = (props, flatData) => {
     return Promise.reject(resp);
   };
   const asyncNodeClick = (item) => {
-    if (getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC)) {
-      const {
-        callback = null,
-        cache = true
-      } = props.async || {};
+    const {
+      callback = null,
+      cache = true
+    } = props.async || {};
+    if (typeof callback === "function" && getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC) !== false) {
+      const isAsyncInit = getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC_INIT);
       setNodeAttr(item, NODE_ATTRIBUTES.IS_ASYNC_INIT, true);
-      if (typeof callback === "function") {
-        if (!getNodeAttr2(item, NODE_ATTRIBUTES.IS_CACHED)) {
-          setNodeAttr(item, NODE_ATTRIBUTES.IS_CACHED, cache);
-          Object.assign(item, {
-            loading: true
-          });
-          return Promise.resolve(callback(item, (resp) => setNodeRemoteLoad(resp, item)).then((resp) => setNodeRemoteLoad(resp, item)).catch((err) => console.error("load remote data error:", err)).finally(() => {
-            assignTreeNode(getNodePath(item), props.data, props.children, __spreadValues({
-              loading: false
-            }, cache ? {
-              cached: true
-            } : {}));
-          }));
+      if (!getNodeAttr2(item, NODE_ATTRIBUTES.IS_CACHED)) {
+        setNodeAttr(item, NODE_ATTRIBUTES.IS_CACHED, cache);
+        if (isNodeOpened(item) && isAsyncInit) {
+          return Promise.resolve(true);
+        }
+        const dataAttr = resolveScopedSlotParam(item);
+        const callbackResult = callback(item, (resp) => setNodeRemoteLoad(resp, item), dataAttr);
+        if (typeof callbackResult === "object" && callbackResult !== null) {
+          setTreeNodeLoading(item, true);
+          if (callbackResult instanceof Promise) {
+            return Promise.resolve(callbackResult.then((resp) => setNodeRemoteLoad(resp, item)).catch((err) => console.error("load remote data error:", err)).finally(() => {
+              setTreeNodeLoading(item, false);
+              setNodeAttr(item, NODE_ATTRIBUTES.IS_CACHED, true);
+            }));
+          }
+          setNodeRemoteLoad(callbackResult, item);
+          setTreeNodeLoading(item, false);
+          return Promise.resolve(true);
         }
-        return Promise.resolve(true);
       }
-      return Promise.reject("async need to set prop: asyncLoad with function wich will return promise object");
+      return Promise.resolve(true);
     }
     return Promise.resolve(true);
   };
   const deepAutoOpen = () => {
-    const autoOpenNodes = flatData.data.filter((item) => item.async && item.isOpen && !getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC_INIT));
+    const autoOpenNodes = flatData.data.filter((item) => getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC) && item.isOpen && !getNodeAttr2(item, NODE_ATTRIBUTES.IS_ASYNC_INIT));
     if (autoOpenNodes.length) {
       Promise.all(autoOpenNodes.map((item) => asyncNodeClick(item))).then(() => {
         deepAutoOpen();
@@ -21375,7 +21425,7 @@ var useNodeAsync = (props, flatData) => {
     deepAutoOpen
   };
 };
-var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
+var useNodeAction = (props, ctx, flatData, renderData, schemaValues, initOption) => {
   let selectedNodeId = null;
   const {
     setNodeAttr,
@@ -21387,9 +21437,12 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
     hasChildNode,
     isItemOpen,
     isNodeOpened,
-    isNodeChecked,
-    isNodeMatched
-  } = useNodeAttribute(flatData);
+    isNodeLoading,
+    resolveScopedSlotParam
+  } = useNodeAttribute(flatData, props);
+  const {
+    registerNextLoop
+  } = initOption;
   const {
     asyncNodeClick,
     deepAutoOpen
@@ -21420,11 +21473,18 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
     }
     return null;
   };
+  const getLoadingIcon = (item) => {
+    var _a, _b, _c;
+    return ((_c = (_b = (_a = ctx.slots).nodeLoading) == null ? void 0 : _b.call(_a, resolveScopedSlotParam(item))) != null ? _c : isNodeLoading(item)) ? createVNode(spinner, null, null) : "";
+  };
   const getActionIcon = (item) => {
     if (ctx.slots.nodeAction) {
       return ctx.slots.nodeAction(resolveScopedSlotParam(item));
     }
     let prefixFnVal = null;
+    if (isNodeLoading(item)) {
+      return getLoadingIcon(item);
+    }
     if (typeof props.prefixIcon === "function") {
       prefixFnVal = props.prefixIcon(resolveScopedSlotParam(item), "node_action");
       if (prefixFnVal !== "default") {
@@ -21432,7 +21492,7 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
       }
     }
     if (prefixFnVal === "default" || typeof props.prefixIcon === "boolean" && props.prefixIcon) {
-      if (hasChildNode(item) || item.async) {
+      if (hasChildNode(item) || item.async || !props.autoCheckChildren) {
         return isItemOpen(item) ? createVNode(downShape, null, null) : createVNode(rightShape, null, null);
       }
     }
@@ -21456,10 +21516,6 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
     }
     return null;
   };
-  const getLoadingIcon = (item) => {
-    var _a, _b, _c;
-    return ((_c = (_b = (_a = ctx.slots).nodeLoading) == null ? void 0 : _b.call(_a, resolveScopedSlotParam(item))) != null ? _c : item.loading) ? createVNode(spinner, null, null) : "";
-  };
   const setNodeOpened = (item, isOpen = null, e = null, fireEmit = true) => {
     const newVal = isOpen === null ? !isItemOpen(item) : !!isOpen;
     setNodeAttr(item, NODE_ATTRIBUTES.IS_OPENED, newVal);
@@ -21499,8 +21555,17 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
     }
   };
   const hanldeTreeNodeClick = (item, e) => {
-    asyncNodeClick(item);
-    setNodeOpened(item, null, e);
+    const isOpen = isNodeOpened(item);
+    asyncNodeClick(item).finally(() => {
+      if (getNodeAttr2(item, NODE_ATTRIBUTES.IS_LOADING)) {
+        registerNextLoop("setNodeOpenedAfterLoading", {
+          type: "once",
+          fn: () => setNodeOpened(item, !isOpen, e)
+        });
+      } else {
+        setNodeOpened(item, !isOpen, e);
+      }
+    });
   };
   const handleNodeActionClick = (e, node) => {
     e.stopImmediatePropagation();
@@ -21576,13 +21641,6 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
       "style": getNodeLineStyle(maxDeep - index)
     }, null));
   };
-  const resolveScopedSlotParam = (item) => __spreadProps(__spreadValues({}, item), {
-    hasChildNode: hasChildNode(item),
-    isMatched: isNodeMatched(item),
-    isChecked: isNodeChecked(item),
-    isOpened: isNodeOpened(item),
-    isRoot: isRootNode(item)
-  });
   const renderTreeNode = (item) => {
     var _a, _b, _c, _d, _e;
     return createVNode("div", {
@@ -21597,7 +21655,7 @@ var useNodeAction = (props, ctx, flatData, renderData, schemaValues) => {
       "onClick": (e) => handleNodeActionClick(e, item)
     }, [getActionIcon(item)]), createVNode("span", {
       "class": resolveClassName("node-content")
-    }, [[getNodePrefixIcon(item), getLoadingIcon(item)], createVNode("span", {
+    }, [[getNodePrefixIcon(item)], createVNode("span", {
       "class": resolveClassName("node-text")
     }, [(_c = (_b = (_a = ctx.slots).node) == null ? void 0 : _b.call(_a, resolveScopedSlotParam(item))) != null ? _c : [getLabel(item, props)]]), (_e = (_d = ctx.slots).nodeAppend) == null ? void 0 : _e.call(_d, resolveScopedSlotParam(item))]), getVirtualLines(item)])]);
   };
@@ -21944,36 +22002,44 @@ var useTreeInit = (props) => {
       }
       return uid || item[NODE_ATTRIBUTES.UUID] || uuid_1.v4();
     }
-    function getCachedTreeNodeAttr(uuid2, node, attr, cachedAttr, defVal = void 0) {
+    function getCachedTreeNodeAttr(uuid2, node, cachedAttr, defVal = void 0) {
+      const sourceAttr = NODE_SOURCE_ATTRS[cachedAttr];
+      if (Object.prototype.hasOwnProperty.call(node, sourceAttr)) {
+        return node[sourceAttr];
+      }
       const cached = (cachedSchema || []).find((item) => item[NODE_ATTRIBUTES.UUID] === uuid2);
       let result = void 0;
       if (cached) {
         result = cached[cachedAttr];
-      } else {
-        result = attr === null ? void 0 : node[attr];
       }
-      if (result === void 0) {
+      if (result === void 0 || result === null) {
         result = defVal;
       }
       return result;
     }
     function isCachedTreeNodeOpened(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, "isOpen", NODE_ATTRIBUTES.IS_OPENED, false);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_OPENED, false);
     }
     function isCachedTreeNodeChecked(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, "checked", NODE_ATTRIBUTES.IS_CHECKED, false);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_CHECKED, false);
     }
     function isCachedTreeNodeMatch(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, "isMatch", NODE_ATTRIBUTES.IS_MATCH, true);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_MATCH, true);
     }
     function isCachedTreeNodeSelected(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, null, NODE_ATTRIBUTES.IS_SELECTED, false);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_SELECTED, false);
     }
     function isCachedTreeNodeHasCached(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, "cached", NODE_ATTRIBUTES.IS_CACHED, false);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_CACHED, false);
     }
     function isCachedTreeNodeAsync(uuid2, node) {
-      return getCachedTreeNodeAttr(uuid2, node, "async", NODE_ATTRIBUTES.IS_ASYNC, false);
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_ASYNC, null);
+    }
+    function isCachedTreeNodeLoading(uuid2, node) {
+      if (Object.prototype.hasOwnProperty.call(node, NODE_ATTRIBUTES.IS_LOADING)) {
+        return node[NODE_ATTRIBUTES.IS_LOADING];
+      }
+      return getCachedTreeNodeAttr(uuid2, node, NODE_ATTRIBUTES.IS_LOADING, false);
     }
     function validateIsOpenLoopFn(target) {
       return !target[NODE_ATTRIBUTES.IS_OPENED];
@@ -22004,6 +22070,7 @@ var useTreeInit = (props) => {
               [NODE_ATTRIBUTES.IS_CHECKED]: isCachedTreeNodeChecked(uuid2, item),
               [NODE_ATTRIBUTES.IS_CACHED]: isCachedTreeNodeHasCached(uuid2, item),
               [NODE_ATTRIBUTES.IS_ASYNC]: isCachedTreeNodeAsync(uuid2, item),
+              [NODE_ATTRIBUTES.IS_LOADING]: isCachedTreeNodeLoading(uuid2, item),
               [children]: null
             };
             Object.assign(item, {
@@ -22050,13 +22117,49 @@ var useTreeInit = (props) => {
     }
     nextLoopEvents.set(key, event);
   };
+  const resolveEventOption = (event) => {
+    if (typeof event === "function") {
+      return {
+        type: "loop",
+        fn: event
+      };
+    }
+    if (typeof event === "object" && typeof event.type === "string" && typeof event.fn === "function") {
+      return event;
+    }
+    console.error("loop event error", event);
+    return null;
+  };
+  const executeFn = (event) => {
+    var _a2;
+    const resoveEvent = resolveEventOption(event);
+    if (resoveEvent !== null) {
+      Reflect.apply(resoveEvent.fn, globalThis, []);
+    }
+    return (_a2 = resoveEvent == null ? void 0 : resoveEvent.type) != null ? _a2 : "once";
+  };
   const executeNextEvent = () => {
     Array.from(nextLoopEvents.keys()).forEach((key) => {
       const target = nextLoopEvents.get(key);
       if (Array.isArray(target)) {
-        target.forEach((event) => Reflect.apply(event, globalThis, []));
+        const clearList = [];
+        target.forEach((event, index) => {
+          const result = executeFn(event);
+          if (result === "once") {
+            clearList.unshift(index);
+          }
+        });
+        if (clearList.length) {
+          clearList.forEach((index) => target.splice(index, 1));
+        }
+        if (target.length === 0) {
+          nextLoopEvents.delete(key);
+        }
       } else {
-        Reflect.apply(target, globalThis, []);
+        const result = executeFn(target);
+        if (result === "once") {
+          nextLoopEvents.delete(key);
+        }
       }
     });
   };
@@ -22096,6 +22199,7 @@ var useTreeInit = (props) => {
     asyncNodeClick,
     deepAutoOpen,
     afterDataUpdate,
+    registerNextLoop,
     onSelected
   };
 };
@@ -22107,7 +22211,8 @@ var Component$2 = defineComponent({
     const {
       flatData,
       schemaValues,
-      onSelected
+      onSelected,
+      registerNextLoop
     } = useTreeInit(props);
     const {
       setNodeAttr,
@@ -22119,7 +22224,7 @@ var Component$2 = defineComponent({
       isNodeChecked,
       isNodeMatched,
       hasChildNode
-    } = useNodeAttribute(flatData);
+    } = useNodeAttribute(flatData, props);
     const {
       searchFn,
       isSearchActive,
@@ -22155,7 +22260,9 @@ var Component$2 = defineComponent({
       setNodeAction,
       setSelect,
       asyncNodeClick
-    } = useNodeAction(props, ctx, flatData, renderData, schemaValues);
+    } = useNodeAction(props, ctx, flatData, renderData, schemaValues, {
+      registerNextLoop
+    });
     const setChecked = (item, checked = true) => {
       setNodeAction(resolveNodeItem(item), NODE_ATTRIBUTES.IS_CHECKED, checked);
     };