dcp-design-react 1.7.42

package/lib/table/src/table/types.d.ts

@@ -0,0 +1,444 @@
+import React from 'react';
+import type { BuildInPlacements } from 'rc-trigger';
+import type { ComponentSize, CSSProperties, Nullable, IDict, IAuth, AjaxResponse } from '../../../_utils/types';
+import type { IFormData, IFormItem } from '../../../form/src/types';
+export type { ITableContext } from '../context';
+export type IFixed = 'left' | 'right';
+export type IAlign = 'left' | 'center' | 'right';
+export type InsertMode = 'before' | 'after';
+export type IFilterType = 'text' | 'textarea' | 'checkbox' | 'radio' | 'number' | 'date' | 'tree';
+export type ICheckStrategy = 'SHOW_ALL' | 'SHOW_PARENT' | 'SHOW_CHILD';
+export type IEditerType = 'text' | 'textarea' | 'number' | 'select' | 'select-multiple' | 'checkbox' | 'switch' | 'search-helper' | 'search-helper-multiple' | 'tree-helper' | 'tree-helper-multiple' | 'date' | 'datetime' | 'time';
+export type ISelectionType = 'checkbox' | 'radio';
+export type IRecord<T = any> = {
+    [key: string]: T;
+};
+export type getRowKeyType = (row: IRecord, index: number) => string | number;
+export type IRowKey = ReturnType<getRowKeyType>;
+export declare const DEFAULT_DISTANCE = 10;
+export declare const DEFAULT_TRUE_VALUE = "1";
+export declare const DEFAULT_FALSE_VALUE = "0";
+export declare const EMPTY_MIN_HEIGHT = 100;
+export declare const MIN_POPPER_WIDTH = 150;
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+export declare const DATE_TIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+export declare const TIME_FORMAT = "HH:mm:ss";
+export declare const DEFAULT_FILENAME_FORMAT = "YYYYMMDDHHmmss";
+export declare const BUILT_IN_PLACEMENTS: BuildInPlacements;
+export type IClicked = [IRowKey, string] | [];
+export type IRowColSpan = {
+    rowSpan: number;
+    colSpan: number;
+};
+export type IMergeCell = {
+    row: number;
+    col: number;
+    rowSpan: number;
+    colSpan: number;
+};
+export declare enum EAlign {
+    left = "flex-start",
+    right = "flex-end"
+}
+export type IFormatType = 'date' | 'datetime' | 'dateShortTime' | 'percent' | 'finance' | 'secret-name' | 'secret-phone' | 'secret-IDnumber' | 'secret-bankNumber';
+export type IPaginationConfig = {
+    current?: number;
+    pageSize?: number;
+    total?: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+};
+export type IPagination = Required<Pick<IPaginationConfig, 'current' | 'pageSize' | 'total'>>;
+export type IRule = {
+    required?: boolean;
+    message?: string;
+    validator?: (value: unknown) => boolean;
+};
+export type IFieldAuthItem = {
+    visible: number;
+    disabled?: number;
+    secretName?: string;
+};
+export type IValidItem = {
+    rowKey: IRowKey;
+    dataIndex: string;
+    text: string;
+};
+export type IFilter = {
+    [key: string]: Record<string, any>;
+};
+export type ISorter = {
+    [key: string]: Nullable<string>;
+};
+export type ISummaries = {
+    [key: string]: number;
+};
+export type ISuperFilter = {
+    type: string;
+    bracketLeft: string;
+    fieldName: string;
+    expression: string;
+    value: unknown;
+    bracketRight: string;
+    logic: string;
+};
+export type IEditerReturn = {
+    type: IEditerType;
+    items?: Array<IDict>;
+    editable?: boolean;
+    disabled?: boolean;
+    extra?: {
+        maxLength?: number;
+        showCount?: boolean;
+        max?: number;
+        min?: number;
+        stringMode?: boolean;
+        trueValue?: string | number;
+        falseValue?: string | number;
+        minDateTime?: string;
+        maxDateTime?: string;
+        format?: string;
+        prefix?: React.ReactNode;
+        suffix?: React.ReactNode;
+        placeholder?: string;
+        readOnly?: boolean;
+        disabled?: boolean;
+        filterable?: boolean;
+        allowClear?: boolean;
+        listHeight?: number;
+        collapseTags?: boolean;
+        maxTagTextLength?: number;
+        cornerSign?: boolean;
+        password?: boolean;
+        disabledColor?: string;
+        disabledBackgroundColor?: string;
+        autoSize?: {
+            minRows?: number;
+            maxRows?: number;
+        };
+    };
+    helper?: {
+        filters?: IFormItem[];
+        table?: {
+            fetch?: IFetch;
+            columns?: IColumn[];
+            rowKey?: ((row: IRecord, index: number) => IRowKey) | IRowKey;
+            webPagination?: boolean;
+        };
+        tree?: {
+            fetch?: IFetch & {
+                valueKey?: string;
+                textKey?: string;
+            };
+            asyncLoad?: boolean;
+            checkStrictly?: boolean;
+            checkStrategy?: ICheckStrategy;
+            defaultExpandAll?: boolean;
+        };
+        width?: number | string;
+        initialValue?: IFormData;
+        onlySelect?: boolean;
+        autoQueryAssign?: boolean;
+        closeRemoteMatch?: boolean;
+        combinedDataIndex?: string;
+        fieldAliasMap?: (() => Record<string, string>) | Record<string, string>;
+        filterAliasMap?: (() => string[]) | string[];
+        beforeOpen?: (value: Record<string, string | number>, row: IRecord, column: IColumn) => void | Promise<void> | boolean;
+        closed?: (rowData: Record<string, any>) => void;
+    };
+    rules?: IRule[];
+    onInput?: (value: Record<string, string | number>) => void;
+    onChange?: (value: Record<string, string | number | Array<string | number>>, record: IRecord, shRecords?: IRecord[]) => void;
+    onEnter?: (value: Record<string, string | number | Array<string | number>>, record: IRecord) => void;
+    onBlur?: (value: Record<string, string | number | Array<string | number>>, record: IRecord) => void;
+    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+};
+export type IFetchFn = (params?: Record<string, unknown>) => Promise<AjaxResponse>;
+export type IFetchParams = Record<string, any>;
+export type IFetch = {
+    api: IFetchFn;
+    params?: IFetchParams;
+    formatter?: (params: IFetchParams) => IFetchParams;
+    beforeFetch?: (params: IFetchParams) => boolean;
+    afterFetch?: (records: IRecord[]) => IRecord[];
+    stopToFirst?: boolean;
+    dataKey?: string;
+    callback?: (resData: AjaxResponse['data'], response?: AjaxResponse) => void;
+};
+export type IRowSelection = {
+    type: ISelectionType;
+    defaultSelectedRowKeys?: IRowKey[];
+    selectedRowKeys?: IRowKey[];
+    hideSelectAll?: boolean;
+    checkStrictly?: boolean;
+    filterable?: boolean;
+    selectByClickRow?: boolean;
+    selectFirstRowOnChange?: boolean;
+    clearableAfterFetched?: boolean;
+    selectAllOnCurrentPage?: boolean;
+    fetchSelectedRows?: {
+        api: IFetchFn;
+        params?: IFetchParams;
+        dataKey?: string;
+    };
+    fetchAllRowKeys?: {
+        api: IFetchFn;
+        params?: IFetchParams;
+        dataKey?: string;
+    };
+    disabled?: (row: IRecord) => boolean;
+    onChange?: (rowKeys: IRowKey[], selectedRows: IRecord[]) => void;
+    onSelect?: (selected: boolean, record: IRecord, rowKeys: IRowKey[]) => void;
+    onSelectAll?: (selected: boolean, rowKeys: IRowKey[]) => void;
+};
+export type IRowHighlight = {
+    currentRowKey?: IRowKey;
+    disabled?: (row: IRecord) => boolean;
+    onChange?: (rowKey: IRowKey, row: IRecord) => void;
+};
+export type ITreeConfig = {
+    virtual?: boolean;
+    expandIconColumn?: string;
+};
+export type IExpandable = {
+    defaultExpandAllRows?: boolean;
+    defaultExpandedRowKeys?: IRowKey[];
+    expandedRowKeys?: IRowKey[];
+    hideExpandAll?: boolean;
+    rowExpandable?: (row: IRecord) => boolean;
+    expandedRowClassName?: string;
+    expandedRowRender?: (row: IRecord, rowIndex: number) => React.ReactNode;
+    onExpand?: (expand: boolean, row: IRecord) => void;
+    onChange?: (expandedKeys: IRowKey[], expandedRows: IRecord[]) => void;
+};
+export type ISummation = {
+    groupItems?: Array<{
+        dataIndex: string;
+        titleIndex?: string;
+        color?: string;
+        backgroundColor?: string;
+    }>;
+    fetch?: {
+        api: IFetchFn;
+        params?: IFetchParams;
+        dataKey?: string;
+    };
+    onChange?: (summationRows: Record<string, number | string>[]) => void;
+};
+export type IExportExcel = {
+    fileName?: string;
+    fetch?: {
+        api: IFetchFn;
+        params?: IFetchParams;
+    };
+    beforeExport?: (records: IRecord[]) => IRecord[];
+    cellStyle?: boolean;
+    hideIcon?: boolean;
+};
+export type ITablePrint = {
+    showLogo?: boolean;
+};
+export type IAuthConfig = {
+    fetch?: {
+        api: IFetchFn;
+        params?: IFetchParams;
+        dataKey?: string;
+    };
+    fieldList?: IAuth[];
+    isExport?: number;
+    isImport?: number;
+    isPrint?: number;
+};
+export type IAlertConfig = {
+    position?: 'top' | 'bottom';
+    hideAlert?: boolean;
+    hideClearButton?: boolean;
+};
+export type IColumn = {
+    dataIndex: string;
+    title: string;
+    description?: string;
+    colSpan?: number;
+    rowSpan?: number;
+    width?: number;
+    minWidth?: number;
+    renderWidth?: number;
+    fixed?: IFixed;
+    align?: IAlign;
+    theadAlign?: IAlign;
+    printFixed?: boolean;
+    hidden?: boolean;
+    noAuth?: boolean;
+    noFixed?: boolean;
+    ellipsis?: boolean;
+    className?: string;
+    theadClassName?: string;
+    children?: Array<IColumn> | Nullable<undefined>;
+    sorter?: boolean | ((a: IRecord, b: IRecord) => boolean);
+    filter?: {
+        type: IFilterType;
+        items?: Array<IDict>;
+        style?: CSSProperties;
+    };
+    precision?: number;
+    displayPrecision?: number;
+    formatType?: IFormatType;
+    required?: boolean;
+    canCopy?: boolean;
+    editRender?: (row: IRecord, column: IColumn) => IEditerReturn;
+    dictItems?: Array<IDict>;
+    summation?: {
+        sumBySelection?: boolean;
+        displayWhenNotSelect?: boolean;
+        dataKey?: string;
+        unit?: string;
+        render?: (tableData: IRecord[]) => React.ReactNode;
+    };
+    groupSummary?: {
+        dataKey?: string;
+        unit?: string;
+        render?: () => React.ReactNode;
+    };
+    headRender?: (column: IColumn, tableData: IRecord[]) => React.ReactNode;
+    render?: (text: string | number, row: IRecord, column: IColumn, rowIndex: number, columnIndex: number) => React.ReactNode | string | number;
+};
+export type IDerivedColumn = IColumn & {
+    type?: string;
+    level?: number;
+    parentDataIndex?: string;
+};
+export type IDerivedRowKey = {
+    level: number;
+    rowKey: IRowKey;
+    rowKeyPath: string;
+    indexPath: string;
+    parentRowKey?: IRowKey;
+    children?: IDerivedRowKey[];
+};
+export type ITableProps = {
+    columns: IColumn[];
+    columnsChange?: (columns: IColumn[]) => void;
+    dataSource?: IRecord[];
+    rowKey: ((row: IRecord, index: number) => IRowKey) | IRowKey;
+    size?: ComponentSize;
+    height?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    border?: boolean;
+    stripe?: boolean;
+    fetch?: IFetch;
+    loading?: boolean;
+    resizable?: boolean;
+    uniqueKey?: string;
+    customClass?: string;
+    showHeader?: boolean;
+    ellipsis?: boolean;
+    nativeScrollBar?: boolean;
+    rowStyle?: CSSProperties | ((row: IRecord, rowIndex: number) => CSSProperties);
+    cellStyle?: CSSProperties | ((row: IRecord, column: IColumn, rowIndex: number, columnIndex: number) => CSSProperties);
+    mergeCells?: IMergeCell[];
+    spanMethod?: (options: {
+        row: IRecord;
+        column: IColumn;
+        rowIndex: number;
+        columnIndex: number;
+        tableData: IRecord[];
+    }) => IRowColSpan | [number, number];
+    dragMergeCell?: boolean;
+    rowDraggable?: boolean;
+    initialSorter?: ISorter;
+    initialFilter?: IFilter;
+    rowSelection?: IRowSelection;
+    rowHighlight?: IRowHighlight;
+    treeConfig?: ITreeConfig;
+    expandable?: IExpandable;
+    summation?: ISummation;
+    footRender?: (flattenColumns: IColumn[], tableData: IRecord[]) => React.ReactNode;
+    multipleSort?: boolean;
+    ignorePageIndex?: boolean;
+    scrollPagination?: boolean;
+    webPagination?: boolean;
+    paginationConfig?: IPaginationConfig;
+    topSpaceAlign?: IAlign;
+    exportExcel?: IExportExcel;
+    tablePrint?: ITablePrint;
+    authConfig?: IAuthConfig;
+    infoBarConfig?: IAlertConfig;
+    /** @deprecated use `infoBarConfig` instead, and it will be deprecated in the next major version */
+    showAlert?: boolean;
+    /** @deprecated use `infoBarConfig` instead, and it will be deprecated in the next major version */
+    alertPosition?: 'top' | 'bottom';
+    beforeClipboard?: (records: string[][], columnKeys: string[]) => string[][] | Promise<string[][]>;
+    beforeTableImport?: (records: IRecord[]) => IRecord[] | Promise<IRecord[]>;
+    showFullScreen?: boolean;
+    showRefresh?: boolean;
+    showTableImport?: boolean;
+    showClipboard?: boolean;
+    showSelectCollection?: boolean;
+    showSuperSearch?: boolean;
+    showFastSearch?: boolean;
+    showGroupSummary?: boolean;
+    showToolBox?: boolean;
+    showColumnDefine?: boolean;
+    showTableInfo?: boolean;
+    children?: React.ReactNode;
+    onlyShowIcon?: boolean;
+    onChange?: (pagination: IPagination, filters: IFilter, sorter: ISorter, superFilters: ISuperFilter[], extra: {
+        currentDataSource: IRecord[];
+    }) => void;
+    onDataChange?: (tableData: IRecord[]) => void;
+    onDataLoad?: (tableData: IRecord[]) => void;
+    onRowClick?: (row: IRecord, column: IColumn, event: React.MouseEvent<HTMLTableCellElement>) => void;
+    onRowDblclick?: (row: IRecord, column: IColumn, event: React.MouseEvent<HTMLTableCellElement>) => void;
+    onRowContextmenu?: (row: IRecord, column: IColumn, event: React.MouseEvent<HTMLTableCellElement>) => void;
+    onRowEnter?: (row: IRecord, event: KeyboardEvent) => void;
+    onScrollEnd?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFetchError?: (error: any) => void;
+    onMergeChange?: (cells: IMergeCell[]) => void;
+};
+export type TableRef = {
+    CALCULATE_HEIGHT: () => void;
+    DO_REFRESH: (cb: () => void) => Promise<void>;
+    GET_LOG: () => {
+        required: IValidItem[];
+        validate: IValidItem[];
+        inserted: IRecord[];
+        updated: IRecord[];
+        removed: IRecord[];
+    };
+    GET_FETCH_PARAMS: () => IFetchParams;
+    CLEAR_TABLE_DATA: () => void;
+    CLEAR_LOG: () => void;
+    CREATE_FOCUS: (rowKey: IRowKey, dataIndex: string) => void;
+    FORCE_UPDATE: () => void;
+    DO_EXPORT: () => void;
+    SCROLL_TO_RECORD: (rowKey: IRowKey) => void;
+    SCROLL_TO_COLUMN: (dataIndex: string) => void;
+    SET_SELECTION: (rowKeys: IRowKey[], isHandleChange?: boolean) => void;
+    SET_SELECTION_ROWS: (records: IRecord[]) => void;
+    SET_TABLE_DATA: (records: IRecord[]) => void;
+    SET_TABLE_COLUMN: (dataIndex: string, option: Record<string, any>, forceUpdate?: boolean) => void;
+    DEFINE_INITIAL_COLUMNS: (columns: IColumn[]) => void;
+    INSERT_RECORDS: <T extends IRecord>(records: T | T[], option?: {
+        mode?: InsertMode;
+        parentRowKey?: IRowKey;
+    }) => void;
+    REMOVE_RECORDS: <T extends IRecord | IRowKey>(records: T | T[]) => void;
+    VALIDATE_FIELDS: (rowKeys?: IRowKey[], dataIndexes?: string[]) => {
+        required: IValidItem[];
+        validate: IValidItem[];
+    };
+};
+export type TableBodyRef = {
+    renderCellTitle: (column: IColumn, row: IRecord, rowIndex: number, columnIndex: number) => string;
+    setClickedValues: (clicked: IClicked) => void;
+    createFocus: (rowKey: IRowKey, dataIndex: string) => void;
+    forceUpdate: () => void;
+};
+export type ToolBoxRef = {
+    exportHandle: () => void;
+};
+export type ToolMethodRef = {
+    clickHandle: () => void;
+};

