@vue-ui-kit/ant 1.8.6 → 1.8.7

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/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);