@oiij/naive-ui 0.0.50 → 0.0.51

package/dist/components/preset-input/index.d.ts

@@ -1,34 +1,144 @@
 import { ButtonProps, CheckboxGroupProps, CheckboxProps, ColorPickerProps, DatePickerProps, DividerProps, DynamicTagsProps, InputNumberProps, InputProps, RadioGroupProps, RadioProps, RateProps, SelectProps, SliderProps, SwitchProps, TimePickerProps } from 'naive-ui';
+import { VNode } from 'vue';
 import { ClassStyle } from '../data-table-plus';
 import { SearchInputProps } from '../search-input/index';
 export { default as NPresetInput } from './PresetInput.vue';
 export type PresetInputType = {
-    'button': ButtonProps & {
-        label?: string;
-    };
-    'color-picker': ColorPickerProps;
-    'checkbox': CheckboxGroupProps & {
-        options?: CheckboxProps[];
-    };
-    'divider': DividerProps;
-    'date-picker': DatePickerProps;
-    'dynamic-tags': DynamicTagsProps;
-    'input': InputProps;
-    'input-number': InputNumberProps;
-    'search': SearchInputProps;
-    'radio': RadioGroupProps & {
-        options?: RadioProps[];
-    };
-    'rate': RateProps;
-    'select': SelectProps;
-    'slider': SliderProps;
-    'switch': SwitchProps;
-    'time-picker': TimePickerProps;
+    'button': {
+        props?: ButtonProps & {
+            label?: string;
+        };
+        slots?: {
+            default?: () => VNode;
+            icon?: () => VNode;
+        };
+    };
+    'color-picker': {
+        props?: ColorPickerProps;
+        slots?: {
+            label?: (color: string | null) => VNode;
+            action?: () => VNode;
+        };
+    };
+    'checkbox': {
+        props?: CheckboxGroupProps & {
+            options?: CheckboxProps[];
+        };
+        slots?: {
+            default?: () => VNode;
+        };
+    };
+    'divider': {
+        props?: DividerProps;
+        slots?: {
+            default?: () => VNode;
+        };
+    };
+    'date-picker': {
+        props?: DatePickerProps;
+        slots?: undefined;
+    };
+    'dynamic-tags': {
+        props?: DynamicTagsProps;
+        slots?: {
+            input?: (info: {
+                submit: (value: any) => void;
+                deactivate: () => void;
+            }) => VNode;
+            trigger?: (info: {
+                activate: () => void;
+                disabled: boolean;
+            }) => VNode;
+        };
+    };
+    'input': {
+        props?: InputProps;
+        slots?: {
+            clearIcon?: () => VNode;
+            count?: (props: {
+                value: string;
+            }) => VNode;
+            passwordInvisibleIcon?: () => VNode;
+            passwordVisibleIcon?: () => VNode;
+            prefix?: () => VNode;
+            separator?: () => VNode;
+            suffix?: () => VNode;
+        };
+    };
+    'input-number': {
+        props?: InputNumberProps;
+        slots?: {
+            addIcon?: () => VNode;
+            minusIcon?: () => VNode;
+            prefix?: () => VNode;
+            suffix?: () => VNode;
+        };
+    };
+    'search': {
+        props?: SearchInputProps;
+        slots?: {
+            prefix?: () => VNode;
+            prefixIcon?: () => VNode;
+            button?: (props: {
+                value: string;
+                loading: boolean;
+            }) => VNode;
+            buttonIcon?: () => VNode;
+        };
+    };
+    'radio': {
+        props?: RadioGroupProps & {
+            options?: RadioProps[];
+        };
+        slots?: {
+            default?: () => VNode;
+        };
+    };
+    'rate': {
+        props?: RateProps;
+        slots?: {
+            default?: (info: {
+                index: number;
+            }) => VNode;
+        };
+    };
+    'select': {
+        props?: SelectProps;
+        slots?: {
+            header?: () => VNode;
+            action?: () => VNode;
+            empty?: () => VNode;
+            arrow?: () => VNode;
+        };
+    };
+    'slider': {
+        props?: SliderProps;
+        slots?: {
+            thumb?: () => VNode;
+        };
+    };
+    'switch': {
+        props?: SwitchProps;
+        slots?: {
+            checked?: () => VNode;
+            checkedIcon?: () => VNode;
+            icon?: () => VNode;
+            unchecked?: () => VNode;
+            uncheckedIcon?: () => VNode;
+        };
+    };
+    'time-picker': {
+        props?: TimePickerProps;
+        slots?: {
+            icon?: () => VNode;
+        };
+    };
 };
 export type PresetInputOptions = {
     [K in keyof PresetInputType]: {
         type?: K;
-        props?: PresetInputType[K] & ClassStyle;
+        props?: PresetInputType[K]['props'] & ClassStyle;
+        slots?: PresetInputType[K]['slots'];
     };
 }[keyof PresetInputType];
 export type PresetInputProps<V> = {

package/dist/components/preset-picker/PresetPicker.vue.d.ts

@@ -1,21 +1,19 @@
-import { RObject } from '../remote-request/index';
-import { PresetPickerEmits, PresetPickerExposeActions, PresetPickerExposeRefs, PresetPickerProps, PresetPickerValue } from './index';
-declare const _default: <V extends PresetPickerValue, R extends RObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+import { DataTableColumns } from 'naive-ui';
+import { DataObject } from '../../composables/index';
+import { PresetPickerEmits, PresetPickerExpose, PresetPickerProps, PresetPickerValue } from './index';
+declare const _default: <V extends PresetPickerValue, R extends DataObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onClose?: (() => any) | undefined;
         readonly "onUpdate:value"?: ((val: V | null, raw: R | R[] | null) => any) | undefined;
-        readonly onNegativeClick?: (() => any) | undefined;
-        readonly onPositiveClick?: (() => any) | undefined;
         readonly onAfterEnter?: (() => any) | undefined;
         readonly onAfterLeave?: (() => any) | undefined;
         readonly onEsc?: (() => any) | undefined;
         readonly onMaskClick?: (() => any) | undefined;
+        readonly onNegativeClick?: (() => any) | undefined;
+        readonly onPositiveClick?: (() => any) | undefined;
         readonly "onUpdate:show"?: ((value: boolean) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:value" | "onUpdate:show" | "onClose" | "onEsc" | "onAfterEnter" | "onAfterLeave" | "onPositiveClick" | "onNegativeClick" | "onMaskClick"> & PresetPickerProps<V, R> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        refs: PresetPickerExposeRefs<R>;
-        actions: PresetPickerExposeActions<R>;
-    }>): void;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:value" | "onUpdate:show" | "onAfterEnter" | "onAfterLeave" | "onClose" | "onEsc" | "onMaskClick" | "onNegativeClick" | "onPositiveClick"> & PresetPickerProps<V, R> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<PresetPickerExpose<R>>): void;
     attrs: any;
     slots: {
         'button-icon'?(_: {}): any;
@@ -23,8 +21,19 @@ declare const _default: <V extends PresetPickerValue, R extends RObject>(__VLS_p
         'clear-button'?(_: {}): any;
         'clear-icon'?(_: {}): any;
         default?(_: {
-            refs: PresetPickerExposeRefs<R>;
-            actions: PresetPickerExposeActions<R>;
+            showModalFlag: boolean;
+            checkedRowKeys: (string | number)[];
+            checkedRows: R[];
+            columns: DataTableColumns<any>;
+            showModal: () => void;
+            updateCheckedRowKeysEffect: (keys: (string | number)[], rows: (R | undefined)[], meta: {
+                row: R | undefined;
+                action: "check" | "uncheck" | "checkAll" | "uncheckAll";
+            }, currentData: R[]) => void;
+            clickRowEffect: (row: R) => void;
+            clearValue: () => void;
+            setCheckedRowKeys: (keys: (string | number)[]) => void;
+            setCheckedRows: (rows: R[]) => void;
         }): any;
         'modal-action'?(_: {}): any;
         'modal-header'?(_: {}): any;

package/dist/components/preset-picker/index.d.ts

@@ -1,17 +1,15 @@
 import { BadgeProps, ButtonProps, DataTableColumns, ModalProps } from 'naive-ui';
 import { TableSelectionColumn } from 'naive-ui/es/data-table/src/interface';
 import { Ref } from 'vue';
+import { DataObject } from '../../composables/index';
 import { ClassStyle } from '../data-table-plus';
-import { RObject } from '../remote-request/index';
 export { default as NPresetPicker } from './PresetPicker.vue';
 export type PresetPickerValue = string | number | (string | number)[] | null;
-export type PresetPickerExposeRefs<R extends RObject = RObject> = {
+export type PresetPickerExpose<R extends DataObject = DataObject> = {
     showModalFlag: Ref<boolean, boolean>;
     checkedRowKeys: Ref<(string | number)[], (string | number)[]>;
     checkedRows: Ref<R[], R[]>;
     columns: DataTableColumns<any>;
-};
-export type PresetPickerExposeActions<R extends RObject = RObject> = {
     showModal: () => void;
     updateCheckedRowKeysEffect: (keys: (string | number)[], rows: (R | undefined)[], meta: {
         row: R | undefined;
@@ -22,7 +20,7 @@ export type PresetPickerExposeActions<R extends RObject = RObject> = {
     setCheckedRowKeys: (keys: (string | number)[]) => void;
     setCheckedRows: (rows: R[]) => void;
 };
-export type PresetPickerProps<V extends PresetPickerValue, R extends RObject = RObject> = {
+export type PresetPickerProps<V extends PresetPickerValue, R extends DataObject = DataObject> = {
     value?: V;
     fallbackLabel?: string | ((val: string | number) => string);
     multiple?: boolean;
@@ -41,7 +39,7 @@ export type PresetPickerProps<V extends PresetPickerValue, R extends RObject = R
     badgeProps?: BadgeProps & ClassStyle;
     modalProps?: ModalProps & ClassStyle;
 };
-export type PresetPickerEmits<V extends PresetPickerValue, R extends RObject = RObject> = {
+export type PresetPickerEmits<V extends PresetPickerValue, R extends DataObject = DataObject> = {
     (e: 'update:value', val: V | null, raw: R | R[] | null): void;
     (e: 'afterEnter'): void;
     (e: 'afterLeave'): void;

package/dist/components/preset-select/PresetSelect.vue.d.ts

@@ -1,42 +1,175 @@
-import { SelectOption } from 'naive-ui';
-import { RObject } from '../remote-request/index';
-import { PresetSelectEmits, PresetSelectExposeActions, PresetSelectExposeRefs, PresetSelectProps, PresetSelectValue } from './index';
-declare const _default: <V extends PresetSelectValue, P extends RObject, D extends RObject, R extends RObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+import { SelectInst, SelectOption } from 'naive-ui';
+import { DataObject } from '../../composables/index';
+import { PresetSelectEmits, PresetSelectExpose, PresetSelectProps, PresetSelectValue } from './index';
+declare const _default: <V extends PresetSelectValue, P extends DataObject, D extends DataObject, R extends DataObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
         readonly onError?: ((err: Error, params: P[]) => any) | undefined;
+        readonly onSearch?: ((value: string) => any) | undefined;
+        readonly onClear?: (() => any) | undefined;
+        readonly onSuccess?: ((data: D, params: P[]) => any) | undefined;
+        readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
         readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
         readonly onScroll?: ((ev: Event) => any) | undefined;
-        readonly onSuccess?: ((data: D, params: P[]) => any) | undefined;
-        readonly "onUpdate:value"?: ((val: V | null, option: SelectOption | SelectOption[] | null, raw: R | R[] | null) => any) | undefined;
-        readonly onClear?: (() => any) | undefined;
-        readonly onSearch?: ((value: string) => any) | undefined;
         readonly onFinally?: ((params: P[], data?: D | undefined, err?: Error | undefined) => any) | undefined;
         readonly onBefore?: ((params: P[]) => any) | undefined;
+        readonly "onUpdate:value"?: ((val: V | null, option: SelectOption | SelectOption[] | null, raw: R | R[] | null) => any) | undefined;
         readonly "onUpdate:page"?: ((page: number) => any) | undefined;
         readonly "onUpdate:pageSize"?: ((pageSize: number) => any) | undefined;
         readonly onCreate?: ((label: string) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onClear" | "onUpdate:value" | "onError" | "onScroll" | "onCreate" | "onSearch" | "onSuccess" | "onFinally" | "onBefore" | "onUpdate:page" | "onUpdate:pageSize"> & PresetSelectProps<V, P, D, R> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        refs: PresetSelectExposeRefs<P, D, R>;
-        actions: PresetSelectExposeActions<P, D>;
-    }>): void;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onBefore" | "onSuccess" | "onError" | "onFinally" | "onFocus" | "onBlur" | "onClear" | "onUpdate:value" | "onScroll" | "onUpdate:page" | "onUpdate:pageSize" | "onCreate" | "onSearch"> & PresetSelectProps<V, P, D, R> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<PresetSelectExpose<P, D, R>>): void;
     attrs: any;
     slots: {
         header?(_: {
-            refs: PresetSelectExposeRefs<P, D, R>;
-            actions: PresetSelectExposeActions<P, D>;
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
+            selectRef: SelectInst | null;
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
         }): any;
         footer?(_: {
-            refs: PresetSelectExposeRefs<P, D, R>;
-            actions: PresetSelectExposeActions<P, D>;
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
+            selectRef: SelectInst | null;
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
         }): any;
         'footer-extra'?(_: {
-            refs: PresetSelectExposeRefs<P, D, R>;
-            actions: PresetSelectExposeActions<P, D>;
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
+            selectRef: SelectInst | null;
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
+        }): any;
+        empty?(_: {
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
+            selectRef: SelectInst | null;
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
+        }): any;
+        arrow?(_: {
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
+            selectRef: SelectInst | null;
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
         }): any;
-        empty?(_: {}): any;
-        arrow?(_: {}): any;
     };
     emit: PresetSelectEmits<V, P, D, R>;
 }>) => import('vue').VNode & {

package/dist/components/preset-select/index.d.ts

@@ -1,23 +1,23 @@
 import { PaginationProps, SelectGroupOption, SelectInst, SelectOption, SelectProps } from 'naive-ui';
 import { ShallowRef } from 'vue';
+import { DataObject, DataRequestFields, UseDataRequestReturns } from '../../composables/index';
 import { ClassStyle } from '../data-table-plus';
-import { DataTablePlusExposeActionsBase, DataTablePlusExposeRefsBase } from '../data-table-plus/index';
-import { RemoteRequestEmits, RemoteRequestProps, RObject } from '../remote-request/index';
+import { RemoteRequestEmits, RemoteRequestProps } from '../remote-request/index';
 export { default as NPresetSelect } from './PresetSelect.vue';
 export type ArrayAwareType<V, T> = V extends null ? null : (V extends any[] ? T[] : T) | null;
-export type OptionFormat<R extends RObject = RObject> = (row: R) => SelectOption | SelectGroupOption | false | undefined | null;
+export type OptionFormat<R extends DataObject = DataObject> = (row: R) => SelectOption | SelectGroupOption | false | undefined | null;
 export type PresetSelectValue = string | number | (string | number)[] | null;
-export type PresetSelectFields = Partial<Record<'page' | 'pageSize' | 'search' | 'list' | 'count' | 'rowKey' | 'label' | 'value' | 'children', string>>;
-export type PresetSelectPagination = {
-    page: number;
-    pageSize: number;
-    itemCount: number;
+export type PresetSelectFields = DataRequestFields & {
+    label?: string;
+    value?: string;
+    rowKey?: string;
+    search?: string;
+    children?: string;
 };
-export type PresetSelectExposeRefs<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = DataTablePlusExposeRefsBase<P, D, R> & {
+export type PresetSelectExpose<P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = UseDataRequestReturns<P, D, R> & {
     selectRef: Readonly<ShallowRef<SelectInst | null>>;
 };
-export type PresetSelectExposeActions<P extends RObject = RObject, D extends RObject = RObject> = DataTablePlusExposeActionsBase<P, D> & {};
-export type PresetSelectProps<V extends PresetSelectValue, P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = RemoteRequestProps<P, D> & {
+export type PresetSelectProps<V extends PresetSelectValue, P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = RemoteRequestProps<P, D> & {
     value?: V;
     fallbackLabel?: string | ((val: string | number) => SelectOption);
     multiple?: boolean;
@@ -29,7 +29,7 @@ export type PresetSelectProps<V extends PresetSelectValue, P extends RObject = R
     selectProps?: SelectProps & ClassStyle;
     pagination?: Omit<PaginationProps, 'page' | 'pageSize'> & ClassStyle | boolean;
 };
-export type PresetSelectEmits<V extends PresetSelectValue, P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = RemoteRequestEmits<P, D> & {
+export type PresetSelectEmits<V extends PresetSelectValue, P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = RemoteRequestEmits<P, D> & {
     (e: 'blur', ev: FocusEvent): void;
     (e: 'clear'): void;
     (e: 'create', label: string): SelectOption;

package/dist/components/remote-request/RemoteRequest.vue.d.ts

@@ -1,50 +1,43 @@
-import { RemoteRequestEmits, RemoteRequestProps, RObject } from './index';
-declare const _default: <P extends RObject, D extends RObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+import { DataObject } from '../../composables/index';
+import { RemoteRequestEmits, RemoteRequestExpose, RemoteRequestProps } from './index';
+declare const _default: <P extends DataObject, D extends DataObject, R extends DataObject>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onError?: ((err: Error, params: P[]) => any) | undefined;
         readonly onSuccess?: ((data: D, params: P[]) => any) | undefined;
         readonly onFinally?: ((params: P[], data?: D | undefined, err?: Error | undefined) => any) | undefined;
         readonly onBefore?: ((params: P[]) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onError" | "onSuccess" | "onFinally" | "onBefore"> & RemoteRequestProps<P, D> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        refs: {
-            loading: Readonly<import('vue').Ref<boolean, boolean>>;
-            data: Readonly<import('vue').Ref<D | undefined, D | undefined>>;
-            error: Readonly<import('vue').Ref<Error | undefined, Error | undefined>>;
-            params: Readonly<import('vue').Ref<[] | P[], [] | P[]>>;
-        };
-        actions: {
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onBefore" | "onSuccess" | "onError" | "onFinally"> & RemoteRequestProps<P, D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<RemoteRequestExpose<P, D, R>>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            loading: boolean;
+            data: D | undefined;
+            error: Error | undefined;
+            params: [] | P[];
+            list: R[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            } | {
+                page: number;
+                pageSize: number;
+                itemCount: number;
+            };
             run: (...params: P[]) => void;
             runAsync: (...params: P[]) => Promise<D>;
             refresh: () => void;
             refreshAsync: () => Promise<D>;
             cancel: () => void;
             mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
-            setParam: (_params: Partial<P>) => void;
-            runParam: (_params: Partial<P>) => void;
-            runParamAsync: (_params: Partial<P>) => Promise<D>;
-        };
-    }>): void;
-    attrs: any;
-    slots: {
-        default?(_: {
-            refs: {
-                loading: Readonly<import('vue').Ref<boolean, boolean>>;
-                data: Readonly<import('vue').Ref<D | undefined, D | undefined>>;
-                error: Readonly<import('vue').Ref<Error | undefined, Error | undefined>>;
-                params: Readonly<import('vue').Ref<[] | P[], [] | P[]>>;
-            };
-            actions: {
-                run: (...params: P[]) => void;
-                runAsync: (...params: P[]) => Promise<D>;
-                refresh: () => void;
-                refreshAsync: () => Promise<D>;
-                cancel: () => void;
-                mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
-                setParam: (_params: Partial<P>) => void;
-                runParam: (_params: Partial<P>) => void;
-                runParamAsync: (_params: Partial<P>) => Promise<D>;
-            };
+            setParams: (_params: Partial<P>) => void;
+            runParams: (_params: Partial<P>) => void;
+            runParamsAsync: (_params: Partial<P>) => Promise<D>;
+            onBefore: import('@vueuse/core').EventHookOn<[P[]]>;
+            onSuccess: import('@vueuse/core').EventHookOn<[D, P[]]>;
+            onError: import('@vueuse/core').EventHookOn<[Error, P[]]>;
+            onFinally: import('@vueuse/core').EventHookOn<[P[], D | undefined, Error | undefined]>;
         }): any;
     };
     emit: RemoteRequestEmits<P, D>;

package/dist/components/remote-request/index.d.ts

@@ -1,8 +1,9 @@
 import { UseRequestOptions, UseRequestPlugin } from 'vue-hooks-plus/es/useRequest/types';
+import { DataObject, DataRequestFields, UseDataRequestReturns } from '../../composables/index';
 export { default as NRemoteRequest } from './RemoteRequest.vue';
-export type RObject = Record<string, any>;
-export type RemoteRequestFields = Partial<Record<string, string>>;
-export type RemoteRequestProps<P extends RObject = RObject, D extends RObject = RObject> = {
+export type RemoteRequestFields = DataRequestFields & {};
+export type RemoteRequestExpose<P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = UseDataRequestReturns<P, D, R>;
+export type RemoteRequestProps<P extends DataObject = DataObject, D extends DataObject = DataObject> = {
     api: (...args: P[]) => Promise<D>;
     defaultParams?: Partial<P>;
     manual?: boolean;
@@ -10,7 +11,7 @@ export type RemoteRequestProps<P extends RObject = RObject, D extends RObject =
     requestOptions?: UseRequestOptions<D, P[]>;
     requestPlugins?: UseRequestPlugin<D, P[]>[];
 };
-export type RemoteRequestEmits<P extends RObject = RObject, D extends RObject = RObject> = {
+export type RemoteRequestEmits<P extends DataObject = DataObject, D extends DataObject = DataObject> = {
     (e: 'before', params: P[]): void;
     (e: 'success', data: D, params: P[]): void;
     (e: 'error', err: Error, params: P[]): void;