vxe-pc-ui 4.4.26 → 4.5.1

package/styles/components/split.scss

@@ -0,0 +1,106 @@
+@use "sass:list";
+
+.vxe-split {
+  &.is--vertical {
+    & > .vxe-split-wrapper {
+      flex-direction: column;
+      & > .vxe-split-item {
+        width: 100%;
+      }
+    }
+  }
+  &.is--drag {
+    user-select: none;
+    & > .vxe-split-wrapper {
+      & > .vxe-split-item {
+        & > .vxe-split-item--wrapper {
+          &::after {
+            content: "";
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 1;
+            background: transparent;
+          }
+        }
+      }
+    } 
+  }
+}
+.vxe-split-wrapper {
+  height: 100%;
+  display: flex;
+  flex-direction: row;
+  overflow: hidden;
+}
+
+.vxe-split-slots {
+  display: none;
+}
+
+.vxe-split-item-handle {
+  flex-shrink: 0;
+  background-color: var(--vxe-split-handle-bar-background-color);
+  user-select: none;
+  &:hover {
+    background-color: var(--vxe-ui-font-primary-lighten-color);
+  }
+  &:active {
+    background-color: var(--vxe-ui-font-primary-darken-color);
+  }
+}
+
+.vxe-split-item--wrapper {
+  position: relative;
+  word-break: break-word;
+  overflow: auto;
+  flex-grow: 1;
+  & > .vxe-split {
+    height: 100%;
+  }
+}
+
+.vxe-split-item {
+  display: flex;
+  position: relative;
+  overflow: auto;
+  &.is--fill {
+    flex-grow: 1;
+  }
+  &.is--width, 
+  &.is--height {
+    flex-shrink: 0;
+  }
+  &.is--border {
+    & > .vxe-split-item--wrapper,
+    & > .vxe-split-item-handle {
+      border: 1px solid var(--vxe-ui-base-popup-border-color);
+    }
+  }
+  &.is--horizontal {
+    flex-direction: row;
+    & > .vxe-split-item-handle {
+      width: var(--vxe-split-handle-bar-width);
+      cursor: w-resize;
+    }
+    &.is--border {
+      & > .vxe-split-item-handle {
+        border-width: 1px 0 1px 0;
+      }
+    }
+  }
+  &.is--vertical {
+    flex-direction: column;
+    & > .vxe-split-item-handle {
+      height: var(--vxe-split-handle-bar-height);
+      cursor: n-resize;
+    }
+    &.is--border {
+      & > .vxe-split-item-handle {
+        border-width: 0 1px 0 1px;
+      }
+    }
+  }
+}

package/styles/helpers/baseVar.scss

@@ -0,0 +1,4 @@
+// 24 栅格布局
+$colSpanList: 4.16667%, 8.33333%, 12.5%, 16.66667%, 20.83333%, 25%, 29.16667%, 33.33333%,
+              37.5%, 41.66667%, 45.83333%, 50%, 54.16667%, 58.33333%, 62.5%, 66.66667%,
+              70.83333%, 75%, 79.16667%, 83.33333%, 87.5%, 91.66667%, 95.83333%, 100%;

package/styles/theme/base.scss

@@ -145,7 +145,7 @@
   --vxe-ui-switch-font-color: #fff;
   --vxe-ui-switch-icon-background-color: #fff;
   --vxe-ui-switch-open-background-color: var(--vxe-ui-font-primary-color);
-  --vxe-ui-switch-disabled-background-color: rgba(0,0,0,0.15) ;
+  --vxe-ui-switch-disabled-background-color: rgba(0,0,0,0.15);
 
   /*upload*/
   --vxe-ui-upload-file-button-border-style: dashed;
@@ -175,4 +175,8 @@
   --vxe-ui-calendar-selected-color: #fff;
   --vxe-ui-calendar-festival-selected-color: var(--vxe-ui-calendar-selected-color);
   --vxe-ui-calendar-notice-selected-background-color: var(--vxe-ui-calendar-selected-color);
