vxe-pc-ui 4.9.1 → 4.9.3

package/styles/components/split.scss

@@ -118,6 +118,7 @@
 }
 
 .vxe-split-pane-handle {
+  display: flex;
   position: relative;
   flex-shrink: 0;
   user-select: none;
@@ -143,18 +144,22 @@
     background-color: var(--vxe-ui-split-handle-bar-hover-background-color);
   }
 }
-.vxe-split-pane-action-btn {
+
+.vxe-split-pane-action-btn-wrapper {
   position: absolute;
+  display: flex;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 2;
+}
+.vxe-split-pane-action-btn {
   display: flex;
   flex-direction: row;
   align-items: center;
   justify-content: center;
   font-size: 0.5em;
   border-radius: var(--vxe-ui-base-border-radius);
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-  z-index: 2;
   color: var(--vxe-ui-layout-background-color);
   background-color: var(--vxe-ui-split-handle-button-background-color);
   border: 1px solid var(--vxe-ui-input-border-color);
@@ -165,7 +170,86 @@
     background-color: var(--vxe-ui-font-primary-color);
   }
   &:active {
-    transform: translate(-50%, -50%) scale(0.9);
+    transform: scale(0.9);
+  }
+}
+.vxe-split-pane-handle {
+  &.is--horizontal {
+    flex-direction: row;
+    &.is--border {
+      border-width: 1px 0 1px 0;
+    }
+    .vxe-split-pane-action-btn-wrapper {
+      flex-direction: column;
+      & div {
+        margin-top: 1em;
+        &:first-child {
+          margin-top: 0;
+        }
+      }
+    }
+    .vxe-split-pane-handle-bar {
+      width: var(--vxe-ui-split-handle-bar-horizontal-width);
+      height: 100%;
+    }
+    .vxe-split-pane-action-btn {
+      width: var(--vxe-ui-split-handle-bar-horizontal-width);
+      height: var(--vxe-ui-split-handle-bar-horizontal-height);
+    }
+  }
+  &.is--vertical {
+    flex-direction: column;
+    &.is--border {
+      border-width: 0 1px 0 1px;
+    }
+    .vxe-split-pane-action-btn-wrapper {
+      flex-direction: row;
+      & div {
+        margin-left: 1em;
+        &:first-child {
+          margin-left: 0;
+        }
+      }
+    }
+    .vxe-split-pane-handle-bar {
+      height: var(--vxe-ui-split-handle-bar-vertical-height);
+      width: 100%;
+    }
+    .vxe-split-pane-action-btn {
+      width: var(--vxe-ui-split-handle-bar-vertical-width);
+      height: var(--vxe-ui-split-handle-bar-vertical-height);
+    }
+  }
+  &.is--resize {
+    &.is-resize--immediate {
+      &.is--horizontal {
+        .vxe-split-pane-handle-bar {
+          cursor: w-resize;
+        }
+      }
+      &.is--vertical {
+        .vxe-split-pane-handle-bar {
+          cursor: n-resize;
+        }
+      }
+      & > .vxe-split-pane-handle-bar {
+        &:active {
+          background-color: var(--vxe-ui-font-primary-color);
+        }
+      }
+    }
+    &.is-resize--lazy {
+      &.is--horizontal {
+        .vxe-split-pane-handle-bar {
+          cursor: col-resize;
+        }
+      }
+      &.is--vertical {
+        .vxe-split-pane-handle-bar {
+          cursor: row-resize;
+        }
+      }
+    }
   }
 }
 
@@ -173,17 +257,23 @@
   display: flex;
   position: relative;
   overflow: hidden;
+  &.is--fill {
+    flex-grow: 1;
+  }
   &.is--hidden {
-    width: 0;
+    &.is--horizontal {
+      width: 0;
+    }
+    &.is--vertical {
+      height: 0;
+    }
   }
   &.is--padding {
     & > .vxe-split-pane--wrapper {
       padding: var(--vxe-ui-layout-padding-default);
     }
   }
-  &.is--fill {
-    flex-grow: 1;
-  }
+  &.is--hidden,
   &.is--width, 
   &.is--height {
     flex-shrink: 0;
@@ -193,84 +283,15 @@
       border: 1px solid var(--vxe-ui-base-popup-border-color);
     }
   }
