balala-revogrid 1.0.0

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

@@ -0,0 +1,921 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+/**
+ * ColumnStretchPlugin - 列自动撑满插件
+ * 让指定列自动撑满表格剩余空间
+ *
+ * 参考自 src/components/readable/ColumnStretchPlugin.js
+ */
+import { BasePlugin } from "./base.plugin";
+const DEFAULT_CONFIG = {
+    stretchColumn: 'last',
+    minWidth: 50,
+    showHeaderBorder: true,
+    showRowBorder: true,
+};
+/**
+ * 获取滚动条宽度
+ */
+let cachedScrollbarWidth = null;
+function getScrollbarWidth() {
+    var _a;
+    if (cachedScrollbarWidth !== null) {
+        return cachedScrollbarWidth;
+    }
+    const outer = document.createElement('div');
+    outer.style.visibility = 'hidden';
+    outer.style.overflow = 'scroll';
+    outer.style.msOverflowStyle = 'scrollbar';
+    document.body.appendChild(outer);
+    const inner = document.createElement('div');
+    outer.appendChild(inner);
+    cachedScrollbarWidth = outer.offsetWidth - inner.offsetWidth;
+    (_a = outer.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(outer);
+    return cachedScrollbarWidth;
+}
+/**
+ * 查找 DOM 元素
+ */
+function findElementBySelector(element, selector) {
+    const selectors = selector.split(' > ').map(s => s.trim());
+    let currentElement = element;
+    for (const sel of selectors) {
+        if (!currentElement)
+            return null;
+        const isClassSelector = sel.startsWith('.');
+        const selectorName = isClassSelector ? sel.slice(1) : sel;
+        currentElement = Array.from(currentElement.children).find(child => isClassSelector
+            ? child.classList.contains(selectorName)
+            : child.tagName.toLowerCase() === selectorName.toLowerCase()) || null;
+    }
+    return currentElement;
+}
+export class ColumnStretchPlugin extends BasePlugin {
+    constructor(revogrid, providers, config) {
+        super(revogrid, providers);
+        this.containerWidth = 0;
+        this.columnsData = null;
+        this.manuallyResizedColumns = new Set(); // 记录被手动调整过的列（不记录宽度）
+        this.resizeEndTimeout = null;
+        this.resizeObserver = null;
+        this.virtualGridContainer = null; // 外层容器
+        this.virtualGridOverlay = null; // 内层网格线
+        this.virtualHeaderOverlay = null; // 表头覆盖层
+        this.wheelHandler = null; // 滚轮事件处理器
+        this.isInitialRecorded = false; // 标记是否已记录初始状态
+        this.userResizedColumns = new Set(); // 记录用户主动拖拽的列索引（临时标记）
+        this.isApplyingStretch = false; // 标记是否正在应用拉伸，防止递归调用
+        this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
+        // 将插件实例保存到 revogrid 元素上，供其他插件访问
+        this.revogrid.__columnStretchPlugin = this;
+        // 设置 CSS 变量控制边框显示和颜色
+        if (this.config.showRowBorder === false) {
+            this.revogrid.style.setProperty('--revo-grid-wheel-capture-row-border', 'none');
+        }
+        else if (this.config.rowBorderColor) {
+            this.revogrid.style.setProperty('--revo-grid-wheel-capture-row-border-color', this.config.rowBorderColor);
+        }
+        if (this.config.headerBorderColor) {
+            this.revogrid.style.setProperty('--revo-grid-wheel-capture-header-border-color', this.config.headerBorderColor);
+        }
+        if (this.config.groupRowBorderColor) {
+            this.revogrid.style.setProperty('--revo-grid-group-row-border-color', this.config.groupRowBorderColor);
+        }
+        // 如果 providers 为 null，异步获取
+        if (!providers) {
+            this.revogrid.getProviders().then(p => {
+                if (p) {
+                    this.providers = p;
+                    this.init();
+                }
+            });
+        }
+        else {
+            this.init();
+        }
+    }
+    init() {
+        var _a, _b;
+        // 监听列设置前事件（在 applyNewColumns 之前）
+        const onBeforeColumnsSet = (e) => {
+            var _a;
+            const columns = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.columns;
+            if (columns) {
+                // 提前为自动宽度列设置初始宽度
+                this.setInitialStretchColumnWidth(columns);
+            }
+        };
+        this.revogrid.addEventListener('beforecolumnsset', onBeforeColumnsSet);
+        this.addEventListener('beforecolumnsset', onBeforeColumnsSet);
+        // 监听列应用前事件
+        const onBeforeColumnApplied = (e) => {
+            var _a;
+            const columns = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.columns;
+            if (columns) {
+                this.columnsData = columns;
+                // 只在第一次触发时记录初始状态
+                if (!this.isInitialRecorded) {
+                    this.recordInitialSizedColumns();
+                    this.isInitialRecorded = true;
+                }
+                this.applyStretchImpl();
+            }
+        };
+        this.revogrid.addEventListener('beforecolumnapplied', onBeforeColumnApplied);
+        this.addEventListener('beforecolumnapplied', onBeforeColumnApplied);
+        // 监听 headerresize 事件，记录用户主动拖拽的列
+        const onHeaderResize = (e) => {
+            const detail = e.detail;
+            if (!detail)
+                return;
+            // 记录用户主动拖拽的列索引
+            for (const indexStr in detail) {
+                this.userResizedColumns.add(parseInt(indexStr, 10));
+            }
+        };
+        this.revogrid.addEventListener('headerresize', onHeaderResize);
+        this.addEventListener('headerresize', onHeaderResize);
+        // 监听 aftercolumnresize 事件（包含完整的列信息，包括 pin 属性）
+        // 在这里执行拉伸计算，确保 dimension store 已经更新
+        const onAfterColumnResize = (e) => {
+            // 防止递归调用
+            if (this.isApplyingStretch) {
+                return;
+            }
+            const detail = e.detail;
+            if (!detail || !this.columnsData)
+                return;
+            // 获取被拉伸列的 prop
+            const stretchColumnProp = this.getStretchColumnProp();
+            if (!stretchColumnProp) {
+                this.userResizedColumns.clear();
+                this.applyStretchImpl();
+                return;
+            }
+            // 检查是否在调整被拉伸的列本身
+            // 注意：detail 中的 column 包含 pin 属性，可以判断列类型
+            let isResizingStretchColumn = false;
+            for (const indexStr in detail) {
+                const index = parseInt(indexStr, 10);
+                const column = detail[index];
+                if ((column === null || column === void 0 ? void 0 : column.prop) === stretchColumnProp && this.userResizedColumns.has(index)) {
+                    // 用户主动拖拽自动列宽列 → 转换为固定宽度
+                    this.manuallyResizedColumns.add(column.prop);
+                    isResizingStretchColumn = true;
+                }
+                // 否则是被动调整（其他列变化导致的） → 保持自动宽度，不标记
+            }
+            // 清空临时标记
+            this.userResizedColumns.clear();
+            // 立即同步执行拉伸计算，此时 dimension store 已经更新
+            // 如果不是调整自适应列本身，则需要重新分配宽度
+            if (!isResizingStretchColumn) {
+                this.applyStretchImpl();
+            }
+        };
+        this.revogrid.addEventListener('aftercolumnresize', onAfterColumnResize);
+        this.addEventListener('aftercolumnresize', onAfterColumnResize);
+        // 监听滚动变化事件（不触发拉伸计算，只更新滚动条宽度）
+        const onScrollChange = () => {
+            this.containerWidth = getScrollbarWidth();
+        };
+        this.revogrid.addEventListener('scrollchange', onScrollChange);
+        this.addEventListener('scrollchange', onScrollChange);
+        // 监听窗口大小变化
+        const onResize = () => {
+            this.containerWidth = getScrollbarWidth();
+            if (this.columnsData) {
+                this.applyStretchImpl();
+            }
+        };
+        this.resizeObserver = new ResizeObserver(onResize);
+        this.resizeObserver.observe(this.revogrid);
+        // 初始化
+        this.containerWidth = getScrollbarWidth();
+        // 如果已有列数据，立即应用拉伸
+        if ((_a = this.providers) === null || _a === void 0 ? void 0 : _a.column) {
+            const columnCollection = this.providers.column.collection;
+            if (((_b = this.revogrid.columns) === null || _b === void 0 ? void 0 : _b.length) && columnCollection) {
+                this.columnsData = columnCollection.columns;
+                // 延迟执行，确保 DOM 已渲染
+                setTimeout(() => {
+                    this.applyStretchImpl();
+                }, 100);
+            }
+        }
+    }
+    /**
+     * 记录初始化时已设置 size 的列
+     * 如果自动宽度列配置了 size，将其标记为手动调整过的列（固定宽度）
+     */
+    recordInitialSizedColumns() {
+        const columns = this.revogrid.columns;
+        if (!columns || columns.length === 0)
+            return;
+        const { stretchColumn } = this.config;
+        if (!stretchColumn)
+            return;
+        let stretchColumnProp = null;
+        // 根据配置类型获取 prop
+        if (stretchColumn === 'last') {
+            // 最后一列
+            const lastCol = columns[columns.length - 1];
+            stretchColumnProp = (lastCol === null || lastCol === void 0 ? void 0 : lastCol.prop) || null;
+        }
+        else if (typeof stretchColumn === 'string') {
+            // 指定 prop
+            stretchColumnProp = stretchColumn;
+        }
+        else if (typeof stretchColumn === 'number') {
+            // 指定索引
+            const col = columns[stretchColumn];
+            stretchColumnProp = (col === null || col === void 0 ? void 0 : col.prop) || null;
+        }
+        if (!stretchColumnProp)
+            return;
+        // 递归查找列（支持分组列）
+        const findColumn = (cols) => {
+            for (const col of cols) {
+                if (col.children) {
+                    // 分组列，递归查找
+                    const found = findColumn(col.children);
+                    if (found)
+                        return found;
+                }
+                else if (col.prop === stretchColumnProp) {
+                    // 找到目标列
+                    return col;
+                }
+            }
+            return null;
+        };
+        // 检查自动宽度列是否配置了 size
+        const targetColumn = findColumn(columns);
+        if (targetColumn && targetColumn.size) {
+            // 如果配置了 size，标记为手动调整过的列（固定宽度）
+            this.manuallyResizedColumns.add(stretchColumnProp);
+        }
+    }
+    /**
+     * 同步自动宽度列的 size 到 dimension store
+     * 解决拖拽后 col.size 有值但 sizes[index] 为 undefined 的问题
+     */
+    syncStretchColumnSize() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!this.columnsData)
+            return;
+        const { stretchColumn } = this.config;
+        if (!stretchColumn)
+            return;
+        // 获取自动宽度列的 prop
+        let stretchColumnProp = null;
+        if (stretchColumn === 'last') {
+            const columns = this.columnsData.rgCol;
+            if (columns && columns.length > 0) {
+                stretchColumnProp = ((_a = columns[columns.length - 1]) === null || _a === void 0 ? void 0 : _a.prop) || null;
+            }
+        }
+        else if (typeof stretchColumn === 'string') {
+            stretchColumnProp = stretchColumn;
+        }
+        else if (typeof stretchColumn === 'number') {
+            const allColumns = this.revogrid.columns;
+            if (allColumns && stretchColumn >= 0 && stretchColumn < allColumns.length) {
+                stretchColumnProp = ((_b = allColumns[stretchColumn]) === null || _b === void 0 ? void 0 : _b.prop) || null;
+            }
+        }
+        if (!stretchColumnProp)
+            return;
+        // 在所有列类型中查找
+        const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+        for (const dimensionType of dimensionTypes) {
+            const columns = this.columnsData[dimensionType];
+            if (!columns)
+                continue;
+            const columnIndex = columns.findIndex(col => col.prop === stretchColumnProp);
+            if (columnIndex === -1)
+                continue;
+            const targetColumn = columns[columnIndex];
+            if (!targetColumn || !targetColumn.size)
+                continue;
+            // 检查 dimension store 中是否已有该列的宽度
+            const dimensionStore = (_e = (_d = (_c = this.providers) === null || _c === void 0 ? void 0 : _c.dimension) === null || _d === void 0 ? void 0 : _d.stores[dimensionType]) === null || _e === void 0 ? void 0 : _e.store;
+            if (!dimensionStore)
+                continue;
+            const sizes = dimensionStore.get('sizes') || {};
+            if (sizes[columnIndex] === undefined) {
+                // 如果 dimension store 中没有该列的宽度，同步 col.size
+                (_g = (_f = this.providers) === null || _f === void 0 ? void 0 : _f.dimension) === null || _g === void 0 ? void 0 : _g.setCustomSizes(dimensionType, { [columnIndex]: targetColumn.size }, true);
+            }
+            break;
+        }
+    }
+    /**
+     * 在列应用前为自动宽度列设置初始宽度
+     */
+    setInitialStretchColumnWidth(columnsData) {
+        const { stretchColumn } = this.config;
+        if (!stretchColumn)
+            return;
+        // 查找自动宽度列
+        const result = this.findStretchColumn(columnsData, stretchColumn);
+        if (!result)
+            return;
+        const { column, dimensionType, index } = result;
+        // 如果该列已经有 size，说明是手动设置的或已经计算过，不处理
+        if (column.size)
+            return;
+        // 计算初始宽度
+        const initialWidth = this.calculateInitialStretchWidth(columnsData, dimensionType, index);
+        if (initialWidth <= 0)
+            return;
+        // 直接修改列对象的 size 属性
+        column.size = initialWidth;
+    }
+    /**
+     * 查找自动宽度列
+     */
+    findStretchColumn(columnsData, stretchColumn) {
+        var _a, _b;
+        // 获取自动宽度列的 prop
+        let stretchColumnProp = null;
+        if (stretchColumn === 'last') {
+            const columns = columnsData.rgCol;
+            if (columns && columns.length > 0) {
+                stretchColumnProp = ((_a = columns[columns.length - 1]) === null || _a === void 0 ? void 0 : _a.prop) || null;
+            }
+        }
+        else if (typeof stretchColumn === 'string') {
+            stretchColumnProp = stretchColumn;
+        }
+        else if (typeof stretchColumn === 'number') {
+            const allColumns = this.revogrid.columns;
+            if (allColumns && stretchColumn >= 0 && stretchColumn < allColumns.length) {
+                stretchColumnProp = ((_b = allColumns[stretchColumn]) === null || _b === void 0 ? void 0 : _b.prop) || null;
+            }
+        }
+        if (!stretchColumnProp)
+            return null;
+        // 在所有列类型中查找
+        const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+        for (const dimensionType of dimensionTypes) {
+            const columns = columnsData[dimensionType];
+            if (!columns)
+                continue;
+            const index = columns.findIndex(col => col.prop === stretchColumnProp);
+            if (index !== -1) {
+                return {
+                    column: columns[index],
+                    dimensionType,
+                    index,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * 计算自动宽度列的初始宽度
+     */
+    calculateInitialStretchWidth(columnsData, stretchColumnType, stretchColumnIndex) {
+        // 计算可用宽度
+        const rowHeaderEl = findElementBySelector(this.revogrid, '.main-viewport > .viewports > .rowHeaders');
+        const rowHeaderWidth = (rowHeaderEl === null || rowHeaderEl === void 0 ? void 0 : rowHeaderEl.clientWidth) || 0;
+        const viewportEl = this.revogrid.querySelector('.main-viewport');
+        const hasVerticalScroll = viewportEl ? viewportEl.scrollHeight > viewportEl.clientHeight : false;
+        const scrollbarWidth = hasVerticalScroll ? this.containerWidth : 0;
+        const availableWidth = this.revogrid.clientWidth - scrollbarWidth - rowHeaderWidth;
+        // 计算其他列的总宽度（排除自动宽度列）
+        let totalOtherColumnsWidth = 0;
+        const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+        dimensionTypes.forEach(dimensionType => {
+            const columns = columnsData[dimensionType];
+            if (!columns)
+                return;
+            columns.forEach((col, index) => {
+                // 跳过自动宽度列
+                if (dimensionType === stretchColumnType && index === stretchColumnIndex) {
+                    return;
+                }
+                // 计算其他列的宽度
+                const colWidth = col.size || col.minSize || 100;
+                totalOtherColumnsWidth += colWidth;
+            });
+        });
+        // 计算剩余宽度
+        const remainingWidth = availableWidth - totalOtherColumnsWidth;
+        const stretchColumn = columnsData[stretchColumnType][stretchColumnIndex];
+        const minWidth = this.getColumnMinWidth(stretchColumn);
+        return Math.max(minWidth, remainingWidth);
+    }
+    /**
+     * 获取列的最小宽度
+     */
+    getColumnMinWidth(column) {
+        return column.minSize || column.size || this.config.minWidth || 50;
+    }
+    /**
+     * 获取被拉伸列的 prop
+     */
+    getStretchColumnProp() {
+        var _a, _b;
+        if (!this.columnsData)
+            return null;
+        const { stretchColumn } = this.config;
+        if (stretchColumn === 'last') {
+            const columns = this.columnsData.rgCol;
+            if (columns && columns.length > 0) {
+                return ((_a = columns[columns.length - 1]) === null || _a === void 0 ? void 0 : _a.prop) || null;
+            }
+        }
+        else if (typeof stretchColumn === 'string') {
+            return stretchColumn;
+        }
+        else if (typeof stretchColumn === 'number') {
+            const columns = this.revogrid.columns;
+            if (columns && stretchColumn >= 0 && stretchColumn < columns.length) {
+                return ((_b = columns[stretchColumn]) === null || _b === void 0 ? void 0 : _b.prop) || null;
+            }
+        }
+        return null;
+    }
+    /**
+     * 应用列拉伸（实际实现）
+     */
+    applyStretchImpl() {
+        if (!this.columnsData)
+            return;
+        // 防止递归调用
+        if (this.isApplyingStretch) {
+            return;
+        }
+        this.isApplyingStretch = true;
+        // 先同步自动宽度列的 size 到 dimension store
+        this.syncStretchColumnSize();
+        // 获取行头宽度
+        const rowHeaderEl = findElementBySelector(this.revogrid, '.main-viewport > .viewports > .rowHeaders');
+        const rowHeaderWidth = (rowHeaderEl === null || rowHeaderEl === void 0 ? void 0 : rowHeaderEl.clientWidth) || 0;
+        // 计算可用宽度
+        const availableWidth = this.revogrid.clientWidth - rowHeaderWidth;
+        // 计算所有列的总宽度
+        let totalColumnsWidth = 0;
+        const dimensionTypes = ['colPinStart', 'rgCol', 'colPinEnd'];
+        dimensionTypes.forEach(dimensionType => {
+            var _a, _b;
+            if ((_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.stores[dimensionType]) {
+                const dimensionStore = this.providers.dimension.stores[dimensionType].store;
+                const realSize = dimensionStore.get('realSize') || 0;
+                totalColumnsWidth += realSize;
+            }
+        });
+        // 计算剩余空间
+        const occupiedWidth = availableWidth - totalColumnsWidth;
+        // 只有当有足够空间需要分配时才进行自动调整
+        if (Math.abs(occupiedWidth) < 1) {
+            this.isApplyingStretch = false;
+            return;
+        }
+        const { stretchColumn } = this.config;
+        if (stretchColumn === 'all') {
+            this.stretchAllColumns(occupiedWidth);
+        }
+        else if (stretchColumn === 'last') {
+            this.stretchLastColumn(occupiedWidth);
+        }
+        else if (typeof stretchColumn === 'number') {
+            this.stretchColumnByIndex(stretchColumn, occupiedWidth);
+        }
+        else if (typeof stretchColumn === 'string') {
+            this.stretchColumnByProp(stretchColumn, occupiedWidth);
+        }
+        this.isApplyingStretch = false;
+    }
+    /**
+     * 创建模拟网格覆盖层
+     */
+    createvirtualGridOverlay() {
+        if (this.virtualGridContainer)
+            return;
+        // 查找 viewports 容器
+        const viewportsContainer = this.revogrid.querySelector('.viewports');
+        if (!viewportsContainer)
+            return;
+        // 查找 rgCol 视口
+        const rgColViewport = this.revogrid.querySelector('revogr-viewport-scroll.rgCol');
+        if (!rgColViewport)
+            return;
+        // 查找滚动元素
+        const verticalInner = rgColViewport.querySelector('.vertical-inner');
+        if (!verticalInner)
+            return;
+        // 获取表头高度
+        const headerWrapper = rgColViewport.querySelector('.header-wrapper');
+        const headerHeight = (headerWrapper === null || headerWrapper === void 0 ? void 0 : headerWrapper.offsetHeight) || 0;
+        // 创建外层容器（覆盖整个表格区域）
+        this.virtualGridContainer = document.createElement('div');
+        this.virtualGridContainer.className = 'virtual-grid-container';
+        this.virtualGridContainer.style.cssText = `
+      position: absolute;
+      top: ${headerHeight}px;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      pointer-events: none;
+      z-index: 10;
+      display: none;
+      overflow: hidden;
+    `;
+        // 创建内层网格线（覆盖整个宽度，但线通过 background-position 定位到右侧）
+        this.virtualGridOverlay = document.createElement('div');
+        this.virtualGridOverlay.className = 'virtual-grid-overlay';
+        this.virtualGridOverlay.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      will-change: transform;
+      pointer-events: none;
+    `;
+        this.virtualGridContainer.appendChild(this.virtualGridOverlay);
+        viewportsContainer.appendChild(this.virtualGridContainer);
+        // 创建表头覆盖层（白色背景 + 底边线）
+        this.virtualHeaderOverlay = document.createElement('div');
+        this.virtualHeaderOverlay.className = 'virtual-header-overlay';
+        this.virtualHeaderOverlay.style.cssText = `
+      position: absolute;
+      top: 0;
+      right: 0;
+      height: ${headerHeight}px;
+      pointer-events: none;
+      z-index: 11;
+      display: none;
+      box-sizing: border-box;
+    `;
+        viewportsContainer.appendChild(this.virtualHeaderOverlay);
+        // 监听滚动事件，同步内层位置
+        const onScroll = () => {
+            if (this.virtualGridOverlay) {
+                const scrollTop = verticalInner.scrollTop;
+                this.virtualGridOverlay.style.transform = `translateY(-${scrollTop}px)`;
+            }
+        };
+        verticalInner.addEventListener('scroll', onScroll, { passive: true });
+        // 只监听滚轮事件，其他事件穿透到表格
+        this.wheelHandler = (e) => {
+            // 如果按下 shift 键，不拦截事件，让它传递给水平滚动处理器
+            if (e.shiftKey)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            verticalInner.scrollTop += e.deltaY;
+        };
+        this.virtualGridContainer.addEventListener('wheel', this.wheelHandler, { passive: false });
+        // 其他事件穿透到下层
+        const passThrough = (e) => {
+            // 获取鼠标位置下的元素（排除当前覆盖层）
+            this.virtualGridContainer.style.pointerEvents = 'none';
+            const target = document.elementFromPoint(e.clientX, e.clientY);
+            this.virtualGridContainer.style.pointerEvents = 'auto';
+            if (target && target !== this.virtualGridContainer) {
+                // 创建并派发相同的事件到目标元素
+                const newEvent = new e.constructor(e.type, e);
+                target.dispatchEvent(newEvent);
+            }
+        };
+        // 穿透点击、双击、右键等事件
+        ['click', 'dblclick', 'mousedown', 'mouseup', 'contextmenu'].forEach(eventType => {
+            this.virtualGridContainer.addEventListener(eventType, passThrough);
+        });
+    }
+    /**
+     * 更新模拟网格覆盖层
+     */
+    // @ts-ignore 暂时禁用，保留代码
+    updatevirtualGridOverlay(gapWidth) {
+        var _a, _b, _c, _d;
+        if (gapWidth <= 0) {
+            // 隐藏覆盖层
+            if (this.virtualGridContainer) {
+                this.virtualGridContainer.style.display = 'none';
+            }
+            if (this.virtualHeaderOverlay) {
+                this.virtualHeaderOverlay.style.display = 'none';
+            }
+            return;
+        }
+        // 确保覆盖层存在
+        this.createvirtualGridOverlay();
+        if (!this.virtualGridContainer || !this.virtualGridOverlay)
+            return;
+        // 获取行高
+        const rowHeight = this.getRowHeight();
+        // 获取内容高度
+        const contentHeight = ((_d = (_c = (_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.stores) === null || _c === void 0 ? void 0 : _c.rgRow) === null || _d === void 0 ? void 0 : _d.store.get('realSize')) || 0;
+        // 获取表头高度
+        const rgColViewport = this.revogrid.querySelector('revogr-viewport-scroll.rgCol');
+        const headerWrapper = rgColViewport === null || rgColViewport === void 0 ? void 0 : rgColViewport.querySelector('.header-wrapper');
+        const headerHeight = (headerWrapper === null || headerWrapper === void 0 ? void 0 : headerWrapper.offsetHeight) || 0;
+        // 更新外层容器样式（覆盖整个表格区域）
+        this.virtualGridContainer.style.display = 'block';
+        this.virtualGridContainer.style.top = `${headerHeight}px`;
+        this.virtualGridContainer.style.left = '0';
+        this.virtualGridContainer.style.right = '0';
+        // 更新内层网格线样式（宽度为整个容器，但线通过 background-position 定位到右侧）
+        this.virtualGridOverlay.style.width = '100%';
+        this.virtualGridOverlay.style.height = `${contentHeight}px`;
+        this.virtualGridOverlay.style.backgroundImage = `linear-gradient(to bottom, transparent ${rowHeight - 1}px, #e0e0e0 ${rowHeight - 1}px, #e0e0e0 ${rowHeight}px)`;
+        this.virtualGridOverlay.style.backgroundSize = `${gapWidth}px ${rowHeight}px`;
+        this.virtualGridOverlay.style.backgroundRepeat = 'repeat-y';
+        this.virtualGridOverlay.style.backgroundPosition = 'right top';
+        // 同步当前滚动位置
+        const verticalInner = rgColViewport === null || rgColViewport === void 0 ? void 0 : rgColViewport.querySelector('.vertical-inner');
+        if (verticalInner) {
+            const scrollTop = verticalInner.scrollTop;
+            this.virtualGridOverlay.style.transform = `translateY(-${scrollTop}px)`;
+        }
+        // 更新表头覆盖层样式
+        if (this.virtualHeaderOverlay) {
+            this.virtualHeaderOverlay.style.display = 'block';
+            this.virtualHeaderOverlay.style.width = `${gapWidth}px`;
+            this.virtualHeaderOverlay.style.height = `${headerHeight}px`;
+        }
+    }
+    /**
+     * 获取行高
+     */
+    getRowHeight() {
+        // 优先从实际DOM获取行高
+        const existingRow = this.revogrid.querySelector('.rgRow');
+        if (existingRow) {
+            const height = existingRow.clientHeight;
+            return height || 32;
+        }
+        return 32; // 默认行高
+    }
+    /**
+     * 移除模拟网格覆盖层
+     */
+    removevirtualGridOverlay() {
+        // 移除滚轮事件监听
+        if (this.wheelHandler && this.virtualGridContainer) {
+            this.virtualGridContainer.removeEventListener('wheel', this.wheelHandler);
+            this.wheelHandler = null;
+        }
+        if (this.virtualGridContainer) {
+            this.virtualGridContainer.remove();
+            this.virtualGridContainer = null;
+            this.virtualGridOverlay = null;
+        }
+        if (this.virtualHeaderOverlay) {
+            this.virtualHeaderOverlay.remove();
+            this.virtualHeaderOverlay = null;
+        }
+    }
+    /**
+     * 拉伸最后一列
+     * @returns 剩余未分配的宽度
+     */
+    stretchLastColumn(extraWidth) {
+        if (!this.columnsData)
+            return extraWidth;
+        const columnType = 'rgCol';
+        const columns = this.columnsData[columnType];
+        if (!columns || columns.length === 0)
+            return extraWidth;
+        const columnIndex = columns.length - 1;
+        const targetColumn = columns[columnIndex];
+        if (!targetColumn || !this.isValidColumn(targetColumn))
+            return extraWidth;
+        if (targetColumn.autoSize)
+            return extraWidth;
+        // 如果拉伸列被手动调整过，不再自动拉伸
+        if (targetColumn.prop && this.manuallyResizedColumns.has(targetColumn.prop)) {
+            return extraWidth;
+        }
+        return this.applyColumnStretch(columnType, columnIndex, targetColumn, extraWidth);
+    }
+    /**
+     * 按索引拉伸列
+     * @returns 剩余未分配的宽度
+     */
+    stretchColumnByIndex(index, extraWidth) {
+        var _a;
+        const columns = this.revogrid.columns;
+        if (!columns || index < 0 || index >= columns.length)
+            return extraWidth;
+        const column = columns[index];
+        if (!column || !this.isValidColumn(column))
+            return extraWidth;
+        const columnType = column.pin || 'rgCol';
+        const colsOfType = (_a = this.columnsData) === null || _a === void 0 ? void 0 : _a[columnType];
+        if (!colsOfType)
+            return extraWidth;
+        const columnIndex = colsOfType.findIndex(col => col.prop === column.prop);
+        if (columnIndex === -1)
+            return extraWidth;
+        const targetColumn = colsOfType[columnIndex];
+        if (targetColumn.autoSize)
+            return extraWidth;
+        if (targetColumn.prop && this.manuallyResizedColumns.has(targetColumn.prop))
+            return extraWidth;
+        return this.applyColumnStretch(columnType, columnIndex, targetColumn, extraWidth);
+    }
+    /**
+     * 按 prop 拉伸列
+     * @returns 剩余未分配的宽度
+     */
+    stretchColumnByProp(prop, extraWidth) {
+        if (!this.columnsData)
+            return extraWidth;
+        // 如果拉伸列被手动调整过，不再自动拉伸
+        if (this.manuallyResizedColumns.has(prop)) {
+            return extraWidth;
+        }
+        // 在所有列类型中查找
+        const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+        for (const columnType of dimensionTypes) {
+            const columns = this.columnsData[columnType];
+            if (!columns)
+                continue;
+            const columnIndex = columns.findIndex(col => col.prop === prop);
+            if (columnIndex === -1)
+                continue;
+            const targetColumn = columns[columnIndex];
+            if (!targetColumn || !this.isValidColumn(targetColumn))
+                continue;
+            if (targetColumn.autoSize)
+                continue;
+            return this.applyColumnStretch(columnType, columnIndex, targetColumn, extraWidth);
+        }
+        return extraWidth;
+    }
+    /**
+     * 应用列拉伸
+     * @returns 剩余未分配的宽度（当列达到最小宽度限制时）
+     */
+    applyColumnStretch(columnType, columnIndex, column, extraWidth) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        // 获取当前列宽
+        const currentColumnWidth = ((_d = (_c = (_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.stores[columnType]) === null || _c === void 0 ? void 0 : _c.store.get('sizes')) === null || _d === void 0 ? void 0 : _d[columnIndex]) ||
+            column.size ||
+            100;
+        // 获取列的最小宽度
+        const minColumnWidth = this.getColumnMinWidth(column);
+        // 计算新的列宽
+        const targetWidth = currentColumnWidth + extraWidth;
+        const newColumnWidth = Math.max(minColumnWidth, targetWidth);
+        // 计算剩余宽度（如果达到最小宽度限制，剩余的空间需要分配给其他列）
+        const actualChange = newColumnWidth - currentColumnWidth;
+        const remainingWidth = extraWidth - actualChange;
+        // 只有当宽度发生变化时才应用更改
+        if (Math.abs(newColumnWidth - currentColumnWidth) > 1) {
+            // 1. 更新 dimension store
+            (_f = (_e = this.providers) === null || _e === void 0 ? void 0 : _e.dimension) === null || _f === void 0 ? void 0 : _f.setCustomSizes(columnType, { [columnIndex]: newColumnWidth }, true);
+            // 2. 更新列数据的 size 属性
+            const columnData = (_h = (_g = this.columnsData) === null || _g === void 0 ? void 0 : _g[columnType]) === null || _h === void 0 ? void 0 : _h[columnIndex];
+            if (columnData && this.columnsData) {
+                columnData.size = newColumnWidth;
+                // 3. 检查当前调整的列是否是自适应列
+                const stretchColumnProp = this.getStretchColumnProp();
+                const isStretchColumn = column.prop === stretchColumnProp;
+                // 如果当前调整的是自适应列本身，需要检查它是否在 rgCol 区域
+                // 如果在 rgCol 区域，说明可能是被冻结列调整触发的，需要强制刷新
+                if (isStretchColumn && columnType === 'rgCol') {
+                    // 使用微任务延迟执行，确保 dimension store 更新完成
+                    Promise.resolve().then(() => {
+                        const headerUnified = this.revogrid.querySelector('revogr-header-unified');
+                        if (headerUnified && typeof headerUnified.forceRefresh === 'function') {
+                            headerUnified.forceRefresh();
+                        }
+                    });
+                }
+            }
+        }
+        return Math.max(0, remainingWidth);
+    }
+    /**
+     * 拉伸所有列
+     */
+    stretchAllColumns(extraWidth) {
+        if (!this.columnsData)
+            return;
+        const sizeMap = new Map();
+        let columnCount = 0;
+        // 遍历所有列类型
+        const dimensionTypes = ['rgCol', 'colPinStart', 'colPinEnd'];
+        for (const columnType of dimensionTypes) {
+            const columns = this.columnsData[columnType];
+            if (!columns)
+                continue;
+            const columnIndices = [];
+            columns.forEach((column, index) => {
+                // 跳过已设置自动大小、固定大小或已被手动调整过的列
+                if (column.autoSize || column.size)
+                    return;
+                if (column.prop && this.manuallyResizedColumns.has(column.prop))
+                    return;
+                columnCount++;
+                columnIndices.push(index);
+            });
+            if (columnIndices.length > 0) {
+                sizeMap.set(columnType, columnIndices);
+            }
+        }
+        // 如果没有可拉伸的列，直接返回
+        if (!columnCount)
+            return;
+        // 计算平均宽度变化量
+        const avgChange = extraWidth / columnCount;
+        // 应用新宽度到所有可拉伸列
+        sizeMap.forEach((indices, columnType) => {
+            var _a, _b;
+            const newSizes = {};
+            const columns = this.columnsData[columnType];
+            indices.forEach(index => {
+                var _a, _b, _c, _d;
+                const column = columns[index];
+                const currentWidth = ((_d = (_c = (_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.stores[columnType]) === null || _c === void 0 ? void 0 : _c.store.get('sizes')) === null || _d === void 0 ? void 0 : _d[index]) ||
+                    column.size ||
+                    100;
+                const minColumnWidth = this.getColumnMinWidth(column);
+                const newWidth = Math.max(minColumnWidth, currentWidth + avgChange);
+                if (Math.abs(newWidth - currentWidth) > 1) {
+                    newSizes[index] = newWidth;
+                }
+            });
+            if (Object.keys(newSizes).length > 0) {
+                (_b = (_a = this.providers) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.setCustomSizes(columnType, newSizes, true);
+            }
+        });
+    }
+    /**
+     * 检查列是否有效
+     */
+    isValidColumn(column) {
+        return !!column.prop || !column.children;
+    }
+    /**
+     * 公开的 applyStretch 方法
+     */
+    applyStretch() {
+        this.applyStretchImpl();
+    }
+    /**
+     * 立即同步执行拉伸计算（不使用防抖）
+     * 用于需要立即响应的场景，如拖拽结束
+     */
+    applyStretchImmediate() {
+        this.applyStretchImpl();
+    }
+    /**
+     * 重置手动调整记录
+     */
+    resetManualResize() {
+        this.manuallyResizedColumns.clear();
+        this.applyStretchImpl();
+    }
+    /**
+     * 检查列是否被手动调整过宽度
+     */
+    isManuallyResized(prop) {
+        return this.manuallyResizedColumns.has(prop);
+    }
+    /**
+     * 标记列为手动调整过
+     */
+    markAsManuallyResized(prop) {
+        this.manuallyResizedColumns.add(prop);
+    }
+    /**
+     * 取消列的手动调整标记
+     */
+    unmarkAsManuallyResized(prop) {
+        this.manuallyResizedColumns.delete(prop);
+    }
+    /**
+     * 获取拉伸列配置
+     */
+    getStretchColumnConfig() {
+        return this.config.stretchColumn;
+    }
+    /**
+     * 更新配置
+     */
+    updateConfig(config) {
+        this.config = Object.assign(Object.assign({}, this.config), config);
+        this.applyStretchImpl();
+    }
+    destroy() {
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+            this.resizeObserver = null;
+        }
+        if (this.resizeEndTimeout) {
+            clearTimeout(this.resizeEndTimeout);
+        }
+        // 移除覆盖层
+        this.removevirtualGridOverlay();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=column-stretch.plugin.js.map