hy-virtual-tree 1.1.28 → 1.1.29

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## Changelog
 
+### 1.1.29
+
+_2025-09-17_
+
+- 扩展[VirtualTree] 功能
+（1）修复开启 businessConfig.showOnlineState 时，隐藏的节点仍可被选中
+（2）修复开启 businessConfig.showOnlineState 时，设备上下线不会同步更新勾选状态
+（3）添加 businessConfig.sortByStatus，对设备在线和离线状态进行排序
+
 ### 1.1.28
 
 _2025-09-16_

package/dist/index.js

@@ -423,6 +423,7 @@ const useConfig = (config) => {
     let businessConfig = {
         statusTextList: [],
         filterConfig: [],
+        sortByStatus: true,
         clearEmptyBusiness: false,
         integratedBusiness: false,
         ...(config.businessConfig || {})
@@ -441,6 +442,7 @@ const useConfig = (config) => {
                 'SOS'
             ],
             filterConfig: [],
+            sortByStatus: true,
             clearEmptyBusiness: false,
             integratedBusiness: false,
             ...(config.businessConfig || {})
@@ -664,11 +666,15 @@ function useCheck(props, tree) {
                 continue;
             nodes.forEach((node) => {
                 const children = node.children;
+                if (tree.hiddenNodeKeySet.has(node.key))
+                    return;
                 if (children) {
                     let allChecked = true;
                     let hasChecked = false;
                     for (const childNode of children) {
                         const key = childNode.key;
+                        if (tree.hiddenNodeKeySet.has(key))
+                            continue;
                         if (checkedKeySet.has(key)) {
                             hasChecked = true;
                         }
@@ -716,7 +722,7 @@ function useCheck(props, tree) {
         // 多选
         const toggle = (node, checked) => {
             // 对隐藏的节点不做处理
-            if (hiddenNodeKeySet.has(node.key))
+            if (hiddenNodeKeySet.has(node.key) || tree.hiddenNodeKeySet.has(node.key))
                 return;
             checkedKeySet[checked ? 'add' : 'delete'](node.key);
             const children = node.children;
@@ -965,6 +971,7 @@ function useCheck(props, tree) {
         isIndeterminate,
         // expose
         getChecked,
+        afterNodeCheck,
         getCheckedKeys,
         getCheckedNodes,
         getHalfCheckedKeys,
@@ -1389,14 +1396,15 @@ function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
     };
 }
 
-var WorkerFactory = /*#__PURE__*/createBase64WorkerFactory('/* rollup-plugin-web-worker-loader */
(function () {
  'use strict';

  /** 生成配置项 */
  /** 生成处理函数 */
  const useHandleFun = (config) => {
      const { business } = config;
      const props = { ...config.props };
      let { countFilter, totalFilter } = props;
      /** 获取key值 */
      function getKey(node, isBusiness = false) {
          if (!node)
              return '';
          if (business && isBusiness) {
              switch (business) {
                  case 'device':
                  case 'groupDevice':
                      return node.deviceId;
                  case 'user':
                  case 'cs':
                      return node.id;
              }
          }
          return node[props.value];
      }
      /** 获取label值 */
      function getLabel(node) {
          if (!node)
              return '';
          return node[props.label];
      }
      /** 获取children值 */
      function getChildren(node) {
          if (!node)
              return [];
          const children = node[props.children];
          return children ? [...children] : [];
      }
      /** 获取count值 */
      function getCount(node) {
          if (!node)
              return;
          return node[props.count];
      }
      /** 获取total值 */
      function getTotal(node) {
          if (!node)
              return;
          return node[props.total];
      }
      if (['device', 'groupDevice'].includes(`${business}`)) {
          countFilter = (data) => {
              return data.dataType === 3 && data.onlineState === 1;
          };
          totalFilter = (data) => {
              return data.dataType === 3;
          };
      }
      else if (business === 'user') {
          countFilter = totalFilter = (data) => {
              return data.dataType === 5;
          };
      }
      else if (business === 'cs') {
          countFilter = totalFilter = (data) => {
              return data.dataType === 8;
          };
      }
      return {
          getKey,
          getLabel,
          getChildren,
          getCount,
          getTotal,
          countFilter,
          totalFilter,
          // 设置设备状态
          setDeviceStatus: (data) => {
              if (data.onlineState === 1) {
                  // 监控中
                  if (data.monitor === 1 || data.beMonitor === 1) {
                      return 2;
                  }
                  // 通话中
                  if (data.videoCall === 1) {
                      return 3;
                  }
                  // 录像中
                  if (data.videoRecording === 1) {
                      return 4;
                  }
                  // 录音中
                  if (data.audioRecording === 1) {
                      return 5;
                  }
                  // 广播中
                  if (data.broadcast === 1) {
                      return 6;
                  }
                  // SOS
                  if (data.sos === 1) {
                      return 7;
                  }
                  // 在线
                  return 1;
              }
              // 离线
              return 0;
          }
      };
  };

  const isString = (e) => typeof e === 'string';
  const isNumber = (e) => typeof e === 'number';
  const isArray = (e) => Array.isArray(e);

  // 处理filterConfig
  function handleFilterConfig(filterConfig) {
      return (filterConfig || []).filter((item) => {
          return (isString(item.prop) &&
              (isString(item.value) ||
                  isNumber(item.value) ||
                  (isArray(item.value) && item.condition === 'between')) &&
              /^(eq|ne|in|notIn|between|gt|lt|ge|le)$/.test(item.condition));
      });
  }
  // 校验filterConfig
  function useFilterConfig(data, filterList) {
      if (!filterList || !filterList.length)
          return true;
      return filterList.every(({ prop, value, condition }) => {
          const target = data[prop];
          switch (condition) {
              case 'eq':
                  return target === value;
              case 'ne':
                  return target !== value;
          }
          if (Array.isArray(value)) {
              if (condition === 'between') {
                  return Array.isArray(value) && value.length
                      ? target >= value[0] && target <= value[1]
                      : false;
              }
          }
          if (isNumber(target)) {
              if (!isNumber(value))
                  return false;
              switch (condition) {
                  case 'gt':
                      return target > value;
                  case 'lt':
                      return target < value;
                  case 'ge':
                      return target >= value;
                  case 'le':
                      return target <= value;
              }
          }
          else if (isString(target)) {
              const isIn = target.includes(`${value}`);
              switch (condition) {
                  case 'in':
                      return isIn;
                  case 'notIn':
                      return !isIn;
              }
          }
          return false;
      });
  }

  self.onmessage = async (event) => {
      const { data, config } = event.data;
      const generateTree = generateMap[config.business];
      if (!generateTree) {
          self.close();
          return;
      }
      const tree = generateTree(data, config);
      self.postMessage(tree);
  };
  // 设备树结构
  function generateDeviceTree(data, config) {
      const { expandedKeySet } = config;
      const { showOnlineState, clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter, setDeviceStatus } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 设备树 */
      function createDeviceTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const deviceMap = new Map();
          const hiddenNodeKeySet = new Set();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 3) {
                      const deviceList = [[], []];
                      children = children ? children : [];
                      if (rawNode.deviceList) {
                          rawNode.deviceList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.deviceId,
                                  label: v.devName || v.deviceId,
                                  dataType: 3, // 代表设备
                                  deviceStatus: setDeviceStatus(v) // 设备状态
                              };
                              if (useFilterConfig(target, filterList)) {
                                  if (target.deviceStatus === 0) {
                                      deviceList[1].push(target);
                                      if (showOnlineState) {
                                          hiddenNodeKeySet.add(getKey(target));
                                      }
                                  }
                                  else {
                                      deviceList[0].push(target);
                                  }
                                  // 保存业务数据
                                  if (integratedBusiness && !hiddenNodeKeySet.has(getKey(target))) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                          children = [...children, ...deviceList[0], ...deviceList[1]];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有设备的部门和群组 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  // 隐藏没有在线设备的部门和群组
                  if (showOnlineState) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有用户的部门 步骤二
                      if (!showOnlineState && clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                      // 仅显示在线设备时，隐藏没有在线设备的部门和群组
                      if (showOnlineState && !childCount) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      if (!showOnlineState || !hiddenNodeKeySet.has(node.key)) {
                          {
                              count += countFilter(rawNode) ? 1 : 0;
                          }
                          {
                              total += totalFilter(rawNode) ? 1 : 0;
                          }
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 设备
                  if (rawNode.dataType === 3) {
                      const { deviceId } = node.data;
                      const deviceInfo = deviceMap.get(deviceId) || [];
                      deviceInfo.push(node);
                      deviceMap.set(deviceId, deviceInfo);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              deviceMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet
          };
      }
      return createDeviceTree(data);
  }
  // 群组设备树结构
  function generateGroupDeviceTree(data, config) {
      const { expandedKeySet } = config;
      const { showOnlineState, clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter, setDeviceStatus } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 群组设备树 */
      function createDeviceTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const deviceMap = new Map();
          const hiddenNodeKeySet = new Set();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  const businessList = [];
                  // 业务逻辑
                  let children = getChildren(rawNode);
                  // 群组
                  if (rawNode.children?.length ||
                      rawNode.groupList?.length ||
                      ![3, 4].includes(rawNode.dataType)) {
                      const groupList = [];
                      children = children ? children : [];
                      if (rawNode.groupList?.length) {
                          rawNode.groupList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.groupName || v.id,
                                  dataType: 4 // 代表群组
                              };
                              groupList.push(target);
                          });
                          children = [...children, ...groupList];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 设备
                  if (rawNode.deviceList?.length) {
                      const deviceList = [[], []];
                      children = children ? children : [];
                      rawNode.deviceList.forEach((v) => {
                          const target = {
                              ...v,
                              onlyId: rawNode.id + '' + v.deviceId,
                              label: v.devName || v.deviceId,
                              dataType: 3, // 代表设备
                              deviceStatus: setDeviceStatus(v) // 设备状态
                          };
                          if (useFilterConfig(target, filterList)) {
                              if (target.deviceStatus === 0) {
                                  deviceList[1].push(target);
                                  if (showOnlineState) {
                                      hiddenNodeKeySet.add(getKey(target));
                                  }
                              }
                              else {
                                  deviceList[0].push(target);
                              }
                              if (integratedBusiness && !hiddenNodeKeySet.has(getKey(target))) {
                                  businessList.push(target);
                                  deepBusinessList.push(target);
                              }
                          }
                      });
                      children = [...children, ...deviceList[0], ...deviceList[1]];
                  }
                  // 过滤没有设备的部门和群组 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  // 隐藏没有在线设备的部门和群组
                  if (showOnlineState) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有设备的部门和群组 步骤二
                      if (!showOnlineState && clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                      // 仅显示在线设备时，隐藏没有在线设备的部门和群组
                      if (showOnlineState && !childCount) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      if (!showOnlineState || !hiddenNodeKeySet.has(node.key)) {
                          {
                              count += countFilter(rawNode) ? 1 : 0;
                          }
                          {
                              total += totalFilter(rawNode) ? 1 : 0;
                          }
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 设备
                  if (rawNode.dataType === 3) {
                      const { deviceId } = node.data;
                      const deviceInfo = deviceMap.get(deviceId) || [];
                      deviceInfo.push(node);
                      deviceMap.set(deviceId, deviceInfo);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              deviceMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet
          };
      }
      return createDeviceTree(data);
  }
  // 群组树结构
  function generateGroupTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren} = useHandleFun(config);
      /** 群组树 */
      function createGroupTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  const businessList = [];
                  let deviceCount = 0;
                  let deviceTotal = 0;
                  // 业务逻辑
                  let children = getChildren(rawNode);
                  // 群组
                  if (rawNode.children?.length ||
                      rawNode.groupList?.length ||
                      ![3, 4].includes(rawNode.dataType)) {
                      const groupList = [];
                      children = children ? children : [];
                      if (rawNode.groupList?.length) {
                          rawNode.groupList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.groupName || v.id,
                                  dataType: 4 // 代表群组
                              };
                              groupList.push(target);
                          });
                          children = [...children, ...groupList];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 设备
                  if (rawNode.deviceList?.length) {
                      deviceCount = rawNode.deviceList.reduce((value, v) => {
                          if (integratedBusiness) {
                              businessList.push(v);
                              deepBusinessList.push(v);
                          }
                          return value + (v.onlineState === 1 ? 1 : 0);
                      }, deviceCount);
                      deviceTotal = rawNode.deviceList.length || 0;
                      count += deviceCount;
                      total += deviceTotal;
                  }
                  // 过滤没有设备和群组的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && ![3, 4].includes(rawNode.dataType)) {
                          continue;
                      }
                  }
                  // 处理逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有设备的部门和群组 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else if (rawNode.dataType !== 3) {
                      node.count = deviceCount;
                      node.total = deviceTotal;
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createGroupTree(data);
  }
  // 用户树结构
  function generateUserTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 用户树 */
      function createUserTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const userMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 5) {
                      children = children ? children : [];
                      if (rawNode.deviceUserList) {
                          rawNode.deviceUserList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.name || v.id,
                                  dataType: 5, // 代表用户
                              };
                              if (useFilterConfig(target, filterList)) {
                                  children.push(target);
                                  if (integratedBusiness) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有用户的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 5) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有用户的部门 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      {
                          count += countFilter(rawNode) ? 1 : 0;
                      }
                      {
                          total += totalFilter(rawNode) ? 1 : 0;
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 用户
                  if (rawNode.dataType === 5) {
                      const { id } = node.data;
                      const userList = userMap.get(id) || [];
                      userList.push(node);
                      userMap.set(id, userList);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              userMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createUserTree(data);
  }
  // 采集站树结构
  function generateCsTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 采集站树 */
      function createCsTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const csMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 8) {
                      children = children ? children : [];
                      if (rawNode.csList) {
                          rawNode.csList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.sname || v.scode,
                                  dataType: 8, // 代表采集站
                              };
                              if (useFilterConfig(target, filterList)) {
                                  children.push(target);
                                  if (integratedBusiness) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有采集器的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 8) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有采集器的部门 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      {
                          count += countFilter(rawNode) ? 1 : 0;
                      }
                      {
                          total += totalFilter(rawNode) ? 1 : 0;
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 采集站
                  if (rawNode.dataType === 8) {
                      const { id } = node.data;
                      const userList = csMap.get(id) || [];
                      userList.push(node);
                      csMap.set(id, userList);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              csMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createCsTree(data);
  }
  const generateMap = {
      // 设备树
      device: generateDeviceTree,
      // 群组设备树
      groupDevice: generateGroupDeviceTree,
      // 群组树
      group: generateGroupTree,
      // 用户树
      user: generateUserTree,
      // 采集站
      cs: generateCsTree
  };

})();
//# sourceMappingURL=generateTree.js.map

');
+var WorkerFactory = /*#__PURE__*/createBase64WorkerFactory('/* rollup-plugin-web-worker-loader */
(function () {
  'use strict';

  /** 生成配置项 */
  /** 生成处理函数 */
  const useHandleFun = (config) => {
      const { business } = config;
      const props = { ...config.props };
      let { countFilter, totalFilter } = props;
      /** 获取key值 */
      function getKey(node, isBusiness = false) {
          if (!node)
              return '';
          if (business && isBusiness) {
              switch (business) {
                  case 'device':
                  case 'groupDevice':
                      return node.deviceId;
                  case 'user':
                  case 'cs':
                      return node.id;
              }
          }
          return node[props.value];
      }
      /** 获取label值 */
      function getLabel(node) {
          if (!node)
              return '';
          return node[props.label];
      }
      /** 获取children值 */
      function getChildren(node) {
          if (!node)
              return [];
          const children = node[props.children];
          return children ? [...children] : [];
      }
      /** 获取count值 */
      function getCount(node) {
          if (!node)
              return;
          return node[props.count];
      }
      /** 获取total值 */
      function getTotal(node) {
          if (!node)
              return;
          return node[props.total];
      }
      if (['device', 'groupDevice'].includes(`${business}`)) {
          countFilter = (data) => {
              return data.dataType === 3 && data.onlineState === 1;
          };
          totalFilter = (data) => {
              return data.dataType === 3;
          };
      }
      else if (business === 'user') {
          countFilter = totalFilter = (data) => {
              return data.dataType === 5;
          };
      }
      else if (business === 'cs') {
          countFilter = totalFilter = (data) => {
              return data.dataType === 8;
          };
      }
      return {
          getKey,
          getLabel,
          getChildren,
          getCount,
          getTotal,
          countFilter,
          totalFilter,
          // 设置设备状态
          setDeviceStatus: (data) => {
              if (data.onlineState === 1) {
                  // 监控中
                  if (data.monitor === 1 || data.beMonitor === 1) {
                      return 2;
                  }
                  // 通话中
                  if (data.videoCall === 1) {
                      return 3;
                  }
                  // 录像中
                  if (data.videoRecording === 1) {
                      return 4;
                  }
                  // 录音中
                  if (data.audioRecording === 1) {
                      return 5;
                  }
                  // 广播中
                  if (data.broadcast === 1) {
                      return 6;
                  }
                  // SOS
                  if (data.sos === 1) {
                      return 7;
                  }
                  // 在线
                  return 1;
              }
              // 离线
              return 0;
          }
      };
  };

  const isString = (e) => typeof e === 'string';
  const isNumber = (e) => typeof e === 'number';
  const isArray = (e) => Array.isArray(e);

  // 处理filterConfig
  function handleFilterConfig(filterConfig) {
      return (filterConfig || []).filter((item) => {
          return (isString(item.prop) &&
              (isString(item.value) ||
                  isNumber(item.value) ||
                  (isArray(item.value) && item.condition === 'between')) &&
              /^(eq|ne|in|notIn|between|gt|lt|ge|le)$/.test(item.condition));
      });
  }
  // 校验filterConfig
  function useFilterConfig(data, filterList) {
      if (!filterList || !filterList.length)
          return true;
      return filterList.every(({ prop, value, condition }) => {
          const target = data[prop];
          switch (condition) {
              case 'eq':
                  return target === value;
              case 'ne':
                  return target !== value;
          }
          if (Array.isArray(value)) {
              if (condition === 'between') {
                  return Array.isArray(value) && value.length
                      ? target >= value[0] && target <= value[1]
                      : false;
              }
          }
          if (isNumber(target)) {
              if (!isNumber(value))
                  return false;
              switch (condition) {
                  case 'gt':
                      return target > value;
                  case 'lt':
                      return target < value;
                  case 'ge':
                      return target >= value;
                  case 'le':
                      return target <= value;
              }
          }
          else if (isString(target)) {
              const isIn = target.includes(`${value}`);
              switch (condition) {
                  case 'in':
                      return isIn;
                  case 'notIn':
                      return !isIn;
              }
          }
          return false;
      });
  }

  self.onmessage = async (event) => {
      const { data, config } = event.data;
      const generateTree = generateMap[config.business];
      if (!generateTree) {
          self.close();
          return;
      }
      const tree = generateTree(data, config);
      self.postMessage(tree);
  };
  // 设备树结构
  function generateDeviceTree(data, config) {
      const { expandedKeySet } = config;
      const { sortByStatus, showOnlineState, clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter, setDeviceStatus } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 设备树 */
      function createDeviceTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const deviceMap = new Map();
          const hiddenNodeKeySet = new Set();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 3) {
                      const deviceList = [[], []];
                      children = children ? children : [];
                      if (rawNode.deviceList) {
                          rawNode.deviceList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.deviceId,
                                  label: v.devName || v.deviceId,
                                  dataType: 3, // 代表设备
                                  deviceStatus: setDeviceStatus(v) // 设备状态
                              };
                              if (useFilterConfig(target, filterList)) {
                                  if (target.deviceStatus === 0) {
                                      deviceList[sortByStatus ? 1 : 0].push(target);
                                      if (showOnlineState) {
                                          hiddenNodeKeySet.add(getKey(target));
                                      }
                                  }
                                  else {
                                      deviceList[0].push(target);
                                  }
                                  // 保存业务数据
                                  if (integratedBusiness && !hiddenNodeKeySet.has(getKey(target))) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                          children = [...children, ...deviceList[0], ...deviceList[1]];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有设备的部门和群组 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  // 隐藏没有在线设备的部门和群组
                  if (showOnlineState) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有用户的部门 步骤二
                      if (!showOnlineState && clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                      // 仅显示在线设备时，隐藏没有在线设备的部门和群组
                      if (showOnlineState && !childCount) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      if (!showOnlineState || !hiddenNodeKeySet.has(node.key)) {
                          {
                              count += countFilter(rawNode) ? 1 : 0;
                          }
                          {
                              total += totalFilter(rawNode) ? 1 : 0;
                          }
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 设备
                  if (rawNode.dataType === 3) {
                      const { deviceId } = node.data;
                      const deviceInfo = deviceMap.get(deviceId) || [];
                      deviceInfo.push(node);
                      deviceMap.set(deviceId, deviceInfo);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              deviceMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet
          };
      }
      return createDeviceTree(data);
  }
  // 群组设备树结构
  function generateGroupDeviceTree(data, config) {
      const { expandedKeySet } = config;
      const { sortByStatus, showOnlineState, clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter, setDeviceStatus } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 群组设备树 */
      function createDeviceTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const deviceMap = new Map();
          const hiddenNodeKeySet = new Set();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  const businessList = [];
                  // 业务逻辑
                  let children = getChildren(rawNode);
                  // 群组
                  if (rawNode.children?.length ||
                      rawNode.groupList?.length ||
                      ![3, 4].includes(rawNode.dataType)) {
                      const groupList = [];
                      children = children ? children : [];
                      if (rawNode.groupList?.length) {
                          rawNode.groupList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.groupName || v.id,
                                  dataType: 4 // 代表群组
                              };
                              groupList.push(target);
                          });
                          children = [...children, ...groupList];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 设备
                  if (rawNode.deviceList?.length) {
                      const deviceList = [[], []];
                      children = children ? children : [];
                      rawNode.deviceList.forEach((v) => {
                          const target = {
                              ...v,
                              onlyId: rawNode.id + '' + v.deviceId,
                              label: v.devName || v.deviceId,
                              dataType: 3, // 代表设备
                              deviceStatus: setDeviceStatus(v) // 设备状态
                          };
                          if (useFilterConfig(target, filterList)) {
                              if (target.deviceStatus === 0) {
                                  deviceList[sortByStatus ? 1 : 0].push(target);
                                  if (showOnlineState) {
                                      hiddenNodeKeySet.add(getKey(target));
                                  }
                              }
                              else {
                                  deviceList[0].push(target);
                              }
                              if (integratedBusiness && !hiddenNodeKeySet.has(getKey(target))) {
                                  businessList.push(target);
                                  deepBusinessList.push(target);
                              }
                          }
                      });
                      children = [...children, ...deviceList[0], ...deviceList[1]];
                  }
                  // 过滤没有设备的部门和群组 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  // 隐藏没有在线设备的部门和群组
                  if (showOnlineState) {
                      if (!children || children.length === 0 && rawNode.dataType !== 3) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有设备的部门和群组 步骤二
                      if (!showOnlineState && clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                      // 仅显示在线设备时，隐藏没有在线设备的部门和群组
                      if (showOnlineState && !childCount) {
                          hiddenNodeKeySet.add(node.key);
                      }
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      if (!showOnlineState || !hiddenNodeKeySet.has(node.key)) {
                          {
                              count += countFilter(rawNode) ? 1 : 0;
                          }
                          {
                              total += totalFilter(rawNode) ? 1 : 0;
                          }
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 设备
                  if (rawNode.dataType === 3) {
                      const { deviceId } = node.data;
                      const deviceInfo = deviceMap.get(deviceId) || [];
                      deviceInfo.push(node);
                      deviceMap.set(deviceId, deviceInfo);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              deviceMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet
          };
      }
      return createDeviceTree(data);
  }
  // 群组树结构
  function generateGroupTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren} = useHandleFun(config);
      /** 群组树 */
      function createGroupTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  const businessList = [];
                  let deviceCount = 0;
                  let deviceTotal = 0;
                  // 业务逻辑
                  let children = getChildren(rawNode);
                  // 群组
                  if (rawNode.children?.length ||
                      rawNode.groupList?.length ||
                      ![3, 4].includes(rawNode.dataType)) {
                      const groupList = [];
                      children = children ? children : [];
                      if (rawNode.groupList?.length) {
                          rawNode.groupList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.groupName || v.id,
                                  dataType: 4 // 代表群组
                              };
                              groupList.push(target);
                          });
                          children = [...children, ...groupList];
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 设备
                  if (rawNode.deviceList?.length) {
                      deviceCount = rawNode.deviceList.reduce((value, v) => {
                          if (integratedBusiness) {
                              businessList.push(v);
                              deepBusinessList.push(v);
                          }
                          return value + (v.onlineState === 1 ? 1 : 0);
                      }, deviceCount);
                      deviceTotal = rawNode.deviceList.length || 0;
                      count += deviceCount;
                      total += deviceTotal;
                  }
                  // 过滤没有设备和群组的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && ![3, 4].includes(rawNode.dataType)) {
                          continue;
                      }
                  }
                  // 处理逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有设备的部门和群组 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else if (rawNode.dataType !== 3) {
                      node.count = deviceCount;
                      node.total = deviceTotal;
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createGroupTree(data);
  }
  // 用户树结构
  function generateUserTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 用户树 */
      function createUserTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const userMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 5) {
                      children = children ? children : [];
                      if (rawNode.deviceUserList) {
                          rawNode.deviceUserList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.name || v.id,
                                  dataType: 5, // 代表用户
                              };
                              if (useFilterConfig(target, filterList)) {
                                  children.push(target);
                                  if (integratedBusiness) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有用户的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 5) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有用户的部门 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      {
                          count += countFilter(rawNode) ? 1 : 0;
                      }
                      {
                          total += totalFilter(rawNode) ? 1 : 0;
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 用户
                  if (rawNode.dataType === 5) {
                      const { id } = node.data;
                      const userList = userMap.get(id) || [];
                      userList.push(node);
                      userMap.set(id, userList);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              userMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createUserTree(data);
  }
  // 采集站树结构
  function generateCsTree(data, config) {
      const { expandedKeySet } = config;
      const { clearEmptyBusiness, integratedBusiness } = config.businessConfig;
      const { getKey, getLabel, getChildren, countFilter, totalFilter } = useHandleFun(config);
      const filterList = handleFilterConfig(config.businessConfig?.filterConfig);
      /** 采集站树 */
      function createCsTree(data) {
          let maxLevel = 1;
          const treeNodeMap = new Map();
          const levelTreeNodeMap = new Map();
          const csMap = new Map();
          const traverse = (nodes, level = 1, parent = undefined) => {
              const siblings = [];
              const deepBusinessList = [];
              let count = 0;
              let total = 0;
              for (let rawNode of nodes) {
                  // 业务逻辑
                  const businessList = [];
                  let children = getChildren(rawNode);
                  if (rawNode.dataType !== 8) {
                      children = children ? children : [];
                      if (rawNode.csList) {
                          rawNode.csList.forEach((v) => {
                              const target = {
                                  ...v,
                                  onlyId: rawNode.id + '' + v.id,
                                  label: v.sname || v.scode,
                                  dataType: 8, // 代表采集站
                              };
                              if (useFilterConfig(target, filterList)) {
                                  children.push(target);
                                  if (integratedBusiness) {
                                      businessList.push(target);
                                      deepBusinessList.push(target);
                                  }
                              }
                          });
                      }
                      rawNode = {
                          ...rawNode,
                          children,
                          onlyId: rawNode.id,
                          dataType: 1, // 部门
                          label: rawNode.orgName || rawNode.companyName
                      };
                  }
                  // 过滤没有采集器的部门 步骤一
                  if (clearEmptyBusiness) {
                      if (!children || children.length === 0 && rawNode.dataType !== 8) {
                          continue;
                      }
                  }
                  // 通用逻辑
                  const value = getKey(rawNode);
                  const node = {
                      level,
                      key: value,
                      data: rawNode
                  };
                  node.label = getLabel(rawNode);
                  node.parent = parent;
                  node.isLeaf = !children || children.length === 0;
                  node.expanded = expandedKeySet.has(value);
                  if (children && children.length) {
                      const { list, count: childCount, total: childTotal, businessList: list2 } = traverse(children, level + 1, node);
                      // 过滤没有采集器的部门 步骤二
                      if (clearEmptyBusiness && childTotal === 0) {
                          continue;
                      }
                      // 保存下层业务数据
                      if (integratedBusiness) {
                          for (const target of list2) {
                              businessList.push(target);
                              deepBusinessList.push(target);
                          }
                          node.data.childrenDeviceList = businessList;
                      }
                      node.children = list;
                      node.count = childCount ;
                      node.total = childTotal ;
                      count += childCount;
                      total += childTotal;
                  }
                  else {
                      node.count = 0;
                      node.total = 0;
                      // 统计
                      {
                          count += countFilter(rawNode) ? 1 : 0;
                      }
                      {
                          total += totalFilter(rawNode) ? 1 : 0;
                      }
                  }
                  siblings.push(node);
                  treeNodeMap.set(value, node);
                  if (!levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.set(level, []);
                  }
                  if (levelTreeNodeMap.has(level)) {
                      levelTreeNodeMap.get(level).push(node);
                  }
                  // 采集站
                  if (rawNode.dataType === 8) {
                      const { id } = node.data;
                      const userList = csMap.get(id) || [];
                      userList.push(node);
                      csMap.set(id, userList);
                  }
              }
              if (level > maxLevel) {
                  maxLevel = level;
              }
              return { list: siblings, count, total, businessList: deepBusinessList };
          };
          const { list } = traverse(data || []);
          const treeNodes = list;
          return {
              treeNodeMap,
              csMap,
              levelTreeNodeMap,
              maxLevel,
              treeNodes,
              hiddenNodeKeySet: new Set()
          };
      }
      return createCsTree(data);
  }
  const generateMap = {
      // 设备树
      device: generateDeviceTree,
      // 群组设备树
      groupDevice: generateGroupDeviceTree,
      // 群组树
      group: generateGroupTree,
      // 用户树
      user: generateUserTree,
      // 采集站
      cs: generateCsTree
  };

})();
//# sourceMappingURL=generateTree.js.map

');
 /* eslint-enable */
 
 // 设备树
 function updateDeviceTree(tree, data, config) {
     const deviceMap = tree.deviceMap || new Map();
+    let beOnlineList = [], beOfflineList = [];
     const { countFilter, totalFilter, setDeviceStatus } = useHandleFun(config);
-    const { showOnlineState, integratedBusiness } = config.businessConfig;
+    const { sortByStatus, showOnlineState, integratedBusiness } = config.businessConfig;
     // 更新父节点统计
     const updateParnetCount = (keySet) => {
         const isCountFiler = countFilter && isFunction(countFilter);
@@ -1423,7 +1431,7 @@ function updateDeviceTree(tree, data, config) {
                             ? total + (item.children ? item.total : totalFilter(item.data))
                             : total;
                     if (item.data.deviceStatus === 0) {
-                        deviceList[1].push(item);
+                        deviceList[sortByStatus ? 1 : 0].push(item);
                     }
                     else {
                         deviceList[0].push(item);
@@ -1473,13 +1481,20 @@ function updateDeviceTree(tree, data, config) {
             });
             // 在仅显示设备时，切换显隐状态
             if (showOnlineState) {
-                tree.hiddenNodeKeySet[target.data.deviceStatus === 0 ? 'add' : 'delete'](target.key);
+                if (target.data.deviceStatus === 0) {
+                    tree.hiddenNodeKeySet.add(target.key);
+                    beOfflineList.push(target);
+                }
+                else {
+                    tree.hiddenNodeKeySet.delete(target.key);
+                    beOnlineList.push(target);
+                }
             }
             target.parent && parentKeySet.add(target.parent.key);
         });
     });
     updateParnetCount(parentKeySet);
-    return tree;
+    return { tree, beOnlineList, beOfflineList };
 }
 // 用户树
 function updateUserTree(tree, data, config) {
@@ -1504,7 +1519,7 @@ function updateUserTree(tree, data, config) {
             });
         });
     });
-    return tree;
+    return { tree };
 }
 // 采集站
 function updateCsTree(tree, data, config) {
@@ -1529,7 +1544,7 @@ function updateCsTree(tree, data, config) {
             });
         });
     });
