morningfast-plus 1.0.21 → 1.1.0

package/components/templates/table-page/src/instance.d.ts

@@ -0,0 +1,17 @@
+import { MpFormSchema } from '../../../form';
+import { MpTablePageModel } from './types';
+export interface TablePageInstance<Query extends MpTablePageModel = MpTablePageModel> {
+    reload: () => Promise<void>;
+    search: () => Promise<void>;
+    reset: (nextModel?: Query) => Promise<void>;
+    getSearchModel: () => Query;
+    setSearchModel: (model: Query) => void;
+    updateSearchModel: (patch: Partial<Query>) => void;
+    setSearchFormSchemas: (schemas: MpFormSchema[]) => void;
+    updateSearchFormSchemas: (schemas: Partial<MpFormSchema>[]) => void;
+    getSelectedRows: () => unknown[];
+    getSelectedRowKeys: () => string[];
+    openColumnSetting: () => void;
+    openExportSetting: () => void;
+    openImportSetting: () => void;
+}

package/components/templates/table-page/src/table-page.d.ts

@@ -0,0 +1,93 @@
+import { PropType } from 'vue';
+import { MpColumnSettingItem } from '../../../column-setting';
+import { MpExportSettingPayload } from '../../../export-setting';
+import { MpFormModel, MpFormSchema } from '../../../form';
+import { MpMainContainerDefaultTab } from '../../../main-container-default';
+import { MpSearchFormProps } from '../../../search-form';
+import { MpTableColumn } from '../../../table';
+import { MpTablePageApi, MpTablePageActionOption, MpTablePageColumnSettingConfig, MpTablePageExportConfig, MpTablePageImportConfig, MpTablePageImportRecord, MpTablePageImportSubmitPayload, MpTablePageModel, MpTablePagePaginationState } from './types';
+export declare const mpTablePageProps: {
+    readonly modelValue: {
+        readonly type: PropType<MpTablePageModel>;
+        readonly default: undefined;
+    };
+    readonly searchSchemas: {
+        readonly type: PropType<MpFormSchema[]>;
+        readonly default: () => never[];
+    };
+    readonly api: {
+        readonly type: PropType<MpTablePageApi>;
+        readonly default: undefined;
+    };
+    readonly tableData: {
+        readonly type: PropType<any[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: PropType<MpTableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly pagination: {
+        readonly type: PropType<Partial<MpTablePagePaginationState>>;
+        readonly default: undefined;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly rowKey: {
+        readonly type: PropType<string | ((row: any) => string)>;
+        readonly default: undefined;
+    };
+    readonly reserveSelection: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly actionOptions: {
+        readonly type: PropType<MpTablePageActionOption[]>;
+        readonly default: () => never[];
+    };
+    readonly columnSetting: {
+        readonly type: PropType<false | MpTablePageColumnSettingConfig>;
+        readonly default: undefined;
+    };
+    readonly exportSetting: {
+        readonly type: PropType<false | MpTablePageExportConfig>;
+        readonly default: undefined;
+    };
+    readonly importSetting: {
+        readonly type: PropType<false | MpTablePageImportConfig>;
+        readonly default: undefined;
+    };
+    readonly searchFormProps: {
+        readonly type: PropType<Partial<MpSearchFormProps>>;
+        readonly default: () => {};
+    };
+    readonly tabs: {
+        readonly type: PropType<MpMainContainerDefaultTab[]>;
+        readonly default: () => never[];
+    };
+    readonly activeTab: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+};
+export declare const mpTablePageEmits: {
+    'update:modelValue': (value: MpTablePageModel) => boolean;
+    'update:activeTab': (value: string) => boolean;
+    submit: (value: MpTablePageModel) => boolean;
+    reset: (value: MpTablePageModel) => boolean;
+    'selection-change': (selection: any[]) => boolean;
+    'column-setting-confirm': (items: MpColumnSettingItem[]) => boolean;
+    'column-setting-reset': () => boolean;
+    export: (payload: MpExportSettingPayload) => boolean;
+    'open-export-task-center': () => boolean;
+    'open-import-setting': () => boolean;
+    'update:importFormModel': (value: MpFormModel) => boolean;
+    import: (payload: MpTablePageImportSubmitPayload) => boolean;
+    'download-import-template': () => boolean;
+    'refresh-import-records': () => boolean;
+    'import-record-page-change': (page: number) => boolean;
+    'import-record-page-size-change': (pageSize: number) => boolean;
+    'download-import-error-file': (record: MpTablePageImportRecord) => boolean;
+};

package/components/templates/table-page/src/table-page.vue.d.ts

@@ -0,0 +1,211 @@
+import { MpColumnSettingItem } from '../../../column-setting';
+import { MpExportSettingPayload } from '../../../export-setting';
+import { MpFormSchema } from '../../../form';
+import { MpTablePageActionOption, MpTablePageColumnSettingConfig, MpTablePageModel } from './types';
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<MpTablePageModel>;
+        readonly default: undefined;
+    };
+    readonly searchSchemas: {
+        readonly type: import('vue').PropType<MpFormSchema[]>;
+        readonly default: () => never[];
+    };
+    readonly api: {
+        readonly type: import('vue').PropType<import('./types').MpTablePageApi>;
+        readonly default: undefined;
+    };
+    readonly tableData: {
+        readonly type: import('vue').PropType<any[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: import('vue').PropType<import('../../..').MpTableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly pagination: {
+        readonly type: import('vue').PropType<Partial<import('./types').MpTablePagePaginationState>>;
+        readonly default: undefined;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly rowKey: {
+        readonly type: import('vue').PropType<string | ((row: any) => string)>;
+        readonly default: undefined;
+    };
+    readonly reserveSelection: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly actionOptions: {
+        readonly type: import('vue').PropType<MpTablePageActionOption[]>;
+        readonly default: () => never[];
+    };
+    readonly columnSetting: {
+        readonly type: import('vue').PropType<false | MpTablePageColumnSettingConfig>;
+        readonly default: undefined;
+    };
+    readonly exportSetting: {
+        readonly type: import('vue').PropType<false | import('./types').MpTablePageExportConfig>;
+        readonly default: undefined;
+    };
+    readonly importSetting: {
+        readonly type: import('vue').PropType<false | import('./types').MpTablePageImportConfig>;
+        readonly default: undefined;
+    };
+    readonly searchFormProps: {
+        readonly type: import('vue').PropType<Partial<import('../../..').MpSearchFormProps>>;
+        readonly default: () => {};
+    };
+    readonly tabs: {
+        readonly type: import('vue').PropType<import('../../..').MpMainContainerDefaultTab[]>;
+        readonly default: () => never[];
+    };
+    readonly activeTab: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>, {
+    reload: () => Promise<void>;
+    search: () => Promise<void>;
+    reset: (nextModel?: MpTablePageModel | undefined) => Promise<void>;
+    getSearchModel: () => MpTablePageModel;
+    setSearchModel: (model: MpTablePageModel) => void;
+    updateSearchModel: (patch: Partial<MpTablePageModel>) => void;
+    setSearchFormSchemas: (schemas: MpFormSchema[]) => void;
+    updateSearchFormSchemas: (schemas: Partial<MpFormSchema>[]) => void;
+    getSelectedRows: () => unknown[];
+    getSelectedRowKeys: () => string[];
+    openColumnSetting: () => void;
+    openExportSetting: () => void;
+    openImportSetting: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: (value: MpTablePageModel) => void;
+    submit: (value: MpTablePageModel) => void;
+    "update:modelValue": (value: MpTablePageModel) => void;
+    "selection-change": (selection: any[]) => void;
+    "update:activeTab": (value: string) => void;
+    "column-setting-confirm": (items: MpColumnSettingItem[]) => void;
+    "column-setting-reset": () => void;
+    export: (payload: MpExportSettingPayload) => void;
+    "open-export-task-center": () => void;
+    "open-import-setting": () => void;
+    "update:importFormModel": (value: import('../../../form/src/field-renderer').MpFieldModel) => void;
+    import: (payload: import('./types').MpTablePageImportSubmitPayload) => void;
+    "download-import-template": () => void;
+    "refresh-import-records": () => void;
+    "import-record-page-change": (page: number) => void;
+    "import-record-page-size-change": (pageSize: number) => void;
+    "download-import-error-file": (record: import('./types').MpTablePageImportRecord) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<MpTablePageModel>;
+        readonly default: undefined;
+    };
+    readonly searchSchemas: {
+        readonly type: import('vue').PropType<MpFormSchema[]>;
+        readonly default: () => never[];
+    };
+    readonly api: {
+        readonly type: import('vue').PropType<import('./types').MpTablePageApi>;
+        readonly default: undefined;
+    };
+    readonly tableData: {
+        readonly type: import('vue').PropType<any[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: import('vue').PropType<import('../../..').MpTableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly pagination: {
+        readonly type: import('vue').PropType<Partial<import('./types').MpTablePagePaginationState>>;
+        readonly default: undefined;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly rowKey: {
+        readonly type: import('vue').PropType<string | ((row: any) => string)>;
+        readonly default: undefined;
+    };
+    readonly reserveSelection: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly actionOptions: {
+        readonly type: import('vue').PropType<MpTablePageActionOption[]>;
+        readonly default: () => never[];
+    };
+    readonly columnSetting: {
+        readonly type: import('vue').PropType<false | MpTablePageColumnSettingConfig>;
+        readonly default: undefined;
+    };
+    readonly exportSetting: {
+        readonly type: import('vue').PropType<false | import('./types').MpTablePageExportConfig>;
+        readonly default: undefined;
+    };
+    readonly importSetting: {
+        readonly type: import('vue').PropType<false | import('./types').MpTablePageImportConfig>;
+        readonly default: undefined;
+    };
+    readonly searchFormProps: {
+        readonly type: import('vue').PropType<Partial<import('../../..').MpSearchFormProps>>;
+        readonly default: () => {};
+    };
+    readonly tabs: {
+        readonly type: import('vue').PropType<import('../../..').MpMainContainerDefaultTab[]>;
+        readonly default: () => never[];
+    };
+    readonly activeTab: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>> & Readonly<{
+    onReset?: ((value: MpTablePageModel) => any) | undefined;
+    onSubmit?: ((value: MpTablePageModel) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: MpTablePageModel) => any) | undefined;
+    "onSelection-change"?: ((selection: any[]) => any) | undefined;
+    "onUpdate:activeTab"?: ((value: string) => any) | undefined;
+    "onColumn-setting-confirm"?: ((items: MpColumnSettingItem[]) => any) | undefined;
+    "onColumn-setting-reset"?: (() => any) | undefined;
+    onExport?: ((payload: MpExportSettingPayload) => any) | undefined;
+    "onOpen-export-task-center"?: (() => any) | undefined;
+    "onOpen-import-setting"?: (() => any) | undefined;
+    "onUpdate:importFormModel"?: ((value: import('../../../form/src/field-renderer').MpFieldModel) => any) | undefined;
+    onImport?: ((payload: import('./types').MpTablePageImportSubmitPayload) => any) | undefined;
+    "onDownload-import-template"?: (() => any) | undefined;
+    "onRefresh-import-records"?: (() => any) | undefined;
+    "onImport-record-page-change"?: ((page: number) => any) | undefined;
+    "onImport-record-page-size-change"?: ((pageSize: number) => any) | undefined;
+    "onDownload-import-error-file"?: ((record: import('./types').MpTablePageImportRecord) => any) | undefined;
+}>, {
+    readonly loading: boolean;
+    readonly modelValue: MpTablePageModel;
+    readonly columns: import('../../..').MpTableColumn<any>[];
+    readonly rowKey: string | ((row: any) => string);
+    readonly reserveSelection: boolean;
+    readonly pagination: Partial<import('./types').MpTablePagePaginationState>;
+    readonly tabs: import('../../..').MpMainContainerDefaultTab[];
+    readonly activeTab: string;
+    readonly searchSchemas: MpFormSchema[];
+    readonly api: import('./types').MpTablePageApi;
+    readonly tableData: any[];
+    readonly actionOptions: MpTablePageActionOption<any>[];
+    readonly columnSetting: false | MpTablePageColumnSettingConfig<any>;
+    readonly exportSetting: false | import('./types').MpTablePageExportConfig<any>;
+    readonly importSetting: false | import('./types').MpTablePageImportConfig;
+    readonly searchFormProps: Partial<import('../../..').MpSearchFormProps>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/templates/table-page/src/types.d.ts

@@ -0,0 +1,199 @@
+import { Component, ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+import { MpColumnSettingOptions } from '../../../column-setting';
+import { MpExportSettingItem, MpExportSettingPayload, MpExportSettingScope } from '../../../export-setting';
+import { MpFormModel, MpFormSchema } from '../../../form';
+import { MpMainContainerDefaultTab } from '../../../main-container-default';
+import { MpSearchFormProps } from '../../../search-form';
+import { MpTableColumn, MpTablePagination, MpTablePaginationChange } from '../../../table';
+export interface MpTablePagePaginationState {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface MpTablePageBackendPaginationState {
+    page: number;
+    page_size: number;
+    total?: number;
+}
+export type MpTablePageModel = MpFormModel & {
+    pagination?: MpTablePagePaginationState;
+};
+export type MpTablePageApiResult<Row = any> = Row[] | {
+    rows?: Row[];
+    list?: Row[];
+    data?: Row[];
+    total?: number;
+} | {
+    data?: {
+        list?: Row[];
+        rows?: Row[];
+        data?: Row[];
+        total?: number;
+        page?: number;
+        page_size?: number;
+        total_page?: number;
+    };
+    total?: number;
+};
+export interface MpTablePageRequest<Query extends MpTablePageModel = MpTablePageModel> {
+    page: number;
+    page_size: number;
+    filters: Query;
+    sort?: unknown;
+}
+export interface MpTablePageResult<Row = any> {
+    rows: Row[];
+    total: number;
+}
+export type MpTablePageApi<Row = any, Query extends MpTablePageModel = MpTablePageModel> = (params: Query & MpTablePageBackendPaginationState) => Promise<MpTablePageApiResult<Row>> | MpTablePageApiResult<Row>;
+export interface UseMpTablePageOptions<Row = any, Query extends MpTablePageModel = MpTablePageModel> {
+    api?: MpTablePageApi<Row, Query>;
+    model: Ref<Query>;
+    tableData?: MaybeRefOrGetter<Row[] | undefined>;
+    immediate?: boolean;
+    pagination?: MaybeRefOrGetter<Partial<MpTablePagePaginationState> | undefined>;
+    beforeFetch?: (params: Query & MpTablePageBackendPaginationState) => Promise<Partial<Query> | void> | Partial<Query> | void;
+    afterFetch?: (rows: Row[]) => Promise<Row[] | void> | Row[] | void;
+    rowKey?: keyof Row | string | ((row: Row) => string);
+    getRowKey?: (row: Row) => string;
+    emitSubmit?: (value: Query) => void;
+    emitReset?: (value: Query) => void;
+    emitSelectionChange?: (selection: Row[]) => void;
+}
+export interface UseMpTablePageReturn<Row = any, Query extends MpTablePageModel = MpTablePageModel> {
+    rows: Ref<Row[]>;
+    pagination: ComputedRef<MpTablePagePaginationState>;
+    tablePagination: ComputedRef<MpTablePagination>;
+    loading: Ref<boolean>;
+    selectedRows: Ref<Row[]>;
+    selectedRowKeys: ComputedRef<string[]>;
+    buildParams: () => Query & MpTablePageBackendPaginationState;
+    getSearchModel: () => Query;
+    setSearchModel: (model: Query) => void;
+    updateSearchModel: (patch: Partial<Query>) => void;
+    setRows: (rows: Row[]) => void;
+    setLoading: (value: boolean) => void;
+    load: () => Promise<void>;
+    search: () => Promise<void>;
+    reset: (nextModel?: Query) => Promise<void>;
+    changePage: (page: number) => Promise<void>;
+    changePageSize: (pageSize: number) => Promise<void>;
+    changePagination: (payload: MpTablePaginationChange) => Promise<void>;
+    changeSelection: (selection: Row[]) => void;
+    clearSelection: () => void;
+}
+export interface MpTablePageColumnSettingConfig<Row = any> extends MpColumnSettingOptions {
+    columns?: MaybeRefOrGetter<MpTableColumn<Row>[] | undefined>;
+}
+export interface MpTablePageActionOption<Row = any> {
+    key?: string;
+    label: string;
+    value?: unknown;
+    type?: 'primary' | 'success' | 'warning' | 'danger' | 'info' | '';
+    plain?: boolean;
+    link?: boolean;
+    icon?: Component;
+    disabled?: boolean | ((context: MpTablePageActionContext<Row>) => boolean);
+    visible?: boolean | ((context: MpTablePageActionContext<Row>) => boolean);
+    handle: (context: MpTablePageActionContext<Row>) => void | Promise<void>;
+}
+export interface MpTablePageActionContext<Row = any> {
+    value?: unknown;
+    selectedRows: Row[];
+    selectedRowKeys: string[];
+    reload: () => Promise<void>;
+    openColumnSetting: () => void;
+    openExportSetting: () => void;
+    openImportSetting: () => Promise<void> | void;
+}
+export interface MpTablePageExportConfig<Row = any> {
+    enabled?: boolean;
+    columns?: MaybeRefOrGetter<MpTableColumn<Row>[] | undefined>;
+    title?: string;
+    width?: string | number;
+    loading?: boolean;
+    querySummary?: string[];
+    selectedCount?: number;
+    defaultScope?: MpExportSettingScope;
+    taskCenterEnabled?: boolean;
+    request?: (context: {
+        payload: MpExportSettingPayload;
+        params: MpTablePageModel & MpTablePageBackendPaginationState;
+        selectedRows: Row[];
+        selectedRowKeys: string[];
+    }) => Promise<unknown> | unknown;
+    successMessage?: string | ((result: unknown) => string);
+}
+export interface MpTablePageImportRecord {
+    id: string | number;
+    fileName?: string;
+    status?: string;
+    createdAt?: string;
+    errorFileUrl?: string;
+    [key: string]: unknown;
+}
+export interface MpTablePageImportRecordPagination {
+    currentPage: number;
+    pageSize: number;
+    total: number;
+}
+export interface MpTablePageImportSubmitPayload {
+    file: File;
+    form: MpFormModel;
+}
+export interface MpTablePageImportConfig {
+    enabled?: boolean;
+    title?: string;
+    width?: string | number;
+    schemas?: MpFormSchema[];
+    formModel?: MpFormModel;
+    initialFormModel?: MpFormModel;
+    labelWidth?: string | number;
+    accept?: string;
+    maxSize?: number;
+    loading?: boolean;
+    records?: MpTablePageImportRecord[];
+    recordsPagination?: MpTablePageImportRecordPagination;
+    recordsLoading?: boolean;
+    templateEnabled?: boolean;
+    templateUrl?: string;
+    submitRequest?: (payload: {
+        file: File;
+        form: MpFormModel;
+    }) => Promise<unknown> | unknown;
+    loadRecords?: (pagination: {
+        page: number;
+        pageSize: number;
+    }) => Promise<{
+        records: MpTablePageImportRecord[];
+        total: number;
+    }> | {
+        records: MpTablePageImportRecord[];
+        total: number;
+    };
+    downloadTemplate?: () => Promise<void> | void;
+    downloadErrorFile?: (record: MpTablePageImportRecord) => Promise<void> | void;
+    successMessage?: string | ((result: unknown) => string);
+}
+export interface MpTablePageProps<Row = any> {
+    modelValue?: MpTablePageModel;
+    searchSchemas?: MpFormSchema[];
+    api?: MpTablePageApi<Row>;
+    tableData?: Row[];
+    columns?: MpTableColumn<Row>[];
+    pagination?: Partial<MpTablePagePaginationState>;
+    loading?: boolean;
+    rowKey?: string | ((row: Row) => string);
+    reserveSelection?: boolean;
+    actionOptions?: MpTablePageActionOption<Row>[];
+    columnSetting?: MpTablePageColumnSettingConfig<Row> | false;
+    exportSetting?: MpTablePageExportConfig<Row> | false;
+    importSetting?: MpTablePageImportConfig | false;
+    searchFormProps?: Partial<MpSearchFormProps>;
+    tabs?: MpMainContainerDefaultTab[];
+    activeTab?: string;
+}
+export interface MpTablePageExportPayload {
+    scope: MpExportSettingScope;
+    columns: MpExportSettingItem[];
+}

package/components/templates/table-page/src/use-table-page-summary.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+import { MpFormSchema } from '../../../form';
+import { MpTablePageModel } from './types';
+export declare function useMpTablePageSummary(options: {
+    schemas: ComputedRef<MpFormSchema[]>;
+    model: ComputedRef<MpTablePageModel>;
+}): ComputedRef<string[]>;

package/components/templates/table-page/src/use-table-page.d.ts

@@ -0,0 +1,2 @@
+import { MpTablePageModel, UseMpTablePageOptions, UseMpTablePageReturn } from './types';
+export declare function useMpTablePage<Row = any, Query extends MpTablePageModel = MpTablePageModel>(options: UseMpTablePageOptions<Row, Query>): UseMpTablePageReturn<Row, Query>;

package/components/upload/src/button.vue.d.ts

@@ -283,13 +283,13 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     drag: boolean;
     multiple: boolean;
+    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     showIcon: boolean;
+    action: string;
     beforeUpload: (rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>;
-    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onPreview: (uploadFile: import('element-plus').UploadFile) => void;
     onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
-    action: string;
     withCredentials: boolean;
     showFileList: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
     accept: string;

package/components/upload/src/list.vue.d.ts

@@ -283,13 +283,13 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     drag: boolean;
     multiple: boolean;
+    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     showIcon: boolean;
+    action: string;
     beforeUpload: (rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>;
-    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onPreview: (uploadFile: import('element-plus').UploadFile) => void;
     onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
-    action: string;
     withCredentials: boolean;
     showFileList: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
     accept: string;

package/components/upload/src/picture.vue.d.ts

@@ -283,13 +283,13 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     drag: boolean;
     multiple: boolean;
+    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     showIcon: boolean;
+    action: string;
     beforeUpload: (rawFile: import('element-plus').UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>;
-    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onPreview: (uploadFile: import('element-plus').UploadFile) => void;
     onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
-    action: string;
     withCredentials: boolean;
     showFileList: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
     accept: string;

package/components/upload/src/upload.vue.d.ts

@@ -376,13 +376,13 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     drag: boolean;
     multiple: boolean;
+    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     showIcon: boolean;
+    action: string;
     beforeUpload: (rawFile: UploadRawFile) => import('element-plus/es/utils/typescript.mjs').Awaitable<void | undefined | null | boolean | File | Blob>;
-    onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onPreview: (uploadFile: import('element-plus').UploadFile) => void;
     onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
     onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
-    action: string;
     withCredentials: boolean;
     showFileList: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
     accept: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "morningfast-plus",
-    "version": "1.0.21",
+    "version": "1.1.0",
     "type": "module",
     "description": "A library based on Vue 3 and Element Plus",
     "author": "jishu_app@morningfast.com",