@weitutech/by-components 1.1.184 → 1.1.185

package/lib/by-components.common.js

@@ -74524,8 +74524,8 @@ var component = normalizeComponent(
 )
 
 /* harmony default export */ var pager = (component.exports);
-;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"5daa4f39-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/table/index.vue?vue&type=template&id=35ba1298
-var tablevue_type_template_id_35ba1298_render = function render() {
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"5daa4f39-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/table/index.vue?vue&type=template&id=22e15733
+var tablevue_type_template_id_22e15733_render = function render() {
   var _vm = this,
     _c = _vm._self._c;
   return _c('div', [_c('vxe-grid', _vm._g(_vm._b({
@@ -74597,6 +74597,7 @@ var tablevue_type_template_id_35ba1298_render = function render() {
       "submit-method": _vm.gridOptions.customColumnConfig.submitMethod,
       "fixed-max-count": _vm.gridOptions.customColumnConfig.fixedMaxCount,
       "use-multi-level-header": _vm.gridOptions.customColumnConfig.useMultiLevelHeader,
+      "aggregation-group": _vm.gridOptions.customColumnConfig.aggregationGroup,
       "dialog-visible": _vm.customTableVisible
     },
     on: {
@@ -74609,7 +74610,7 @@ var tablevue_type_template_id_35ba1298_render = function render() {
     }
   }) : _vm._e()], 1);
 };
-var tablevue_type_template_id_35ba1298_staticRenderFns = [];
+var tablevue_type_template_id_22e15733_staticRenderFns = [];
 
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.push.js
 var es_array_push = __webpack_require__(4114);
@@ -74631,8 +74632,8 @@ var es_set_is_superset_of_v2 = __webpack_require__(2475);
 var es_set_symmetric_difference_v2 = __webpack_require__(5024);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.union.v2.js
 var es_set_union_v2 = __webpack_require__(1698);
-;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"5daa4f39-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/custom-column/index.vue?vue&type=template&id=2a1d0253
-var custom_columnvue_type_template_id_2a1d0253_render = function render() {
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"5daa4f39-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/custom-column/index.vue?vue&type=template&id=d822d96a
+var custom_columnvue_type_template_id_d822d96a_render = function render() {
   var _vm = this,
     _c = _vm._self._c;
   return _c('div', {
@@ -75023,7 +75024,7 @@ var custom_columnvue_type_template_id_2a1d0253_render = function render() {
     }), 0)], 1)], 1)]);
   }), 0)], 1)], 1)])])])])], 1);
 };
-var custom_columnvue_type_template_id_2a1d0253_staticRenderFns = [];
+var custom_columnvue_type_template_id_d822d96a_staticRenderFns = [];
 
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.filter.js
 var es_iterator_filter = __webpack_require__(2489);
@@ -75031,6 +75032,8 @@ var es_iterator_filter = __webpack_require__(2489);
 var es_iterator_find = __webpack_require__(116);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.flat-map.js
 var es_iterator_flat_map = __webpack_require__(531);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.some.js
+var es_iterator_some = __webpack_require__(3579);
 // EXTERNAL MODULE: ./node_modules/vuedraggable/dist/vuedraggable.umd.js
 var vuedraggable_umd = __webpack_require__(9135);
 var vuedraggable_umd_default = /*#__PURE__*/__webpack_require__.n(vuedraggable_umd);