-    return tree;
+    return { tree };
 }
 const updateTreeMap = {
     // 设备树
@@ -1604,6 +1619,7 @@ class VirtualTree {
     _onNodeExpand;
     _onNodeCollapse;
     _getKey;
+    _updateTree;
     _businessConfig = {};
     _isDestroy = false;
     getChecked;
@@ -1738,81 +1754,6 @@ class VirtualTree {
             });
         };
     })();
-    /** 更新树数据 */
-    _updateTree = (() => {
-        // 更新父节点统计
-        const updateParnetCount = (keySet) => {
-            if (!this._tree)
-                return;
-            const { countFilter, totalFilter } = useHandleFun({
-                props: this._props
-            });
-            const isCountFiler = countFilter && isFunction(countFilter);
-            const isTotalFiler = totalFilter && isFunction(totalFilter);
-            const parentKeySet = new Set();
-            for (const key of keySet) {
-                const target = this._tree.treeNodeMap.get(key);
-                if (!target)
-                    continue;
-                let count = isCountFiler ? 0 : target.data.count;
-                let total = isTotalFiler ? 0 : target.data.total;
-                if (isCountFiler || isTotalFiler) {
-                    for (let i = 0; i < target.children.length; i++) {
-                        const item = target.children[i];
-                        count =
-                            isCountFiler && countFilter
-                                ? count + (item.children ? item.count : countFilter(item.data))
-                                : count;
-                        total =
-                            isTotalFiler && totalFilter
-                                ? total + (item.children ? item.total : totalFilter(item.data))
-                                : total;
-                    }
-                }
-                target.count = count;
-                target.total = total;
-                target.parent && parentKeySet.add(target.parent.key);
-            }
-            parentKeySet.size && updateParnetCount(parentKeySet);
-        };
-        return (data) => {
-            return new Promise(async (resolve) => {
-                // 业务树更新
-                if (this._business) {
-                    const updateMethod = updateTreeMap[this._business];
-                    const value = updateMethod(this._tree, data, {
-                        business: this._business,
-                        props: {
-                            value: this._props.value,
-                            label: this._props.label,
-                            children: this._props.children,
-                            count: this._props.count,
-                            total: this._props.total
-                        },
-                        businessConfig: this._businessConfig
-                    });
-                    Object.assign(this._tree, value);
-                    resolve({});
-                    return;
-                }
-                // 通用树更新
-                const { treeNodeMap } = await this._createTree(data);
-                const parentKeySet = new Set();
-                for (const [key, value] of treeNodeMap) {
-                    const target = this._tree.treeNodeMap.get(key);
-                    if (!target)
-                        continue;
-                    this._tree.treeNodeMap.set(key, Object.assign(target, {
-                        data: value.data,
-                        label: value.label
-                    }));
-                    target.parent && parentKeySet.add(target.parent.key);
-                }
-                updateParnetCount(parentKeySet);
-                resolve({});
-            });
-        };
-    })();
     /** 生成平铺树列表 */
     _genereateFlattenTree() {
         const expandedKeys = this._expandedKeySet;
@@ -1930,7 +1871,7 @@ class VirtualTree {
             return;
         this._tree = await this._createTree(config.data);
         this._flattenTree = this._genereateFlattenTree();
-        const { checkedKeys, isIndeterminate, isChecked, toggleCheckbox, getChecked, getCheckedKeys, getCheckedNodes, 
+        const { checkedKeys, updateCheckedKeys, isIndeterminate, isChecked, toggleCheckbox, getChecked, afterNodeCheck, getCheckedKeys, getCheckedNodes, 
         // getHalfCheckedKeys,
         // getHalfCheckedNodes,
         setChecked, setCheckedKeys, setCheckedNodes } = useCheck(config, this._tree);
@@ -2248,6 +2189,97 @@ class VirtualTree {
             }
         });
         config.onLoad && config.onLoad();
+        // @ts-ignore
+        // 更新函数
+        this._updateTree = (() => {
+            // 更新父节点统计
+            const updateParnetCount = (keySet) => {
+                if (!this._tree)
+                    return;
+                const { countFilter, totalFilter } = useHandleFun({
+                    props: this._props
+                });
+                const isCountFiler = countFilter && isFunction(countFilter);
+                const isTotalFiler = totalFilter && isFunction(totalFilter);
+                const parentKeySet = new Set();
+                for (const key of keySet) {
+                    const target = this._tree.treeNodeMap.get(key);
+                    if (!target)
+                        continue;
+                    let count = isCountFiler ? 0 : target.data.count;
+                    let total = isTotalFiler ? 0 : target.data.total;
+                    if (isCountFiler || isTotalFiler) {
+                        for (let i = 0; i < target.children.length; i++) {
+                            const item = target.children[i];
+                            count =
+                                isCountFiler && countFilter
+                                    ? count + (item.children ? item.count : countFilter(item.data))
+                                    : count;
+                            total =
+                                isTotalFiler && totalFilter
+                                    ? total + (item.children ? item.total : totalFilter(item.data))
+                                    : total;
+                        }
+                    }
+                    target.count = count;
+                    target.total = total;
+                    target.parent && parentKeySet.add(target.parent.key);
+                }
+                parentKeySet.size && updateParnetCount(parentKeySet);
+            };
+            return (data) => {
+                return new Promise(async (resolve, reject) => {
+                    // 业务树更新
+                    if (this._business) {
+                        const updateMethod = updateTreeMap[this._business];
+                        if (!updateMethod) {
+                            reject({});
+                            return;
+                        }
+                        const { tree, beOfflineList } = updateMethod(this._tree, data, {
+                            business: this._business,
+                            props: {
+                                value: this._props.value,
+                                label: this._props.label,
+                                children: this._props.children,
+                                count: this._props.count,
+                                total: this._props.total
+                            },
+                            businessConfig: this._businessConfig
+                        });
+                        Object.assign(this._tree, tree);
+                        let updateNode = null;
+                        for (const node of (beOfflineList || [])) {
+                            if (checkedKeys.has(node.key)) {
+                                checkedKeys.delete(node.key);
+                                updateNode = node;
+                            }
+                        }
+                        updateCheckedKeys();
+                        if (updateNode) {
+                            afterNodeCheck(updateNode, false);
+                        }
+                        resolve({});
+                        return;
+                    }
+                    // 通用树更新
+                    const { treeNodeMap } = await this._createTree(data);
+                    const parentKeySet = new Set();
+                    for (const [key, value] of treeNodeMap) {
+                        const target = this._tree.treeNodeMap.get(key);
+                        if (!target)
+                            continue;
+                        this._tree.treeNodeMap.set(key, Object.assign(target, {
+                            data: value.data,
+                            label: value.label
+                        }));
+                        target.parent && parentKeySet.add(target.parent.key);
+                    }
+                    updateParnetCount(parentKeySet);
+                    resolve({});
+                });
+            };
+        })();
     }
     /** 全量更新数据 */
     setData = (() => {
@@ -2289,7 +2321,7 @@ class VirtualTree {
         const cacheInterval = 500;
         let cacheData = [];
         return async (data, callback) => {
-            if (!this._tree)
+            if (!this._tree || !this._updateTree)
                 return;
             cacheTimer && clearTimeout(cacheTimer);
             if (Array.isArray(data)) {
@@ -2303,7 +2335,7 @@ class VirtualTree {
             // cacheInterval毫秒仅更新一次数据
             if (Date.now() - cacheTime >= cacheInterval) {
                 cacheTime = Date.now();
-                this._updateTree([...cacheData]);
+                await this._updateTree([...cacheData]);
                 cacheData = [];
                 this._refreshVirtualScroll();
                 callback && callback();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hy-virtual-tree",
-  "version": "1.1.28",
+  "version": "1.1.29",
   "type": "module",
   "scripts": {
     "dev": "vite",