package/lib/table/src/toolbox/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { IColumn, ToolBoxRef } from '../table/types';
+type IToolBoxProps = {
+    tableColumns: IColumn[];
+    showFullScreen?: boolean;
+    showReload?: boolean;
+    showPrint?: boolean;
+    showImport?: boolean;
+    showExport?: boolean;
+    showClipboard?: boolean;
+    showCollection?: boolean;
+    showFastSearch?: boolean;
+    showSuperSearch?: boolean;
+    showGroupSummary?: boolean;
+    showToolBox?: boolean;
+};
+declare const ToolBox: React.ForwardRefExoticComponent<IToolBoxProps & React.RefAttributes<ToolBoxRef>>;
+export default ToolBox;

package/lib/table/src/utils/index.d.ts

@@ -0,0 +1,43 @@
+import dayjs, { Dayjs } from 'dayjs';
+import { hasOwn } from '../../../_utils/util';
+import type { IColumn, IDerivedRowKey, IRecord, IRowKey, ISorter } from '../table/types';
+import type { Nullable, AnyObject, JSXElement } from '../../../_utils/types';
+export { hasOwn };
+export declare const columnsFlatMap: (columns: IColumn[]) => IColumn[];
+export declare const createFilterColumns: (columns: IColumn[]) => IColumn[];
+export declare const getAllColumns: (columns: IColumn[]) => IColumn[];
+export declare const mapTableColumns: (columns: IColumn[], callback?: ((column: IColumn) => void) | undefined) => IColumn[];
+export declare const deepFindColumn: (columns: IColumn[], mark: string) => Nullable<IColumn>;
+export declare const findFirstColumn: (column: IColumn) => IColumn;
+export declare const findLastColumn: (column: IColumn) => IColumn;
+export declare const filterTableColumns: (columns: IColumn[], marks: string[]) => IColumn[];
+export declare const deepFindRowKey: (rowKeys: IDerivedRowKey[], mark: IRowKey) => Nullable<IDerivedRowKey>;
+export declare const tableDataFlatMap: (list: IRecord[]) => IRecord[];
+export declare const getAllTableData: (list: IRecord[]) => IRecord[];
+export declare const convertToRows: (columns: IColumn[]) => IColumn[][];
+export declare const getNodeOffset: (el: Nullable<HTMLElement>, container: HTMLElement, rest?: {
+    left: number;
+    top: number;
+}) => any;
+export declare const parseHeight: (height: number | string) => Nullable<number | string>;
+export declare const difference: <T extends AnyObject<any>>(obj: T, base: T) => T;
+export declare const isArrayContain: (targetArr: unknown[], arr: unknown[]) => boolean;
+export declare const getCellValue: (record: IRecord, dataIndex: string) => any;
+export declare const setCellValue: (record: IRecord, dataIndex: string, val: unknown, precision?: number) => void;
+export declare const getSplitValue: (record: IRecord, key: string) => string;
+export declare const setSplitValue: (record: IRecord, key: string, val: string, precision?: number) => void;
+export declare const formatNumber: (value: string | number) => string;
+export declare const validateNumber: (val: string) => boolean;
+export declare const stringToNumber: (input: string) => number | '';
+export declare const getDate: (dateString: string | undefined, format: string) => dayjs.Dayjs | null;
+export declare const formatDate: (date: Dayjs | null, format: string) => string;
+export declare const createUidKey: (prefix?: string) => string;
+export declare const getVNodeText: <T extends string | number>(val: JSXElement | T) => T[];
+export declare const getGroupValidData: (list: IRecord[]) => IRecord<any>[];
+export declare const createOrderBy: (sorter: ISorter) => string;
+export declare const createWhereSQL: (filters: any, showType?: boolean) => string;
+export declare const groupByProps: (array?: IRecord[], props?: string[]) => any[][];
+export declare const deepGetRowkey: (arr: any[], value: IRowKey) => IRowKey[] | undefined;
+export declare const deepFindRecord: (arr: IRecord[], fn: (node: IRecord) => boolean) => Nullable<IRecord>;
+export declare const deepTreeFilter: (tree: any[], fn: (node: unknown) => boolean) => any[];
+export declare const flatToTree: (list: any[], id: string, pid: string) => any[];

