adtec-hnyzfc-core-package 1.0.0

package/dist/src/types/vxe-pc-ui/components/toolbar.d.ts

@@ -0,0 +1,336 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, ValueOf } from '@vxe-ui/core'
+import { VxeButtonProps } from './button'
+import { VxeTableDefines, VxeTableConstructor, VxeTablePrivateMethods } from './table'
+import { VxeGridConstructor } from './grid'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeToolbar: DefineVxeComponentApp<VxeToolbarProps, VxeToolbarEventProps, VxeToolbarSlots, VxeToolbarMethods>
+export type VxeToolbarComponent = DefineVxeComponentOptions<VxeToolbarProps, VxeToolbarEventProps>
+
+export type VxeToolbarInstance = DefineVxeComponentInstance<VxeToolbarProps, VxeToolbarConstructor>
+
+export interface VxeToolbarConstructor extends VxeComponentBaseOptions, VxeToolbarMethods {
+  props: VxeToolbarProps
+  context: SetupContext<VxeToolbarEmits>
+  reactData: ToolbarReactData
+  getRefMaps(): ToolbarPrivateRef
+  getComputeMaps(): ToolbarPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface ToolbarPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeToolbarPrivateRef extends ToolbarPrivateRef { }
+
+export namespace VxeToolbarPropTypes {
+  export type Size = VxeComponentSizeType
+  export type Id = string
+  export type Loading = boolean
+
+  interface ResizableConfig {
+    storage?: boolean
+  }
+  export type Resizable = boolean | ResizableConfig
+  export interface ResizableOpts extends ResizableConfig { }
+
+  interface RefreshOptions {
+    queryMethod?(params: { [key: string]: any }): any
+    code?: 'query' | 'reload' | '' | null
+    icon?: string
+    iconLoading?: string
+    /**
+     * @deprecated 请使用 queryMethod
+     */
+    query?(params: { [key: string]: any }): Promise<any>
+  }
+  export type Refresh = boolean | RefreshOptions
+
+  interface ImportOptions {
+    icon?: string
+  }
+  export type Import = boolean | ImportOptions
+
+  interface ExportOptions {
+    icon?: string
+  }
+  export type Export = boolean | ExportOptions
+
+  export interface PrintOptions {
+    icon?: string
+  }
+  export type Print = boolean | PrintOptions
+
+  interface ZoomOptions {
+    iconIn?: string
+    iconOut?: string
+  }
+  export type Zoom = boolean | ZoomOptions
+
+  interface CustomOptions {
+    icon?: string
+
+    /**
+     * 已废弃，请使用 custom-config.trigger
+     * @deprecated
+     */
+    trigger?: string,
+    /**
+     * 已废弃，请使用 custom-config.immediate
+     * @deprecated
+     */
+    immediate?: boolean
+    /**
+     * 已废弃，请使用 custom-config.storage
+     * @deprecated
+     */
+    storage?: boolean
+    /**
+     * 已废弃，请使用 custom-config.checkMethod
+     * @deprecated
+     */
+    checkMethod?(params: { column: VxeTableDefines.ColumnInfo }): boolean
+    /**
+     * 已废弃，请使用 custom-config.showFooter
+     * @deprecated
+     */
+    showFooter?: boolean
+    /**
+     * 已废弃，请使用 custom-config.allowFixed
+     * @deprecated
+     */
+    allowFixed?: boolean
+    /**
+     * 已废弃，请使用 custom-config.resetButtonText
+     * @deprecated
+     */
+    resetButtonText?: string
+    /**
+     * 已废弃，请使用 custom-config.confirmButtonText
+     * @deprecated
+     */
+    confirmButtonText?: string
+    /**
+     * 已废弃，请使用 custom-config.showFooter
+     * @deprecated
+     */
+    isFooter?: boolean
+  }
+  export type Custom = boolean | CustomOptions
+
+  interface ButtonAndToolConfig extends VxeButtonProps {
+    code?: string
+    visible?: boolean
+    params?: any
+  }
+
+  export interface ButtonRender {
+    /**
+     * 渲染器名称
+     */
+    name?: string
+    /**
+     * 目标组件渲染的参数
+     */
+    props?: { [key: string]: any }
+    /**
+     * 目标组件渲染的属性
+     */
+    attrs?: { [key: string]: any }
+    /**
+     * 目标组件渲染的事件
+     */
+    events?: { [key: string]: (...args: any[]) => any }
+  }
+  export interface ButtonConfig extends ButtonAndToolConfig {
+    dropdowns?: ButtonConfig[]
+    buttonRender?: ButtonRender
+  }
+  export type Buttons = ButtonConfig[]
+
+  export interface ToolRender {
+    /**
+     * 渲染器名称
+     */
+    name?: string
+    /**
+     * 目标组件渲染的参数
+     */
+    props?: { [key: string]: any }
+    /**
+     * 目标组件渲染的属性
+     */
+    attrs?: { [key: string]: any }
+    /**
+     * 目标组件渲染的事件
+     */
+    events?: { [key: string]: (...args: any[]) => any }
+  }
+  export interface ToolConfig extends ButtonAndToolConfig {
+    dropdowns?: ToolConfig[]
+    toolRender?: ToolRender
+  }
+  export type Tools = ToolConfig[]
+
+  export type Perfect = boolean
+
+  export type ClassName = string | ((params: {
+    $toolbar: VxeToolbarConstructor
+  }) => string)
+}
+
+export type VxeToolbarProps = {
+  size?: VxeToolbarPropTypes.Size
+  /**
+   * 唯一 ID 标识
+   */
+  id?: VxeToolbarPropTypes.Id
+  /**
+   * 是否加载中
+   */
+  loading?: VxeToolbarPropTypes.Loading
+  /**
+   * 列宽拖动配置
+   */
+  resizable?: VxeToolbarPropTypes.Resizable
+  /**
+   * 刷新按钮配置
+   */
+  refresh?: VxeToolbarPropTypes.Refresh
+  refreshOptions?: VxeToolbarPropTypes.RefreshOptions
+  /**
+   * 导入按钮配置
+   */
+  import?: VxeToolbarPropTypes.Import
+  importOptions?: VxeToolbarPropTypes.ImportOptions
+  /**
+   * 导出按钮配置
+   */
+  export?: VxeToolbarPropTypes.Export
+  exportOptions?: VxeToolbarPropTypes.ExportOptions
+  /**
+   * 打印按钮配置项
+   */
+  print?: VxeToolbarPropTypes.Print
+  printOptions?: VxeToolbarPropTypes.PrintOptions
+  /**
+   * 最大化按钮配置项
+   */
+  zoom?: VxeToolbarPropTypes.Zoom
+  zoomOptions?: VxeToolbarPropTypes.ZoomOptions
+  /**
+   * 个性化设置配置
+   */
+  custom?: VxeToolbarPropTypes.Custom
+  customOptions?: VxeToolbarPropTypes.CustomOptions
+  /**
+   * 按钮列表
+   */
+  buttons?: VxeToolbarPropTypes.Buttons
+  tools?: VxeToolbarPropTypes.Tools
+  /**
+   * 配套的样式
+   */
+  perfect?: VxeToolbarPropTypes.Perfect
+  className?: VxeToolbarPropTypes.ClassName
+}
+
+export interface ToolbarPrivateComputed {
+}
+export interface VxeToolbarPrivateComputed extends ToolbarPrivateComputed { }
+
+export interface ToolbarReactData {
+  isRefresh: boolean
+  connectFlag: 0
+  columns: VxeTableDefines.ColumnInfo[]
+}
+
+export interface ToolbarInternalData {
+  connectTable: VxeTableConstructor<any> & VxeTablePrivateMethods<any> | null | undefined
+}
+
+export interface ToolbarMethods {
+  dispatchEvent(type: ValueOf<VxeToolbarEmits>, params: Record<string, any>, evnt: Event | null): void
+  syncUpdate(params: {
+    collectColumn: VxeTableDefines.ColumnInfo<any>[]
+    $table: VxeTableConstructor
+  }): void
+}
+export interface VxeToolbarMethods extends ToolbarMethods { }
+
+export interface ToolbarPrivateMethods { }
+export interface VxeToolbarPrivateMethods extends ToolbarPrivateMethods { }
+
+export type VxeToolbarEmits = [
+  'button-click',
+  'tool-click'
+]
+
+export namespace VxeToolbarDefines {
+  export interface ToolbarEventParams<D = any> extends VxeComponentEventParams {
+    $toolbar: VxeToolbarConstructor
+    $table: VxeTableConstructor<D>
+    $grid: VxeGridConstructor<D> | null | undefined
+  }
+
+  export interface ButtonClickEventParams<D = any> extends ToolbarEventParams<D> {
+    code: string
+    button: VxeToolbarPropTypes.ButtonConfig
+  }
+
+  export interface ToolClickEndEventParams<D = any> extends ToolbarEventParams<D> {
+    code: string
+    tool: VxeToolbarPropTypes.ToolConfig
+  }
+}
+
+export type VxeToolbarEventProps<D = any> = {
+  onButtonClick?: VxeToolbarEvents.ButtonClick<D>
+  onToolClick?: VxeToolbarEvents.ToolClick<D>
+}
+
+export interface VxeToolbarListeners<D = any> {
+  buttonClick?: VxeToolbarEvents.ButtonClick<D>
+  toolClick?: VxeToolbarEvents.ToolClick<D>
+}
+
+export namespace VxeToolbarEvents {
+  export type ButtonClick<D = any> = (params: VxeToolbarDefines.ButtonClickEventParams<D>) => void
+  export type ToolClick<D = any> = (params: VxeToolbarDefines.ToolClickEndEventParams<D>) => void
+}
+
+export namespace VxeToolbarSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeToolbarSlots {
+  /**
+   * 自定义左侧按钮列表
+   */
+  buttons?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+  /**
+   * 自定义左侧按钮列表前缀插槽模板
+   */
+  buttonPrefix?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+  /**
+   * 自定义左侧按钮列表后缀插槽模板
+   */
+  buttonSuffix?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+  /**
+   * 自定义右侧工具列表
+   */
+  tools?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+  /**
+   * 自定义右侧工具列表前缀插槽模板
+   */
+  toolPrefix?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+  /**
+   * 自定义右侧工具列表后缀插槽模板
+   */
+  toolSuffix?: (params: VxeToolbarSlotTypes.DefaultSlotParams) => any
+}
+
+export const Toolbar: typeof VxeToolbar
+export default VxeToolbar

package/dist/src/types/vxe-pc-ui/components/tooltip.d.ts

@@ -0,0 +1,196 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, VxeComponentStyleType, ValueOf } from '@vxe-ui/core'
+import { VxeIconPropTypes } from './icon'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeTooltip: DefineVxeComponentApp<VxeTooltipProps, VxeTooltipEventProps, VxeTooltipSlots, VxeTooltipMethods>
+export type VxeTooltipComponent = DefineVxeComponentOptions<VxeTooltipProps, VxeTooltipEventProps>
+
+export type VxeTooltipInstance = DefineVxeComponentInstance<VxeTooltipProps, VxeTooltipConstructor>
+
+export interface VxeTooltipConstructor extends VxeComponentBaseOptions, VxeTooltipMethods {
+  props: VxeTooltipProps
+  context: SetupContext<VxeTooltipEmits>
+  reactData: TooltipReactData
+  getRefMaps(): TooltipPrivateRef
+  getComputeMaps(): TooltipPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface TooltipPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeTooltipPrivateRef extends TooltipPrivateRef { }
+
+export namespace VxeTooltipPropTypes {
+  export type Size = VxeComponentSizeType
+  export type ModelValue = boolean
+  export type Selector = string | HTMLElement
+  export type Trigger = 'hover' | 'click' | 'manual' | '' | null
+  export type Theme = '' | 'light' | 'dark'
+  export type Content = string | number
+  export type UseHtml = boolean
+  export type ZIndex = string | number
+  export type PopupClassName = string | ((params: { $tooltip: VxeTooltipConstructor }) => string)
+  export type Width = string | number
+  export type Height = string | number
+  export type MinWidth = string | number
+  export type MinHeight = string | number
+  export type MaxWidth = string | number
+  export type MaxHeight = string | number
+  export type Placement = 'top' | 'bottom' | ''
+  export type DefaultPlacement = 'top' | 'bottom' | ''
+  export type IsArrow = boolean
+  export type Enterable = boolean
+  export type EnterDelay = number
+  export type LeaveDelay = number
+  export type LeaveMethod = (params: { $event: MouseEvent }) => boolean
+
+  /**
+   * 已废弃，请使用 UseHtml
+   * @deprecated
+   */
+  export type UseHTML = boolean
+}
+
+export interface VxeTooltipProps {
+  size?: VxeTooltipPropTypes.Size
+  modelValue?: VxeTooltipPropTypes.ModelValue
+  selector?: VxeTooltipPropTypes.Selector
+  trigger?: VxeTooltipPropTypes.Trigger
+  theme?: VxeTooltipPropTypes.Theme
+  content?: VxeTooltipPropTypes.Content
+  useHtml?: VxeTooltipPropTypes.UseHtml
+  /**
+   * 已废弃，请使用 useHtml
+   * @deprecated
+   */
+  useHTML?: VxeTooltipPropTypes.UseHTML
+  popupClassName?: VxeTooltipPropTypes.PopupClassName
+  Width?: VxeTooltipPropTypes.Width
+  height?: VxeTooltipPropTypes.Height
+  minWidth?: VxeTooltipPropTypes.MinWidth
+  minHeight?: VxeTooltipPropTypes.MinHeight
+  maxWidth?: VxeTooltipPropTypes.MaxWidth
+  maxHeight?: VxeTooltipPropTypes.MaxHeight
+  zIndex?: VxeTooltipPropTypes.ZIndex
+  placement?: VxeTooltipPropTypes.Placement
+  defaultPlacement?: VxeTooltipPropTypes.DefaultPlacement
+  isArrow?: VxeTooltipPropTypes.IsArrow
+  enterable?: VxeTooltipPropTypes.Enterable
+  enterDelay?: VxeTooltipPropTypes.EnterDelay
+  leaveDelay?: VxeTooltipPropTypes.LeaveDelay
+  leaveMethod?: VxeTooltipPropTypes.LeaveMethod
+}
+
+export interface TooltipPrivateComputed {
+}
+export interface VxeTooltipPrivateComputed extends TooltipPrivateComputed { }
+
+export interface TooltipReactData {
+  target: HTMLElement | null
+  isUpdate: boolean
+  visible: boolean
+  tipPos: null | {
+    x: number
+    y: number
+    oLeft: number
+    oTop: number
+  }
+  tipContent: string | number | undefined
+  tipActive: boolean
+  tipTarget: HTMLElement | null
+  tipZindex: number
+  tipStore: {
+    style: VxeComponentStyleType
+    placement: any
+    arrowStyle: VxeComponentStyleType
+  }
+}
+
+export interface TooltipInternalData {
+  showDelayTip?(): void
+}
+
+export interface TooltipMethods {
+  dispatchEvent(type: ValueOf<VxeTooltipEmits>, params: Record<string, any>, evnt: Event | null): void
+  /**
+   * 显示
+   */
+  openByEvent(evnt: Event, target?: any, content?: VxeTooltipPropTypes.Content): Promise<void>
+  /**
+   * 显示
+   */
+  open(target?: any, content?: VxeTooltipPropTypes.Content): Promise<void>
+  /**
+   * 已废弃，请使用 open
+   * @deprecated
+   */
+  toVisible(target?: HTMLElement, content?: VxeTooltipPropTypes.Content): Promise<void>
+  /**
+   * 隐藏
+   */
+  close(): Promise<any>
+  updatePlacement(): Promise<any>
+  isActived(): boolean
+  setActived(actived: boolean): void
+}
+export interface VxeTooltipMethods extends TooltipMethods { }
+
+export interface TooltipPrivateMethods { }
+export interface VxeTooltipPrivateMethods extends TooltipPrivateMethods { }
+
+export type VxeTooltipEmits = [
+  'update:modelValue'
+]
+
+export namespace VxeTooltipDefines {
+  export interface TooltipEventParams extends VxeComponentEventParams {
+    $tooltip: VxeTooltipConstructor
+  }
+
+  export interface TooltipHelperOption {
+    useHtml?: VxeTooltipPropTypes.UseHtml
+    content?: VxeTooltipPropTypes.Content
+    enterable?: VxeTooltipPropTypes.Enterable
+    theme?: VxeTooltipPropTypes.Theme
+    icon?: VxeIconPropTypes.ClassName
+    iconStatus?: VxeIconPropTypes.Status
+
+    /**
+     * 已废弃，请使用 content
+     * @deprecated
+     */
+    message?: string
+    /**
+     * 已废弃，请使用 useHtml
+     * @deprecated
+     */
+    useHTML?: VxeTooltipPropTypes.UseHTML
+  }
+}
+
+export type VxeTooltipEventProps = {
+  'onUpdate:modelValue'?: VxeTooltipEvents.UpdateModelValue
+}
+
+export interface VxeTooltipListeners {
+  'update:modelValue'?: VxeTooltipEvents.UpdateModelValue
+}
+
+export namespace VxeTooltipEvents {
+  export type UpdateModelValue = (modelValue: VxeTooltipPropTypes.ModelValue) => void
+}
+
+export namespace VxeTooltipSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeTooltipSlots {
+  default?: (params: VxeTooltipSlotTypes.DefaultSlotParams) => any
+  content?: (params: VxeTooltipSlotTypes.DefaultSlotParams) => any
+}
+
+export const Tooltip: typeof VxeTooltip
+export default VxeTooltip

package/dist/src/types/vxe-pc-ui/components/tour.d.ts

@@ -0,0 +1,77 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, ValueOf, VxeComponentSizeType } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeTour: DefineVxeComponentApp<VxeTourProps, VxeTourEventProps, VxeTourSlots, VxeTourMethods>
+export type VxeTourComponent = DefineVxeComponentOptions<VxeTourProps, VxeTourEventProps>
+
+export type VxeTourInstance = DefineVxeComponentInstance<VxeTourProps, VxeTourConstructor>
+
+export interface VxeTourConstructor extends VxeComponentBaseOptions, VxeTourMethods {
+  props: VxeTourProps
+  context: SetupContext<VxeTourEmits>
+  reactData: TourReactData
+  getRefMaps(): TourPrivateRef
+  getComputeMaps(): TourPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface TourPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeTourPrivateRef extends TourPrivateRef { }
+
+export namespace VxeTourPropTypes {
+  export type Size = VxeComponentSizeType
+}
+
+export type VxeTourProps = {
+  size?: VxeTourPropTypes.Size
+}
+
+export interface TourPrivateComputed {
+}
+export interface VxeTourPrivateComputed extends TourPrivateComputed { }
+
+export interface TourReactData {
+}
+
+export interface TourMethods {
+  dispatchEvent(type: ValueOf<VxeTourEmits>, params: Record<string, any>, evnt: Event | null): void
+}
+export interface VxeTourMethods extends TourMethods { }
+
+export interface TourPrivateMethods { }
+export interface VxeTourPrivateMethods extends TourPrivateMethods { }
+
+export type VxeTourEmits = [
+]
+
+export namespace VxeTourDefines {
+  export interface TourEventParams extends VxeComponentEventParams {
+    $tour: VxeTourConstructor
+  }
+
+  export interface ClickEventParams extends TourEventParams { }
+  export interface CloseEventParams extends TourEventParams { }
+}
+
+export type VxeTourEventProps = {
+}
+
+export interface VxeTourListeners {
+}
+
+export namespace VxeTourEvents {
+}
+
+export namespace VxeTourSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeTourSlots {
+}
+
+export const Tour: typeof VxeTour
+export default VxeTour

package/dist/src/types/vxe-pc-ui/components/transfer.d.ts

@@ -0,0 +1,84 @@
+import { RenderFunction, SetupContext, Ref } from 'vue'
+import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType } from '@vxe-ui/core'
+
+/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */
+
+export declare const VxeTransfer: DefineVxeComponentApp<VxeTransferProps, VxeTransferEventProps, VxeTransferSlots, VxeTransferMethods>
+export type VxeTransferComponent = DefineVxeComponentOptions<VxeTransferProps, VxeTransferEventProps>
+
+export type VxeTransferInstance = DefineVxeComponentInstance<VxeTransferProps, VxeTransferConstructor>
+
+export interface VxeTransferConstructor extends VxeComponentBaseOptions, VxeTransferMethods {
+  props: VxeTransferProps
+  context: SetupContext<VxeTransferEmits>
+  reactData: TransferReactData
+  internalData: TransferInternalData
+  getRefMaps(): TransferPrivateRef
+  getComputeMaps(): TransferPrivateComputed
+  renderVN: RenderFunction
+}
+
+export interface TransferPrivateRef {
+  refElem: Ref<HTMLDivElement | undefined>
+}
+export interface VxeTransferPrivateRef extends TransferPrivateRef { }
+
+export namespace VxeTransferPropTypes {
+  export type Size = VxeComponentSizeType
+  export type ModelValue = any[]
+  export interface Option {
+    value?: string | number
+    label?: string | number
+    children?: Option[]
+
+    [key: string]: any
+  }
+  export type Options<D = Option> = D[]
+}
+
+export interface VxeTransferProps {
+  size?: VxeTransferPropTypes.Size
+  modelValue?: VxeTransferPropTypes.ModelValue
+  options?: VxeTransferPropTypes.Options
+}
+
+export interface TransferPrivateComputed {
+}
+export interface VxeTransferPrivateComputed extends TransferPrivateComputed { }
+
+export interface TransferReactData {
+}
+export interface TransferInternalData {
+}
+
+export interface TransferMethods {
+}
+export interface VxeTransferMethods extends TransferMethods { }
+
+export interface TransferPrivateMethods { }
+export interface VxeTransferPrivateMethods extends TransferPrivateMethods { }
+
+export type VxeTransferEmits = []
+
+export namespace VxeTransferDefines {
+  export interface TransferEventParams extends VxeComponentEventParams {
+    $transfer: VxeTransferConstructor
+  }
+}
+
+export type VxeTransferEventProps = {}
+
+export interface VxeTransferListeners { }
+
+export namespace VxeTransferEvents { }
+
+export namespace VxeTransferSlotTypes {
+  export interface DefaultSlotParams {}
+}
+
+export interface VxeTransferSlots {
+  default?: (params: VxeTransferSlotTypes.DefaultSlotParams) => any
+}
+
+export const Transfer: typeof VxeTransfer
+export default VxeTransfer