@oiij/naive-ui 0.0.49 → 0.0.51

package/dist/components/data-table-plus/DataTablePlus.vue.d.ts

@@ -1,16 +1,17 @@
-import { DataTableBaseColumn, DataTableFilterState, DataTableSortState } from 'naive-ui';
-import { RObject } from '../remote-request/index';
-import { DataTablePlusEmits, DataTablePlusExposeActions, DataTablePlusExposeRefs, DataTablePlusProps } from './index';
-declare const _default: <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 { DataTableBaseColumn, DataTableFilterState, DataTableInst, DataTableSortState } from 'naive-ui';
+import { DataObject } from '../../composables/index';
+import { DataTablePlusEmits, DataTablePlusExpose, DataTablePlusProps } 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 onLoad?: ((row: R) => any) | undefined;
         readonly onScroll?: ((ev: Event) => 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;
         readonly onClickRow?: ((row: R, index: number, event: MouseEvent, currentData: R[]) => any) | undefined;
         readonly onContextMenuRow?: ((row: R, index: number, event: MouseEvent, currentData: R[]) => any) | undefined;
+        readonly onScrollBottom?: ((ev: Event) => any) | undefined;
         readonly "onUpdate:checkedRowKeys"?: ((keys: (string | number)[], rows: (R | undefined)[], meta: {
             row: R | undefined;
             action: "check" | "uncheck" | "checkAll" | "uncheckAll";
@@ -20,45 +21,234 @@ declare const _default: <P extends RObject, D extends RObject, R extends RObject
         readonly "onUpdate:sorter"?: ((options: DataTableSortState | DataTableSortState[] | null) => any) | undefined;
         readonly "onUpdate:page"?: ((page: number) => any) | undefined;
         readonly "onUpdate:pageSize"?: ((pageSize: number) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onLoad" | "onError" | "onScroll" | "onSuccess" | "onFinally" | "onBefore" | "onClickRow" | "onContextMenuRow" | "onUpdate:checkedRowKeys" | "onUpdate:expandedRowKeys" | "onUpdate:filters" | "onUpdate:sorter" | "onUpdate:page" | "onUpdate:pageSize"> & DataTablePlusProps<P, D, R> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        refs: DataTablePlusExposeRefs<P, D, R>;
-        actions: DataTablePlusExposeActions<P, D>;
-    }>): void;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onBefore" | "onSuccess" | "onError" | "onFinally" | "onLoad" | "onScroll" | "onClickRow" | "onContextMenuRow" | "onScrollBottom" | "onUpdate:checkedRowKeys" | "onUpdate:expandedRowKeys" | "onUpdate:filters" | "onUpdate:sorter" | "onUpdate:page" | "onUpdate:pageSize"> & DataTablePlusProps<P, D, R> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<DataTablePlusExpose<P, D, R>>): void;
     attrs: any;
     slots: {
         header?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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;
         title?(_: {}): any;
         'header-extra'?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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;
         filter?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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;
         loading?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<P, D>;
-        }): any;
-        'filter-modal'?(_: {
-            refs: DataTablePlusExposeRefs<P, D, R>;
-            actions: DataTablePlusExposeActions<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;
+            };
+            filters: DataTableFilterState | undefined;
+            sorters: Record<string, DataTableSortState> | undefined;
+            dataTableRef: DataTableInst | 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;
     };
     emit: DataTablePlusEmits<P, D, R>;

package/dist/components/data-table-plus/index.d.ts

@@ -1,85 +1,42 @@
-import { DataTableColumns, DataTableFilterState, DataTableInst, DataTableProps, DataTableSortState, DropdownOption, FlexProps, FormItemProps, GridItemProps, GridProps, ModalProps, PaginationProps } from 'naive-ui';
+import { DataTableColumns, DataTableFilterState, DataTableInst, DataTableProps, DataTableSortState, PaginationProps } from 'naive-ui';
 import { FilterState, TableBaseColumn } from 'naive-ui/es/data-table/src/interface';
-import { ComputedRef, CSSProperties, Ref, ShallowRef, VNode } from 'vue';
-import { useRequestResult } from 'vue-hooks-plus/es/useRequest/types';
-import { PresetInputOptions } from '../preset-input/index';
-import { RemoteRequestEmits, RemoteRequestProps, RObject } from '../remote-request/index';
+import { CSSProperties, Ref, ShallowRef } from 'vue';
+import { DataObject, DataRequestFields, UseDataRequestReturns } from '../../composables/index';
+import { RemoteRequestEmits, RemoteRequestProps } from '../remote-request/index';
 import { SearchInputProps } from '../search-input/index';
 export { default as NDataTablePlus } from './DataTablePlus.vue';
 export type ClassStyle = {
     class?: string;
     style?: CSSProperties | string;
 };
-export type DataTablePlusExposeActionsBase<P extends RObject = RObject, D extends RObject = RObject> = {
-    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>;
-};
-export type DataTablePlusExposeActions<P extends RObject = RObject, D extends RObject = RObject> = DataTablePlusExposeActionsBase<P, D> & {
-    onValueUpdate: (key: keyof P, val: any) => void;
-    showFilterModal: () => void;
-    resetParams: () => void;
-};
-export type DataTablePlusPagination = {
-    page: number;
-    pageSize: number;
-    itemCount: number;
-};
-export type DataTablePlusExposeRefsBase<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = Pick<useRequestResult<D, P[], false, false>, 'loading' | 'data' | 'error' | 'params'> & {
-    pagination: Readonly<Ref<DataTablePlusPagination, DataTablePlusPagination>>;
-    rawList: ComputedRef<R[]>;
-};
-export type DataTablePlusExposeRefs<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = DataTablePlusExposeRefsBase<P, D, R> & {
+export type DataTablePlusExpose<P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = UseDataRequestReturns<P, D, R> & {
     filters: Ref<DataTableFilterState | undefined>;
     sorters: Ref<Record<string, DataTableSortState> | undefined>;
     dataTableRef: Readonly<ShallowRef<DataTableInst | null>>;
 };
-export type DataTablePlusFilterOptionItem<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = PresetInputOptions & {
-    key?: keyof P;
-    label?: string | boolean | (FormItemProps & {
-        style?: CSSProperties;
-        class?: string;
-    });
-    collapsed?: boolean;
-    hidden?: boolean | ((refs: DataTablePlusExposeRefs<P, D, R>) => boolean);
-    gridSpan?: string | number;
-    gridItemProps?: GridItemProps;
-    render?: (refs: DataTablePlusExposeRefs<P, D, R>, actions: DataTablePlusExposeActions<P, D>) => VNode | null;
+export type DataTablePlusFields = DataRequestFields & {
+    filter?: string;
+    sorter?: string;
+    rowKey?: string;
+    search?: string;
+    children?: string;
 };
-export type DataTablePlusFilterOptions<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = DataTablePlusFilterOptionItem<P, D, R>[];
-export type DataTablePlusFields = Partial<Record<'page' | 'pageSize' | 'filter' | 'sorter' | 'list' | 'count' | 'rowKey' | 'search' | 'children', string>>;
-export type DataTablePlusProps<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = RemoteRequestProps<P, D> & {
+export type DataTablePlusProps<P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = RemoteRequestProps<P, D> & {
     title?: string;
     columns?: DataTableColumns<R>;
-    filterOptions?: DataTablePlusFilterOptions<P, D, R>;
-    filterGridProps?: GridProps & ClassStyle;
-    filterFlexProps?: FlexProps & ClassStyle;
-    filterLayout?: 'grid' | 'flex' | ['grid' | 'flex'];
-    filterCollapsedType?: 'collapsed' | 'modal';
-    filterModalTrigger?: 'manual' | 'auto';
-    filterLabel?: string;
-    filterClearLabel?: string;
-    filterModalProps?: ModalProps & ClassStyle;
-    contextMenuOptions?: DropdownOption[];
     fields?: DataTablePlusFields;
     search?: SearchInputProps & ClassStyle | boolean;
-    pagination?: Omit<PaginationProps, 'page' | 'pageSize'> & ClassStyle | boolean;
-    clearable?: boolean | 'main' | 'modal';
+    pagination?: Omit<PaginationProps, 'page' | 'pageSize' | 'itemCount'> & ClassStyle | boolean;
     columnsFilterOptions?: (filters: DataTableFilterState) => Record<string, any>;
     columnsSorterOptions?: (sorters: Record<string, DataTableSortState>) => Record<string, any>;
     dataTableProps?: DataTableProps & ClassStyle;
 };
-export type DataTablePlusEmits<P extends RObject = RObject, D extends RObject = RObject, R extends RObject = RObject> = RemoteRequestEmits<P, D> & {
+export type DataTablePlusEmits<P extends DataObject = DataObject, D extends DataObject = DataObject, R extends DataObject = DataObject> = RemoteRequestEmits<P, D> & {
     (e: 'clickRow', row: R, index: number, event: MouseEvent, currentData: R[]): void;
     (e: 'contextMenuRow', row: R, index: number, event: MouseEvent, currentData: R[]): void;
     (e: 'load', row: R): Promise<void>;
     (e: 'scroll', ev: Event): void;
+    (e: 'scrollBottom', ev: Event): void;
     (e: 'update:checkedRowKeys', keys: (string | number)[], rows: (R | undefined)[], meta: {
         row: R | undefined;
         action: 'check' | 'uncheck' | 'checkAll' | 'uncheckAll';

package/dist/components/preset-form/PresetForm.vue.d.ts

@@ -1,16 +1,22 @@
-import { RObject } from '../remote-request/index';
-import { PresetFormProps } from './index';
-declare const _default: <V 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 { PresetFormExpose, PresetFormProps } from './index';
+declare const _default: <V 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 onValidated?: ((val: V) => any) | undefined;
     } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onValidated"> & PresetFormProps<V> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        refs: {
-            formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
-            formValue: import('vue').Ref<V, V>;
-            formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
-        };
-        actions: {
+    expose(exposed: import('vue').ShallowUnwrapRef<PresetFormExpose<V>>): void;
+    attrs: any;
+    slots: {
+        header?(_: {
+            formRef: import('naive-ui').FormInst | undefined;
+            formValue: V;
+            formRules: Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>;
+            formProps: {
+                ref: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                model: import('vue').Reactive<V>;
+                rules: import('vue').Reactive<Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>>;
+            };
+            setValue: (_value: Partial<V>) => void;
             validate: () => Promise<{
                 warnings?: import('async-validator').ValidateError[][];
             }>;
@@ -19,64 +25,44 @@ declare const _default: <V extends RObject>(__VLS_props: NonNullable<Awaited<typ
             reset: () => void;
             clear: () => void;
             onValidated: import('@vueuse/core').EventHookOn<[V]>;
-            setValues: (value: Partial<V>) => void;
-        };
-    }>): void;
-    attrs: any;
-    slots: {
-        header?(_: {
-            refs: {
-                formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
-                formValue: import('vue').Ref<V, V>;
-                formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
-            };
-            actions: {
-                validate: () => Promise<{
-                    warnings?: import('async-validator').ValidateError[][];
-                }>;
-                resetValidation: () => void;
-                resetForm: () => void;
-                reset: () => void;
-                clear: () => void;
-                onValidated: import('@vueuse/core').EventHookOn<[V]>;
-                setValues: (value: Partial<V>) => void;
-            };
         }): any;
         default?(_: {
-            refs: {
-                formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
-                formValue: import('vue').Ref<V, V>;
-                formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
-            };
-            actions: {
-                validate: () => Promise<{
-                    warnings?: import('async-validator').ValidateError[][];
-                }>;
-                resetValidation: () => void;
-                resetForm: () => void;
-                reset: () => void;
-                clear: () => void;
-                onValidated: import('@vueuse/core').EventHookOn<[V]>;
-                setValues: (value: Partial<V>) => void;
+            formRef: import('naive-ui').FormInst | undefined;
+            formValue: V;
+            formRules: Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>;
+            formProps: {
+                ref: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                model: import('vue').Reactive<V>;
+                rules: import('vue').Reactive<Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>>;
             };
+            setValue: (_value: Partial<V>) => void;
+            validate: () => Promise<{
+                warnings?: import('async-validator').ValidateError[][];
+            }>;
+            resetValidation: () => void;
+            resetForm: () => void;
+            reset: () => void;
+            clear: () => void;
+            onValidated: import('@vueuse/core').EventHookOn<[V]>;
         }): any;
         footer?(_: {
-            refs: {
-                formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
-                formValue: import('vue').Ref<V, V>;
-                formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
-            };
-            actions: {
-                validate: () => Promise<{
-                    warnings?: import('async-validator').ValidateError[][];
-                }>;
-                resetValidation: () => void;
-                resetForm: () => void;
-                reset: () => void;
-                clear: () => void;
-                onValidated: import('@vueuse/core').EventHookOn<[V]>;
-                setValues: (value: Partial<V>) => void;
+            formRef: import('naive-ui').FormInst | undefined;
+            formValue: V;
+            formRules: Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>;
+            formProps: {
+                ref: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                model: import('vue').Reactive<V>;
+                rules: import('vue').Reactive<Partial<Record<keyof V, import('naive-ui').FormRules | import('naive-ui').FormItemRule | import('naive-ui').FormItemRule[]>>>;
             };
+            setValue: (_value: Partial<V>) => void;
+            validate: () => Promise<{
+                warnings?: import('async-validator').ValidateError[][];
+            }>;
+            resetValidation: () => void;
+            resetForm: () => void;
+            reset: () => void;
+            clear: () => void;
+            onValidated: import('@vueuse/core').EventHookOn<[V]>;
         }): any;
     };
     emit: (e: "validated", val: V) => void;

package/dist/components/preset-form/_utils.d.ts

@@ -1,2 +1,8 @@
-import { NaiveFormRules, PresetFormOptions } from '.';
-export declare function options2Rules<D extends Record<string, any>>(options?: PresetFormOptions<D>): NaiveFormRules<D> | undefined;
+import { FormItemRule } from 'naive-ui';
+import { DataObject } from '../../composables/index';
+export declare function mergeRule<D extends DataObject = DataObject>(option?: {
+    key?: keyof D;
+    label?: string | (() => string);
+    required?: boolean | (() => boolean);
+    rule?: FormItemRule | FormItemRule[];
+}): FormItemRule | FormItemRule[] | undefined;

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

@@ -1,33 +1,29 @@
-import { FlexProps, FormItemProps, FormItemRule, FormProps, FormRules, GridItemProps, GridProps } from 'naive-ui';
+import { FormItemGiProps, FormItemRule, FormProps, FormRules, GridProps } from 'naive-ui';
 import { VNode } from 'vue';
+import { DataObject } from '../../composables/index';
 import { NaiveFormClearRules, NaiveFormReturns, NaiveFormRules } from '../../composables/useNaiveForm';
 import { ClassStyle } from '../data-table-plus';
 import { PresetInputOptions } from '../preset-input/index';
 export type { NaiveFormRules } from '../../composables/useNaiveForm';
 export { default as NPresetForm } from './PresetForm.vue';
-export type PresetFormExposeRefs<V extends Record<string, any> = Record<string, any>> = Pick<NaiveFormReturns<V>, 'formValue' | 'formRef' | 'formRules'>;
-export type PresetFormExposeActions<V extends Record<string, any> = Record<string, any>> = Pick<NaiveFormReturns<V>, 'validate' | 'resetValidation' | 'resetForm' | 'reset' | 'clear' | 'onValidated'> & {
-    setValues: (value: Partial<V>) => void;
-};
-export type PresetFormOptionsItem<V extends Record<string, any> = Record<string, any>> = PresetInputOptions & {
+export type PresetFormExpose<V extends DataObject = DataObject> = NaiveFormReturns<V>;
+export type PresetFormOptionItem<V extends DataObject = DataObject> = PresetInputOptions & {
     key?: keyof V;
-    label?: string | boolean | FormItemProps & ClassStyle;
-    rules?: FormRules | FormItemRule | FormItemRule[];
-    required?: boolean;
-    collapsed?: boolean;
-    hidden?: boolean | ((refs: PresetFormExposeRefs<V>) => boolean);
-    gridSpan?: string | number;
-    gridItemProps?: GridItemProps & ClassStyle;
-    render?: (refs: PresetFormExposeRefs<V>, actions: PresetFormExposeActions<V>) => VNode | null;
+    label?: string | (() => string);
+    required?: boolean | (() => boolean);
+    collapsed?: boolean | (() => boolean);
+    span?: string | number | (() => string | number);
+    hidden?: boolean | (() => boolean);
+    rule?: FormRules | FormItemRule | FormItemRule[];
+    props?: FormItemGiProps & ClassStyle;
+    render?: (params: PresetFormExpose<V>) => VNode | null;
 };
-export type PresetFormOptions<V extends Record<string, any> = Record<string, any>> = PresetFormOptionsItem<V>[];
-export type PresetFormProps<V extends Record<string, any> = Record<string, any>> = {
+export type PresetFormOptions<V extends DataObject = DataObject> = PresetFormOptionItem<V>[];
+export type PresetFormProps<V extends DataObject = DataObject> = {
     options?: PresetFormOptions<V>;
     values?: V;
     rules?: NaiveFormRules<V>;
     clearRules?: NaiveFormClearRules;
     formProps?: FormProps & ClassStyle;
     gridProps?: GridProps & ClassStyle;
-    flexProps?: FlexProps & ClassStyle;
-    layout?: 'grid' | 'flex' | ['grid' | 'flex'];
 };