package/lib/table/style/alert.less

@@ -0,0 +1,34 @@
+/*
+ * @Author: 焦质晔
+ * @Date: 2020-03-18 10:26:46
+ * @Last Modified by: 焦质晔
+ * @Last Modified time: 2021-12-28 21:55:44
+ */
+@prefix-table: ~'@{qm-prefix}-table';
+
+.@{prefix-table}__alert {
+  display: flex;
+  align-items: center;
+  position: relative;
+  margin-right: @v-module-distance;
+  padding: 0 6px 0 30px;
+  border: 1px solid @v-table-border-color;
+  border-radius: @v-border-radius;
+  background-color: @v-table-header-background-color;
+  .box-sizing-content();
+  .icon {
+    position: absolute;
+    left: @v-module-distance;
+    line-height: 1;
+    font-size: 1.05em;
+    color: @v-primary-color;
+  }
+  em {
+    display: inline-block;
+    color: @v-primary-color;
+    padding: 0 @v-module-distance;
+    margin-right: -5px;
+    font-style: normal;
+    cursor: pointer;
+  }
+}

package/lib/table/style/body.less

@@ -0,0 +1,77 @@
+/*
+ * @Author: 焦质晔
+ * @Date: 2020-02-28 22:13:54
+ * @Last Modified by: 焦质晔
+ * @Last Modified time: 2023-10-15 12:47:18
+ */
+.body--column {
+  .cell--edit {
+    margin: 0 -1 * (@v-module-distance - 1px);
+    // placeholder
+    input::placeholder {
+      text-align: left;
+    }
+    // search
+    .ant-input-search {
+      width: calc(100% + 1px);
+      & > .ant-input-group > .ant-input-group-addon {
+        line-height: 1;
+      }
+    }
+    // search-helper-multiple
+    .search-helper-multiple {
+      .ant-input-group > .ant-select:first-child {
+        z-index: 1;
+        .ant-select-selector {
+          border-top-right-radius: 0;
+          border-bottom-right-radius: 0;
+        }
+      }
+      .ant-select-multiple {
+        .ant-select-selection-overflow-item-rest {
+          pointer-events: none;
+        }
+      }
+    }
+    // textArea
+    textarea[class='ant-input'] {
+      resize: none;
+    }
+    &.is-error {
+      position: relative;
+      .ant-input,
+      .ant-input-affix-wrapper {
+        border-color: @v-danger-color;
+        box-shadow: none;
+        z-index: 1;
+      }
+      .ant-input-search {
+        & + .cell-error {
+          right: 38px;
+        }
+      }
+      .cell-error {
+        position: absolute;
+        top: calc(50% - 9px);
+        font-size: @v-font-size-small;
+        color: @v-danger-color;
+        right: 8px;
+        pointer-events: none;
+        z-index: 1;
+      }
+    }
+  }
+  &.col--center {
+    .cell--edit .ant-input {
+      text-align: center;
+    }
+  }
+  &.col--right {
+    .cell--edit .ant-input {
+      text-align: right;
+    }
+  }
+  &.selected {
+    background-color: @v-table-row-selected-background-color !important;
+  }
+}

package/lib/table/style/clipboard.less

@@ -0,0 +1,29 @@
+/*
+ * @Author: 焦质晔
+ * @Date: 2020-03-26 11:26:46
+ * @Last Modified by: 焦质晔
+ * @Last Modified time: 2022-05-17 14:16:51
+ */
+@prefix-table: ~'@{qm-prefix}-table';
+
+.@{prefix-table}-clipboard {
+  display: inline-block;
+  padding: 5px 3px;
+  line-height: 1;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  .icon {
+    font-size: 1.05em;
+  }
+  &:hover {
+    color: @v-primary-color;
+  }
+  &__setting {
+    .info {
+      padding-left: 20px;
+      margin-bottom: 6px;
+      font-size: @v-font-size-small;
+      color: @v-font-secondary-dark-color;
+    }
+  }
+}