@vue-ui-kit/ant 1.8.6 → 1.9.0

package/dist/index.d.ts

@@ -21,4 +21,4 @@ export default _default;
 export * from './declarations/antProxy';
 export * from './packages/utils/core';
 export { setup, setUIKitConfig, getUIKitConfig, resetUIKitConfig, type UIKitConfig };
-export { PForm, PGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender, };
+export { PForm, PGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender };

package/dist/packages/components/PFormGroup.vue.d.ts

@@ -11,7 +11,7 @@ declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<t
         activeKey: import('vue').ComputedRef<number>;
         setActiveKey: (key: number) => void;
         validateAll: () => Promise<PromiseSettledResult<any>[]>;
-        validate: (__index: number) => Promise<void>;
+        validate: (__index: number, ignoreTabError?: boolean) => Promise<void>;
     }>): void;
     attrs: any;
     slots: ReturnType<() => {

package/dist/packages/components/PGroupBlock.vue.d.ts

@@ -1,7 +1,9 @@
 import { PBlockProps } from '../../declarations/antProxy';
 declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_Prettify<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{}>, never>, never> & PBlockProps<F>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        $form: import('vue').ComputedRef<Recordable<any> | undefined>;
+    }>): void;
     attrs: any;
     slots: ReturnType<() => {}>;
     emit: {};

package/dist/packages/store/renderStore.d.ts