@@ -75854,6 +75857,261 @@ const isNullValue = value => {
 
 ;// ./src/assets/icons/pin.png
 var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAEQUlEQVR4AbSWZ2hTURTHk3Q4UlwoKoggKKhg2qZ9baNFrYJI3CsgihOrgoj4RVBRxIH6RURwgnsLRXEhjkSF2pVWoQgaJS4QR2mslLbQ4e+EvNI2rzevbQznzz333jP+99x3743NEudfaWnpfvCopKRktZnQcSVQWFjYh6TbwQyr1XoWEsfRlRJXAh0zQWIj1TjVcbxt/38RqCX5bBI1gnxIXGhpabGiR0lcCSQmJmqRDF8zMzPvoy8GIivKysrOiNIRcSNAglms+oEkoL0praZpd1j5XNHBWmwu07aTuBDgY1tHontEttP6Wf1u9LBkZWXdtdlsc6TD3DJI3BBdR48JsL8HWfHpSMA7tbW1uRG9tcnIyBByMxhogIQHEgVerzeRvqXbBAiSRHIp9TYJBPZT8vl5eXn16FHC3GMGZwIhsSAlJeW2kOgWAZL3ZyVegi0BFvTlJNgpugrY+NgONzZCcpbdbj/RZQIkH0nCVwSZBH4T0MU+X0FXCtVyg6vNzc27MAwBC1u30DQBbrlBfGyrCPAa53GgEiJO9rcIXSkk3oKBHMultFPAMCDiMyTAKlfiVA1adCQlJVXB+BwYiOf1hoaGiaz8K7pSIC0n4IgYQXg9bV4ETrZkURSB8vLyIRiex2gAaCtVdG5R8uk4Ls3Nzf1LXyl+v98B4WtiRLsZwqfx9UVQIeNRBJxO5y8m3gHZowBkhuNgBYOBh5I/k7lYKCoqGsp2Sdnt2J7kbjhGGyVRBMQCtnJmgyQfg/5SqiLjZhEIBHolJCTcxX4E8AaDwU20hmJIALZfkpOTc0gewGt0U1PTi66QCIVCl/CTd+E9vvM9Hk8TfUMxJCCWqampP3F2QeIt/bHoL+QkoCuFj06OmdwPNWzBzJycnBqVQ6cExCk7O7uKUk5iK/z0x3ISfCoSnBg3hPdgKzIP/6AoKigJiGN6enqIoAdFBxMg4VWQOIGNyAZN03yixEJMAnzNI6iA/thIPIeQqKioaHdM5e5gciR4QHLlvyBsWkVJQB4LtqCACsjl0+qE4mhsbHxK0v7oYYHkNFGwjXkti50OJQFerEMYaqCtHCCJfJhOkj5uQ2JMxOhjpDXVdEqAD2oeEbYCXf6guCnvDm7DqegfgAaJZ5WVlSnoepXEjq45MSRQXFw8CveLQJfXlDyN5A9lQG5LqjAZXb5yZ11d3RP0wcCCXbW0ZhFFgH3vzQoLCNAPyHV8hsTpLpfrk/R1cFl9524QEp8ZywZhApz7H+imJYoA+34U7zQgfzTWkChfdCOQ7BuXjbxu32We7bggbVfQjgC32HKc8ynvJwKn8Xqdo68UuWywd5Ac86xVSmODyVYCnPfxBJLz+7C+vt5B4DcG9oZDVOk32UsNJ2MMhglwlPpGzvte9ttt5q2PEdf0dJgA5TsM1rMS/co1HaCnhjb+tWSQfB8lfN7TYEb+scb+AQAA//+s7i/8AAAABklEQVQDAIG7vmAdeEmvAAAAAElFTkSuQmCC";
+;// ./src/utils/aggregationUtils.js
+
+
+
+
+
+
+
+/**
+ * 聚合工具函数
+ * 用于处理多级表头的聚合分组逻辑
+ */
+
+/**
+ * 判断是否需要聚合处理
+ * @param {Array} columns - 列数据
+ * @returns {boolean} 是否需要聚合
+ */
+function shouldAggregate(columns) {
+  if (!Array.isArray(columns) || columns.length === 0) {
+    return false;
+  }
+
+  // 统计 groupkey 的出现次数
+  const groupkeyCount = new Map();
+  columns.forEach(group => {
+    const groupkey = group.groupkey || group.groupKey || group.aggrKey;
+    if (groupkey) {
+      groupkeyCount.set(groupkey, (groupkeyCount.get(groupkey) || 0) + 1);
+    }
+  });
+
+  // 如果有重复的 groupkey，则需要聚合
+  return Array.from(groupkeyCount.values()).some(count => count > 1);
+}
+
+/**
+ * 聚合列数据
+ * 将具有相同 groupkey 的组聚合为一个组
+ * @param {Array} columns - 原始列数据
+ * @returns {Object} { aggregated: 聚合后的数据, originalMap: 原始数据映射 }
+ */
+function aggregateColumns(columns) {
+  if (!Array.isArray(columns) || columns.length === 0) {
+    return {
+      aggregated: [],
+      originalMap: new Map()
+    };
+  }
+
+  // 检查是否需要聚合
+  if (!shouldAggregate(columns)) {
+    return {
+      aggregated: deepClone(columns),
+      originalMap: new Map()
+    };
+  }
+
+  // 按 groupkey 分组
+  const groupkeyGroups = new Map();
+  const originalMap = new Map(); // 聚合组 -> 原始组数组的映射
+
+  columns.forEach(group => {
+    const groupkey = group.groupkey || group.groupKey || group.aggrKey;
+    if (groupkey) {
+      if (!groupkeyGroups.has(groupkey)) {
+        groupkeyGroups.set(groupkey, {
+          label: group.groupName || group.label,
+          // 使用 groupName 或 label
+          groupkey: groupkey,
+          groupName: group.groupName || group.label,
+          data: [],
+          originalGroups: [] // 保存原始组数据
+        });
+        originalMap.set(groupkey, []);
+      }
+      groupkeyGroups.get(groupkey).originalGroups.push(deepClone(group));
+      originalMap.get(groupkey).push(deepClone(group));
+    } else {
+      // 没有 groupkey 的组，保持不变
+      groupkeyGroups.set(group.label || `no-groupkey-${Date.now()}`, {
+        label: group.label,
+        data: [],
+        originalGroups: [deepClone(group)]
+      });
+      if (!originalMap.has(group.label)) {
+        originalMap.set(group.label, []);
+      }
+      originalMap.get(group.label).push(deepClone(group));
+    }
+  });
+
+  // 对每个聚合组，按 itemKey 合并 data
+  const aggregated = [];
+  groupkeyGroups.forEach((aggGroup, key) => {
+    if (aggGroup.originalGroups.length === 0) {
+      return;
+    }
+
+    // 按 itemKey 分组合并
+    const itemKeyMap = new Map();
+    aggGroup.originalGroups.forEach(originalGroup => {
+      if (Array.isArray(originalGroup.data)) {
+        originalGroup.data.forEach(item => {
+          const itemKey = item.itemKey || item.key;
+          if (!itemKeyMap.has(itemKey)) {
+            // 取第一个出现的项作为模板，保留所有属性
+            itemKeyMap.set(itemKey, {
+              ...deepClone(item),
+              itemKey: itemKey,
+              originalItems: [] // 保存所有原始项
+            });
+          }
+          itemKeyMap.get(itemKey).originalItems.push(deepClone(item));
+        });
+      }
+    });
+
+    // 将 itemKeyMap 转换为数组
+    const aggregatedData = Array.from(itemKeyMap.values());
+    aggregated.push({
+      label: aggGroup.label,
+      groupkey: aggGroup.groupkey,
+      groupName: aggGroup.groupName,
+      data: aggregatedData,
+      originalGroups: aggGroup.originalGroups
+    });
+  });
+  return {
+    aggregated,
+    originalMap
+  };
+}
+
+/**
+ * 将聚合后的数据展开为原始数据
+ * 用于表格展示时恢复原始结构
+ * @param {Array} aggregatedColumns - 聚合后的列数据
+ * @param {Map} originalMap - 原始数据映射（可选，如果没有则从 aggregatedColumns 中获取）
+ * @returns {Array} 展开后的原始列数据
+ */
+function expandAggregatedColumns(aggregatedColumns, originalMap = null) {
+  if (!Array.isArray(aggregatedColumns) || aggregatedColumns.length === 0) {
+    return [];
+  }
+  const expanded = [];
+  aggregatedColumns.forEach(aggGroup => {
+    if (!aggGroup.originalGroups || aggGroup.originalGroups.length === 0) {
+      // 如果没有 originalGroups，说明不是聚合数据，直接使用
+      expanded.push(deepClone(aggGroup));
+      return;
+    }
+
+    // 从聚合数据中获取当前状态（type, sort, fixed 等）
+    const currentStateMap = new Map();
+    if (Array.isArray(aggGroup.data)) {
+      aggGroup.data.forEach(item => {
+        const itemKey = item.itemKey || item.key;
+        if (itemKey) {
+          currentStateMap.set(itemKey, {
+            type: item.type,
+            sort: item.sort,
+            fixed: item.fixed
+          });
+        }
+      });
+    }
+
+    // 将状态同步到原始组
+    aggGroup.originalGroups.forEach(originalGroup => {
+      const expandedGroup = deepClone(originalGroup);
+
+      // 恢复原始 label（如果存在 groupName 则使用原始的 label）
+      if (aggGroup.groupName && originalGroup.label) {
+        expandedGroup.label = originalGroup.label;
+      }
+
+      // 同步每个 item 的状态，并按照聚合数据中的 sort 值排序
+      if (Array.isArray(expandedGroup.data)) {
+        expandedGroup.data.forEach(item => {
+          const itemKey = item.itemKey || item.key;
+          const currentState = currentStateMap.get(itemKey);
+          if (currentState) {
+            // 同步状态：type, sort, fixed 等
+            item.type = currentState.type;
+            item.sort = currentState.sort;
+            if (currentState.fixed) {
+              item.fixed = currentState.fixed;
+            } else {
+              delete item.fixed;
+            }
+          }
+        });
+        // 按照 sort 值排序，确保顺序与聚合数据中的顺序一致
+        expandedGroup.data.sort((a, b) => {
+          const sortA = typeof a.sort === 'number' ? a.sort : Number(a.sort) || 0;
+          const sortB = typeof b.sort === 'number' ? b.sort : Number(b.sort) || 0;
+          return sortA - sortB;
+        });
+      }
+      expanded.push(expandedGroup);
+    });
+  });
+  return expanded;
+}
+
+/**
+ * 根据 itemKey 同步操作所有相关的项
+ * @param {Array} columns - 列数据（checkBoxMenu 格式）
+ * @param {string} itemKey - 要同步的 itemKey
+ * @param {Function} updateFn - 更新函数，接收 (item) => void
+ */
+function syncItemsByItemKey(columns, itemKey, updateFn) {
+  if (!Array.isArray(columns) || !itemKey) {
+    return;
+  }
+  columns.forEach(group => {
+    if (Array.isArray(group.data)) {
+      group.data.forEach(item => {
+        const currentItemKey = item.itemKey || item.key;
+        if (currentItemKey === itemKey) {
+          updateFn(item);
+        }
+      });
+    }
+  });
+}
+
+/**
+ * 判断项是否属于聚合组
+ * @param {Object} item - 项数据
+ * @param {Array} columns - 列数据（checkBoxMenu 格式）
+ * @returns {boolean} 是否属于聚合组
+ */
+function isItemInAggregatedGroup(item, columns) {
+  if (!item || !columns || !Array.isArray(columns)) {
+    return false;
+  }
+  const itemKey = item.itemKey || item.key;
+  if (!itemKey) {
+    return false;
+  }
+
+  // 查找该项所属的组
+  for (const group of columns) {
+    if (Array.isArray(group.data)) {
+      const foundItem = group.data.find(i => (i.itemKey || i.key) === itemKey);
+      if (foundItem) {
+        // 如果组的 originalGroups 存在且长度 > 1，说明是聚合组
+        return group.originalGroups && Array.isArray(group.originalGroups) && group.originalGroups.length > 1;
+      }
+    }
+  }
+  return false;
+}
 ;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/custom-column/index.vue?vue&type=script&lang=js
 
 
@@ -75873,6 +76131,8 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
 
 
 
+
+
 
 
 /* harmony default export */ var custom_columnvue_type_script_lang_js = ({
@@ -75908,6 +76168,11 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
     useMultiLevelHeader: {
       type: Boolean,
       default: false
+    },
+    // 是否启用聚合分组（仅在 useMultiLevelHeader 为 true 时生效） - gridOptions.customColumnConfig.aggregationGroup配置
+    aggregationGroup: {
+      type: Boolean,
+      default: false
     }
   },
   data() {
@@ -75935,6 +76200,10 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       search: '',
       /** 原始列数据备份 */
       columnList: [],
+      /** 聚合模式下的原始数据映射（用于展开） */
+      originalColumnMap: null,
+      /** 是否处于聚合模式 */
+      isAggregationMode: false,
       /** 对话框按钮配置 */
       dialogButtons: [{
         text: '取消',
@@ -76020,7 +76289,98 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
         // 根据是否有固定列决定分割列位置
         return fixedCols.length > 0 ? [...fixedCols, separator, ...normalCols] : [separator, ...normalCols];
       };
-      if (bePreservedColumn && bePreservedColumn.length > 0) {
+
+      // ====== 聚合处理逻辑 ======
+      // 判断是否需要聚合：useMultiLevelHeader && aggregationGroup && 存在相同的 groupkey
+      this.isAggregationMode = false;
+      this.originalColumnMap = null;
+      if (this.useMultiLevelHeader && this.aggregationGroup && shouldAggregate(initColumn)) {
+        // 进行聚合处理
+        const {
+          aggregated,
+          originalMap
+        } = aggregateColumns(initColumn);
+        initColumn = aggregated;
+        this.originalColumnMap = originalMap;
+        this.isAggregationMode = true;
+
+        // 为聚合后的数据设置 parent 属性
+        initColumn.forEach(group => {
+          if (Array.isArray(group.data)) {
+            group.data.forEach(item => {
+              item.parent = {
+                label: group.label
+              };
+            });
+          }
+        });
+        if (bePreservedColumn && bePreservedColumn.length > 0) {
+          // 将保存的数据按 itemKey 分组（服务端保存的是聚合后的结构）
+          const preservedByItemKey = new Map();
+          bePreservedColumn.forEach(col => {
+            const itemKey = col.itemKey || col.key;
+            if (itemKey && !preservedByItemKey.has(itemKey)) {
+              preservedByItemKey.set(itemKey, col);
+            }
+          });
+
+          // 将保存的数据状态应用到聚合后的数据上
+          initColumn.forEach(group => {
+            if (Array.isArray(group.data)) {
+              group.data.forEach(item => {
+                const itemKey = item.itemKey || item.key;
+                const preservedItem = preservedByItemKey.get(itemKey);
+                if (preservedItem) {
+                  item.type = ['true', true, '1', 1].includes(preservedItem.type);
+                  item.sort = preservedItem.sort;
+                  item.fixed = preservedItem.fixed;
+                } else {
+                  // 如果服务端没有保存该项，说明该项之前没有被选中，应该设置为 false
+                  item.type = false;
+                }
+              });
+            }
+          });
+        } else {
+          // 聚合模式下，如果没有保存的数据（恢复默认时），需要确保使用原始数据的 type 值
+          // 因为 aggregateColumns 会保留第一个出现的项的属性，但如果第一个项的 type 是 false，
+          // 我们需要检查所有 originalItems，如果有任何一个的 type 是 true，则使用 true
+          // 如果所有 originalItems 的 type 都是 false 或 undefined，则使用 true（默认选中）
+          initColumn.forEach(group => {
+            if (Array.isArray(group.data)) {
+              group.data.forEach(item => {
+                if (item.originalItems && item.originalItems.length > 0) {
+                  // 检查所有 originalItems 的 type 值
+                  const hasTrueType = item.originalItems.some(origItem => origItem.type === true || origItem.type === 'true' || origItem.type === 1 || origItem.type === '1');
+                  // 如果任何一个 originalItem 的 type 是 true，则使用 true；否则使用 true（默认选中）
+                  item.type = hasTrueType || item.type === undefined || item.type === null ? true : item.type;
+                } else if (item.type === undefined || item.type === null) {
+                  // 如果没有 originalItems，默认设置为 true
+                  item.type = true;
+                }
+              });
+            }
+          });
+        }
+
+        // 聚合模式下，需要设置 checkBoxMenu 和 draggableMenu
+        this.checkBoxMenu = this.deepClone(initColumn);
+        // 聚合模式下，左侧顺序应该保持原始数据的顺序，不受保存顺序影响
+        // 所以这里不根据 savedGroupOrder 重新排序 checkBoxMenu
+        this.draggableMenu = setDraggableMenu(this.checkBoxMenu);
+        if (this.useMultiLevelHeader) {
+          if (this.baseGroupOrder.length === 0) {
+            this.baseGroupOrder = this.checkBoxMenu.map(g => g.label);
+          }
+          // 如果有保存的顺序，使用保存的顺序；否则使用 baseGroupOrder
+          if (this.savedGroupOrder && this.savedGroupOrder.length > 0) {
+            this.groupOrderPersist = this.savedGroupOrder.slice();
+          } else if (this.groupOrderPersist.length === 0) {
+            this.groupOrderPersist = this.baseGroupOrder.slice();
+          }
+          this.refreshMultiHeaderDerivedData();
+        }
+      } else if (bePreservedColumn && bePreservedColumn.length > 0) {
         // 需要处理被保存过的进行回显
         initColumn.forEach(cols => {
           cols.data.forEach(col => {
@@ -76049,12 +76409,16 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       } else {
         // console.log('==========从未被保存过', initColumn)
 
-        // 从未被保存过
+        // 从未被保存过：按照原始数据的默认状态初始化
+        // 如果原始数据有 type 字段，使用原始数据的 type 值；否则默认为 true
         let num = 0;
         initColumn.forEach(cols => {
           cols.data.forEach(col => {
             num++;
-            col.type = true;
+            // 如果原始数据没有 type 字段，则设置为 true（默认选中）
+            if (col.type === undefined || col.type === null) {
+              col.type = true;
+            }
             col.width = col.width ? +col.width : 0;
             col.sort = num;
             // 设置 fixed 和 parent 属性
@@ -76079,11 +76443,98 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       }
       if (this.useMultiLevelHeader) {
         // 多级表头模式
-        const clonedCheckBoxMenu = this.checkBoxMenu.map(group => ({
-          ...group,
-          data: group.data.map(col => this.deepClone(col))
-        }));
-        this.emitChangeTableGroup(clonedCheckBoxMenu);
+        // 如果是聚合模式，需要基于 groupCards 的顺序构建数据传给表格
+        if (this.isAggregationMode) {
+          // 使用和 submit 方法相同的逻辑，基于 groupCards 和 fixedAreaList 构建聚合数据
+          const orderedAggregatedGroups = [];
+          const labelToGroupData = new Map();
+          let sortIndex = 1
+
+          // 先处理固定项，按固定项的顺序添加到对应组，并重新分配 sort 值
+          ;
+          (this.fixedAreaList || []).forEach(item => {
+            if (item.type && item.parent) {
+              const label = item.parent.label;
+              if (!labelToGroupData.has(label)) {
+                labelToGroupData.set(label, []);
+              }
+              const itemData = {
+                ...item,
+                parent: item.parent
+              };
+              itemData.sort = sortIndex++;
+              labelToGroupData.get(label).push(itemData);
+            }
+          });
+
+          // 然后处理 groupCards 中的项，按它们在 groupCards 中的顺序添加到对应组，并重新分配 sort 值
+          this.groupCards.forEach(group => {
+            const label = group.label;
+            if (!labelToGroupData.has(label)) {
+              labelToGroupData.set(label, []);
+            }
+            ;
+            (group.items || []).forEach(item => {
+              if (item.type && item.parent) {
+                const itemData = {
+                  ...item,
+                  parent: item.parent
+                };
+                itemData.sort = sortIndex++;
+                labelToGroupData.get(label).push(itemData);
+              }
+            });
+          });
+
+          // 按 groupCards 的顺序构建聚合组
+          const orderedLabels = this.groupCards.map(g => g.label);
+          // 先添加有固定项的组（如果它们不在 groupCards 中）
+          const fixedGroupLabels = new Set();
+          (this.fixedAreaList || []).forEach(item => {
+            if (item.type && item.parent) {
+              fixedGroupLabels.add(item.parent.label);
+            }
+          });
+          fixedGroupLabels.forEach(label => {
+            if (!orderedLabels.includes(label) && labelToGroupData.has(label)) {
+              orderedLabels.push(label);
+            }
+          });
+
+          // 构建聚合组数据
+          orderedLabels.forEach(label => {
+            const items = labelToGroupData.get(label) || [];
+            if (items.length > 0) {
+              const sourceGroup = this.checkBoxMenu.find(g => g.label === label);
+              const group = {
+                label: label,
+                data: items.map(item => {
+                  const {
+                    parent,
+                    ...itemData
+                  } = item;
+                  return itemData;
+                })
+              };
+              if (sourceGroup) {
+                if (sourceGroup.groupkey) group.groupkey = sourceGroup.groupkey;
+                if (sourceGroup.groupName) group.groupName = sourceGroup.groupName;
+                if (sourceGroup.originalGroups) group.originalGroups = sourceGroup.originalGroups;
+              }
+              orderedAggregatedGroups.push(group);
+            }
+          });
+
+          // 展开聚合数据传给表格
+          const expandedColumns = expandAggregatedColumns(orderedAggregatedGroups, this.originalColumnMap);
+          this.emitChangeTableGroup(expandedColumns);
+        } else {
+          const clonedCheckBoxMenu = this.checkBoxMenu.map(group => ({
+            ...group,
+            data: group.data.map(col => this.deepClone(col))
+          }));
+          this.emitChangeTableGroup(clonedCheckBoxMenu);
+        }
       } else {
         const clonedDraggableMenu = this.draggableMenu.filter(item => item.key !== 'sort-cut-off').map(item => this.deepClone(item)).sort((a, b) => a.sort - b.sort);
         this.emitChangeTable(clonedDraggableMenu);
@@ -76153,18 +76604,86 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
      * @param { boolean } type 是否显示
      */
     changeCheckbox(key, type) {
-      this.draggableMenu.forEach(item => {
-        if (item.key === key) {
-          item.type = type;
+      // 查找操作的项
+      let targetItem = null;
+      this.checkBoxMenu.forEach(group => {
+        if (Array.isArray(group.data)) {
+          group.data.forEach(item => {
+            if (item.key === key) {
+              targetItem = item;
+            }
+          });
         }
       });
-      this.checkBoxMenu.forEach(item => {
-        item.data.forEach(each => {
-          if (each.key === key) {
-            each.type = type;
+
+      // 如果是聚合模式，需要同步所有相同 itemKey 的项
+      if (this.isAggregationMode && targetItem) {
+        const itemKey = targetItem.itemKey || targetItem.key;
+        if (itemKey) {
+          // 同步所有相同 itemKey 的项
+          syncItemsByItemKey(this.checkBoxMenu, itemKey, item => {
+            item.type = type;
+          });
+          // 在聚合模式下，需要从 checkBoxMenu 重新构建 draggableMenu，以确保所有项的 parent 属性正确
+          // 但是需要保留 draggableMenu 中的顺序（通过 sort 值）和 fixed 状态
+          const setDraggableMenu = arr => {
+            const allColumns = arr.flatMap(item => item.data);
+            const fixedCols = allColumns.filter(col => col.fixed === 'left').sort((a, b) => a.sort - b.sort);
+            const normalCols = allColumns.filter(col => col.fixed !== 'left').sort((a, b) => a.sort - b.sort);
+            const separator = {
+              type: true,
+              label: '',
+              key: 'sort-cut-off',
+              fixed: fixedCols.length > 0 ? 'left' : undefined,
+              parent: ''
+            };
+            return fixedCols.length > 0 ? [...fixedCols, separator, ...normalCols] : [separator, ...normalCols];
+          };
+
+          // 保存当前的 sort 和 fixed 状态
+          const currentStateMap = new Map();
+          this.draggableMenu.forEach(item => {
+            if (item.key !== 'sort-cut-off') {
+              const itemKeyForState = item.itemKey || item.key;
+              currentStateMap.set(itemKeyForState, {
+                sort: item.sort,
+                fixed: item.fixed
+              });
+            }
+          });
+
+          // 从 checkBoxMenu 重新构建 draggableMenu
+          this.draggableMenu = setDraggableMenu(this.checkBoxMenu);
+
+          // 恢复 sort 和 fixed 状态
+          this.draggableMenu.forEach(item => {
+            if (item.key !== 'sort-cut-off') {
+              const itemKeyForState = item.itemKey || item.key;
+              const state = currentStateMap.get(itemKeyForState);
+              if (state) {
+                item.sort = state.sort;
+                if (state.fixed) {
+                  item.fixed = state.fixed;
+                }
+              }
+            }
+          });
+        }
+      } else {
+        // 非聚合模式，保持原有逻辑
+        this.draggableMenu.forEach(item => {
+          if (item.key === key) {
+            item.type = type;
           }
         });
-      });
+        this.checkBoxMenu.forEach(item => {
+          item.data.forEach(each => {
+            if (each.key === key) {
+              each.type = type;
+            }
+          });
+        });
+      }
       if (this.useMultiLevelHeader) {
         this.refreshMultiHeaderDerivedData();
       }
@@ -76177,7 +76696,10 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
         this.savedGroupOrder = [];
         this.baseGroupOrder = [];
       }
-      this.initTableList(this.deepClone(this.columnList));
+      // 恢复默认时，传递空数组作为 bePreservedColumn，让 initTableList 按照原始数据的默认状态初始化
+      // 注意：这里传入空数组，initTableList 会走到 else 分支，将所有项的 type 设置为 true
+      // 但原始数据可能已经有自己的 type 值，所以需要先重置为原始数据
+      this.initTableList(this.deepClone(this.columnList), []);
       // 恢复默认后，滚动到顶部
       this.$nextTick(() => {
         this.$nextTick(() => {
@@ -76230,17 +76752,75 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       }
       const shouldCheck = !this.getGroupCheckState(group);
 
-      // 批量更新该组下所有项的勾选状态
-      group.data.forEach(item => {
-        // 更新 checkBoxMenu 中的状态
-        item.type = shouldCheck;
-        // 同步更新 draggableMenu 中的状态
-        this.draggableMenu.forEach(dragItem => {
-          if (dragItem.key === item.key) {
-            dragItem.type = shouldCheck;
+      // 如果是聚合模式，需要同步所有相同 itemKey 的项
+      if (this.isAggregationMode) {
+        group.data.forEach(item => {
+          const itemKey = item.itemKey || item.key;
+          if (itemKey) {
+            // 同步所有相同 itemKey 的项
+            syncItemsByItemKey(this.checkBoxMenu, itemKey, item => {
+              item.type = shouldCheck;
+            });
           }
         });
-      });
+        // 在聚合模式下，需要从 checkBoxMenu 重新构建 draggableMenu，以确保所有项的 parent 属性正确
+        // 但是需要保留 draggableMenu 中的顺序（通过 sort 值）和 fixed 状态
+        const setDraggableMenu = arr => {
+          const allColumns = arr.flatMap(item => item.data);
+          const fixedCols = allColumns.filter(col => col.fixed === 'left').sort((a, b) => a.sort - b.sort);
+          const normalCols = allColumns.filter(col => col.fixed !== 'left').sort((a, b) => a.sort - b.sort);
+          const separator = {
+            type: true,
+            label: '',
+            key: 'sort-cut-off',
+            fixed: fixedCols.length > 0 ? 'left' : undefined,
+            parent: ''
+          };
+          return fixedCols.length > 0 ? [...fixedCols, separator, ...normalCols] : [separator, ...normalCols];
+        };
+
+        // 保存当前的 sort 和 fixed 状态
+        const currentStateMap = new Map();
+        this.draggableMenu.forEach(item => {
+          if (item.key !== 'sort-cut-off') {
+            const itemKeyForState = item.itemKey || item.key;
+            currentStateMap.set(itemKeyForState, {
+              sort: item.sort,
+              fixed: item.fixed
+            });
+          }
+        });
+
+        // 从 checkBoxMenu 重新构建 draggableMenu
+        this.draggableMenu = setDraggableMenu(this.checkBoxMenu);
+
+        // 恢复 sort 和 fixed 状态
+        this.draggableMenu.forEach(item => {
+          if (item.key !== 'sort-cut-off') {
+            const itemKeyForState = item.itemKey || item.key;
+            const state = currentStateMap.get(itemKeyForState);
+            if (state) {
+              item.sort = state.sort;
+              if (state.fixed) {
+                item.fixed = state.fixed;
+              }
+            }
+          }
+        });
+      } else {
+        // 非聚合模式，保持原有逻辑
+        // 批量更新该组下所有项的勾选状态
+        group.data.forEach(item => {
+          // 更新 checkBoxMenu 中的状态
+          item.type = shouldCheck;
+          // 同步更新 draggableMenu 中的状态
+          this.draggableMenu.forEach(dragItem => {
+            if (dragItem.key === item.key) {
+              dragItem.type = shouldCheck;
+            }
+          });
+        });
+      }
       if (this.useMultiLevelHeader) {
         this.refreshMultiHeaderDerivedData();
       }
@@ -76373,6 +76953,14 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       return item && item.fixed === 'left';
     },
     toggleFixed(item, toFixed) {
+      // 如果是聚合模式且该项属于聚合组，禁止固定
+      if (this.isAggregationMode && toFixed) {
+        if (isItemInAggregatedGroup(item, this.checkBoxMenu)) {
+          this.$message.warning('聚合组内的项不能进行固定');
+          return;
+        }
+      }
+
       // 根据 toFixed 将该项移动到分割线以上或以下
       const idx = this.draggableMenu.findIndex(i => i.key === item.key);
       if (idx === -1) return;
@@ -76438,19 +77026,43 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
         const present = new Set();
         orderedLabels.forEach(label => {
           if (labelToData.has(label)) {
-            params.column.push({
+            // 从 checkBoxMenu 中找到对应的组，获取 groupkey 和 groupName
+            const sourceGroup = this.checkBoxMenu.find(g => g.label === label);
+            const groupData = {
               label,
               data: labelToData.get(label)
-            });
+            };
+            // 如果是聚合模式，需要保存 groupkey 和 groupName
+            if (this.isAggregationMode && sourceGroup) {
+              if (sourceGroup.groupkey) {
+                groupData.groupkey = sourceGroup.groupkey;
+              }
+              if (sourceGroup.groupName) {
+                groupData.groupName = sourceGroup.groupName;
+              }
+            }
+            params.column.push(groupData);
             present.add(label);
           }
         });
         baseOrder.forEach(label => {
           if (!present.has(label) && labelToData.has(label)) {
-            params.column.push({
+            // 从 checkBoxMenu 中找到对应的组，获取 groupkey 和 groupName
+            const sourceGroup = this.checkBoxMenu.find(g => g.label === label);
+            const groupData = {
               label,
               data: labelToData.get(label)
-            });
+            };
+            // 如果是聚合模式，需要保存 groupkey 和 groupName
+            if (this.isAggregationMode && sourceGroup) {
+              if (sourceGroup.groupkey) {
+                groupData.groupkey = sourceGroup.groupkey;
+              }
+              if (sourceGroup.groupName) {
+                groupData.groupName = sourceGroup.groupName;
+              }
+            }
+            params.column.push(groupData);
           }
         });
       } else {
@@ -76520,11 +77132,99 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
       });
       if (this.useMultiLevelHeader) {
         // 多级表头模式
-        const clonedColumn = params.column.map(group => ({
-          ...group,
-          data: group.data.map(col => this.deepClone(col))
-        }));
-        this.emitChangeTableGroup(clonedColumn);
+        // 如果是聚合模式，需要展开为原始数据传给表格
+        // 注意：需要基于当前的 groupCards 和 fixedAreaList 构建聚合数据，以反映拖动后的顺序
+        if (this.isAggregationMode) {
+          // 先从 groupCards 和 fixedAreaList 构建出聚合后的数据结构（反映当前顺序）
+          const orderedAggregatedGroups = [];
+          const labelToGroupData = new Map();
+          let sortIndex = 1
+
+          // 先处理固定项，按固定项的顺序添加到对应组，并重新分配 sort 值
+          ;
+          (this.fixedAreaList || []).forEach(item => {
+            if (item.type && item.parent) {
+              const label = item.parent.label;
+              if (!labelToGroupData.has(label)) {
+                labelToGroupData.set(label, []);
+              }
+              const itemData = {
+                ...item,
+                parent: item.parent
+              };
+              itemData.sort = sortIndex++;
+              labelToGroupData.get(label).push(itemData);
+            }
+          });
+
+          // 然后处理 groupCards 中的项，按它们在 groupCards 中的顺序添加到对应组，并重新分配 sort 值
+          this.groupCards.forEach(group => {
+            const label = group.label;
+            if (!labelToGroupData.has(label)) {
+              labelToGroupData.set(label, []);
+            }
+            ;
+            (group.items || []).forEach(item => {
+              if (item.type && item.parent) {
+                const itemData = {
+                  ...item,
+                  parent: item.parent
+                };
+                itemData.sort = sortIndex++;
+                labelToGroupData.get(label).push(itemData);
+              }
+            });
+          });
+
+          // 按 groupCards 的顺序构建聚合组
+          const orderedLabels = this.groupCards.map(g => g.label);
+          // 先添加有固定项的组（如果它们不在 groupCards 中）
+          const fixedGroupLabels = new Set();
+          (this.fixedAreaList || []).forEach(item => {
+            if (item.type && item.parent) {
+              fixedGroupLabels.add(item.parent.label);
+            }
+          });
+          fixedGroupLabels.forEach(label => {
+            if (!orderedLabels.includes(label) && labelToGroupData.has(label)) {
+              orderedLabels.push(label);
+            }
+          });
+
+          // 构建聚合组数据
+          orderedLabels.forEach(label => {
+            const items = labelToGroupData.get(label) || [];
+            if (items.length > 0) {
+              const sourceGroup = this.checkBoxMenu.find(g => g.label === label);
+              const group = {
+                label: label,
+                data: items.map(item => {
+                  const {
+                    parent,
+                    ...itemData
+                  } = item;
+                  return itemData;
+                })
+              };
+              if (sourceGroup) {
+                if (sourceGroup.groupkey) group.groupkey = sourceGroup.groupkey;
+                if (sourceGroup.groupName) group.groupName = sourceGroup.groupName;
+                if (sourceGroup.originalGroups) group.originalGroups = sourceGroup.originalGroups;
+              }
+              orderedAggregatedGroups.push(group);
+            }
+          });
+
+          // 展开聚合数据传给表格
+          const expandedColumns = expandAggregatedColumns(orderedAggregatedGroups, this.originalColumnMap);
+          this.emitChangeTableGroup(expandedColumns);
+        } else {
+          const clonedColumn = params.column.map(group => ({
+            ...group,
+            data: group.data.map(col => this.deepClone(col))
+          }));
+          this.emitChangeTableGroup(clonedColumn);
+        }
       } else {
         this.emitChangeTable(cols.sort((a, b) => a.sort - b.sort));
       }
@@ -76575,8 +77275,8 @@ var pin_namespaceObject = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAA
 ;
 var custom_column_component = normalizeComponent(
   components_custom_columnvue_type_script_lang_js,
-  custom_columnvue_type_template_id_2a1d0253_render,
-  custom_columnvue_type_template_id_2a1d0253_staticRenderFns,
+  custom_columnvue_type_template_id_d822d96a_render,
+  custom_columnvue_type_template_id_d822d96a_staticRenderFns,
   false,
   null,
   null,
@@ -77277,7 +77977,8 @@ var custom_column_component = normalizeComponent(
         // 更新分页配置
         this.gridOptions.pagerConfig.currentPage = currentPage;
         this.gridOptions.pagerConfig.pageSize = pageSize;
-        this.gridOptions.pagerConfig.total = allData.length;
+        // 如果有置顶行，总数需要减1（置顶行不参与分页计数）
+        this.gridOptions.pagerConfig.total = specialFirstRow ? allData.length - 1 : allData.length;
 
         // 获取当前页数据
         currentPageData = normalData.slice(start, end);
@@ -77527,8 +78228,8 @@ var custom_column_component = normalizeComponent(
 ;
 var table_component = normalizeComponent(
   components_tablevue_type_script_lang_js,
-  tablevue_type_template_id_35ba1298_render,
-  tablevue_type_template_id_35ba1298_staticRenderFns,
+  tablevue_type_template_id_22e15733_render,
+  tablevue_type_template_id_22e15733_staticRenderFns,
   false,
   null,
   null,
@@ -78823,8 +79524,6 @@ var ByCommonSelectorvue_type_template_id_05ec4584_render = function render() {
 };
 var ByCommonSelectorvue_type_template_id_05ec4584_staticRenderFns = [];
 
-// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.some.js
-var es_iterator_some = __webpack_require__(3579);
 ;// ./node_modules/pinyin-pro/dist/index.mjs