@antdv/pro-utils/lib/useEditableArray/index.d.ts

@antdv/pro-utils

import type { FormInstance, FormProps } from 'ant-design-vue';
import type { NamePath } from 'ant-design-vue/lib/form/interface';
import type { GetRowKey } from 'ant-design-vue/lib/table/interface';
import type { FunctionalComponent, Ref } from 'vue';
import type { AnyObject, Key, VueNode } from '..';
export type RowEditableType = 'single' | 'multiple';
export type RecordKey = Key | Key[];
export declare function recordKeyToString(rowKey: RecordKey): Key;
export interface AddLineOptions {
    position?: 'top' | 'bottom';
    recordKey?: RecordKey;
    newRecordType?: 'dataSource' | 'cache';
    parentKey?: RecordKey;
}
export interface NewLineConfig<T> {
    defaultValue?: T;
    options: AddLineOptions;
}
export type ActionRenderFunction<T> = (row: T, config: ActionRenderConfig<T, NewLineConfig<T>>, defaultDoms: {
    save: VueNode;
    delete: VueNode;
    cancel: VueNode;
}) => VueNode[];
export interface RowEditableConfig<DataType> {
    formProps?: Omit<FormProps & {
        formRef?: Ref<FormInstance | undefined>;
        onInit?: (values: DataType, form: FormInstance) => void;
    }, 'onFinish'>;
    form?: FormInstance;
    type?: RowEditableType;
    editableKeys?: Key[];
    onChange?: (editableKeys: Key[], editableRows: DataType[] | DataType) => void;
    onValuesChange?: (record: DataType, dataSource: DataType[]) => void;
    actionRender?: ActionRenderFunction<DataType>;
    onSave?: (key: RecordKey, record: DataType & {
        index?: number;
    }, originRow: DataType & {
        index?: number;
    }, newLineConfig?: NewLineConfig<DataType>) => Promise<any | void>;
    onCancel?: (key: RecordKey, record: DataType & {
        index?: number;
    }, originRow: DataType & {
        index?: number;
    }, newLineConfig?: NewLineConfig<DataType>) => Promise<any | void>;
    onDelete?: (key: RecordKey, row: DataType & {
        index?: number;
    }) => Promise<any | void>;
    deletePopconfirmMessage?: string;
    onlyOneLineEditorAlertMessage?: false | string;
    onlyAddOneLineAlertMessage?: false | string;
    tableName?: NamePath;
    saveText?: string;
    cancelText?: string;
    deleteText?: string;
    getRealIndex?: (record: DataType) => number;
}
export interface ActionTypeText<T> {
    deleteText?: VueNode;
    cancelText?: VueNode;
    saveText?: VueNode;
    editorType?: 'Array' | 'Map';
    addEditRecord?: (row: T, options?: AddLineOptions) => boolean;
}
export type ActionRenderConfig<T, LineConfig = NewLineConfig<T>> = {
    editableKeys?: RowEditableConfig<T>['editableKeys'];
    recordKey: RecordKey;
    preEditRowRef: Ref<T | null>;
    index?: number;
    cancelEditable: (key: RecordKey) => void;
    onSave: RowEditableConfig<T>['onSave'];
    onCancel: RowEditableConfig<T>['onCancel'];
    onDelete?: RowEditableConfig<T>['onDelete'];
    deletePopconfirmMessage: RowEditableConfig<T>['deletePopconfirmMessage'];
    setEditableRowKeys: (value: Key[]) => void;
    newLineConfig?: LineConfig;
    tableName?: NamePath;
    children?: VueNode;
} & ActionTypeText<T>;
export declare function editableRowByKey<RecordType>(keyProps: {
    data: RecordType[];
    childrenColumnName: string;
    getRowKey: GetRowKey<RecordType>;
    key: RecordKey;
    row: RecordType;
}, action: 'update' | 'top' | 'delete'): RecordType[];
export interface SaveEditableActionRef<T = any> {
    save: () => ReturnType<NonNullable<RowEditableConfig<T>['onSave']>> | Promise<void>;
}
export declare const SaveEditableAction: import("vue").DefineSetupFnComponent<SaveEditableActionProps, {}, {}, SaveEditableActionProps & {}, import("vue").PublicProps>;
export interface SaveEditableActionProps extends ActionRenderConfig<any> {
    row: any;
    children?: any;
}
export declare const DeleteEditableAction: FunctionalComponent<ActionRenderConfig<any> & {
    row: any;
}>;
export declare function defaultActionRender<T>(row: T, config: ActionRenderConfig<T, NewLineConfig<T>>): {
    save: import("vue/jsx-runtime").JSX.Element;
    saveRef: Ref<SaveEditableActionRef<T> | undefined, SaveEditableActionRef<T> | undefined>;
    delete: import("vue/jsx-runtime").JSX.Element | undefined;
    cancel: import("vue/jsx-runtime").JSX.Element;
};
export declare function useEditableArray<RecordType extends AnyObject>(props: RowEditableConfig<RecordType> & {
    getRowKey: GetRowKey<RecordType>;
    dataSource: RecordType[];
    onValuesChange?: (record: RecordType, dataSource: RecordType[]) => void;
    childrenColumnName: string | undefined;
    setDataSource: (dataSource: RecordType[]) => void;
}): {
    editableKeys: import("vue").ComputedRef<Key[] | undefined>;
    setEditableRowKeys: (val: Key[] | undefined) => void;
    isEditable: (row: RecordType & {
        index: number;
    }) => {
        recordKey: string;
        isEditable: boolean | undefined;
        preIsEditable: boolean;
    };
    actionRender: (row: RecordType & {
        index: number;
    }) => void | VueNode[];
    startEditable: (recordKey: Key, record?: RecordType) => boolean;
    cancelEditable: (recordKey: RecordKey, needReTry?: boolean) => Promise<true | undefined>;
    addEditRecord: (row: RecordType, options?: AddLineOptions) => boolean;
    saveEditable: (recordKey: RecordKey, needReTry?: boolean) => Promise<boolean>;
    newLineRecord: Ref<{
        defaultValue?: import("vue").UnwrapRef<RecordType> | undefined;
        options: {
            position?: "top" | "bottom" | undefined;
            recordKey?: Key | Key[] | undefined;
            newRecordType?: "dataSource" | "cache" | undefined;
            parentKey?: Key | Key[] | undefined;
        };
    } | undefined, NewLineConfig<RecordType> | {
        defaultValue?: import("vue").UnwrapRef<RecordType> | undefined;
        options: {
            position?: "top" | "bottom" | undefined;
            recordKey?: Key | Key[] | undefined;
            newRecordType?: "dataSource" | "cache" | undefined;
            parentKey?: Key | Key[] | undefined;
        };
    } | undefined>;
    preEditableKeys: Readonly<Ref<Key[] | undefined, Key[] | undefined>>;
    onValuesChange: (value: RecordType, values: RecordType) => void;
    getRealIndex: ((record: RecordType) => number) | undefined;
};
export type UseEditableType = typeof useEditableArray;
export type UseEditableUtilType = ReturnType<UseEditableType>;