-  &.is--resize {
-    &.is--expand {
-      &.is-resize--immediate {
-        &.is--horizontal {
-          & > .vxe-split-pane-handle {
-            .vxe-split-pane-handle-bar {
-              cursor: w-resize;
-            }
-          }
-        }
-        &.is--vertical {
-          & > .vxe-split-pane-handle {
-            .vxe-split-pane-handle-bar {
-              cursor: n-resize;
-            }
-          }
-        }
-        & > .vxe-split-pane-handle {
-          & > .vxe-split-pane-handle-bar {
-            &:active {
-              background-color: var(--vxe-ui-font-primary-color);
-            }
-          }
-        }
-      }
-      &.is-resize--lazy {
-        &.is--horizontal {
-          & > .vxe-split-pane-handle {
-            .vxe-split-pane-handle-bar {
-              cursor: col-resize;
-            }
-          }
-        }
-        &.is--vertical {
-          & > .vxe-split-pane-handle {
-            .vxe-split-pane-handle-bar {
-              cursor: row-resize;
-            }
-          }
-        }
-      }
-    }
-  }
-  &.is--horizontal {
-    flex-direction: row;
-    & > .vxe-split-pane-handle {
-      .vxe-split-pane-handle-bar {
-        width: var(--vxe-ui-split-handle-bar-horizontal-width);
-        height: 100%;
-      }
-      .vxe-split-pane-action-btn {
-        width: var(--vxe-ui-split-handle-bar-horizontal-width);
-        height: var(--vxe-ui-split-handle-bar-horizontal-height);
-      }
-    }
-    &.is--border {
-      & > .vxe-split-pane-handle {
-        border-width: 1px 0 1px 0;
-      }
-    }
-  }
-  &.is--vertical {
-    flex-direction: column;
-    & > .vxe-split-pane-handle {
-      .vxe-split-pane-handle-bar {
-        height: var(--vxe-ui-split-handle-bar-vertical-height);
-        width: 100%;
-      }
-      .vxe-split-pane-action-btn {
-        width: var(--vxe-ui-split-handle-bar-vertical-width);
-        height: var(--vxe-ui-split-handle-bar-vertical-height);
-      }
-    }
-    &.is--border {
-      & > .vxe-split-pane-handle {
-        border-width: 0 1px 0 1px;
-      }
-    }
+}
+
+.vxe-split--render-vars {
+  width: 0;
+  height: 0;
+  overflow: hidden;
+  .vxe-split--handle-bar-info {
+    width: var(--vxe-ui-split-handle-bar-horizontal-width);
+    height: var(--vxe-ui-split-handle-bar-vertical-height);
   }
 }
 

package/types/components/grid.d.ts

