balala-revogrid 1.0.0

package/dist/collection/plugins/customColumnDrag/drag.handler.js

@@ -0,0 +1,726 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+const DRAG_THRESHOLD = 5;
+export class DragHandler {
+    constructor(revogrid, canDrag, onDragUpdate, cannotDropBefore) {
+        this.revogrid = revogrid;
+        this.canDrag = canDrag;
+        this.onDragUpdate = onDragUpdate;
+        this.cannotDropBefore = cannotDropBefore;
+        this.isDragging = false;
+        this.isPreparing = false;
+        this.startX = 0;
+        this.startY = 0;
+        // 源信息
+        this.sourceCell = null;
+        this.sourceRowIndex = -1;
+        this.sourceColumnIndex = -1;
+        this.sourceColumn = null;
+        this.sourceIsChild = false;
+        // 拖拽元素
+        this.dragGhost = null;
+        this.dropIndicator = null;
+        // 目标信息
+        this.currentDropTarget = null;
+        this.dropPosition = 'left';
+        this.targetType = 'normal';
+        // 缓存列数量（避免每次 mousemove 都重新计算）
+        this.cachedColumnCounts = null;
+        // 拖拽偏移量（鼠标相对于源单元格左上角的偏移）
+        this.dragOffsetX = 0;
+        this.dragOffsetY = 0;
+        this.initTimeout = null;
+        this.isDestroyed = false;
+        // 延迟启动拖拽期间，记录最新鼠标位置（避免使用旧坐标导致 ghost 偏移）
+        this.pendingDragClientX = 0;
+        this.pendingDragClientY = 0;
+        // 双击检测
+        this.lastClickTime = 0;
+        this.lastClickTarget = null;
+        this.onPrepareMove = (e) => {
+            if (!this.isPreparing || !this.sourceCell)
+                return;
+            const deltaX = Math.abs(e.clientX - this.startX);
+            const deltaY = Math.abs(e.clientY - this.startY);
+            if (deltaX > DRAG_THRESHOLD || deltaY > DRAG_THRESHOLD) {
+                this.startDrag(e.clientX, e.clientY);
+            }
+        };
+        this.onPrepareUp = () => {
+            this.cancelPrepare();
+        };
+        this.onContextMenu = (e) => {
+            // 右键点击时取消准备状态
+            e.preventDefault();
+            this.cancelPrepare();
+        };
+        this.onMouseMove = (e) => {
+            if (!this.isDragging)
+                return;
+            // 更新浮动副本位置（保持鼠标相对于ghost的位置不变）
+            if (this.dragGhost) {
+                this.dragGhost.style.left = `${e.clientX - this.dragOffsetX}px`;
+                this.dragGhost.style.top = `${e.clientY - this.dragOffsetY}px`;
+            }
+            // 查找目标列
+            const target = this.getTargetFromPoint(e.clientX, e.clientY);
+            if (target && target !== this.sourceCell) {
+                this.currentDropTarget = target;
+                // 解析目标信息
+                const targetInfo = this.parseHeaderCell(target);
+                if (targetInfo) {
+                    // 判断目标类型
+                    if (targetInfo.isChild) {
+                        this.targetType = 'child';
+                        this.targetGroupName = targetInfo.groupName;
+                    }
+                    else if (this.isGroupHeader(target)) {
+                        this.targetType = 'group';
+                        this.targetGroupName = targetInfo.groupName;
+                    }
+                    else {
+                        this.targetType = 'normal';
+                        this.targetGroupName = undefined;
+                    }
+                }
+                // 计算定位线位置
+                const targetRect = target.getBoundingClientRect();
+                const midX = targetRect.left + targetRect.width / 2;
+                let dropPosition = e.clientX < midX ? 'left' : 'right';
+                // 检查是否试图拖到不可放置列之前
+                if (targetInfo && dropPosition === 'left' && this.cannotDropBefore) {
+                    if (this.cannotDropBefore(targetInfo.column)) {
+                        // 不允许拖到该列左侧，隐藏指示线
+                        this.hideDropIndicator();
+                        this.currentDropTarget = null;
+                        return;
+                    }
+                }
+                this.dropPosition = dropPosition;
+                // 更新定位线 - 高度只在目标单元格范围内
+                this.updateDropIndicator(target, this.dropPosition);
+            }
+            else {
+                this.hideDropIndicator();
+                this.currentDropTarget = null;
+            }
+        };
+        this.onMouseUp = (e) => {
+            if (!this.isDragging)
+                return;
+            // 只响应左键释放
+            if (e.button === 0 && this.currentDropTarget && this.sourceColumn) {
+                const targetInfo = this.parseHeaderCell(this.currentDropTarget);
+                if (targetInfo) {
+                    const details = {
+                        sourceRowIndex: this.sourceRowIndex,
+                        sourceColumnIndex: this.sourceColumnIndex,
+                        sourceColumn: this.sourceColumn,
+                        sourceIsChild: this.sourceIsChild,
+                        sourceGroupName: this.sourceGroupName,
+                        targetRowIndex: targetInfo.rowIndex,
+                        targetColumnIndex: targetInfo.columnIndex,
+                        targetColumn: targetInfo.column,
+                        targetType: this.targetType,
+                        targetGroupName: this.targetGroupName,
+                        targetChildIndex: this.targetChildIndex,
+                        dropPosition: this.dropPosition,
+                    };
+                    this.onDragUpdate(details);
+                }
+            }
+            this.endDrag();
+        };
+        this.onContextMenuDrag = (e) => {
+            // 拖拽过程中右键点击，取消拖拽
+            if (this.isDragging) {
+                e.preventDefault();
+                this.endDrag();
+            }
+        };
+        this.boundMouseDown = this.onMouseDown.bind(this);
+        this.init();
+    }
+    init() {
+        this.initTimeout = window.setTimeout(() => {
+            if (!this.isDestroyed) {
+                this.revogrid.addEventListener('mousedown', this.boundMouseDown, true);
+            }
+            this.initTimeout = null;
+        }, 500);
+    }
+    onMouseDown(e) {
+        // 只响应左键点击
+        if (e.button !== 0) {
+            return;
+        }
+        const target = e.target;
+        // 检查是否点击在可交互元素上（按钮、链接、输入框等）
+        if (this.isInteractiveElement(target)) {
+            return;
+        }
+        const headerCell = target.closest('.rgHeaderCell');
+        if (!headerCell)
+            return;
+        // 双击检测：如果在300ms内点击同一个单元格两次，认为是双击，不触发拖拽
+        const now = Date.now();
+        const timeSinceLastClick = now - this.lastClickTime;
+        const isSameTarget = this.lastClickTarget === headerCell;
+        if (isSameTarget && timeSinceLastClick < 300) {
+            // 清除之前的定时器
+            if (this.dragDelayTimer) {
+                clearTimeout(this.dragDelayTimer);
+                this.dragDelayTimer = undefined;
+            }
+            this.stopPendingDragTracking();
+            // 重置状态
+            this.lastClickTime = 0;
+            this.lastClickTarget = null;
+            this.sourceCell = null;
+            this.sourceColumn = null;
+            return;
+        }
+        // 记录本次点击
+        this.lastClickTime = now;
+        this.lastClickTarget = headerCell;
+        // 检查是否是编组头（编组头不允许拖拽）
+        if (this.isGroupHeader(headerCell)) {
+            return;
+        }
+        // 检查是否点击在 resize 区域（右边缘 8px 范围内）
+        if (this.isInResizeZone(e, headerCell)) {
+            return;
+        }
+        // 解析源列信息
+        const sourceInfo = this.parseHeaderCell(headerCell);
+        if (!sourceInfo)
+            return;
+        const { column, rowIndex, columnIndex, isChild, groupName } = sourceInfo;
+        if (!this.canDrag(column, rowIndex, columnIndex)) {
+            return;
+        }
+        // 保存拖拽信息
+        this.startX = e.clientX;
+        this.startY = e.clientY;
+        this.sourceCell = headerCell;
+        this.sourceRowIndex = rowIndex;
+        this.sourceColumnIndex = columnIndex;
+        this.sourceColumn = column;
+        this.sourceIsChild = isChild;
+        this.sourceGroupName = groupName;
+        // 阻止默认行为，防止触发文本选中
+        e.preventDefault();
+        // 延迟100ms开始拖拽，避免双击时触发
+        this.startPendingDragTracking(e);
+        this.dragDelayTimer = window.setTimeout(() => {
+            this.dragDelayTimer = undefined;
+            const clientX = this.pendingDragClientX;
+            const clientY = this.pendingDragClientY;
+            this.stopPendingDragTracking();
+            this.startDrag(clientX, clientY);
+        }, 100);
+        // 监听 mouseup，如果在延迟期间释放鼠标，取消拖拽
+        const cancelDrag = () => {
+            if (this.dragDelayTimer) {
+                clearTimeout(this.dragDelayTimer);
+                this.dragDelayTimer = undefined;
+                this.stopPendingDragTracking();
+                // 清理拖拽状态
+                this.sourceCell = null;
+                this.sourceColumn = null;
+            }
+            document.removeEventListener('mouseup', cancelDrag);
+        };
+        document.addEventListener('mouseup', cancelDrag);
+    }
+    /**
+     * 检查是否点击在可交互元素上
+     */
+    isInteractiveElement(target) {
+        // 检查元素本身
+        const tagName = target.tagName.toLowerCase();
+        if (['button', 'a', 'input', 'select', 'textarea'].includes(tagName)) {
+            return true;
+        }
+        // 检查是否有特定的类名（如 header-more-icon）
+        if (target.classList.contains('header-more-icon')) {
+            return true;
+        }
+        // 检查是否有 onclick 事件
+        if (target.onclick || target.getAttribute('onclick')) {
+            return true;
+        }
+        // 检查父元素是否是可交互元素
+        const parent = target.parentElement;
+        if (parent && parent !== target.closest('.rgHeaderCell')) {
+            const parentTagName = parent.tagName.toLowerCase();
+            if (['button', 'a'].includes(parentTagName)) {
+                return true;
+            }
+            if (parent.classList.contains('header-more-icon')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 检查是否点击在 resize 区域（单元格右边缘）
+     */
+    isInResizeZone(e, cell) {
+        const rect = cell.getBoundingClientRect();
+        const resizeZoneWidth = 8; // resize 触发区域宽度
+        // 检查是否在右边缘
+        const isNearRightEdge = e.clientX >= rect.right - resizeZoneWidth;
+        // 也检查是否点击了 resize 相关的元素
+        const target = e.target;
+        const isResizeElement = target.classList.contains('resize') ||
+            target.classList.contains('resizable') ||
+            target.closest('.resize') !== null ||
+            target.closest('.header-resize') !== null;
+        return isNearRightEdge || isResizeElement;
+    }
+    /**
+     * 获取 viewport 类型
+     */
+    getViewportType(cell) {
+        const headerArea = cell.closest('.header-area-colPinStart, .header-area-rgCol, .header-area-colPinEnd');
+        if (headerArea) {
+            if (headerArea.classList.contains('header-area-colPinStart')) {
+                return 'colPinStart';
+            }
+            if (headerArea.classList.contains('header-area-colPinEnd')) {
+                return 'colPinEnd';
+            }
+            return 'rgCol';
+        }
+        // 默认返回中间区域
+        return 'rgCol';
+    }
+    /**
+     * 获取列数量缓存（拖拽开始时计算一次，拖拽结束时清除）
+     */
+    getColumnCounts() {
+        if (this.cachedColumnCounts) {
+            return this.cachedColumnCounts;
+        }
+        const columns = this.revogrid.columns;
+        if (!columns) {
+            return { pinStart: 0, normal: 0, pinEnd: 0 };
+        }
+        let pinStart = 0;
+        let normal = 0;
+        let pinEnd = 0;
+        for (const col of columns) {
+            if (col.children) {
+                for (const child of col.children) {
+                    if (child.pin === 'colPinStart')
+                        pinStart++;
+                    else if (child.pin === 'colPinEnd')
+                        pinEnd++;
+                    else
+                        normal++;
+                }
+            }
+            else {
+                if (col.pin === 'colPinStart')
+                    pinStart++;
+                else if (col.pin === 'colPinEnd')
+                    pinEnd++;
+                else
+                    normal++;
+            }
+        }
+        this.cachedColumnCounts = { pinStart, normal, pinEnd };
+        return this.cachedColumnCounts;
+    }
+    /**
+     * 计算全局扁平索引
+     * 需要根据 viewport 类型计算偏移量
+     */
+    calculateGlobalIndex(localIndex, viewportType) {
+        const counts = this.getColumnCounts();
+        if (viewportType === 'colPinStart') {
+            return localIndex;
+        }
+        else if (viewportType === 'rgCol') {
+            return counts.pinStart + localIndex;
+        }
+        else {
+            return counts.pinStart + counts.normal + localIndex;
+        }
+    }
+    /**
+     * 解析表头单元格信息
+     */
+    parseHeaderCell(cell) {
+        var _a, _b;
+        const colIndexAttr = cell.getAttribute('data-rgcol');
+        const localIndex = colIndexAttr ? parseInt(colIndexAttr, 10) : -1;
+        // 获取 viewport 类型并计算全局索引
+        const viewportType = this.getViewportType(cell);
+        const columnIndex = this.calculateGlobalIndex(localIndex, viewportType);
+        // 判断是否是分组行（第一行）还是子列行（第二行）
+        const isGroupRow = cell.closest('.group-rgRow') !== null;
+        const rowIndex = isGroupRow ? 0 : 1;
+        // 判断是否是子列（在第二行且有父分组）
+        const hasParent = this.hasParentGroup(cell);
+        const isChild = !isGroupRow && hasParent;
+        // 获取分组名
+        let groupName;
+        if (isChild) {
+            groupName = this.getParentGroupName(cell);
+        }
+        else if (this.isGroupHeader(cell)) {
+            groupName = ((_a = cell.querySelector('.header-content')) === null || _a === void 0 ? void 0 : _a.textContent) || undefined;
+        }
+        // 尝试从 revogrid 获取真实的列配置
+        const column = this.getColumnByFlatIndex(columnIndex) || {
+            prop: colIndexAttr || String(columnIndex),
+            name: ((_b = cell.querySelector('.header-content')) === null || _b === void 0 ? void 0 : _b.textContent) || '',
+        };
+        return { column, rowIndex, columnIndex, isChild, groupName };
+    }
+    /**
+     * 根据扁平索引获取真实的列配置
+     */
+    getColumnByFlatIndex(flatIndex) {
+        const columns = this.revogrid.columns;
+        if (!columns)
+            return null;
+        let currentIndex = 0;
+        for (const col of columns) {
+            if (col.children) {
+                for (const child of col.children) {
+                    if (currentIndex === flatIndex) {
+                        return child;
+                    }
+                    currentIndex++;
+                }
+            }
+            else {
+                if (currentIndex === flatIndex) {
+                    return col;
+                }
+                currentIndex++;
+            }
+        }
+        return null;
+    }
+    /**
+     * 判断单元格是否有父分组（是否是分组的子列）
+     * 从 DOM 结构看：
+     * - group-rgRow: 包含分组头和普通列（第一行）
+     * - header-rgRow actual-rgRow: 包含子列（第二行）
+     */
+    hasParentGroup(cell) {
+        // 检查是否在第二行（actual-rgRow）且不在 group-rgRow 中
+        const isInActualRow = cell.closest('.actual-rgRow') !== null;
+        const isInGroupRow = cell.closest('.group-rgRow') !== null;
+        return isInActualRow && !isInGroupRow;
+    }
+    /**
+     * 判断单元格是否是分组头
+     * 从 DOM 结构看：
+     * - 分组头在 group-rgRow 中，但没有 merged-header 类
+     * - 普通列在 group-rgRow 中，有 merged-header 类
+     * - 或者检查是否在 header-rgRow.group 中
+     * - 特殊情况：当没有分组时（groupingDepth === 0），所有列都在 group-rgRow 中且没有 merged-header 类，但它们不是分组头
+     */
+    isGroupHeader(cell) {
+        // 必须在 group-rgRow 中
+        if (!cell.closest('.group-rgRow')) {
+            return false;
+        }
+        // 检查是否有 grouping-depth 属性（表示有分组）
+        const groupingDepth = cell.getAttribute('data-grouping-depth');
+        const hasGrouping = groupingDepth && parseInt(groupingDepth, 10) > 0;
+        // 如果没有分组，则不是分组头
+        if (!hasGrouping) {
+            return false;
+        }
+        // 没有 merged-header 类就是分组头
+        if (!cell.classList.contains('merged-header')) {
+            return true;
+        }
+        // 或者 colspan > 1
+        const colspan = cell.getAttribute('colspan') || cell.getAttribute('aria-colspan');
+        return colspan ? parseInt(colspan, 10) > 1 : false;
+    }
+    /**
+     * 获取父分组名称
+     * 从 DOM 结构看，子列在 actual-rgRow 中，分组头在 group-rgRow 中
+     * 需要根据子列的位置找到对应的分组头
+     */
+    getParentGroupName(cell) {
+        var _a, _b;
+        // 获取子列的位置信息
+        const cellRect = cell.getBoundingClientRect();
+        const cellCenterX = cellRect.left + cellRect.width / 2;
+        // 从当前单元格向上查找 header-wrapper，然后找 group-rgRow
+        const headerWrapper = cell.closest('.header-wrapper');
+        if (!headerWrapper)
+            return undefined;
+        const groupRow = headerWrapper.querySelector('.group-rgRow');
+        if (!groupRow)
+            return undefined;
+        // 查找 group-rgRow 中不是 merged-header 的单元格（即分组头）
+        // 或者查找 header-rgRow.group 中的单元格
+        const headerGroupRow = headerWrapper.querySelector('.header-rgRow.group');
+        if (headerGroupRow) {
+            const groupHeaders = Array.from(headerGroupRow.querySelectorAll('.rgHeaderCell'));
+            for (const header of groupHeaders) {
+                const headerRect = header.getBoundingClientRect();
+                // 检查子列是否在这个分组头的水平范围内
+                if (cellCenterX >= headerRect.left && cellCenterX <= headerRect.right) {
+                    return ((_a = header.querySelector('.header-content')) === null || _a === void 0 ? void 0 : _a.textContent) || undefined;
+                }
+            }
+        }
+        // 备用方案：在 group-rgRow 中查找覆盖当前位置的单元格
+        const allHeaders = Array.from(groupRow.querySelectorAll('.rgHeaderCell'));
+        for (const header of allHeaders) {
+            const headerRect = header.getBoundingClientRect();
+            // 检查子列是否在这个表头的水平范围内
+            if (cellCenterX >= headerRect.left && cellCenterX <= headerRect.right) {
+                // 检查这个表头是否是分组头（不是 merged-header 或者宽度较大）
+                const headerText = (_b = header.querySelector('.header-content')) === null || _b === void 0 ? void 0 : _b.textContent;
+                if (headerText) {
+                    return headerText;
+                }
+            }
+        }
+        return undefined;
+    }
+    startPendingDragTracking(e) {
+        this.pendingDragClientX = e.clientX;
+        this.pendingDragClientY = e.clientY;
+        this.stopPendingDragTracking();
+        this.pendingDragMoveListener = (moveEvent) => {
+            this.pendingDragClientX = moveEvent.clientX;
+            this.pendingDragClientY = moveEvent.clientY;
+        };
+        document.addEventListener('mousemove', this.pendingDragMoveListener, true);
+    }
+    stopPendingDragTracking() {
+        if (!this.pendingDragMoveListener)
+            return;
+        document.removeEventListener('mousemove', this.pendingDragMoveListener, true);
+        this.pendingDragMoveListener = undefined;
+    }
+    cancelPrepare() {
+        this.isPreparing = false;
+        this.sourceCell = null;
+        document.removeEventListener('mousemove', this.onPrepareMove);
+        document.removeEventListener('mouseup', this.onPrepareUp);
+        document.removeEventListener('contextmenu', this.onContextMenu);
+    }
+    startDrag(clientX, clientY) {
+        if (!this.sourceCell || !this.sourceColumn)
+            return;
+        this.stopPendingDragTracking();
+        // 在加拖拽 class 前先取位置，保证按下瞬间视觉位置不跳
+        const sourceRect = this.sourceCell.getBoundingClientRect();
+        this.isDragging = true;
+        this.revogrid.classList.add('custom-column-drag-active');
+        // 添加类名禁用单元格动画
+        this.revogrid.classList.add('column-drag-start');
+        // 清理 resize 插件的 hover 句柄线，避免与列拖拽定位线叠加
+        this.revogrid.querySelectorAll('.resize-handle-hover').forEach(el => {
+            el.classList.remove('resize-handle-hover');
+        });
+        // 禁止拖拽时选中文本
+        document.body.style.userSelect = 'none';
+        // 计算鼠标相对于源单元格的偏移量
+        this.dragOffsetX = clientX - sourceRect.left;
+        this.dragOffsetY = clientY - sourceRect.top;
+        this.createDragGhost(sourceRect);
+        this.createDropIndicator();
+        document.addEventListener('mousemove', this.onMouseMove);
+        document.addEventListener('mouseup', this.onMouseUp);
+        document.addEventListener('contextmenu', this.onContextMenuDrag);
+    }
+    createDragGhost(sourceRect) {
+        if (!this.sourceCell)
+            return;
+        const sourceCellStyle = window.getComputedStyle(this.sourceCell);
+        const sourceContentEl = this.sourceCell.querySelector('.header-content');
+        const sourceContentStyle = sourceContentEl ? window.getComputedStyle(sourceContentEl) : null;
+        const content = (sourceContentEl === null || sourceContentEl === void 0 ? void 0 : sourceContentEl.textContent) || '';
+        const sourceTextAlign = (sourceContentStyle === null || sourceContentStyle === void 0 ? void 0 : sourceContentStyle.textAlign) || sourceCellStyle.textAlign;
+        const textAlign = sourceTextAlign === 'start' ? 'left' : sourceTextAlign === 'end' ? 'right' : sourceTextAlign;
+        const justifyContent = textAlign === 'center' ? 'center' : textAlign === 'right' ? 'flex-end' : 'flex-start';
+        const lineHeight = (sourceContentStyle === null || sourceContentStyle === void 0 ? void 0 : sourceContentStyle.lineHeight) && sourceContentStyle.lineHeight !== 'normal'
+            ? sourceContentStyle.lineHeight
+            : 'normal';
+        const letterSpacing = (sourceContentStyle === null || sourceContentStyle === void 0 ? void 0 : sourceContentStyle.letterSpacing) || sourceCellStyle.letterSpacing;
+        const fontFamily = (sourceContentStyle === null || sourceContentStyle === void 0 ? void 0 : sourceContentStyle.fontFamily) || sourceCellStyle.fontFamily;
+        const fontWeight = (sourceContentStyle === null || sourceContentStyle === void 0 ? void 0 : sourceContentStyle.fontWeight) || sourceCellStyle.fontWeight;
+        const getPaddingValues = (style) => [
+            style.paddingTop,
+            style.paddingRight,
+            style.paddingBottom,
+            style.paddingLeft,
+        ];
+        const hasNonZeroPadding = (values) => values.some(v => parseFloat(v) > 0);
+        const contentWrapperEl = (sourceContentEl === null || sourceContentEl === void 0 ? void 0 : sourceContentEl.querySelector('.header-content-wrapper')) || null;
+        const contentWrapperPaddingValues = contentWrapperEl
+            ? getPaddingValues(window.getComputedStyle(contentWrapperEl))
+            : null;
+        const contentPaddingValues = sourceContentStyle ? getPaddingValues(sourceContentStyle) : null;
+        const cellPaddingValues = getPaddingValues(sourceCellStyle);
+        const paddingValues = contentWrapperPaddingValues && hasNonZeroPadding(contentWrapperPaddingValues)
+            ? contentWrapperPaddingValues
+            : contentPaddingValues && hasNonZeroPadding(contentPaddingValues)
+                ? contentPaddingValues
+                : hasNonZeroPadding(cellPaddingValues)
+                    ? cellPaddingValues
+                    : ['0px', '9px', '0px', '9px'];
+        const padding = `${paddingValues[0]} ${paddingValues[1]} ${paddingValues[2]} ${paddingValues[3]}`;
+        this.dragGhost = document.createElement('div');
+        this.dragGhost.className = 'rv-grid-heading-drag-ghost';
+        this.dragGhost.style.cssText = `
+      position: fixed;
+      left: ${sourceRect.left + 1}px;
+      top: ${sourceRect.top}px;
+      width: ${sourceRect.width}px;
+      height: ${sourceRect.height}px;
+      margin: 0;
+      transform: none;
+      display: flex;
+      align-items: center;
+      justify-content: ${justifyContent};
+      line-height: ${lineHeight};
+      padding: ${padding};
+      pointer-events: none;
+      z-index: 1000;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      box-sizing: border-box;
+      font-size: 13px;
+      font-family: ${fontFamily};
+      font-weight: ${fontWeight};
+      letter-spacing: ${letterSpacing};
+      text-align: ${textAlign};
+      text-transform: ${sourceCellStyle.textTransform};
+      direction: ${sourceCellStyle.direction};
+    `;
+        const ghostText = document.createElement('span');
+        ghostText.textContent = content;
+        ghostText.style.cssText = `
+      display: block;
+      max-width: 100%;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    `;
+        this.dragGhost.appendChild(ghostText);
+        document.body.appendChild(this.dragGhost);
+    }
+    createDropIndicator() {
+        this.dropIndicator = document.createElement('div');
+        this.dropIndicator.className = 'custom-drop-indicator';
+        this.dropIndicator.style.cssText = `
+      position: fixed;
+      width: 2px;
+      background-color: #0f87ff;
+      pointer-events: none;
+      z-index: 999;
+      display: none;
+    `;
+        document.body.appendChild(this.dropIndicator);
+    }
+    updateDropIndicator(target, position) {
+        if (!this.dropIndicator)
+            return;
+        const targetRect = target.getBoundingClientRect();
+        // 定位线位置和高度只在目标单元格范围内
+        const indicatorX = position === 'left' ? targetRect.left : targetRect.right;
+        // 吸附到整像素，避免冻结边界出现半像素渲染导致 2px 线看起来像 1px。
+        const indicatorLeft = Math.round(indicatorX - 1);
+        this.dropIndicator.style.left = `${indicatorLeft}px`;
+        this.dropIndicator.style.top = `${targetRect.top}px`;
+        this.dropIndicator.style.height = `${targetRect.height}px`;
+        this.dropIndicator.style.display = 'block';
+    }
+    hideDropIndicator() {
+        if (this.dropIndicator) {
+            this.dropIndicator.style.display = 'none';
+        }
+    }
+    endDrag() {
+        this.isDragging = false;
+        // 恢复文本选中
+        document.body.style.userSelect = '';
+        this.revogrid.classList.remove('custom-column-drag-active');
+        // 注意：不在这里移除 column-drag-start 类
+        // 该类会在 applyColumnMove 完成后移除
+        // 如果没有触发 applyColumnMove（位置未改变），则在这里延迟移除
+        if (!this.currentDropTarget || this.sourceColumnIndex === -1) {
+            setTimeout(() => {
+                this.revogrid.classList.remove('column-drag-start');
+            }, 50);
+        }
+        if (this.dragGhost) {
+            this.dragGhost.remove();
+            this.dragGhost = null;
+        }
+        if (this.dropIndicator) {
+            this.dropIndicator.remove();
+            this.dropIndicator = null;
+        }
+        document.removeEventListener('mousemove', this.onMouseMove);
+        document.removeEventListener('mouseup', this.onMouseUp);
+        document.removeEventListener('contextmenu', this.onContextMenuDrag);
+        // 重置状态
+        this.sourceCell = null;
+        this.currentDropTarget = null;
+        this.sourceRowIndex = -1;
+        this.sourceColumnIndex = -1;
+        this.sourceColumn = null;
+        this.sourceIsChild = false;
+        this.sourceGroupName = undefined;
+        this.targetType = 'normal';
+        this.targetGroupName = undefined;
+        this.targetChildIndex = undefined;
+        // 清除列数量缓存（列配置可能已变化）
+        this.cachedColumnCounts = null;
+        // 重置拖拽偏移量
+        this.dragOffsetX = 0;
+        this.dragOffsetY = 0;
+    }
+    getTargetFromPoint(x, y) {
+        var _a, _b;
+        const dragGhostVisibility = (_a = this.dragGhost) === null || _a === void 0 ? void 0 : _a.style.visibility;
+        const dropIndicatorVisibility = (_b = this.dropIndicator) === null || _b === void 0 ? void 0 : _b.style.visibility;
+        if (this.dragGhost)
+            this.dragGhost.style.visibility = 'hidden';
+        if (this.dropIndicator)
+            this.dropIndicator.style.visibility = 'hidden';
+        const element = document.elementFromPoint(x, y);
+        const target = element === null || element === void 0 ? void 0 : element.closest('.rgHeaderCell');
+        if (this.dragGhost)
+            this.dragGhost.style.visibility = dragGhostVisibility || '';
+        if (this.dropIndicator)
+            this.dropIndicator.style.visibility = dropIndicatorVisibility || '';
+        return target;
+    }
+    destroy() {
+        this.isDestroyed = true;
+        // 清理初始化定时器
+        if (this.initTimeout !== null) {
+            clearTimeout(this.initTimeout);
+            this.initTimeout = null;
+        }
+        // 清理拖拽延迟定时器
+        if (this.dragDelayTimer) {
+            clearTimeout(this.dragDelayTimer);
+            this.dragDelayTimer = undefined;
+        }
+        this.stopPendingDragTracking();
+        this.endDrag();
+        this.revogrid.removeEventListener('mousedown', this.boundMouseDown, true);
+    }
+}
+//# sourceMappingURL=drag.handler.js.map