@@ -6,18 +6,18 @@ export declare const addRender: (name: string, { renderItemContent, renderDefaul
 declare const _default: {
     renders: {
         $button: {
-            renderItemContent({ props, events }: RenderOptions, { data, field, }: RenderFormParams, defaultHandler: {
+            renderItemContent({ props, events }: RenderOptions, { data, field }: RenderFormParams, defaultHandler: {
                 [key: string]: (...args: any[]) => any;
             }): import("vue/jsx-runtime").JSX.Element;
-            renderDefault({ props, events }: RenderOptions, { row, field, }: RenderTableParams, defaultHandler: {
+            renderDefault({ props, events }: RenderOptions, { row, field }: RenderTableParams, defaultHandler: {
                 [key: string]: (...args: any[]) => any;
             }): import("vue/jsx-runtime").JSX.Element;
         };
         $buttons: {
-            renderItemContent({ props, children }: RenderOptions, { data, field, }: RenderFormParams, defaultHandler: {
+            renderItemContent({ props, children }: RenderOptions, { data, field }: RenderFormParams, defaultHandler: {
                 [key: string]: (...args: any[]) => any;
             }): import("vue/jsx-runtime").JSX.Element;
-            renderDefault({ props, children }: RenderOptions, { data, row, field, }: RenderTableParams, defaultHandler: {
+            renderDefault({ props, children }: RenderOptions, { data, row, field }: RenderTableParams, defaultHandler: {
                 [key: string]: (...args: any[]) => any;
             }): import("vue/jsx-runtime").JSX.Element;
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-ui-kit/ant",
-  "version": "1.8.6",
+  "version": "1.9.0",
   "description": "Vue3 UI Kit based on Ant Design",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/declarations/antProxy.ts

@@ -4,7 +4,6 @@ import { ColProps } from 'ant-design-vue/lib/grid/Col';
 import { FormProps } from 'ant-design-vue/lib/form/Form';
 import { TableColumnType, TableProps, TooltipProps } from 'ant-design-vue';
 import { ButtonType } from 'ant-design-vue/lib/button/buttonTypes';
-import { ComputedRef } from 'vue';
 
 export interface CellFuncArg<D = Recordable> {
   row: D;
@@ -54,8 +53,8 @@ export interface PFormItemProps<F = Recordable> {
   title?: string;
   span?: number;
   colon?: boolean;
-  labelCol?: ColProps
-  wrapperCol?: ColProps
+  labelCol?: ColProps;
+  wrapperCol?: ColProps;
   forceRequired?: boolean; // 在页面需要必填标示，但field不需要必填校验时使用
   align?: 'left' | 'right' | 'center';
   col?: ColProps;
@@ -67,9 +66,9 @@ export interface PFormItemProps<F = Recordable> {
     default?: (
       { data, field }: ItemFuncArg<F>,
       passTrigger?: (cusFields?: string | string[]) => void,
-      passDelayTrigger?: (cusFields?: string | string[], time?: number) => void
+      passDelayTrigger?: (cusFields?: string | string[], time?: number) => void,
     ) => any;
-    defaultValue?: any
+    defaultValue?: any;
   };
 }
 
@@ -151,7 +150,13 @@ export interface ToolbarButtonProps extends PButtonProps {
 
 export interface ToolbarConfig {
   buttons?: Array<ToolbarButtonProps>;
-  tools?: Array<{ code: string; icon: string; type?: ButtonType; disabled?: boolean; size?: 'small' | 'large' | 'middle' }>;
+  tools?: Array<{
+    code: string;
+    icon: string;
+    type?: ButtonType;
+    disabled?: boolean;
+    size?: 'small' | 'large' | 'middle';
+  }>;
   disabled?: boolean;
 }
 
@@ -167,11 +172,11 @@ export interface ResponsePathConfig<D = Recordable> {
     | ((res: Recordable) => string | { status: string; content: string; icon?: string });
 }
 
-declare type HandlerMulti = (ids: Array<string | number>) => any;
+export type HandlerMultiDel = (ids: Array<string | number>) => any;
 
 export interface AjaxConfig<F = Recordable> {
   query: (Q: { page?: IPage; form: Partial<F> }) => Promise<Recordable>;
-  multiDelete?: HandlerMulti;
+  multiDelete?: HandlerMultiDel;
 }
 
 export interface ProxyConfig<D = Recordable, F = Recordable> {
@@ -195,7 +200,7 @@ export type PGridProps<D = Recordable, F = Recordable> = {
   selectConfig?: SelectConfig<D>;
   rowKey?: string;
   manualFetch?: boolean;
-  align?: 'left' | 'right' | 'center'
+  align?: 'left' | 'right' | 'center';
   formConfig?: PFormProps<F>;
   columns?: ColumnProps<D>[];
   toolbarConfig?: ToolbarConfig;
@@ -303,7 +308,7 @@ export interface PFormBlockInstance {
   $form: Recordable;
 }
 
-export interface PFormGroupInstance<F = Recordable> {
+export interface PFormGroupInstance {
   activeKey: number;
   setActiveKey: (activeKey: number) => void;
   validateAll: () => Promise<void>;

package/src/index.ts

@@ -7,7 +7,6 @@ import PromisePicker from '@/components/PromisePicker.vue';
 import { addFormatter } from '@/utils/AFormatters';
 import { addRender } from '@/store/renderStore';
 import { setUIKitConfig, getUIKitConfig, resetUIKitConfig, UIKitConfig } from '@/utils/config';
-import * as utils from '@/utils/core';
 
 // 创建setup方法
 function setup(config?: Partial<UIKitConfig>) {
@@ -35,21 +34,7 @@ export * from '#/antProxy';
 export * from '@/utils/core';
 
 // 导出配置方法
-export { 
-  setup, 
-  setUIKitConfig, 
-  getUIKitConfig, 
-  resetUIKitConfig,
-  type UIKitConfig 
-};
+export { setup, setUIKitConfig, getUIKitConfig, resetUIKitConfig, type UIKitConfig };
 
 // 直接导出组件，使用户可以直接导入使用
-export {
-  PForm,
-  PGrid,
-  PFormGroup,
-  PGroupBlock,
-  PromisePicker,
-  addFormatter,
-  addRender,
-};
+export { PForm, PGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender };

package/src/packages/components/PFormGroup.vue

@@ -161,7 +161,7 @@
       return Promise.resolve(results)
     })
   },
-  validate: async (__index: number) => {
+  validate: async (__index: number, ignoreTabError?: boolean) => {
     const index = model.value.findIndex(f => f.__index === __index)
     try {
       await (fr.value
@@ -173,7 +173,7 @@
     }
     catch (e) {
       // 校验失败，加入error_indexes
-      if (!error_indexes.value.includes(__index)) {
+      if (!error_indexes.value.includes(__index) && !ignoreTabError) {
         error_indexes.value = [...error_indexes.value, __index]
       }
       return Promise.reject(e)

package/src/packages/components/PGroupBlock.vue

@@ -1,12 +1,17 @@
 <script lang="ts" setup name="PGroupBlock" generic="F = Recordable">
-  import { PBlockProps, PFormProps } from '#/antProxy';
-  import { computed, toRefs } from 'vue';
+  import { PBlockProps, PFormInstance, PFormProps } from '#/antProxy';
+  import { computed, ref, toRefs } from 'vue';
   import PForm from '@/components/PForm.vue';
 
   const props = defineProps<PBlockProps<F>>();
+  const formEl = ref<PFormInstance>()
   const { source } = toRefs(props);
+  const $form = computed(() => formEl.value?.$form)
   const formSetting = computed<PFormProps<Partial<F>>>(() => props.getFormSetting(source.value));
+  defineExpose({
+    $form,
+  })
 </script>
 <template>
-  <p-form v-bind="formSetting" :data="source!" />
+  <p-form ref="formEl" v-bind="formSetting" :data="source!" />
 </template>

package/src/packages/store/renderStore.tsx

@@ -23,7 +23,7 @@ import {
 } from 'ant-design-vue';
 import { set, isFunction, merge, omit } from 'xe-utils';
 import { ButtonProps } from 'ant-design-vue/lib/button';
-import { isBadValue, isGoodValue, noValue, valued } from '@/utils/is';
+import { isBadValue, isGoodValue, valued } from '@/utils/is';
 import TableInput from '@/renders/TableInput.vue';
 import Icon from '@/renders/Icon';
 import { computed } from 'vue';
@@ -223,184 +223,191 @@ const renders = {
   ...Object.fromEntries(Object.keys(componentsMap).map((name) => [name, renderBasic(name)])),
   // 简单按钮
   $button: {
-    renderItemContent({ props = {}, events = {} }: RenderOptions, {
-      data,
-      field,
-    }: RenderFormParams, defaultHandler: {
-      [key: string]: (...args: any[]) => any
-    }) {
+    renderItemContent(
+      { props = {}, events = {} }: RenderOptions,
+      { data, field }: RenderFormParams,
+      defaultHandler: {
+        [key: string]: (...args: any[]) => any;
+      },
+    ) {
       return (
         <Button
           {...omit(props, ['content'])}
           icon={props.icon ? <Icon icon={props.icon} /> : null}
           onClick={() => {
-            events.click?.({ data, field })
+            events.click?.({ data, field });
             if (props.htmlType === 'reset' && defaultHandler?.reset) {
               if (props.beforeClick && isFunction(props.beforeClick)) {
                 props.beforeClick({ data, field }).then((res: void | Recordable) => {
-                  defaultHandler.reset(res ? { data: res, field } : { data, field })
-                })
-              }
-              else {
-                defaultHandler.reset({ data, field })
+                  defaultHandler.reset(res ? { data: res, field } : { data, field });
+                });
+              } else {
+                defaultHandler.reset({ data, field });
               }
             }
           }}
         >
           {props.content}
-          {
-            props.suffix?.({ data, field }) ?? null
-          }
+          {props.suffix?.({ data, field }) ?? null}
         </Button>
-      )
+      );
     },
-    renderDefault({ props = {}, events = {} }: RenderOptions, {
-      row,
-      field,
-    }: RenderTableParams, defaultHandler: {
-      [key: string]: (...args: any[]) => any
-    }) {
+    renderDefault(
+      { props = {}, events = {} }: RenderOptions,
+      { row, field }: RenderTableParams,
+      defaultHandler: {
+        [key: string]: (...args: any[]) => any;
+      },
+    ) {
       return (
         <Button
           {...omit(props, ['content'])}
           icon={props.icon ? <Icon icon={props.icon} /> : null}
           onClick={() => {
-            events.click?.({ row, field })
+            events.click?.({ row, field });
             if (props.htmlType === 'reset' && defaultHandler?.reset) {
               if (props.beforeClick && isFunction(props.beforeClick)) {
-                defaultHandler?.setLoadings?.(true)
-                props.beforeClick({ row, field }).then((res: void | Recordable) => {
-                  defaultHandler.reset(res ? { row: res, field } : { row, field })
-                }).finally(() => {
-                  defaultHandler?.setLoadings?.(false)
-                })
-              }
-              else {
-                defaultHandler.reset({ row, field })
+                defaultHandler?.setLoadings?.(true);
+                props
+                  .beforeClick({ row, field })
+                  .then((res: void | Recordable) => {
+                    defaultHandler.reset(res ? { row: res, field } : { row, field });
+                  })
+                  .finally(() => {
+                    defaultHandler?.setLoadings?.(false);
+                  });
+              } else {
+                defaultHandler.reset({ row, field });
               }
             }
             if (props.htmlType === 'pick' && defaultHandler?.pick) {
               if (props.beforeClick && isFunction(props.beforeClick)) {
-                defaultHandler?.setLoadings?.(true)
-                props.beforeClick({ row, field }).then((res: void | Recordable) => {
-                  defaultHandler.pick(res ? { row: res, field } : { row, field })
-                }).finally(() => {
-                  defaultHandler?.setLoadings?.(false)
-                })
-              }
-              else {
-                defaultHandler.pick({ row, field })
+                defaultHandler?.setLoadings?.(true);
+                props
+                  .beforeClick({ row, field })
+                  .then((res: void | Recordable) => {
+                    defaultHandler.pick(res ? { row: res, field } : { row, field });
+                  })
+                  .finally(() => {
+                    defaultHandler?.setLoadings?.(false);
+                  });
+              } else {
+                defaultHandler.pick({ row, field });
               }
             }
           }}
         >
           {props.content}
         </Button>
-      )
+      );
     },
   },
   // 简单按钮组
   $buttons: {
-    renderItemContent({ props = {}, children = [] }: RenderOptions, {
-      data,
-      field,
-    }: RenderFormParams, defaultHandler: {
-      [key: string]: (...args: any[]) => any
-    }) {
+    renderItemContent(
+      { props = {}, children = [] }: RenderOptions,
+      { data, field }: RenderFormParams,
+      defaultHandler: {
+        [key: string]: (...args: any[]) => any;
+      },
+    ) {
       return (
         <span class="align-gap-box w-fit">
-          {
-            children.map((m) => {
-              return (
-                <Button
-                  {...omit(Object.assign({}, props, m.props), ['content'])}
-                  icon={m.props.icon ? <Icon icon={m.props.icon} /> : null}
-                  onClick={() => {
-                    m.events?.click?.({ data, field })
-                    if (m.props.htmlType === 'reset' && defaultHandler?.reset) {
-                      if (props.beforeClick && isFunction(props.beforeClick)) {
-                        props.beforeClick({ data, field }).then((res: void | Recordable) => {
-                          defaultHandler.reset(res ? { data: res, field } : { data, field })
-                        })
-                      }
-                      else {
-                        defaultHandler.reset({ data, field })
-                      }
+          {children.map((m) => {
+            return (
+              <Button
+                {...omit(Object.assign({}, props, m.props), ['content'])}
+                icon={m.props.icon ? <Icon icon={m.props.icon} /> : null}
+                onClick={() => {
+                  m.events?.click?.({ data, field });
+                  if (m.props.htmlType === 'reset' && defaultHandler?.reset) {
+                    if (props.beforeClick && isFunction(props.beforeClick)) {
+                      props.beforeClick({ data, field }).then((res: void | Recordable) => {
+                        defaultHandler.reset(res ? { data: res, field } : { data, field });
+                      });
+                    } else {
+                      defaultHandler.reset({ data, field });
                     }
-                    if (m.props.htmlType === 'pick' && defaultHandler?.pick) {
-                      if (props.beforeClick && isFunction(props.beforeClick)) {
-                        props.beforeClick({ data, field }).then((res: void | Recordable) => {
-                          defaultHandler.pick(res ? { data: res, field } : { data, field })
-                        })
-                      }
-                      else {
-                        defaultHandler.pick({ data, field })
-                      }
+                  }
+                  if (m.props.htmlType === 'pick' && defaultHandler?.pick) {
+                    if (props.beforeClick && isFunction(props.beforeClick)) {
+                      props.beforeClick({ data, field }).then((res: void | Recordable) => {
+                        defaultHandler.pick(res ? { data: res, field } : { data, field });
+                      });
+                    } else {
+                      defaultHandler.pick({ data, field });
                     }
-                  }}
-                >
-                  {m.props.content}
-                </Button>
-              )
-            })
-          }
+                  }
+                }}
+              >
+                {m.props.content}
+              </Button>
+            );
+          })}
         </span>
-      )
+      );
     },
-    renderDefault({ props = {}, children = [] }: RenderOptions, {
-      data,
-      row,
-      field,
-    }: RenderTableParams, defaultHandler: {
-      [key: string]: (...args: any[]) => any
-    }) {
+    renderDefault(
+      { props = {}, children = [] }: RenderOptions,
+      { data, row, field }: RenderTableParams,
+      defaultHandler: {
+        [key: string]: (...args: any[]) => any;
+      },
+    ) {
       return (
         <span class="align-gap-box w-fit">
-          {
-            children.filter(f => !f?.props?.hiddenIf?.({
-              data,
-              row,
-              field,
-            })).map(m => (
+          {children
+            .filter(
+              (f) =>
+                !f?.props?.hiddenIf?.({
+                  data,
+                  row,
+                  field,
+                }),
+            )
+            .map((m) => (
               <Button
                 {...omit(Object.assign({}, props, m.props), ['content', 'hiddenIf'])}
                 icon={m.props.icon ? <Icon icon={m.props.icon} /> : null}
                 onClick={() => {
-                  m.events?.click?.({ data, row, field })
+                  m.events?.click?.({ data, row, field });
                   if (m.props.htmlType === 'reset' && defaultHandler?.reset) {
                     if (props.beforeClick && isFunction(props.beforeClick)) {
-                      defaultHandler?.setLoadings?.(true)
-                      props.beforeClick({ row, field }).then((res: void | Recordable) => {
-                        defaultHandler.reset(res ? { row: res, field } : { row, field })
-                      }).finally(() => {
-                        defaultHandler?.setLoadings?.(false)
-                      })
-                    }
-                    else {
-                      defaultHandler.reset({ row, field })
+                      defaultHandler?.setLoadings?.(true);
+                      props
+                        .beforeClick({ row, field })
+                        .then((res: void | Recordable) => {
+                          defaultHandler.reset(res ? { row: res, field } : { row, field });
+                        })
+                        .finally(() => {
+                          defaultHandler?.setLoadings?.(false);
+                        });
+                    } else {
+                      defaultHandler.reset({ row, field });
                     }
                   }
                   if (m.props.htmlType === 'pick' && defaultHandler?.pick) {
                     if (props.beforeClick && isFunction(props.beforeClick)) {
-                      defaultHandler?.setLoadings?.(true)
-                      props.beforeClick({ row, field }).then((res: void | Recordable) => {
-                        defaultHandler.pick(res ? { row: res, field } : { row, field })
-                      }).finally(() => {
-                        defaultHandler?.setLoadings?.(false)
-                      })
-                    }
-                    else {
-                      defaultHandler.pick({ row, field })
+                      defaultHandler?.setLoadings?.(true);
+                      props
+                        .beforeClick({ row, field })
+                        .then((res: void | Recordable) => {
+                          defaultHandler.pick(res ? { row: res, field } : { row, field });
+                        })
+                        .finally(() => {
+                          defaultHandler?.setLoadings?.(false);
+                        });
+                    } else {
+                      defaultHandler.pick({ row, field });
                     }
                   }
                 }}
               >
                 {m.props.content}
               </Button>
-            ))
-          }
+            ))}
         </span>
-      )
+      );
     },
   },
   ButtonTree: {
@@ -622,7 +629,7 @@ export const addRender = (
   },
 ) => {
   if (renders.hasOwnProperty(name)) {
-    console.warn(`render ${name} already exists`);
+    console.warn(`render ${name} already exists, you are trying to override it`);
   }
   renders[name] = {
     renderItemContent,