@vue-ui-kit/ant 1.8.5 → 1.8.7

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>) {
@@ -30,12 +29,12 @@ export default {
   setup,
 };
 
+// 导出所有类型
 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 };

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: {

package/src/packages/utils/treeHelper.ts

@@ -1,72 +1,62 @@
-interface TreeConfig {
-  children?: string;
-}
-
-type TreeDefaultHandler<T> = (
-  arent: null | ITreeAble<T>,
-  parent: ITreeAble<T>[],
-  treeData: (
-    item: T | ITreeAble<T>,
-    index?: number,
-    treeData?: ITreeAble<T>[],
-    paths?: string[],
-    parent?: null | ITreeAble<T>,
-    nodes?: Array<T | ITreeAble<T>>,
-  ) => any,
-  iterate: any,
-  context: string[],
-  path: Array<T | ITreeAble<T>>,
-  node: string,
-  parseChildren: TreeConfig,
-) => any;
-
-const helperCreateTreeFunc = <T extends Recordable>(handle: TreeDefaultHandler<T>) => {
-  return function (
-    treeData: ITreeAble<T>[],
-    iterate: (item: T | ITreeAble<T>) => any,
-    options?: TreeConfig,
-    context?: any,
-  ) {
-    const opts = options || {};
-    const optChildren = opts.children || 'children';
-    return handle(null, treeData, iterate, context, [], [], optChildren, opts);
-  };
-};
-const eachTreeItem = <T extends Recordable>(
-  parent: null | ITreeAble<T>,
-  treeData: ITreeAble<T>[],
-  iterate: (
-    item: T | ITreeAble<T>,
-    index?: number,
-    treeData?: ITreeAble<T>[],
-    paths?: string[],
-    parent?: null | ITreeAble<T>,
-    nodes?: Array<T | ITreeAble<T>>,
-  ) => any,
-  context: any,
-  path: string[],
-  node: Array<T | ITreeAble<T>>,
-  parseChildren: string,
-  opts: TreeConfig,
-) => {
-  let paths: string[], nodes: Array<T | ITreeAble<T>>;
-  treeData.forEach((item, index) => {
-    paths = path.concat(['' + index]);
-    nodes = node.concat([item]);
-    iterate.call(context, item, index, treeData, paths, parent, nodes);
-    if (item && parseChildren) {
-      paths.push(parseChildren);
-      eachTreeItem(
-        item,
-        item[parseChildren] || [],
-        iterate,
-        context,
-        paths,
-        nodes,
-        parseChildren,
-        opts,
-      );
-    }
-  });
-};
-export const eachTree = helperCreateTreeFunc(eachTreeItem);
+interface TreeConfig {
+  children?: string;
+}
+
+type TreeDefaultHandler<T> = (
+  arent: null | ITreeAble<T>,
+  parent: ITreeAble<T>[],
+  treeData: (
+    item: T | ITreeAble<T>,
+    index?: number,
+    treeData?: ITreeAble<T>[],
+    paths?: string[],
+    parent?: null | ITreeAble<T>,
+    nodes?: Array<T | ITreeAble<T>>,
+  ) => any,
+  iterate: any,
+  context: string[],
+  path: Array<T | ITreeAble<T>>,
+  node: string,
+  parseChildren: TreeConfig,
+) => any;
+
+const helperCreateTreeFunc = <T extends Recordable>(handle: TreeDefaultHandler<T>) => {
+  return function (
+    treeData: ITreeAble<T>[],
+    iterate: (item: T | ITreeAble<T>) => any,
+    options?: TreeConfig,
+    context?: any,
+  ) {
+    const opts = options || {};
+    const optChildren = opts.children || 'children';
+    return handle(null, treeData, iterate, context, [], [], optChildren, opts);
+  };
+};
+const eachTreeItem = <T extends Recordable>(
+  parent: null | ITreeAble<T>,
+  treeData: ITreeAble<T>[],
+  iterate: (
+    item: T | ITreeAble<T>,
+    index?: number,
+    treeData?: ITreeAble<T>[],
+    paths?: string[],
+    parent?: null | ITreeAble<T>,
+    nodes?: Array<T | ITreeAble<T>>,
+  ) => any,
+  context: any,
+  path: string[],
+  node: Array<T | ITreeAble<T>>,
+  parseChildren: string,
+) => {
+  let paths: string[], nodes: Array<T | ITreeAble<T>>;
+  treeData.forEach((item, index) => {
+    paths = path.concat(['' + index]);
+    nodes = node.concat([item]);
+    iterate.call(context, item, index, treeData, paths, parent, nodes);
+    if (item && parseChildren) {
+      paths.push(parseChildren);
+      eachTreeItem(item, item[parseChildren] || [], iterate, context, paths, nodes, parseChildren);
+    }
+  });
+};
+export const eachTree = helperCreateTreeFunc(eachTreeItem);