+
+  /*split*/
+  --vxe-split-handle-bar-width: 0.4em;
+  --vxe-split-handle-bar-height: var(--vxe-split-handle-bar-width);
 }

package/styles/theme/dark.scss

@@ -107,4 +107,7 @@
 
   /*rate*/
   --vxe-ui-rate-item-color: #bd9537;
+
+  /*split*/
+  --vxe-split-handle-bar-background-color: #28282a;
 }

package/styles/theme/light.scss

@@ -106,4 +106,7 @@
 
   /*rate*/
   --vxe-ui-rate-item-color: #{light_variable.$vxe-ui-rate-item-color};
+
+  /*split*/
+  --vxe-split-handle-bar-background-color: #{light_variable.$vxe-split-handle-bar-background-color};
 }

package/styles/variable.scss

@@ -102,3 +102,7 @@ $vxe-ui-tree-node-hover-current-background-color: #d7effb !default;
 
 /*rate*/
 $vxe-ui-rate-item-color: #f7ba2a !default;
+
+/*split*/
+$vxe-split-handle-bar-background-color: #f0f0f0;
+

package/types/all.d.ts

@@ -65,6 +65,8 @@ import VxeRadioGroup from './components/radio-group'
 import VxeResult from './components/result'
 import VxeRow from './components/row'
 import VxeSelect from './components/select'
+import VxeSplit from './components/split'
+import VxeSplitItem from './components/split-item'
 import VxeSlider from './components/slider'
 import VxeRate from './components/rate'
 import VxeSteps from './components/steps'
