@das-fed/upf-ui 6.4.0-dev.173 → 6.4.0-dev.175

package/packages/components/table/src/filter-pane/filterPane.vue.d.ts

@@ -0,0 +1,26 @@
+import type { Props } from './type';
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (val: any[]) => any;
+    "visible-change": (val: boolean) => any;
+    "filter-confirm": (val: any[] | Record<"value" | "custom", any>, btnType: "reset" | "confirm") => any;
+    "update:keywords": (val: string) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((val: any[]) => any) | undefined;
+    "onVisible-change"?: ((val: boolean) => any) | undefined;
+    "onFilter-confirm"?: ((val: any[] | Record<"value" | "custom", any>, btnType: "reset" | "confirm") => any) | undefined;
+    "onUpdate:keywords"?: ((val: string) => any) | undefined;
+}>, {
+    mode: "select" | "input";
+    modelValue: any[];
+    options: Array<{
+        text: string;
+        value: any;
+    }> | (() => Promise<Array<{
+        text: string;
+        value: any;
+    }>>);
+    defaultValue: any[];
+    keywords: string;
+    autoClearSearch: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/packages/components/table/src/filter-pane/type.d.ts

@@ -0,0 +1,41 @@
+export interface Props {
+  
+  mode?: 'select' | 'input'
+
+  
+  defaultValue?: any[]
+
+  
+  modelValue?: any[]
+
+  
+  keywords?: string
+
+  
+  isMultiple?: boolean
+
+  
+  allowSearch?: boolean
+
+  
+  autoClearSearch?: boolean
+
+  
+  options?: Array<{ text: string; value: any }> | (() => Promise<Array<{ text: string; value: any }>>)
+
+  
+  loaded?: boolean
+}
+export interface Emits {
+  
+  (e: 'update:modelValue', val: any[]): void
+
+  
+  (e: 'update:keywords', val: string): void
+
+  
+  (e: 'visible-change', val: boolean): void
+
+  
+  (e: 'filter-confirm', val: any[] | Record<'value' | 'custom', any>, btnType: 'confirm' | 'reset'): void
+}

package/packages/components/table/src/hooks/use-high-performance.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from "vue";
+export declare function useHighPerformance(rowKey: Ref, highPerformance: Ref, tableRef: Ref): {
+    operationClassPrefix: import("vue").ComputedRef<"" | "uniqueId-">;
+    showMoreOperations: (row: any) => any;
+    initMoreOperationsObserver: () => void;
+};

package/packages/components/table/src/hooks/use-operation.d.ts

@@ -0,0 +1,78 @@
+import type { Ref } from 'vue';
+import type { Props, Emits, operationType } from '../type';
+export declare const useOperation: (props: Props, emit: Emits, rowKey: Ref<string>, $table: Ref) => {
+    $oprationsDropdown: Ref<any[], any[]>;
+    $oprationsChildDropdown: Ref<any[], any[]>;
+    getOperations: (row: any, column: any, index: number) => {
+        btnOperates: operationType[];
+        moreOperates: operationType[];
+    };
+    operationItemDisabled: (item: any, row: any, column: any, index: number) => boolean;
+    operationItemTip: (item: any, row: any, column: any, index: number) => string;
+    getItemChildren: (item: any, row: any) => Promise<any>;
+    oprationsClick: (type: "btnOperates" | "moreOperates", command: any, row: any, column: any, index: number) => Promise<void>;
+    btnOperationsVisible: Ref<any, any>;
+    operationsVisible: Ref<boolean[], boolean[]>;
+    operationLazyData: Ref<{
+        btnOperates: any;
+        moreOperates: any;
+    }, Record<"btnOperates" | "moreOperates", any> | {
+        btnOperates: any;
+        moreOperates: any;
+    }>;
+    operationClass: import("vue").ComputedRef<string>;
+    lazyLoadingMap: Ref<Record<any, any>, Record<any, any>>;
+    btnVisibleChange: (visible: boolean, tableIndex: number, index: any) => void;
+    visibleChange: (visible: boolean, index: number) => void;
+    childDropdownPlacement: Ref<string, string>;
+    currentParentOprationVal: Ref<string, string>;
+    realOperationOptions: import("vue").ComputedRef<{
+        width: any;
+        minWidth: any;
+        type?: string | undefined;
+        showOverflowTooltip?: boolean | Partial<Pick<import("element-plus").ElTooltipProps, "offset" | "effect" | "placement" | "popperClass" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "showArrow">> | undefined;
+        sortOrders?: ("ascending" | "descending" | null)[] | undefined;
+        sortable?: string | boolean | undefined;
+        resizable?: boolean | undefined;
+        reserveSelection?: boolean | undefined;
+        filterMultiple?: boolean | undefined;
+        key?: PropertyKey;
+        style?: unknown;
+        label?: string | undefined;
+        fixed?: string | boolean | undefined;
+        ref?: import("vue").VNodeRef;
+        ref_for?: boolean;
+        ref_key?: string;
+        onVnodeBeforeMount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeMounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeBeforeUpdate?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+        onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
+        onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
+        class?: unknown;
+        selectable?: ((row: any, index: number) => boolean) | undefined;
+        filters?: import("element-plus/es/components/table/src/table-column/defaults.mjs").Filters | undefined;
+        formatter?: ((row: any, column: import("element-plus").TableColumnCtx<any>, cellValue: any, index: number) => string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) | undefined;
+        index?: number | ((index: number) => number) | undefined;
+        align?: string | undefined;
+        className?: string | undefined;
+        labelClassName?: string | undefined;
+        property?: string | undefined;
+        prop?: string | undefined;
+        renderHeader?: ((data: {
+            column: import("element-plus").TableColumnCtx<any>;
+            $index: number;
+        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) | undefined;
+        sortMethod?: ((a: any, b: any) => number) | undefined;
+        sortBy?: string | string[] | ((row: any, index: number) => string) | undefined;
+        columnKey?: string | undefined;
+        headerAlign?: string | undefined;
+        filterMethod?: import("element-plus/es/components/table/src/table-column/defaults.mjs").FilterMethods<any> | undefined;
+        filteredValue?: string[] | undefined;
+        filterPlacement?: string | undefined;
+    }>;
+};

package/packages/components/table/src/hooks/use-setStyle.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, ComputedRef } from 'vue';
+export declare const useSetStyle: (tableCotainer: Ref<any>, rowKey: ComputedRef<string>, isTree: Ref<boolean>) => {
+    isIndeterminate: Ref<boolean, boolean>;
+    setExpandStyle: () => void;
+    setIndeterminateStyle: (data: any[], selectionRows: any[]) => void;
+    checkboxSetTabIndex: () => void;
+};

package/packages/components/table/src/hooks/use-tree-check.d.ts

@@ -0,0 +1,10 @@
+import type { Ref } from 'vue';
+export declare const useTreeCheck: (data: Ref, rowKey: Ref, innerSelectionRows: Ref, selection: Ref) => {
+    isAllChecked: Ref<boolean, boolean>;
+    isImmediate: Ref<boolean, boolean>;
+    isCheckeDisabled: import("vue").ComputedRef<any>;
+    isChecked: import("vue").ComputedRef<any>;
+    setImmediateandAllchecked: () => void;
+    checkboxAllChange: (val: boolean) => void;
+    checkboxChange: (row: any, val: boolean) => void;
+};

package/packages/components/table/src/hooks/useDrag.d.ts

@@ -0,0 +1,10 @@
+import { ElTable } from 'element-plus';
+import type { Ref } from 'vue';
+import type { Props, Emits } from '../type';
+export declare const useDrag: (props: Props, emit: Emits, $table: Ref<InstanceType<typeof ElTable> | null>, data: Ref<any>, tableMaxHeight: Ref<any>, rowKey: Ref<any>, isTree: Ref<any>) => {
+    DRAGCLASSNAME: string;
+    drag: import("vue").ComputedRef<{
+        open: boolean;
+        rowspan: any;
+    }>;
+};

package/packages/components/table/src/key.d.ts

@@ -0,0 +1 @@
+export declare const tableInjectionKey: unique symbol;

package/packages/components/table/src/table-column/index.vue.d.ts

@@ -0,0 +1,83 @@
+import 'element-plus/es/components/table/style/css';
+import type { Props } from './type';
+declare var __VLS_7: {
+    column: any;
+    $index: any;
+}, __VLS_9: {
+    column: any;
+    $index: any;
+}, __VLS_15: {}, __VLS_29: {
+    column: any;
+    $index: any;
+}, __VLS_39: {
+    row: any;
+    column: any;
+    $index: any;
+}, __VLS_41: {
+    row: any;
+    column: any;
+    $index: any;
+}, __VLS_43: {
+    row: any;
+    column: any;
+    $index: any;
+}, __VLS_45: {
+    row: any;
+    column: any;
+    $index: any;
+}, __VLS_47: {
+    row: any;
+    column: any;
+    $index: any;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_7) => any;
+} & {
+    'header-prefix'?: (props: typeof __VLS_9) => any;
+} & {
+    'header-tips'?: (props: typeof __VLS_15) => any;
+} & {
+    'header-suffix'?: (props: typeof __VLS_29) => any;
+} & {
+    default?: (props: typeof __VLS_39) => any;
+} & {
+    default?: (props: typeof __VLS_41) => any;
+} & {
+    default?: (props: typeof __VLS_43) => any;
+} & {
+    default?: (props: typeof __VLS_45) => any;
+} & {
+    default?: (props: typeof __VLS_47) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:filterVal": (val: any[]) => any;
+    "update:filterKeywords": (val: string) => any;
+    "filter-visible-change": (val: boolean) => any;
+    "click-link": (row: any, column: any, $index: number) => any;
+    "filter-confirm": (val: any[] | Record<"value" | "custom", any>, btnType: "reset" | "confirm") => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:filterVal"?: ((val: any[]) => any) | undefined;
+    "onUpdate:filterKeywords"?: ((val: string) => any) | undefined;
+    "onFilter-visible-change"?: ((val: boolean) => any) | undefined;
+    "onClick-link"?: ((row: any, column: any, $index: number) => any) | undefined;
+    "onFilter-confirm"?: ((val: any[] | Record<"value" | "custom", any>, btnType: "reset" | "confirm") => any) | undefined;
+}>, {
+    fixed: "left" | "right" | boolean;
+    disabled: string | ((row: any, column: any, index: number) => boolean);
+    width: string | number;
+    placeholder: string;
+    index: ((index: number) => number) | number;
+    contentType: "span" | "link" | Record<"statusColor", any>;
+    showOverflowTooltip: boolean;
+    filterDefaultVal: any[];
+    filterVal: any[];
+    filterKeywords: string;
+    columnFilterAutoClearSearch: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/packages/components/table/src/table-column/type.d.ts

@@ -0,0 +1,84 @@
+export interface Props {
+  
+  type?: 'index' | 'selection' | 'custom-selection' | 'expand' | 'table-column'
+
+  
+  align?: string
+
+  
+  index?: ((index: number) => number) | number
+
+  
+  contentType?: 'span' | 'link' | Record<'statusColor', any>
+
+  
+  cellName?: string
+
+  
+  width?: string | number
+
+  
+  disabled?: string | ((row: any, column: any, index: number) => boolean)
+
+  
+  fixed?: 'left' | 'right' | boolean
+
+  
+  showOverflowTooltip?: boolean
+
+  
+  placeholder?: string
+
+  
+  required?: boolean
+
+  
+  columnFilter?: boolean
+
+  
+  columnFilterMultiple?: boolean
+
+  
+  columnFilterMode?: 'select' | 'input'
+
+  
+  filterDefaultVal?: any[]
+
+  
+  filterVal?: any[]
+
+  
+  filterKeywords?: string
+
+  
+  columnFilterAllowSearch?: boolean
+
+  
+  columnFilterAutoClearSearch?: boolean
+
+  
+  columnFilterOptions?: Array<{ text: string; value: any }> | (() => Promise<Array<{ text: string; value: any }>>)
+
+  
+  columnFilterLoaded?: boolean
+
+  
+  headerTips?: string
+}
+
+export interface Emits {
+  
+  (e: 'update:filterVal', val: any[]): void
+
+  
+  (e: 'update:filterKeywords', val: string): void
+
+  
+  (e: 'filter-visible-change', val: boolean): void
+
+  
+  (e: 'filter-confirm', val: any[] | Record<'value' | 'custom', any>, btnType: 'confirm' | 'reset'): void
+
+  
+  (e: 'click-link', row: any, column: any, $index: number): void
+}

package/packages/components/table/src/type.d.ts

@@ -0,0 +1,324 @@
+import type { CellCls, ColumnCls, CellStyle, TableColumnInstance } from 'element-plus'
+import type { DasPaginationProps } from '@das-fed/upf-ui/packages/pagination'
+
+export type operationType = {
+  
+  
+  
+  
+  
+  label: string
+  
+  value: string | number
+  
+  tip?: string | ((row: any, column: any, index: number, item: any) => string)
+  
+  disabled?: boolean | ((row: any, column: any, index: number, item: any) => boolean)
+  
+  hide?: boolean | ((row: any, column: any, index: number, item: any) => boolean)
+  
+  children?: operationType[]
+  
+  lazyLoad?: (data: any, row: any) => operationType[]
+}
+
+
+export interface Props {
+  
+  rowKey?: string
+
+  
+  highlightKey?: string
+  
+  highlightRowId?: any[]
+
+  
+  data?: any[]
+
+  
+  loading?: boolean
+
+  
+  border?: boolean
+
+  
+  outerBorder?: boolean
+
+  
+  headerBorder?: boolean
+
+  
+  total?: number | string
+
+  
+  currentPage?: number | string
+
+  
+  pageSize?: number | string
+
+  
+  pageSizes?: number[]
+
+  
+  height?: string
+
+  
+  maxHeight?: string
+
+  
+  headerCellClassName?: CellCls
+
+  
+  headerCellStyle?: CellStyle
+
+  
+  cellStyle?: CellStyle
+
+  
+  rowClassName?: ColumnCls
+
+  
+  paginationProps?: DasPaginationProps
+
+  
+  radioSelection?:
+    | boolean
+    | {
+        
+        disabled?: boolean
+        
+        value?: string
+        
+        label?: string
+        
+        selectable?: (row?: any, index?: any) => boolean
+        
+        width?: string
+      }
+
+  
+  currentRodioSelection?: string | number
+
+  
+  getAllId?: (lastId?: string) => Promise<any[]>
+
+  
+  selection?:
+    | boolean
+    | {
+        
+        disabled?: boolean
+
+        
+        showSelectCount?: boolean
+
+        
+        value?: string
+
+        
+        label?: string
+
+        
+        text?: string
+
+        
+        toolip?: boolean
+
+        
+        showPageSelectBtn?: boolean
+
+        
+        allSelectable?: boolean
+
+        
+        selectable?: (row?: any, index?: any) => boolean
+      }
+
+  
+  selectionRows?: any[]
+
+  
+  selectionIds?: any[]
+
+  
+  isRowSetExpand?: boolean
+
+  
+  expandRowKeys?: any[]
+
+  
+  hideSelectionText?: boolean
+
+  
+  normalHeardText?: boolean
+
+  
+  isSetting?: boolean
+
+  
+  emptyText?: string
+
+  
+  emptyTitle?: string
+
+  
+  emptyImage?: string
+
+  
+  dragSort?:
+    | boolean
+    | {
+        
+        rowspan?: number
+      }
+
+  
+  simpleEmpty?: boolean
+
+  
+  showOperationColumn?: boolean
+  
+  operation?: operationType[] | ((row: any, column: any, index: number) => operationType[])
+  
+  operationOptions?: TableColumnInstance['$props'] & {
+    width: {
+      zh: string | number
+      en?: string | number
+    }
+    minWidth: {
+      zh: string | number
+      en?: string | number
+    }
+  }
+
+  
+  expandRight?: boolean
+
+  
+  scroll?:
+    | boolean
+    | {
+        
+        loadMore?: () => void
+        
+        disabled?: boolean
+        
+        distance?: number | string
+      }
+
+  
+  parentLinkChildren?: boolean
+
+  
+  delay?: number
+
+  
+  showCustomContent: boolean
+
+  
+  disabledIdsList?: Array
+  
+  highPerformance?: boolean
+
+  
+  sumText?: string
+
+  
+  virtual?: boolean
+}
+
+export interface Emits {
+  (e: 'update:loading', val: string | number): void
+
+  
+  (e: 'update:current-rodio-selection', val: string | number): void
+
+  
+  (e: 'update:current-page', currentPage: number | string): void
+
+  
+  (e: 'update:page-size', pageSize: number | string): void
+
+  
+  (e: 'update:selection-rows', selectionRows: any[]): void
+
+  (e: 'update:selection-ids', val: any[]): void
+
+  
+  (e: 'update:expand-row-keys', val: any[]): void
+
+  
+  (e: 'size-change', pageSize: number): void
+
+  
+  (e: 'current-page-change', currentPage: number): void
+
+  
+  (e: 'select', selection: any[], row: any): void
+
+  
+  (e: 'select-all', selection: any[]): void
+
+  
+  (e: 'selection-change', selection: any[]): void
+
+  
+  (e: 'toggleSelectAll', val: boolean, allIds: any[]): void
+
+  
+  (e: 'radio-change', val: string | number, row: any, index: number): void
+
+  
+  (e: 'table-setting'): void
+
+  
+  (e: 'sort-end', oldData: any[], newData: any[], oldIndex: number, newIndex: number): void
+
+  
+  (e: 'operation-click', value: any, row: any, column: any, index: number): void
+
+  
+  (e: 'expand-change', row: any, expandedRows: any[]): void
+
+  
+
+  (e: 'update:rightSelectList', val: any[]): void
+}
+
+export interface TableInjection {
+  showPagination?: any
+  currentPage?: any
+  pageSize?: any
+  expandRight?: boolean
+}
+
+export type Exposes = {
+  
+  $table
+
+  
+  tableScrollTop: () => void
+
+  
+  getCurrentParamsIds: (totalCount?: number) => Promise<boolean>
+}
+
+export interface Slots {
+  
+  default: {}
+
+  
+  'pagination-left': {}
+
+  
+  'pagination-left-btn_left': {}
+
+  
+  'pagination-left-btn_right': {}
+
+  
+  'pagination-right': {}
+
+  
+  empty: {}
+}

package/packages/components/table/src/v-loadmore.d.ts

@@ -0,0 +1,2 @@
+import type { Directive } from 'vue';
+export declare const vLoadmore: Directive<HTMLElement>;