vxe-pc-ui 4.11.1 → 4.11.3

package/packages/tree/src/tree.ts

@@ -1872,84 +1872,55 @@ export default defineVxeComponent({
           dragToChild: !!prevDragToChild,
           offsetIndex: dragOffsetIndex as 0 | 1
         }
-        const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild
-        return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then((status) => {
-          if (!status) {
-            return errRest
-          }
 
-          const dragNodeid = getNodeId(dragNode)
-          const dragNodeRest = nodeMaps[dragNodeid] || {}
-          const _dragNodeIndex = dragNodeRest._index
-          let dragNodeHeight = 0
-          let dragOffsetTop = -1
-          if (animation) {
-            const prevItemEl = el.querySelector<HTMLElement>(`.vxe-tree--node-wrapper[nodeid="${prevDragNode}"]`)
-            const oldItemEl = el.querySelector<HTMLElement>(`.vxe-tree--node-wrapper[nodeid="${dragNodeid}"]`)
-            const targetItemEl = prevItemEl || oldItemEl
-            if (targetItemEl) {
-              dragNodeHeight = targetItemEl.offsetHeight
-            }
-            if (oldItemEl) {
-              dragOffsetTop = oldItemEl.offsetTop
-            }
+        const dragNodeid = getNodeId(dragNode)
+        const dragNodeRest = nodeMaps[dragNodeid] || {}
+        const _dragNodeIndex = dragNodeRest._index
+        let dragNodeHeight = 0
+        let dragOffsetTop = -1
+        if (animation) {
+          const prevItemEl = el.querySelector<HTMLElement>(`.vxe-tree--node-wrapper[nodeid="${prevDragNode}"]`)
+          const oldItemEl = el.querySelector<HTMLElement>(`.vxe-tree--node-wrapper[nodeid="${dragNodeid}"]`)
+          const targetItemEl = prevItemEl || oldItemEl
+          if (targetItemEl) {
+            dragNodeHeight = targetItemEl.offsetHeight
           }
+          if (oldItemEl) {
+            dragOffsetTop = oldItemEl.offsetTop
+          }
+        }
 
-          let oafIndex = -1
-          let nafIndex = -1
-
-          if (transform) {
-            // 移出源位置
-            const oldRest = dragNodeRest
-            const newNodeid = getNodeId(prevDragNode)
-            const newRest = nodeMaps[newNodeid]
-
-            if (oldRest && newRest) {
-              const { level: oldLevel } = oldRest
-              const { level: newLevel } = newRest
-
-              const oldAllMaps: Record<string, any> = {}
-              XEUtils.eachTree([dragNode], item => {
-                oldAllMaps[getNodeId(item)] = item
-              }, { children: mapChildrenField })
-
-              let isSelfToChildStatus = false
-
-              if (oldLevel && newLevel) {
-                // 子到子
+        let oafIndex = -1
+        let nafIndex = -1
+        const oldAllMaps: Record<string, any> = {}
+        let isSelfToChildStatus = false
 
-                if (isPeerDrag && !isCrossDrag) {
-                  if (oldRest.item[parentField] !== newRest.item[parentField]) {
-                    // 非同级
-                    return errRest
-                  }
-                } else {
-                  if (!isCrossDrag) {
-                    return errRest
-                  }
-                  if (oldAllMaps[newNodeid]) {
-                    isSelfToChildStatus = true
-                    if (!(isCrossDrag && isSelfToChildDrag)) {
-                      if (VxeUI.modal) {
-                        VxeUI.modal.message({
-                          status: 'error',
-                          content: getI18n('vxe.error.treeDragChild')
-                        })
-                      }
-                      return errRest
-                    }
-                  }
-                }
-              } else if (oldLevel) {
-                // 子到根
-
-                if (!isCrossDrag) {
+        const oldRest = dragNodeRest
+        const newNodeid = getNodeId(prevDragNode)
+        const newRest = nodeMaps[newNodeid]
+        if (transform) {
+          if (oldRest && newRest) {
+            const { level: oldLevel } = oldRest
+            const { level: newLevel } = newRest
+
+            XEUtils.eachTree([dragNode], item => {
+              oldAllMaps[getNodeId(item)] = item
+            }, { children: mapChildrenField })
+
+            if (oldLevel && newLevel) {
+              // 子到子
+
+              if (isPeerDrag && !isCrossDrag) {
+                if (oldRest.item[parentField] !== newRest.item[parentField]) {
+                  // 非同级
+                  clearNodeDragData()
+                  clearCrossTreeDragStatus()
                   return errRest
                 }
-              } else if (newLevel) {
-                // 根到子
-
+              } else {
                 if (!isCrossDrag) {
+                  clearNodeDragData()
+                  clearCrossTreeDragStatus()
                   return errRest
                 }
                 if (oldAllMaps[newNodeid]) {
@@ -1961,13 +1932,57 @@ export default defineVxeComponent({
                         content: getI18n('vxe.error.treeDragChild')
                       })
                     }
+                    clearNodeDragData()
+                    clearCrossTreeDragStatus()
                     return errRest
                   }
                 }
-              } else {
-                // 根到根
               }
+            } else if (oldLevel) {
+              // 子到根
+
+              if (!isCrossDrag) {
+                clearNodeDragData()
+                clearCrossTreeDragStatus()
+                return errRest
+              }
+            } else if (newLevel) {
+              // 根到子
+
+              if (!isCrossDrag) {
+                clearNodeDragData()
+                clearCrossTreeDragStatus()
+                return errRest
+              }
+              if (oldAllMaps[newNodeid]) {
+                isSelfToChildStatus = true
+                if (!(isCrossDrag && isSelfToChildDrag)) {
+                  if (VxeUI.modal) {
+                    VxeUI.modal.message({
+                      status: 'error',
+                      content: getI18n('vxe.error.treeDragChild')
+                    })
+                  }
+                  clearNodeDragData()
+                  clearCrossTreeDragStatus()
+                  return errRest
+                }
+              }
+            } else {
+              // 根到根
+            }
+          }
+        }
 
+        const isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild
+        return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then((status) => {
+          if (!status) {
+            return errRest
+          }
+
+          if (transform) {
+            // 移出源位置
+            if (oldRest && newRest) {
               const fullList = XEUtils.toTreeArray(internalData.afterTreeList, {
                 key: keyField,
                 parentKey: parentField,

package/types/components/grid.d.ts

@@ -480,6 +480,9 @@ export namespace VxeGridDefines {
 
   export type LayoutKey = 'Form' | 'Toolbar' | 'Top' | 'Table' | 'Bottom' | 'Pager'
 
+  export interface ReadyEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.ReadyEventParams<D> { }
+  export interface InitRenderedEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.InitRenderedEventParams<D> { }
+  export interface DataRenderedEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.DataRenderedEventParams<D> { }
   export interface KeydownStartEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.KeydownStartEventParams<D> { }
   export interface KeydownEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.KeydownEventParams<D> { }
   export interface KeydownEndEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.KeydownEndEventParams<D> { }
@@ -609,6 +612,9 @@ export namespace VxeGridDefines {
 }
 
 export interface VxeGridEventProps<D = any> {
+  onReady?: VxeGridEvents.Ready<D>
+  onInitRendered?: VxeGridEvents.InitRendered<D>
+  onDataRendered?: VxeGridEvents.DataRendered<D>
   onKeydownStart?: VxeGridEvents.KeydownStart<D>
   onKeydown?: VxeGridEvents.Keydown<D>
   onKeydownEnd?: VxeGridEvents.KeydownEnd<D>
@@ -690,6 +696,9 @@ export interface VxeGridEventProps<D = any> {
 }
 
 export interface VxeGridListeners<D = any> {
+  ready?: VxeGridEvents.Ready<D>
+  initRendered?: VxeGridEvents.InitRendered<D>
+  dataRendered?: VxeGridEvents.DataRendered<D>
   keydownStart?: VxeGridEvents.KeydownStart<D>
   keydown?: VxeGridEvents.Keydown<D>
   keydownEnd?: VxeGridEvents.KeydownEnd<D>
@@ -771,6 +780,9 @@ export interface VxeGridListeners<D = any> {
 }
 
 export namespace VxeGridEvents {
+  export type Ready<D = any> = (params: VxeGridDefines.ReadyEventParams<D>) => void
+  export type InitRendered<D = any> = (params: VxeGridDefines.InitRenderedEventParams<D>) => void
+  export type DataRendered<D = any> = (params: VxeGridDefines.DataRenderedEventParams<D>) => void
   export type KeydownStart<D = any> = (params: VxeGridDefines.KeydownStartEventParams<D>) => void
   export type Keydown<D = any> = (params: VxeGridDefines.KeydownEventParams<D>) => void
   export type KeydownEnd<D = any> = (params: VxeGridDefines.KeydownEndEventParams<D>) => void

package/types/components/table.d.ts

@@ -5362,6 +5362,10 @@ export interface TablePrivateMethods<D = any> {
 export interface VxeTablePrivateMethods<D = any> extends TablePrivateMethods<D> { }
 
 export type VxeTableEmits = [
+  'ready',
+  'init-rendered',
+  'data-rendered',
+
   'update:data',
   'keydown-start',
   'keydown',
@@ -5905,6 +5909,18 @@ export namespace VxeTableDefines {
     $columnIndex: number
   }
 
+  export interface ReadyEventParams<D = any> extends TableEventParams<D> {
+  }
+  export interface InitRenderedEventParams<D = any> extends TableEventParams<D> {
+    visibleColumn: ColumnInfo<D>[]
+    visibleData: D
+  }
+  export interface DataRenderedEventParams<D = any> extends TableEventParams<D> {
+    isReload: boolean
+    visibleColumn: ColumnInfo<D>[]
+    visibleData: D
+  }
+
   export interface KeydownStartParams { }
   export interface KeydownStartEventParams<D = any> extends TableEventParams<D>, KeydownStartParams { }
 
@@ -6495,6 +6511,9 @@ export namespace VxeTableDefines {
 }
 
 export interface VxeTableEventProps<D = any> {
+  onReady?: VxeTableEvents.Ready<D>
+  onInitRendered?: VxeTableEvents.InitRendered<D>
+  onDataRendered?: VxeTableEvents.DataRendered<D>
   onKeydownStart?: VxeTableEvents.KeydownStart<D>
   onKeydown?: VxeTableEvents.Keydown<D>
   onKeydownEnd?: VxeTableEvents.KeydownEnd<D>
@@ -6564,6 +6583,9 @@ export interface VxeTableEventProps<D = any> {
 }
 
 export interface VxeTableListeners<D = any> {
+  ready?: VxeTableEvents.Ready<D>
+  initRendered?: VxeTableEvents.InitRendered<D>
+  dataRendered?: VxeTableEvents.DataRendered<D>
   /**
    * 当表格被激活且键盘被按下开始时会触发的事件
    */
@@ -6650,6 +6672,9 @@ export interface VxeTableListeners<D = any> {
 }
 
 export namespace VxeTableEvents {
+  export type Ready<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.ReadyEventParams<D>) => void
+  export type InitRendered<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.InitRenderedEventParams<D>) => void
+  export type DataRendered<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.DataRenderedEventParams<D>) => void
   export type KeydownStart<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.KeydownStartEventParams<D>) => void
   export type Keydown<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.KeydownEventParams<D>) => void
   export type KeydownEnd<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.KeydownEndEventParams<D>) => void