@@ -158,6 +160,8 @@ interface AllComponents {
   VxeResult: typeof VxeResult
   VxeRow: typeof VxeRow
   VxeSelect: typeof VxeSelect
+  VxeSplit: typeof VxeSplit
+  VxeSplitItem: typeof VxeSplitItem
   VxeSlider: typeof VxeSlider
   VxeSteps: typeof VxeSteps
   VxeSwitch: typeof VxeSwitch
@@ -259,6 +263,8 @@ export * from './components/rate'
 export * from './components/result'
 export * from './components/row'
 export * from './components/select'
+export * from './components/split'
+export * from './components/split-item'
 export * from './components/slider'
 export * from './components/steps'
 export * from './components/switch'

package/types/components/col.d.ts

@@ -1,5 +1,5 @@
 import { RenderFunction, SetupContext, Ref } from 'vue'
-import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType } from '@vxe-ui/core'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, VxeComponentAlignType } from '@vxe-ui/core'
 
 /* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
 
@@ -23,10 +23,20 @@ export interface ColPrivateRef {
 export interface VxeColPrivateRef extends ColPrivateRef { }
 
 export namespace VxeColPropTypes {
+  export type Span = string | number
+  export type Align = VxeComponentAlignType
+  export type Width = string | number
+  export type Fill = boolean
+  export type Ellipsis = boolean
   export type Size = VxeComponentSizeType
 }
 
 export interface VxeColProps {
+  span?: VxeColPropTypes.Span
+  align?: VxeColPropTypes.Align
+  width?: VxeColPropTypes.Width
+  fill?: VxeColPropTypes.Fill
+  ellipsis?: VxeColPropTypes.Ellipsis
   size?: VxeColPropTypes.Size
 }
 

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

@@ -0,0 +1,89 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, ValueOf, VxeComponentSlotType } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeSplitItem: DefineVxeComponentApp<VxeSplitItemProps, VxeSplitItemEventProps, VxeSplitItemSlots>
+export type VxeSplitItemComponent = DefineVxeComponentOptions<VxeSplitItemProps, VxeSplitItemEventProps>
+
+export type VxeSplitItemInstance = DefineVxeComponentInstance<VxeSplitItemProps, VxeSplitItemConstructor>
+
+export interface VxeSplitItemConstructor extends VxeComponentBaseOptions, VxeSplitItemMethods {
+  props: VxeSplitItemProps
+  context: SetupContext<VxeSplitItemEmits>
+  reactData: SplitItemReactData
+  getRefMaps(): SplitItemPrivateRef
+  getComputeMaps(): SplitItemPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface SplitItemPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeSplitItemPrivateRef extends SplitItemPrivateRef { }
+
+export namespace VxeSplitItemPropTypes {
+  export type Width = string | number
+  export type Height = string | number
+  export type MinWidth = string | number
+  export type MinHeight = string | number
+}
+
+export type VxeSplitItemProps = {
+  width?: VxeSplitItemPropTypes.Width
+  height?: VxeSplitItemPropTypes.Height
+  minWidth?: VxeSplitItemPropTypes.MinWidth
+  minHeight?: VxeSplitItemPropTypes.MinHeight
+
+  slots?: {
+    default?: string | ((params: VxeSplitItemSlotTypes.DefaultSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
+  }
+}
+
+export interface SplitItemPrivateComputed {
+}
+export interface VxeSplitItemPrivateComputed extends SplitItemPrivateComputed { }
+
+export interface SplitItemReactData {
+}
+
+export interface SplitItemInternalData {
+}
+
+export interface SplitItemMethods {
+  dispatchEvent(type: ValueOf<VxeSplitItemEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeSplitItemMethods extends SplitItemMethods { }
+
+export interface SplitItemPrivateMethods { }
+export interface VxeSplitItemPrivateMethods extends SplitItemPrivateMethods { }
+
+export type VxeSplitItemEmits = [
+]
+
+export namespace VxeSplitItemDefines {
+  export interface SplitItemEventParams extends VxeComponentEventParams {
+    $splitItem: VxeSplitItemConstructor
+  }
+}
+
+export type VxeSplitItemEventProps = {
+}
+
+export interface VxeSplitItemListeners {
+}
+
+export namespace VxeSplitItemEvents {
+}
+
+export namespace VxeSplitItemSlotTypes {
+  export interface DefaultSlotParams {
+  }
+}
+
+export interface VxeSplitItemSlots {
+  default?: (params: VxeSplitItemSlotTypes.DefaultSlotParams) => any
+}
+
+export const SplitItem: typeof VxeSplitItem
+export default VxeSplitItem

package/types/components/split.d.ts

@@ -0,0 +1,100 @@
+import { RenderFunction, SetupContext, Ref, ComputedRef } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, ValueOf } from '@vxe-ui/core'
+import { VxeSplitItemProps } from './split-item'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeSplit: DefineVxeComponentApp<VxeSplitProps, VxeSplitEventProps, VxeSplitSlots>
+export type VxeSplitComponent = DefineVxeComponentOptions<VxeSplitProps, VxeSplitEventProps>
+
+export type VxeSplitInstance = DefineVxeComponentInstance<VxeSplitProps, VxeSplitConstructor>
+
+export interface VxeSplitConstructor extends VxeComponentBaseOptions, VxeSplitMethods {
+  props: VxeSplitProps
+  context: SetupContext<VxeSplitEmits>
+  reactData: SplitReactData
+  getRefMaps(): SplitPrivateRef
+  getComputeMaps(): SplitPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface SplitPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeSplitPrivateRef extends SplitPrivateRef { }
+
+export namespace VxeSplitPropTypes {
+  export type Height = string | number
+  export type Width = string | number
+  export type Vertical = boolean
+  export type Border = boolean
+  export interface ItemConfig {
+    minWidth?: string | number
+    minHeight?: string | number
+  }
+}
+
+export type VxeSplitProps = {
+  height?: VxeSplitPropTypes.Height
+  width?: VxeSplitPropTypes.Width
+  vertical?: VxeSplitPropTypes.Vertical
+  border?: VxeSplitPropTypes.Border
+  itemConfig?: VxeSplitPropTypes.ItemConfig
+}
+
+export interface SplitPrivateComputed {
+  computeItemOpts: ComputedRef<VxeSplitPropTypes.ItemConfig>
+}
+export interface VxeSplitPrivateComputed extends SplitPrivateComputed { }
+
+export interface SplitReactData {
+  staticItems: VxeSplitDefines.ChunkConfig[]
+}
+
+export interface SplitInternalData {
+}
+
+export interface SplitMethods {
+  dispatchEvent(type: ValueOf<VxeSplitEmits>, params: Record<string, any>, evnt: Event | null): void
+  recalculate(): Promise<void>
+}
+export interface VxeSplitMethods extends SplitMethods { }
+
+export interface SplitPrivateMethods { }
+export interface VxeSplitPrivateMethods extends SplitPrivateMethods { }
+
+export type VxeSplitEmits = [
+]
+
+export namespace VxeSplitDefines {
+  export interface SplitEventParams extends VxeComponentEventParams {
+    $split: VxeSplitConstructor
+  }
+
+  export interface ChunkConfig extends VxeSplitItemProps {
+    id: string
+    renderWidth: number
+    renderHeight: number
+  }
+}
+
+export type VxeSplitEventProps = {
+}
+
+export interface VxeSplitListeners {
+}
+
+export namespace VxeSplitEvents {
+}
+
+export namespace VxeSplitSlotTypes {
+  export interface DefaultSlotParams {
+  }
+}
+
+export interface VxeSplitSlots {
+  default?: (params: VxeSplitSlotTypes.DefaultSlotParams) => any
+}
+
+export const Split: typeof VxeSplit
+export default VxeSplit

package/types/components/table-plugins/extend-cell-area.d.ts

@@ -79,23 +79,77 @@ export interface VxeTableExtendCellAreaMethods<D = any> {
 }
 
 export interface VxeTableExtendCellAreaPrivateMethods<D = any> {
+  /**
+   * @private
+   */
   handleKeyboardCellAreaEvent(evnt: KeyboardEvent): void