@@ -529,6 +529,8 @@ export namespace VxeGridDefines {
   export interface RowDragstartEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.RowDragstartEventParams<D> { }
   export interface RowDragoverEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.RowDragoverEventParams<D> { }
   export interface RowDragendEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.RowDragendEventParams<D> { }
+  export interface RowRemoveDragendEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.RowRemoveDragendEventParams<D> { }
+  export interface RowInsertDragendEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.RowInsertDragendEventParams<D> { }
   export interface ColumnDragstartEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.ColumnDragstartEventParams<D> { }
   export interface ColumnDragoverEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.ColumnDragoverEventParams<D> { }
   export interface ColumnDragendEventParams<D = any> extends GridEventParams<D>, VxeTableDefines.ColumnDragendEventParams<D> { }
@@ -620,6 +622,8 @@ export interface VxeGridEventProps<D = any> {
   onRowDragstart?: VxeGridEvents.RowDragstart<D>
   onRowDragover?: VxeGridEvents.RowDragover<D>
   onRowDragend?: VxeGridEvents.RowDragend<D>
+  onRowRemoveDragend?: VxeGridEvents.RowRemoveDragend<D>
+  onRowInsertDragend?: VxeGridEvents.RowInsertDragend<D>
   onColumnDragstart?: VxeGridEvents.ColumnDragstart<D>
   onColumnDragover?: VxeGridEvents.ColumnDragover<D>
   onColumnDragend?: VxeGridEvents.ColumnDragend<D>
@@ -696,6 +700,8 @@ export interface VxeGridListeners<D = any> {
   rowDragstart?: VxeGridEvents.RowDragstart<D>
   rowDragover?: VxeGridEvents.RowDragover<D>
   rowDragend?: VxeGridEvents.RowDragend<D>
+  rowRemoveDragend?: VxeGridEvents.RowRemoveDragend<D>
+  rowInsertDragend?: VxeGridEvents.RowInsertDragend<D>
   columnDragstart?: VxeGridEvents.ColumnDragstart<D>
   columnDragover?: VxeGridEvents.ColumnDragover<D>
   columnDragend?: VxeGridEvents.ColumnDragend<D>
@@ -772,6 +778,8 @@ export namespace VxeGridEvents {
   export type RowDragstart<D = any> = (params: VxeGridDefines.RowDragstartEventParams<D>) => void
   export type RowDragover<D = any> = (params: VxeGridDefines.RowDragoverEventParams<D>) => void
   export type RowDragend<D = any> = (params: VxeGridDefines.RowDragendEventParams<D>) => void
+  export type RowRemoveDragend<D = any> = (params: VxeGridDefines.RowRemoveDragendEventParams<D>) => void
+  export type RowInsertDragend<D = any> = (params: VxeGridDefines.RowInsertDragendEventParams<D>) => void
   export type ColumnDragstart<D = any> = (params: VxeGridDefines.ColumnDragstartEventParams<D>) => void
   export type ColumnDragover<D = any> = (params: VxeGridDefines.ColumnDragoverEventParams<D>) => void
   export type ColumnDragend<D = any> = (params: VxeGridDefines.ColumnDragendEventParams<D>) => void

package/types/components/split-pane.d.ts

@@ -28,6 +28,11 @@ export namespace VxeSplitPanePropTypes {
   export type Height = string | number
   export type MinWidth = string | number
   export type MinHeight = string | number
+
+  /**
+   * 已废弃
+   * @deprecated
+   */
   export type ShowAction = boolean
 }
 
@@ -37,11 +42,15 @@ export interface VxeSplitPaneProps {
   height?: VxeSplitPanePropTypes.Height
   minWidth?: VxeSplitPanePropTypes.MinWidth
   minHeight?: VxeSplitPanePropTypes.MinHeight
-  showAction?: VxeSplitPanePropTypes.ShowAction
-
   slots?: {
     default?: string | ((params: VxeSplitPaneSlotTypes.DefaultSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
   }
+
+  /**
+   * 已废弃
+   * @deprecated
+   */
+  showAction?: VxeSplitPanePropTypes.ShowAction
 }
 
 export interface SplitItemPrivateComputed {

package/types/components/split.d.ts

@@ -59,10 +59,13 @@ export namespace VxeSplitPropTypes {
      */
     trigger?: 'click' | 'dblclick' | '' | null
     /**
-     * 折叠方向
-     * 支持向前和向后折叠
+     * 显示往向前折叠按钮
      */
-    direction?: 'prev' | 'next' | '' | null
+    showPrevButton?: boolean
+    /**
+     * 显示往向后折叠按钮
+     */
+    showNextButton?: boolean
     /**
      * 自定义展开图标
      */
@@ -71,6 +74,13 @@ export namespace VxeSplitPropTypes {
      * 自定义关闭图标
      */
     closeIcon?: string
+
+    /**
+     * 折叠方向
+     * 支持向前和向后折叠
+     * @deprecated
+     */
+    direction?: 'prev' | 'next' | '' | null
   }
 }
 
@@ -125,13 +135,14 @@ export interface SplitPrivateComputed {
   computeItemOpts: ComputedRef<VxeSplitPropTypes.ItemConfig>
   computeBarOpts: ComputedRef<VxeSplitPropTypes.BarConfig>
   computeActionOpts: ComputedRef<VxeSplitPropTypes.ActionConfig>
-  computeIsFoldNext: ComputedRef<boolean>
 }
 export interface VxeSplitPrivateComputed extends SplitPrivateComputed { }
 
 export interface SplitReactData {
   staticItems: VxeSplitDefines.PaneConfig[]
   itemList: VxeSplitDefines.PaneConfig[]
+  barWidth: number
+  barHeight: number
 }
 
 export interface SplitInternalData {
@@ -179,7 +190,6 @@ export namespace VxeSplitDefines {
 
   export interface PaneConfig extends VxeSplitPaneProps {
     id: string
-    isVisible: boolean
     isExpand: boolean
     renderWidth: number
     foldWidth: number
@@ -190,34 +200,29 @@ export namespace VxeSplitDefines {
   }
 
   export interface ActionClickEventParams extends SplitEventParams {
-    item: PaneConfig
-    name: VxeSplitPanePropTypes.Name
+    prevItem: PaneConfig
+    nextItem: PaneConfig
   }
   export interface ActionDblclickEventParams extends ActionClickEventParams {}
   export interface ToggleExpandEventParams extends SplitEventParams {
-    item: PaneConfig
-    name: VxeSplitPanePropTypes.Name
-    targetItem: PaneConfig
-    targetName: VxeSplitPanePropTypes.Name
+    prevItem: PaneConfig
+    nextItem: PaneConfig
     expanded: boolean
+    item: PaneConfig
   }
   export interface ResizeStartEventParams extends SplitEventParams {
-    item: PaneConfig
-    name: VxeSplitPanePropTypes.Name
+    prevItem: PaneConfig
+    nextItem: PaneConfig
   }
   export interface ResizeDragEventParams extends SplitEventParams {
-    item: PaneConfig
-    name: VxeSplitPanePropTypes.Name
-    offsetHeight: number
-    resizeHeight: number
-    offsetWidth: number
-    resizeWidth: number
+    prevItem: PaneConfig
+    nextItem: PaneConfig
   }
   export interface ResizeEndEventParams extends SplitEventParams {
     item: PaneConfig
     name: VxeSplitPanePropTypes.Name
-    resizeHeight: number
-    resizeWidth: number
+    offsetHeight: number
+    offsetWidth: number
   }
 }
 
@@ -259,7 +264,6 @@ export interface VxeSplitSlots {
    */
   [key: string]: ((params: {
     name: VxeSplitPanePropTypes.Name
-    isVisible: boolean
     isExpand: boolean
   }) => any) | undefined
 

package/types/components/table-module/edit.d.ts

@@ -90,12 +90,32 @@ export interface TableEditMethods<D = any> {
    */
   getActiveRecord(): {
     row: D
+    column: VxeTableDefines.ColumnInfo<D>
+    /**
+     * 请使用 getRowIndex(row)
+     * @deprecated
+     */
     rowIndex: number
+    /**
+     * 请使用 getVMRowIndex(row)
+     * @deprecated
+     */
     $rowIndex: number
-    column: VxeTableDefines.ColumnInfo<D>
+    /**
+     * 请使用 getColumnIndex(column)
+     * @deprecated
+     */
     columnIndex: number
+    /**
+     * 请使用 getVMColumnIndex(column)
+     * @deprecated
+     */
     $columnIndex: number
-    // cell: HTMLElement
+    /**
+     * 已废弃
+     * @deprecated
+     */
+    cell: HTMLElement
   }
   /**
    * 已废弃，请使用 getEditCell
@@ -103,12 +123,32 @@ export interface TableEditMethods<D = any> {
    */
   getEditRecord(): {
     row: D
+    column: VxeTableDefines.ColumnInfo<D>
+    /**
+     * 请使用 getRowIndex(row)
+     * @deprecated
+     */
     rowIndex: number
+    /**
+     * 请使用 getVMRowIndex(row)
+     * @deprecated
+     */
     $rowIndex: number
-    column: VxeTableDefines.ColumnInfo<D>
+    /**
+     * 请使用 getColumnIndex(column)
+     * @deprecated
+     */
     columnIndex: number
+    /**
+     * 请使用 getVMColumnIndex(column)
+     * @deprecated
+     */
     $columnIndex: number
-    // cell: HTMLElement
+    /**
+     * 已废弃
+     * @deprecated
+     */
+    cell: HTMLElement
   }
   /**
    * 用于 edit-config，获取已激活编辑的单元格信息

package/types/components/table.d.ts

@@ -745,6 +745,10 @@ export namespace VxeTablePropTypes {
      * 需要 isCrossDrag，只对 tree-config 启用有效，是否允许将自己拖拽到子级行中
      */
     isSelfToChildDrag?: boolean
+    /**
+     * 是否允许在不同表格之间进行拖拽
+     */
+    isCrossTableDrag?: boolean
     /**
      * 是否显示拖拽辅助状态显示
      */
@@ -2570,9 +2574,9 @@ export namespace VxeTablePropTypes {
        */
       position?: 'top' | 'bottom' | ''
       /**
-       * 是否显示
+       * 滚动条显示方式
        */
-      visible?: boolean
+      visible?: 'auto' | 'visible' | 'hidden' | boolean
     }
     /**
      * 纵向滚动条
@@ -2583,9 +2587,9 @@ export namespace VxeTablePropTypes {
        */
       position?: 'left' | 'right' | ''
       /**
-       * 是否显示
+       * 滚动条显示方式
        */
-      visible?: boolean
+      visible?: 'auto' | 'visible' | 'hidden' | boolean
     }
   }
 
@@ -3731,9 +3735,9 @@ export interface TableReactData<D = any> {
 
   isCustomStatus: boolean
 
-  isDragRowMove: Boolean
+  isCrossDragRow: Boolean
   dragRow: any
-  isDragColMove: boolean
+  isCrossDragCol: boolean
   dragCol: VxeTableDefines.ColumnInfo | null
   dragTipText: string
 
@@ -5054,6 +5058,22 @@ export interface TablePrivateMethods<D = any> {
    * @private
    */
   handleRowDragDragoverEvent(evnt: DragEvent): void
+  /**
+   * @private
+   */
+  handleCrossTableRowDragInsertEvent(evnt: DragEvent): void
+  /**
+   * @private
+   */
+  handleCrossTableRowDragFinishEvent(evnt: DragEvent): void
+  /**
+   * @private
+   */
+  handleCrossTableRowDragoverEmptyEvent(evnt: DragEvent): void
+  /**
+   * @private
+   */
+  hideCrossTableRowDropClearStatus(): void
   /**
    * @private
    */
@@ -5201,6 +5221,8 @@ export type VxeTableEmits = [
   'row-dragstart',
   'row-dragover',
   'row-dragend',
+  'row-remove-dragend',
+  'row-insert-dragend',
   'column-dragstart',
   'column-dragover',
   'column-dragend',
@@ -5927,6 +5949,19 @@ export namespace VxeTableDefines {
     }
   }
 
+  export interface RowRemoveDragendEventParams<D = any> {
+    row: D
+  }
+
+  export interface RowInsertDragendEventParams<D = any> {
+    newRow: D
+    oldRow: D
+    dragRow: D
+    dragPos: 'top' | 'bottom'
+    dragToChild: boolean
+    offsetIndex: 0 | 1
+  }
+
   export interface RowDragToChildMethod<D = any> extends RowDragendEventParams<D> {}
 
   export interface ColumnDragstartEventParams<D = any> {
@@ -6275,6 +6310,8 @@ export interface VxeTableEventProps<D = any> {
   onRowDragstart?: VxeTableEvents.RowDragstart<D>
   onRowDragover?: VxeTableEvents.RowDragover<D>
   onRowDragend?: VxeTableEvents.RowDragend<D>
+  onRowRemoveDragend?: VxeTableEvents.RowRemoveDragend<D>
+  onRowInsertDragend?: VxeTableEvents.RowInsertDragend<D>
   onColumnDragstart?: VxeTableEvents.ColumnDragstart<D>
   onColumnDragover?: VxeTableEvents.ColumnDragover<D>
   onColumnDragend?: VxeTableEvents.ColumnDragend<D>
@@ -6356,6 +6393,8 @@ export interface VxeTableListeners<D = any> {
   rowDragstart?: VxeTableEvents.RowDragstart<D>
   rowDragover?: VxeTableEvents.RowDragover<D>
   rowDragend?: VxeTableEvents.RowDragend<D>
+  rowRemoveDragend?: VxeTableEvents.RowRemoveDragend<D>
+  rowInsertDragend?: VxeTableEvents.RowInsertDragend<D>
   columnDragstart?: VxeTableEvents.ColumnDragstart<D>
   columnDragover?: VxeTableEvents.ColumnDragover<D>
   columnDragend?: VxeTableEvents.ColumnDragend<D>
@@ -6420,6 +6459,8 @@ export namespace VxeTableEvents {
   export type RowDragstart<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.RowDragstartEventParams<D>) => void
   export type RowDragover<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.RowDragoverEventParams<D>) => void
   export type RowDragend<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.RowDragendEventParams<D>) => void
+  export type RowRemoveDragend<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.RowRemoveDragendEventParams<D>) => void
+  export type RowInsertDragend<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.RowInsertDragendEventParams<D>) => void
   export type ColumnDragstart<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.ColumnDragstartEventParams<D>) => void
   export type ColumnDragover<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.ColumnDragoverEventParams<D>) => void
   export type ColumnDragend<D = VxeTablePropTypes.Row> = (params: VxeTableDefines.ColumnDragendEventParams<D>) => void