balala-revogrid 1.0.0

package/dist/collection/plugins/column-manage.plugin.js

@@ -0,0 +1,1218 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+/**
+ * 列管理插件
+ * 实现表格列的隐藏、显示、冻结、插入、删除等功能
+ */
+import { BasePlugin } from "./base.plugin";
+import { ColumnStretchPlugin } from "./column-stretch.plugin";
+import { convertCollectionToColumns, getStretchColumnOptions, mergeAdjacentGroups } from "../utils/column.utils";
+/**
+ * 深拷贝列配置（保留函数属性）
+ */
+function deepCloneColumns(cols) {
+    return cols.map(col => {
+        const colAny = col;
+        if (colAny.children) {
+            return Object.assign(Object.assign({}, col), { children: deepCloneColumns(colAny.children) });
+        }
+        return Object.assign({}, col);
+    });
+}
+export class ColumnManagePlugin extends BasePlugin {
+    constructor(revogrid, providers, config) {
+        super(revogrid, providers);
+        this.hiddenProps = new Set();
+        this.originalColumns = null;
+        this.uniqueId = undefined;
+        // 优先使用传入的 config，否则从 additionalData 读取
+        const additionalData = revogrid.additionalData || {};
+        this.config = config || additionalData.columnManage || {};
+        this.autoDetectHiddenColumns(additionalData.allColumns);
+    }
+    /**
+     * 获取当前保存的 uniqueId
+     */
+    getUniqueId() {
+        return this.uniqueId;
+    }
+    /**
+     * 自动检测隐藏的列（通过对比 allColumns 和当前 columns）
+     */
+    autoDetectHiddenColumns(allColumns) {
+        // 获取当前可见列的 prop 集合
+        const visibleProps = new Set();
+        const collectVisibleProps = (cols) => {
+            cols.forEach(col => {
+                const colAny = col;
+                if (colAny.children) {
+                    collectVisibleProps(colAny.children);
+                }
+                else if (col.prop !== undefined) {
+                    visibleProps.add(col.prop);
+                }
+            });
+        };
+        collectVisibleProps(this.revogrid.columns);
+        // 找出 allColumns 中不在 visibleProps 中的列
+        allColumns.forEach(col => {
+            if (col.prop !== undefined && !visibleProps.has(col.prop)) {
+                this.hiddenProps.add(String(col.prop));
+            }
+        });
+    }
+    // ==================== 隐藏/显示列 ====================
+    /**
+     * 隐藏列
+     * 逻辑：
+     * 准备: 当前列配置
+     * 1. 遍历要隐藏的列
+     * 2. 查找列的位置
+     *   - 是分组下的列: 从分组中移除该列，如果分组为空则删除分组
+     *   - 是普通列: 从列数组中移除该列
+     * 3. 标记列为隐藏
+     */
+    hideColumns(columns) {
+        var _a, _b;
+        const props = this.normalizeColumnConfig(columns);
+        // 准备：获取当前列配置
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const options = getStretchColumnOptions(this.providers, stretchPlugin);
+        const currentColumns = convertCollectionToColumns(this.providers, options);
+        // 遍历要隐藏的列
+        props.forEach(prop => {
+            // 查找列的位置和分组信息
+            let found = false;
+            for (let i = currentColumns.length - 1; i >= 0; i--) {
+                const col = currentColumns[i];
+                if (col.children) {
+                    // 当前是分组
+                    const childIdx = col.children.findIndex((child) => child.prop === prop);
+                    if (childIdx !== -1) {
+                        // 从分组中移除该列
+                        col.children.splice(childIdx, 1);
+                        // 如果分组为空，删除分组
+                        if (col.children.length === 0) {
+                            currentColumns.splice(i, 1);
+                        }
+                        found = true;
+                        break;
+                    }
+                }
+                else if (col.prop === prop) {
+                    // 是普通列，从列数组中移除
+                    currentColumns.splice(i, 1);
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                // 标记列为隐藏
+                this.hiddenProps.add(prop);
+            }
+        });
+        // 更新列配置
+        this.revogrid.columns = [...currentColumns];
+        // 触发隐藏变化回调
+        (_b = (_a = this.config).onHiddenChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.getHiddenColumns(), props);
+    }
+    /**
+     * 获取当前隐藏的列
+     */
+    getHiddenColumns() {
+        return Array.from(this.hiddenProps);
+    }
+    /**
+     * 检查列是否隐藏
+     */
+    isColumnHidden(prop) {
+        return this.hiddenProps.has(prop);
+    }
+    // ==================== 冻结列 ====================
+    /**
+     * 设置列冻结
+     * @param prop 列的 prop
+     * @param pin 冻结类型：'colPinStart' 左冻结，'colPinEnd' 右冻结，undefined 取消冻结
+     * 冻结逻辑：
+     * pin值为：
+     * - 'colPinStart': 列冻结到左侧，放到左侧冻结的最后一个
+     * - 'colPinEnd': 列冻结到右侧，放到右侧冻结的第一个
+     * - undefined: 取消冻结。如果之前是左侧冻结，那就放在未冻结的第一个；如果之前是右侧冻结，那就放在未冻结的最后一个
+     */
+    setColumnPin(prop, pin) {
+        var _a, _b;
+        // 准备：获取当前列配置
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const options = getStretchColumnOptions(this.providers, stretchPlugin);
+        const columns = convertCollectionToColumns(this.providers, options);
+        // 查找列的位置和分组信息
+        const { groupIndex: columnGroupIndex, childIndex: columnChildIndex, group: columnGroup, columnData } = this.findColumnInColumns(columns, prop);
+        if (!columnData) {
+            console.warn(`[ColumnManagePlugin] 找不到列 "${prop}"`);
+            return false;
+        }
+        // 获取当前列的冻结状态（从 columns 中获取）
+        const currentPin = columnData.pin;
+        // 如果冻结状态没有变化，直接返回
+        if (currentPin === pin) {
+            return true;
+        }
+        // 如果是分组中的子列，需要特殊处理
+        if (columnGroup && columnChildIndex !== -1) {
+            const groupName = columnGroup.name;
+            // 从编组中移除该列
+            const removed = columnGroup.children.splice(columnChildIndex, 1)[0];
+            // 如果编组中没有列了，删除编组
+            if (columnGroup.children.length === 0) {
+                columns.splice(columnGroupIndex, 1);
+            }
+            // 设置列的 pin 状态
+            if (pin) {
+                removed.pin = pin;
+            }
+            else {
+                delete removed.pin;
+            }
+            // 找到插入位置（传入 currentPin 用于判断取消冻结时的位置）
+            const insertIndex = this.findInsertPositionForPinInColumns(columns, pin, currentPin);
+            // 创建新编组，插入到目标位置
+            const newGroup = {
+                name: groupName,
+                children: [removed],
+            };
+            if (pin) {
+                newGroup.pin = pin;
+            }
+            columns.splice(insertIndex, 0, newGroup);
+        }
+        else {
+            // 移除单个列
+            const removed = columns.splice(columnGroupIndex, 1)[0];
+            // 设置新的 pin 状态
+            if (pin) {
+                removed.pin = pin;
+            }
+            else {
+                delete removed.pin;
+            }
+            // 找到插入位置（传入 currentPin 用于判断取消冻结时的位置）
+            const insertIndex = this.findInsertPositionForPinInColumns(columns, pin, currentPin);
+            // 插入到新位置
+            columns.splice(insertIndex, 0, removed);
+        }
+        // 合并相邻的同名同pin编组
+        mergeAdjacentGroups(columns);
+        // 更新列配置
+        this.revogrid.columns = [...columns];
+        (_b = (_a = this.config).onPinChange) === null || _b === void 0 ? void 0 : _b.call(_a, prop, pin);
+        return true;
+    }
+    /**
+     * 左冻结列
+     */
+    pinColumnLeft(prop) {
+        return this.setColumnPin(prop, 'colPinStart');
+    }
+    /**
+     * 右冻结列
+     */
+    pinColumnRight(prop) {
+        return this.setColumnPin(prop, 'colPinEnd');
+    }
+    /**
+     * 取消列冻结
+     */
+    unpinColumn(prop) {
+        return this.setColumnPin(prop, undefined);
+    }
+    /**
+     * 获取列的冻结状态
+     */
+    getColumnPin(prop) {
+        const cols = this.originalColumns || this.revogrid.columns;
+        if (!cols)
+            return undefined;
+        const col = this.findColumnByProp(cols, prop);
+        return col ? col.pin : undefined;
+    }
+    /**
+     * 检查列是否冻结
+     */
+    isColumnPinned(prop) {
+        return !!this.getColumnPin(prop);
+    }
+    // ==================== 位置调整 ====================
+    /**
+     * 将隐藏的列显示在指定列的左侧或右侧
+     * 逻辑：
+     * 准备: additionalData.allColumns、当前是否分组、当前列所属分组数据、目标列数据
+     * 1. 是否分组下的列
+     *   - 是: 获取列在分组下的索引，根据 position 和索引插入目标列数据
+     *   - 否: 根据 column 获取索引，再根据 position 和索引插入目标列数据
+     * 2. 目标列数据的pin继承当前列的pin
+     */
+    showColumnAt(column, target, position = 'after') {
+        var _a, _b;
+        // 验证列是否隐藏
+        if (!this.hiddenProps.has(column)) {
+            console.warn(`[ColumnManagePlugin] 列 "${column}" 未被隐藏`);
+            return false;
+        }
+        // 准备：获取 allColumns
+        const additionalData = this.revogrid.additionalData || {};
+        const allColumns = additionalData.allColumns;
+        if (!allColumns || !Array.isArray(allColumns)) {
+            console.warn('[ColumnManagePlugin] 找不到 allColumns');
+            return false;
+        }
+        // 准备：获取目标列数据（要显示的列）
+        const targetColumnData = allColumns.find((col) => col.prop === column);
+        if (!targetColumnData) {
+            console.warn(`[ColumnManagePlugin] 在 allColumns 中找不到列 "${column}"`);
+            return false;
+        }
+        // 准备：获取当前列配置
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const options = getStretchColumnOptions(this.providers, stretchPlugin);
+        const columns = convertCollectionToColumns(this.providers, options);
+        // 准备：查找当前列（target）的位置和分组信息
+        const { groupIndex: targetGroupIndex, childIndex: targetChildIndex, group: targetGroup, columnData: currentColumn } = this.findColumnInColumns(columns, target);
+        if (!currentColumn) {
+            console.warn(`[ColumnManagePlugin] 找不到目标列 "${target}"`);
+            return false;
+        }
+        // 创建要插入的列数据（继承当前列的 pin）
+        const insertColumn = Object.assign({}, targetColumnData);
+        if (currentColumn.pin) {
+            insertColumn.pin = currentColumn.pin;
+        }
+        else {
+            delete insertColumn.pin;
+        }
+        // 1. 判断是否分组下的列
+        if (targetGroup && targetChildIndex !== -1) {
+            // 是：获取列在分组下的索引，根据 position 和索引插入目标列数据
+            const insertChildIndex = position === 'before' ? targetChildIndex : targetChildIndex + 1;
+            targetGroup.children.splice(insertChildIndex, 0, insertColumn);
+        }
+        else {
+            // 否：根据 column 获取索引，再根据 position 和索引插入目标列数据
+            const insertIndex = position === 'before' ? targetGroupIndex : targetGroupIndex + 1;
+            columns.splice(insertIndex, 0, insertColumn);
+        }
+        // 更新列配置
+        this.revogrid.columns = [...columns];
+        this.hiddenProps.delete(column);
+        // 触发隐藏变化回调
+        (_b = (_a = this.config).onHiddenChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.getHiddenColumns(), [column]);
+        return true;
+    }
+    /**
+     * 批量将隐藏的列显示在指定列的左侧或右侧
+     */
+    showColumnsAt(columns, target, position = 'after') {
+        const orderedColumns = position === 'after' ? [...columns].reverse() : columns;
+        let success = true;
+        for (const col of orderedColumns) {
+            if (!this.showColumnAt(col, target, position)) {
+                success = false;
+            }
+        }
+        return success;
+    }
+    /**
+     * 替换列：将可见列隐藏，同时将隐藏列显示在可见列的位置
+     * @param hiddenColumn 当前隐藏的列（要显示）
+     * @param visibleColumn 当前可见的列（要隐藏）
+     * 逻辑：
+     * 准备: additionalData.allColumns、当前列配置、可见列位置和分组信息、隐藏列数据
+     * 1. 查找可见列的位置
+     *   - 是分组下的列: 获取分组和子列索引，替换该位置的列
+     *   - 是普通列: 获取列索引，替换该位置的列
+     * 2. 替换列数据的pin和size继承可见列的pin和size
+     * 3. 将可见列标记为隐藏
+     */
+    replaceColumn(hiddenColumn, visibleColumn) {
+        var _a, _b;
+        // 验证隐藏列状态
+        if (!this.hiddenProps.has(hiddenColumn)) {
+            console.warn(`[ColumnManagePlugin] 列 "${hiddenColumn}" 未被隐藏`);
+            return false;
+        }
+        // 验证可见列状态
+        if (this.hiddenProps.has(visibleColumn)) {
+            console.warn(`[ColumnManagePlugin] 列 "${visibleColumn}" 已被隐藏`);
+            return false;
+        }
+        // 准备：获取 allColumns
+        const additionalData = this.revogrid.additionalData || {};
+        const allColumns = additionalData.allColumns;
+        if (!allColumns || !Array.isArray(allColumns)) {
+            console.warn('[ColumnManagePlugin] 找不到 allColumns');
+            return false;
+        }
+        // 准备：获取隐藏列数据（要显示的列）
+        const hiddenColumnData = allColumns.find((col) => col.prop === hiddenColumn);
+        if (!hiddenColumnData) {
+            console.warn(`[ColumnManagePlugin] 在 allColumns 中找不到列 "${hiddenColumn}"`);
+            return false;
+        }
+        // 准备：获取当前列配置
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const options = getStretchColumnOptions(this.providers, stretchPlugin);
+        const columns = convertCollectionToColumns(this.providers, options);
+        // 准备：查找可见列的位置和分组信息
+        const { groupIndex: visibleGroupIndex, childIndex: visibleChildIndex, group: visibleGroup, columnData: visibleColumnData } = this.findColumnInColumns(columns, visibleColumn);
+        if (!visibleColumnData) {
+            console.warn(`[ColumnManagePlugin] 找不到可见列 "${visibleColumn}"`);
+            return false;
+        }
+        // 创建替换列数据（继承可见列的 pin 和 size）
+        const replaceColumn = Object.assign({}, hiddenColumnData);
+        if (visibleColumnData.pin) {
+            replaceColumn.pin = visibleColumnData.pin;
+        }
+        else {
+            delete replaceColumn.pin;
+        }
+        // 1. 判断是否分组下的列
+        if (visibleGroup && visibleChildIndex !== -1) {
+            // 是：替换分组中的列
+            visibleGroup.children.splice(visibleChildIndex, 1, replaceColumn);
+        }
+        else {
+            // 否：替换普通列
+            columns.splice(visibleGroupIndex, 1, replaceColumn);
+        }
+        // 更新列配置
+        this.revogrid.columns = [...columns];
+        // 标记可见列为隐藏，移除隐藏列的隐藏标记
+        this.hiddenProps.add(visibleColumn);
+        this.hiddenProps.delete(hiddenColumn);
+        // 触发隐藏变化回调
+        (_b = (_a = this.config).onHiddenChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.getHiddenColumns(), [hiddenColumn, visibleColumn]);
+        // 触发列替换事件
+        this.emit('columnreplaced', {
+            hiddenColumn,
+            visibleColumn,
+            hiddenColumns: this.getHiddenColumns(),
+        });
+        return true;
+    }
+    /**
+     * 导出当前列配置（用于保存到接口）
+     * 只导出可见列（从 grid.columns 获取，包含拖拽后的新顺序和实际宽度）
+     * 返回列配置数组，包含列顺序、冻结状态、宽度等
+     */
+    exportColumnConfig() {
+        // 1. 获取当前可见列（包含拖拽后的新顺序）
+        const columns = this.revogrid.columns;
+        if (!columns || columns.length === 0) {
+            return [];
+        }
+        // 2. 获取当前列宽度（从 DOM 中读取实际宽度）
+        const sizeMap = this.buildSizeMap(columns);
+        // 3. 获取 ColumnStretchPlugin 实例
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        // 4. 获取自动宽度列配置
+        const stretchOptions = getStretchColumnOptions(this.providers, stretchPlugin);
+        const stretchColumnProps = (stretchOptions === null || stretchOptions === void 0 ? void 0 : stretchOptions.stretchColumnProps) || new Set();
+        const manuallyResizedProps = (stretchOptions === null || stretchOptions === void 0 ? void 0 : stretchOptions.manuallyResizedProps) || new Set();
+        const result = [];
+        // 构建单列配置
+        const buildColumnItem = (col, parentPin) => {
+            const prop = col.prop;
+            const item = { prop };
+            // 判断是否是自动宽度列
+            const isStretchColumn = stretchColumnProps.has(prop);
+            if (isStretchColumn) {
+                // 自动宽度列：只有被手动调整过才导出 size
+                if (manuallyResizedProps.has(prop)) {
+                    const size = sizeMap.get(prop) || col.size;
+                    if (size) {
+                        item.size = size;
+                    }
+                }
+            }
+            else {
+                // 普通列：直接导出 size
+                const size = sizeMap.get(prop) || col.size;
+                if (size) {
+                    item.size = size;
+                }
+            }
+            // 优先使用子列自己的 pin，如果没有则继承父级的 pin
+            const colAny = col;
+            const pin = colAny.pin || parentPin;
+            if (pin) {
+                item.pin = pin;
+            }
+            return item;
+        };
+        // 导出可见列（只保留 prop、size、pin）
+        for (const col of columns) {
+            const colAny = col;
+            if (colAny.children) {
+                // 分组列
+                const parentPin = colAny.pin;
+                const groupChildren = colAny.children
+                    .filter((child) => child.prop)
+                    .map((child) => buildColumnItem(child, parentPin));
+                if (groupChildren.length > 0) {
+                    const groupItem = {
+                        name: colAny.name,
+                        children: groupChildren,
+                    };
+                    if (parentPin) {
+                        groupItem.pin = parentPin;
+                    }
+                    result.push(groupItem);
+                }
+            }
+            else if (col.prop) {
+                // 普通列
+                result.push(buildColumnItem(col));
+            }
+        }
+        return result;
+    }
+    /**
+     * 导入列配置（从接口恢复）
+     * @param config 列配置数据（与 exportColumnConfig 格式一致）
+     * @param uniqueId 可选的唯一标识符，用于防抖
+     * @returns Promise<boolean> 返回 Promise，在渲染完成后 resolve
+     */
+    async importColumnConfig(config, uniqueId) {
+        // 保存 uniqueId 到全局变量
+        if (uniqueId !== undefined) {
+            this.uniqueId = uniqueId;
+        }
+        // 从 additionalData.allColumns 获取基础列定义
+        const additionalData = this.revogrid.additionalData || {};
+        const base = additionalData.allColumns;
+        if (!base || !Array.isArray(base) || !config || config.length === 0) {
+            console.warn('[ColumnManagePlugin] importColumnConfig 失败: 缺少 additionalData.allColumns 或 config');
+            return false;
+        }
+        // 获取 ColumnStretchPlugin 实例和配置
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const stretchColumnConfig = stretchPlugin === null || stretchPlugin === void 0 ? void 0 : stretchPlugin.getStretchColumnConfig();
+        // 确定哪些列是自动宽度列
+        const stretchColumnProps = new Set();
+        if (stretchColumnConfig && base) {
+            if (stretchColumnConfig === 'last') {
+                // 最后一列
+                const lastCol = base[base.length - 1];
+                if (lastCol === null || lastCol === void 0 ? void 0 : lastCol.prop) {
+                    stretchColumnProps.add(lastCol.prop);
+                }
+            }
+            else if (stretchColumnConfig === 'all') {
+                // 所有列
+                base.forEach((col) => {
+                    if (col.prop) {
+                        stretchColumnProps.add(col.prop);
+                    }
+                });
+            }
+            else if (typeof stretchColumnConfig === 'number') {
+                // 指定索引的列
+                const col = base[stretchColumnConfig];
+                if (col === null || col === void 0 ? void 0 : col.prop) {
+                    stretchColumnProps.add(col.prop);
+                }
+            }
+            else if (typeof stretchColumnConfig === 'string') {
+                // 指定 prop 的列
+                stretchColumnProps.add(stretchColumnConfig);
+            }
+        }
+        // 构建 prop -> 基础列配置 的映射
+        const baseColMap = new Map();
+        base.forEach((col) => {
+            if (col.prop) {
+                baseColMap.set(col.prop, col);
+            }
+        });
+        const newColumns = [];
+        this.hiddenProps.clear();
+        // 收集配置中的所有 prop，用于标记隐藏列
+        const visibleProps = new Set();
+        const collectVisibleProps = (items) => {
+            for (const item of items) {
+                const itemAny = item;
+                if (itemAny.children) {
+                    itemAny.children.forEach((child) => {
+                        visibleProps.add(child.prop);
+                    });
+                }
+                else {
+                    visibleProps.add(item.prop);
+                }
+            }
+        };
+        collectVisibleProps(config);
+        // 标记所有不在配置中的列为隐藏
+        baseColMap.forEach((_, prop) => {
+            if (!visibleProps.has(prop)) {
+                this.hiddenProps.add(prop);
+            }
+        });
+        // 处理列配置并更新 ColumnStretchPlugin 的 manuallyResizedColumns
+        const processColumn = (colItem, baseCol) => {
+            const isStretchColumn = stretchColumnProps.has(colItem.prop);
+            const newCol = Object.assign({}, baseCol);
+            if (isStretchColumn) {
+                if (colItem.size) {
+                    newCol.size = colItem.size;
+                    stretchPlugin === null || stretchPlugin === void 0 ? void 0 : stretchPlugin.markAsManuallyResized(colItem.prop);
+                }
+                else {
+                    // 完全不设置 size，让 ColumnStretchPlugin 自动计算
+                    delete newCol.size;
+                    stretchPlugin === null || stretchPlugin === void 0 ? void 0 : stretchPlugin.unmarkAsManuallyResized(colItem.prop);
+                }
+            }
+            else {
+                newCol.size = colItem.size || baseCol.size;
+            }
+            return newCol;
+        };
+        for (const item of config) {
+            const itemAny = item;
+            if (itemAny.children) {
+                // 分组列
+                const groupChildren = [];
+                for (const child of itemAny.children) {
+                    const baseCol = baseColMap.get(child.prop);
+                    if (!baseCol)
+                        continue;
+                    const newCol = processColumn(child, baseCol);
+                    // 优先使用子列的 pin，如果没有则使用分组的 pin
+                    const pin = child.pin || itemAny.pin;
+                    if (pin) {
+                        newCol.pin = pin;
+                    }
+                    else {
+                        delete newCol.pin;
+                    }
+                    groupChildren.push(newCol);
+                }
+                if (groupChildren.length > 0) {
+                    const groupCol = {
+                        name: itemAny.name,
+                        children: groupChildren,
+                    };
+                    if (itemAny.pin) {
+                        groupCol.pin = itemAny.pin;
+                    }
+                    newColumns.push(groupCol);
+                }
+            }
+            else {
+                // 普通列
+                const colItem = item;
+                const baseCol = baseColMap.get(colItem.prop);
+                if (!baseCol)
+                    continue;
+                const newCol = processColumn(colItem, baseCol);
+                if (colItem.pin) {
+                    newCol.pin = colItem.pin;
+                }
+                else {
+                    delete newCol.pin;
+                }
+                newColumns.push(newCol);
+            }
+        }
+        // 更新 originalColumns
+        this.originalColumns = deepCloneColumns(newColumns);
+        // 如果提供了 uniqueId，按照优先级设置到列配置中
+        // 优先级：非冻结列的第一个 > 冻结列的第一个
+        if (uniqueId !== undefined && newColumns.length > 0) {
+            let targetCol = null;
+            // 1. 先查找非冻结列的第一个
+            for (const col of newColumns) {
+                const colAny = col;
+                if (colAny.children) {
+                    // 分组列：查找第一个非冻结的子列
+                    const firstNonPinChild = colAny.children.find((child) => !child.pin);
+                    if (firstNonPinChild) {
+                        targetCol = firstNonPinChild;
+                        break;
+                    }
+                }
+                else if (!colAny.pin) {
+                    // 普通非冻结列
+                    targetCol = colAny;
+                    break;
+                }
+            }
+            // 2. 如果没有非冻结列，使用第一个列（不管是否冻结）
+            if (!targetCol) {
+                const firstCol = newColumns[0];
+                if (firstCol.children && firstCol.children.length > 0) {
+                    targetCol = firstCol.children[0];
+                }
+                else {
+                    targetCol = firstCol;
+                }
+            }
+            // 3. 设置 uniqueId
+            if (targetCol) {
+                targetCol.uniqueId = uniqueId;
+            }
+        }
+        // 返回 Promise，在渲染完成后 resolve
+        return new Promise((resolve) => {
+            var _a;
+            // 监听 aftercolumnsset 事件，确保渲染完成
+            const handleImportComplete = () => {
+                var _a, _b;
+                // 触发配置回调
+                (_b = (_a = this.config).onImportComplete) === null || _b === void 0 ? void 0 : _b.call(_a, config);
+                // resolve Promise
+                resolve(true);
+            };
+            this.revogrid.addEventListener('aftercolumnsset', handleImportComplete, { once: true });
+            // 应用配置
+            this.revogrid.columns = [...newColumns];
+            // 重置自动列宽列的宽度
+            if (stretchPlugin && ((_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension)) {
+                // 监听下一次 beforecolumnapplied 事件，确保列数据已更新
+                const handleColumnApplied = (e) => {
+                    var _a;
+                    // 使用事件中的新列数据，而不是 columnCollection.columns（旧数据）
+                    const columnsData = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.columns;
+                    if (!columnsData) {
+                        stretchPlugin.applyStretch();
+                        return;
+                    }
+                    const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+                    dimensionTypes.forEach(type => {
+                        var _a, _b;
+                        const columns = columnsData[type];
+                        if (!columns)
+                            return;
+                        const dimensionStore = (_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.stores[type];
+                        if (!dimensionStore)
+                            return;
+                        const sizes = dimensionStore.store.get('sizes') || {};
+                        let hasChanges = false;
+                        columns.forEach((col, idx) => {
+                            const prop = col.prop;
+                            if (prop && stretchColumnProps.has(prop) && !stretchPlugin.isManuallyResized(prop) && sizes[idx]) {
+                                delete sizes[idx];
+                                hasChanges = true;
+                            }
+                        });
+                        if (hasChanges) {
+                            dimensionStore.store.set('sizes', Object.assign({}, sizes));
+                        }
+                    });
+                    stretchPlugin.applyStretch();
+                };
+                // 监听一次 beforecolumnapplied 事件
+                this.revogrid.addEventListener('beforecolumnapplied', handleColumnApplied, { once: true });
+            }
+        });
+    }
+    // ==================== 编组管理 ====================
+    /**
+     * 设置列的编组（统一入口方法）
+     * @param columnProp 列的 prop
+     * @param groupName 编组名称，如果为空则移除编组
+     * @returns 是否成功
+     *
+     * 使用示例：
+     * - setColumnGroup('priority', '基础信息') // 将 priority 列设置到 "基础信息" 编组
+     * - setColumnGroup('priority', '') // 移除 priority 列的编组
+     */
+    setColumnGroup(columnProp, groupName) {
+        const stretchPlugin = this.providers.plugins.getByClass(ColumnStretchPlugin);
+        const options = getStretchColumnOptions(this.providers, stretchPlugin);
+        const columns = convertCollectionToColumns(this.providers, options);
+        const trimmedGroupName = (groupName === null || groupName === void 0 ? void 0 : groupName.trim()) || '';
+        const currentGroup = this.getColumnGroup(columns, columnProp);
+        // 如果目标编组和当前编组相同，无需操作
+        if (currentGroup === trimmedGroupName || (!currentGroup && !trimmedGroupName)) {
+            return true;
+        }
+        let result = false;
+        /**
+         * 无编组名称: 移除编组
+         * 有编组名称:
+         * 1. 当前有编组: 从编组中分离出来
+         * 2. 是否有相邻编组且名称一样
+         *   - 有: 合并进去
+         *   - 无: 新建编组
+         */
+        if (!trimmedGroupName) {
+            // 无编组名称: 移除编组
+            result = currentGroup ? this.removeColumnFromGroup(columns, currentGroup, columnProp) : true;
+        }
+        else {
+            // 当前有编组: 从编组中分离出来
+            if (currentGroup) {
+                this.removeColumnFromGroup(columns, currentGroup, columnProp);
+            }
+            // 是否有相邻编组且名称一样
+            const adjacentGroup = this.findAdjacentGroup(columns, columnProp, trimmedGroupName);
+            if (adjacentGroup) {
+                // 合并到同名编组
+                result = this.addColumnToGroup(columns, adjacentGroup);
+                // 合并完成后，检查是否需要合并相邻的同名编组（处理前后都有同名编组的情况）
+                mergeAdjacentGroups(columns);
+            }
+            else {
+                // 创建新编组
+                result = this.createColumnGroup(columns, trimmedGroupName, [columnProp]);
+            }
+        }
+        // 触发编组变化事件
+        if (result) {
+            this.emit('columngroupchanged', {
+                columnProp,
+                groupName: trimmedGroupName || null,
+                previousGroup: currentGroup || null,
+            });
+        }
+        this.revogrid.columns = [...columns];
+        return result;
+    }
+    /**
+     * 查找列相邻的同名编组
+     * @private
+     */
+    findAdjacentGroup(columns, columnProp, groupName) {
+        const columnIndex = columns.findIndex((item) => item.prop === columnProp);
+        if (columnIndex === -1)
+            return null;
+        const columnInfo = columns[columnIndex];
+        const columnPin = columnInfo.pin;
+        let prevGroup = null;
+        let nextGroup = null;
+        // 检查前一个
+        if (columnIndex > 0) {
+            const prevColumn = columns[columnIndex - 1];
+            if (prevColumn.children &&
+                prevColumn.name === groupName &&
+                prevColumn.pin === columnPin) {
+                prevGroup = {
+                    position: 'end',
+                    groupIndex: columnIndex - 1,
+                    columnIndex: columnIndex
+                }; // 添加到前一个编组的末尾
+            }
+        }
+        // 检查后一个
+        if (columnIndex < columns.length - 1) {
+            const nextColumn = columns[columnIndex + 1];
+            if (nextColumn.children &&
+                nextColumn.name === groupName &&
+                nextColumn.pin === columnPin) {
+                nextGroup = {
+                    position: 'start',
+                    groupIndex: columnIndex + 1,
+                    columnIndex: columnIndex
+                }; // 添加到后一个编组的开头
+            }
+        }
+        // 如果前后都有同名编组，优先合并到前一个（添加到前一个编组的末尾）
+        // 这样可以保持列的顺序更自然
+        if (prevGroup) {
+            return prevGroup;
+        }
+        return nextGroup;
+    }
+    /**
+     * 创建列编组
+     * @param columns 列数据源
+     * @param groupName 编组名称
+     * @param columnProps 要编组的列 prop 数组
+     * @param pin 可选的冻结位置
+     * @private
+     */
+    createColumnGroup(columns, groupName, columnProps, pin) {
+        if (columnProps.length === 0) {
+            console.warn('[ColumnManagePlugin] 编组列不能为空');
+            return false;
+        }
+        // 收集要编组的列及其索引
+        const columnsData = [];
+        for (const prop of columnProps) {
+            const index = columns.findIndex((item) => item.prop === prop);
+            columnsData.push({
+                column: columns[index],
+                index: index
+            });
+        }
+        if (columnsData.length === 0)
+            return false;
+        // 按索引倒序删除列
+        columnsData
+            .sort((a, b) => b.index - a.index)
+            .forEach(({ index }) => columns.splice(index, 1));
+        // 创建编组
+        const groupColumn = {
+            name: groupName,
+            children: columnsData.map(({ column }) => {
+                const newCol = Object.assign({}, column);
+                if (pin)
+                    newCol.pin = pin;
+                return newCol;
+            }),
+        };
+        if (pin)
+            groupColumn.pin = pin;
+        // 插入到第一个被删除列的位置
+        const insertIndex = Math.min(...columnsData.map(d => d.index));
+        columns.splice(insertIndex, 0, groupColumn);
+        this.revogrid.columns = [...columns];
+        return true;
+    }
+    /**
+     * 向编组添加列
+     * @param columns 列数据源
+     * @param adjacentGroup 相邻编组信息（包含 groupIndex、columnIndex、position）
+     * @private
+     */
+    addColumnToGroup(columns, adjacentGroup) {
+        const { groupIndex, columnIndex, position } = adjacentGroup;
+        // 1. 通过索引找到目标分组
+        const group = columns[groupIndex];
+        if (!group || !group.children) {
+            console.warn(`[ColumnManagePlugin] 索引 ${groupIndex} 处不是有效的编组`);
+            return false;
+        }
+        // 获取原始列
+        const column = columns[columnIndex];
+        if (!column) {
+            console.warn(`[ColumnManagePlugin] 索引 ${columnIndex} 处找不到列`);
+            return false;
+        }
+        // 2. 先删除原始列，再插入到编组
+        // 注意：删除操作会影响后续索引，所以需要先删除
+        columns.splice(columnIndex, 1);
+        // 3. 重新计算编组索引（如果列在编组前面，删除后编组索引会减1）
+        const adjustedGroupIndex = columnIndex < groupIndex ? groupIndex - 1 : groupIndex;
+        const adjustedGroup = columns[adjustedGroupIndex];
+        // 4. 根据 position 插入到编组
+        if (position === 'start') {
+            adjustedGroup.children.unshift(column);
+        }
+        else {
+            adjustedGroup.children.push(column);
+        }
+        this.revogrid.columns = [...columns];
+        return true;
+    }
+    /**
+     * 从编组移除列
+     * @param columns 列数据源
+     * @param groupName 编组名称
+     * @param columnProp 要移除的列 prop
+     * @private
+     */
+    removeColumnFromGroup(columns, groupName, columnProp) {
+        // 先从子级找到包含该列的编组
+        let groupIndex = -1;
+        let childIndex = -1;
+        for (let i = 0; i < columns.length; i++) {
+            const col = columns[i];
+            if (col.children) {
+                const idx = col.children.findIndex((child) => child.prop === columnProp);
+                if (idx !== -1) {
+                    // 找到了包含该列的编组，验证编组名称是否匹配
+                    if (col.name === groupName) {
+                        groupIndex = i;
+                        childIndex = idx;
+                        break;
+                    }
+                }
+            }
+        }
+        if (groupIndex === -1 || childIndex === -1) {
+            console.warn(`[ColumnManagePlugin] 在编组 "${groupName}" 中找不到列 "${columnProp}"`);
+            return false;
+        }
+        const group = columns[groupIndex];
+        // 拆分编组：移除列之前的、移除的列、移除列之后的
+        const beforeColumns = group.children.slice(0, childIndex);
+        const removedColumn = group.children[childIndex];
+        const afterColumns = group.children.slice(childIndex + 1);
+        // 删除原编组
+        columns.splice(groupIndex, 1);
+        // 重建结构
+        const newItems = [];
+        if (beforeColumns.length > 0) {
+            newItems.push(this.createGroupObject(group.name, beforeColumns, group.pin));
+        }
+        newItems.push(removedColumn);
+        if (afterColumns.length > 0) {
+            newItems.push(this.createGroupObject(group.name, afterColumns, group.pin));
+        }
+        // 插入新结构
+        columns.splice(groupIndex, 0, ...newItems);
+        this.revogrid.columns = columns;
+        return true;
+    }
+    /**
+     * 创建编组对象
+     * @private
+     */
+    createGroupObject(name, children, pin) {
+        const group = { name, children };
+        if (pin)
+            group.pin = pin;
+        return group;
+    }
+    /**
+     * 获取所有编组信息
+     */
+    getGroups() {
+        const columns = this.originalColumns || this.revogrid.columns;
+        if (!columns)
+            return [];
+        return columns
+            .filter((col) => col.children)
+            .map((col) => ({
+            name: col.name,
+            columns: col.children.map((child) => child.prop),
+            pin: col.pin,
+        }));
+    }
+    /**
+     * 检查列是否在编组中
+     */
+    isColumnInGroup(columnProp) {
+        const columns = this.originalColumns || this.revogrid.columns;
+        if (!columns)
+            return false;
+        for (const col of columns) {
+            const colAny = col;
+            if (colAny.children) {
+                if (colAny.children.some((child) => child.prop === columnProp)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取列所在的编组名称
+     */
+    getColumnGroup(columns, columnProp) {
+        if (!columns)
+            return null;
+        for (const col of columns) {
+            const colAny = col;
+            if (colAny.children) {
+                if (colAny.children.some((child) => child.prop === columnProp)) {
+                    return colAny.name;
+                }
+            }
+        }
+        return null;
+    }
+    // ==================== 插入/删除列 ====================
+    // ==================== 内部方法 ====================
+    /**
+     * 从 columns 数组中查找列的位置和分组信息
+     * @param columns 列数组
+     * @param prop 列的 prop
+     * @returns 列信息对象，包含索引、分组信息和列数据
+     */
+    findColumnInColumns(columns, prop) {
+        let groupIndex = -1;
+        let childIndex = -1;
+        let group = null;
+        let columnData = null;
+        // 遍历查找列
+        for (let i = 0; i < columns.length; i++) {
+            const col = columns[i];
+            if (col.children) {
+                // 当前是分组
+                const idx = col.children.findIndex((child) => child.prop === prop);
+                if (idx !== -1) {
+                    groupIndex = i;
+                    childIndex = idx;
+                    group = col;
+                    columnData = col.children[idx];
+                    break;
+                }
+            }
+            else if (col.prop === prop) {
+                // 当前是普通列
+                groupIndex = i;
+                childIndex = -1;
+                columnData = col;
+                break;
+            }
+        }
+        return { groupIndex, childIndex, group, columnData };
+    }
+    buildSizeMap(columns) {
+        const propToWidth = new Map();
+        const headerCells = this.revogrid.querySelectorAll('.rgHeaderCell');
+        const flatCols = this.flattenColumns(columns);
+        headerCells.forEach(cell => {
+            const width = cell.getBoundingClientRect().width;
+            if (width <= 0)
+                return;
+            const colIndex = cell.getAttribute('data-rgcol');
+            if (colIndex === null)
+                return;
+            const localIdx = parseInt(colIndex, 10);
+            let viewportType = 'rgCol';
+            // 适配统一表头的新 DOM 结构
+            if (cell.closest('.header-area-colPinStart')) {
+                viewportType = 'colPinStart';
+            }
+            else if (cell.closest('.header-area-colPinEnd')) {
+                viewportType = 'colPinEnd';
+            }
+            else if (cell.closest('.header-area-rgCol')) {
+                viewportType = 'rgCol';
+            }
+            let currentIdx = 0;
+            for (const col of flatCols) {
+                const pin = col.pin;
+                const colViewport = pin === 'colPinStart' ? 'colPinStart'
+                    : pin === 'colPinEnd' ? 'colPinEnd'
+                        : 'rgCol';
+                if (colViewport === viewportType) {
+                    if (currentIdx === localIdx && col.prop) {
+                        propToWidth.set(col.prop, width);
+                        break;
+                    }
+                    currentIdx++;
+                }
+            }
+        });
+        return propToWidth;
+    }
+    normalizeColumnConfig(config) {
+        const items = Array.isArray(config) ? config : [config];
+        const currentColumns = this.revogrid.columns || [];
+        const flatColumns = this.flattenColumns(currentColumns);
+        return items
+            .map(item => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            const col = flatColumns[item];
+            return (col === null || col === void 0 ? void 0 : col.prop) || '';
+        })
+            .filter(Boolean);
+    }
+    flattenColumns(cols) {
+        const result = [];
+        for (const col of cols) {
+            const colAny = col;
+            if (colAny.children) {
+                result.push(...colAny.children);
+            }
+            else {
+                result.push(col);
+            }
+        }
+        return result;
+    }
+    /**
+     * 找到列应该插入的位置（基于传入的 columns 数组）
+     * @param columns 列数组
+     * @param newPin 新的冻结状态
+     * @param previousPin 之前的冻结状态（用于取消冻结时判断插入位置）
+     */
+    findInsertPositionForPinInColumns(columns, newPin, previousPin) {
+        if (!columns || columns.length === 0)
+            return 0;
+        if (newPin === 'colPinStart') {
+            // 左冻结：插入到所有左冻结列的末尾
+            let lastPinStartIndex = -1;
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                if (col.pin === 'colPinStart') {
+                    lastPinStartIndex = i;
+                }
+                else {
+                    break; // 遇到非左冻结列就停止
+                }
+            }
+            return lastPinStartIndex + 1;
+        }
+        else if (newPin === 'colPinEnd') {
+            // 右冻结：插入到第一个右冻结列前面
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                // 判断是否是右冻结列（检查自身或子列的 pin）
+                let isColPinEnd = col.pin === 'colPinEnd';
+                if (!isColPinEnd && col.children) {
+                    // 如果是编组，检查子列的 pin
+                    isColPinEnd = col.children.some((child) => child.pin === 'colPinEnd');
+                }
+                if (isColPinEnd) {
+                    return i;
+                }
+            }
+            // 如果没有找到右冻结列，插入到末尾
+            return columns.length;
+        }
+        else {
+            // 取消冻结：根据之前的冻结状态决定插入位置
+            if (previousPin === 'colPinEnd') {
+                // 之前是右侧冻结，放在未冻结区域的最后一个
+                // 找到第一个右冻结列的位置
+                for (let i = 0; i < columns.length; i++) {
+                    const col = columns[i];
+                    // 判断是否是右冻结列（检查自身或子列的 pin）
+                    let isColPinEnd = col.pin === 'colPinEnd';
+                    if (!isColPinEnd && col.children) {
+                        isColPinEnd = col.children.some((child) => child.pin === 'colPinEnd');
+                    }
+                    if (isColPinEnd) {
+                        return i; // 插入到第一个右冻结列之前
+                    }
+                }
+                // 如果没有右冻结列，插入到末尾
+                return columns.length;
+            }
+            else {
+                // 之前是左侧冻结或无冻结，放在未冻结区域的第一个
+                let firstNonPinIndex = 0;
+                for (let i = 0; i < columns.length; i++) {
+                    const col = columns[i];
+                    if (col.pin === 'colPinStart') {
+                        firstNonPinIndex = i + 1;
+                    }
+                    else if (!col.pin) {
+                        break;
+                    }
+                }
+                return firstNonPinIndex;
+            }
+        }
+    }
+    findColumnByProp(cols, prop) {
+        for (const col of cols) {
+            const colAny = col;
+            if (colAny.children) {
+                const found = this.findColumnByProp(colAny.children, prop);
+                if (found)
+                    return found;
+            }
+            else if (col.prop === prop) {
+                return col;
+            }
+        }
+        return null;
+    }
+    destroy() {
+        this.hiddenProps.clear();
+        this.originalColumns = null;
+        super.destroy();
+    }
+}
+//# sourceMappingURL=column-manage.plugin.js.map