+  /**
+   * @private
+   */
   handleHeaderCellAreaEvent(evnt: MouseEvent, params: VxeTableDefines.HeaderCellClickEventParams<D>): void
+  /**
+   * @private
+   */
   handleCellAreaMousedownEvent(evnt: MouseEvent, params: VxeTableDefines.CellClickEventParams<D>): void
+  /**
+   * @private
+   */
   handleFilterEvent(evnt: Event, params: VxeTableDefines.FilterChangeEventParams<D>): any
+  /**
+   * @private
+   */
   handleSortEvent(evnt: Event, params: VxeTableDefines.SortChangeEventParams<D>): any
+  /**
+   * @private
+   */
   handleRecalculateCellAreaEvent(): any
+  /**
+   * @private
+   */
   handleCopyCellAreaEvent(evnt: ClipboardEvent): void
+  /**
+   * @private
+   */
   handlePasteCellAreaEvent(evnt: ClipboardEvent): void
+  /**
+   * @private
+   */
   handleCutCellAreaEvent(evnt: ClipboardEvent): void
+  /**
+   * @private
+   */
   handleColResizeCellAreaEvent(evnt: MouseEvent, params: any): void
+  /**
+   * @private
+   */
   handleColResizeDblclickCellAreaEvent(evnt: MouseEvent, params: any): void
+  /**
+   * @private
+   */
   handleRowResizeCellAreaEvent(evnt: MouseEvent, params: any): void
+  /**
+   * @private
+   */
   handleRowResizeDblclickCellAreaEvent(evnt: MouseEvent, params: any): void
+  /**
+   * @private
+   */
   triggerCellAreaExtendMousedownEvent(evnt: MouseEvent, params: any): void
+  /**
+   * @private
+   */
   triggerCopyCellAreaEvent(evnt: MouseEvent): void
+  /**
+   * @private
+   */
   triggerCutCellAreaEvent(evnt: MouseEvent): void
+  /**
+   * @private
+   */
   triggerPasteCellAreaEvent(evnt: MouseEvent): void
+  /**
+   * @private
+   */
   triggerFNROpenEvent(evnt: MouseEvent, tab: 'find' | 'replace'): void
 }