@dt-frames/ui 2.0.23 → 3.0.1

package/es/components/vxe_table/index.js

@@ -0,0 +1,1162 @@
+import { VXETable, Edit, Form, Table, Grid, Tooltip, Filter } from "vxe-table";
+import { h, ref, unref, watch, onUnmounted, computed, defineComponent, useAttrs, useSlots, openBlock, createElementBlock, createElementVNode, createBlock, withCtx, renderSlot, createCommentVNode, createVNode, mergeProps, createSlots, renderList, normalizeProps, guardReactiveProps } from "vue";
+import { isNullOrUnDef, deepMerge, useI18n, isProd, useAppStore } from "@dt-frames/core";
+import XEUtils from "xe-utils";
+import dayjs from "dayjs";
+import { Button as Button$1, Input as Input$1, InputNumber as InputNumber$1, AutoComplete as AutoComplete$1, Select as Select$1, TreeSelect as TreeSelect$1, Switch as Switch$1, Checkbox as Checkbox$1, Radio, Cascader as Cascader$1, Rate as Rate$1, DatePicker as DatePicker$1, TimePicker as TimePicker$1, Empty as Empty$1, SelectOptGroup, SelectOption } from "ant-design-vue";
+import tableProps from "vxe-table/es/table/src/props";
+import { Icon } from "../icons";
+import { DtTableHeader } from "../table";
+import { useThemeStore } from "../../theme/index";
+const componentMap = /* @__PURE__ */ new Map();
+componentMap.set("Button", Button$1);
+componentMap.set("Input", Input$1);
+componentMap.set("InputSearch", Input$1.Search);
+componentMap.set("InputNumber", InputNumber$1);
+componentMap.set("AutoComplete", AutoComplete$1);
+componentMap.set("Select", Select$1);
+componentMap.set("TreeSelect", TreeSelect$1);
+componentMap.set("Switch", Switch$1);
+componentMap.set("Checkbox", Checkbox$1);
+componentMap.set("RadioGroup", Radio.Group);
+componentMap.set("CheckboxGroup", Checkbox$1.Group);
+componentMap.set("Cascader", Cascader$1);
+componentMap.set("Rate", Rate$1);
+componentMap.set("DatePicker", DatePicker$1);
+componentMap.set("MonthPicker", DatePicker$1.MonthPicker);
+componentMap.set("RangePicker", DatePicker$1.RangePicker);
+componentMap.set("WeekPicker", DatePicker$1.WeekPicker);
+componentMap.set("YearPicker", DatePicker$1.YearPicker);
+componentMap.set("TimePicker", TimePicker$1);
+componentMap.set("Empty", Empty$1);
+function createPlaceholderMessage(component) {
+  const { t } = useI18n("UI");
+  if (!component)
+    return;
+  if (component.includes("RangePicker")) {
+    return [t("PLEASE_SELECT"), t("PLEASE_SELECT")];
+  }
+  if (component.includes("Input") || component.includes("Complete") || component.includes("Rate")) {
+    return t("PLEASE_INPUT");
+  } else {
+    return t("PLEASE_SELECT");
+  }
+}
+function mergeConf(conf, ...arg) {
+  let result = { ...conf };
+  arg.map((it) => {
+    let obj = {};
+    for (let key in it) {
+      if (!isNullOrUnDef(it[key])) {
+        obj[key] = it[key];
+      }
+    }
+    result = deepMerge(result, obj);
+  });
+  return result;
+}
+function getComponent(componentName) {
+  const Component = componentMap.get(componentName);
+  if (!Component) {
+    throw `\u60A8\u8FD8\u6CA1\u6709\u6CE8\u518C\u6B64\u7EC4\u4EF6 ${Component}`;
+  }
+  return Component;
+}
+function isEmptyValue(cellValue) {
+  return cellValue === null || cellValue === void 0 || cellValue === "";
+}
+function formatText(cellValue) {
+  return `${isNullOrUnDef(cellValue) ? "" : cellValue}`;
+}
+function cellText(cellValue) {
+  return [formatText(cellValue)];
+}
+function getOnName(type) {
+  return "on" + type.substring(0, 1).toLocaleUpperCase() + type.substring(1);
+}
+function getModelKey(renderOpts) {
+  let prop = "value";
+  switch (renderOpts.name) {
+    case "Switch":
+      prop = "checked";
+      break;
+  }
+  return prop;
+}
+function getModelEvent(renderOpts) {
+  let type = "update:value";
+  switch (renderOpts.name) {
+    case "Switch":
+      type = "update:checked";
+      break;
+  }
+  return type;
+}
+function createEvents(renderOpts, params, inputFunc, changeFunc, clickFunc) {
+  const { events } = renderOpts;
+  const modelEvent = getModelEvent(renderOpts);
+  const changeEvent = "change", clickEvent = "click", isSameEvent = changeEvent === modelEvent;
+  const ons = {};
+  XEUtils.objectEach(events, (func, key) => {
+    ons[getOnName(key)] = (...args) => {
+      func(params, ...args);
+    };
+  });
+  if (inputFunc) {
+    ons[getOnName(modelEvent)] = (targetEvnt) => {
+      inputFunc(targetEvnt);
+      if (events && events[modelEvent]) {
+        events[modelEvent](params, targetEvnt);
+      }
+      if (isSameEvent && changeFunc) {
+        changeFunc(targetEvnt);
+      }
+    };
+  }
+  if (!isSameEvent && changeFunc) {
+    ons[getOnName(changeEvent)] = (...args) => {
+      changeFunc(...args);
+      if (events && events[changeEvent]) {
+        events[changeEvent](params, ...args);
+      }
+    };
+  }
+  if (clickFunc) {
+    ons[getOnName(clickEvent)] = (...args) => {
+      clickFunc(...args);
+      if (events && events[clickEvent]) {
+        events[clickEvent](params, ...args);
+      }
+    };
+  }
+  return ons;
+}
+function createProps(renderOpts, value, defaultProps) {
+  const name = renderOpts.name;
+  return XEUtils.assign(
+    {
+      placeholder: createPlaceholderMessage(name),
+      allowClear: true
+    },
+    defaultProps,
+    renderOpts.props,
+    {
+      [getModelKey(renderOpts)]: value
+    }
+  );
+}
+function createDefaultRender$1(defaultProps, callBack) {
+  return (renderOpts, params) => {
+    const { row, column, $table } = params;
+    const { name, attrs } = renderOpts;
+    const cellValue = XEUtils.get(row, column.field);
+    const args = (callBack && callBack(renderOpts, params)) ?? {};
+    const Component = getComponent(name);
+    return [
+      h(Component, {
+        ...attrs,
+        ...createProps(renderOpts, cellValue, defaultProps),
+        ...args,
+        ...createEvents(
+          renderOpts,
+          params,
+          (value) => {
+            XEUtils.set(row, column.field, value);
+          },
+          () => $table.updateStatus(params)
+        )
+      })
+    ];
+  };
+}
+function createEditRender$2(defaultProps, callBack) {
+  return (renderOpts, params) => {
+    const { row, column, $table } = params;
+    const { name, attrs } = renderOpts;
+    let cellValue = XEUtils.get(row, column.field);
+    const args = (callBack && callBack(renderOpts, params)) ?? {};
+    const Component = getComponent(name);
+    const cls = () => {
+      if (!["Switch"].includes(name)) {
+        return "w-full";
+      }
+    };
+    if (cellValue && ["DatePicker"].includes(name) && !dayjs.isDayjs(cellValue)) {
+      cellValue = dayjs(cellValue);
+    }
+    return [
+      h(Component, {
+        class: cls(),
+        ...attrs,
+        ...createProps(renderOpts, cellValue, defaultProps),
+        ...args,
+        ...createEvents(
+          renderOpts,
+          params,
+          (value) => XEUtils.set(row, column.field, value),
+          () => $table.updateStatus(params)
+        ),
+        onMousedown: (e) => {
+          e.stopPropagation();
+          e.preventDefault();
+        }
+      })
+    ];
+  };
+}
+function createFilterRender$2(defaultProps, callBack) {
+  return (renderOpts, params) => {
+    const { column } = params;
+    const { name, attrs } = renderOpts;
+    const args = (callBack && callBack(renderOpts, params)) ?? {};
+    const Component = getComponent(name);
+    return [
+      h(
+        "div",
+        {
+          class: "vxe-table--filter-antd-wrapper"
+        },
+        column.filters.map((option, oIndex) => {
+          const optionValue = option.data;
+          const checked = !!option.data;
+          return h(Component, {
+            key: oIndex,
+            ...attrs,
+            ...createProps(renderOpts, optionValue, defaultProps),
+            ...args,
+            ...createEvents(
+              renderOpts,
+              params,
+              (value) => {
+                option.data = value;
+              },
+              () => {
+                const { $panel } = params;
+                $panel.changeOption(null, checked, option);
+              }
+            )
+          });
+        })
+      )
+    ];
+  };
+}
+function createDefaultFilterRender() {
+  return (params) => {
+    const { option, row, column } = params;
+    const { data } = option;
+    const cellValue = XEUtils.get(row, column.field);
+    return cellValue === data;
+  };
+}
+function createFormItemRender$1(defaultProps, callBack) {
+  return (renderOpts, params) => {
+    const args = (callBack && callBack(renderOpts, params)) ?? {};
+    const { data, property, $form } = params;
+    const { name } = renderOpts;
+    const { attrs } = renderOpts;
+    const itemValue = XEUtils.get(data, property);
+    const Component = getComponent(name);
+    return [
+      h(Component, {
+        ...attrs,
+        ...createProps(renderOpts, itemValue, defaultProps),
+        ...args,
+        ...createEvents(
+          renderOpts,
+          params,
+          (value) => {
+            XEUtils.set(data, property, value);
+          },
+          () => {
+            $form.updateStatus({
+              ...params,
+              field: property
+            });
+          }
+        )
+      })
+    ];
+  };
+}
+function createCellRender(getSelectCellValue2, callBack) {
+  return (renderOpts, params) => {
+    const args = (callBack && callBack(renderOpts, params)) ?? [];
+    const cellLabel = getSelectCellValue2 && getSelectCellValue2(renderOpts, params, ...args);
+    const { placeholder } = renderOpts;
+    return [
+      h(
+        "span",
+        {
+          class: "vxe-cell--label"
+        },
+        placeholder && isEmptyValue(cellLabel) ? [
+          h(
+            "span",
+            {
+              class: "vxe-cell--placeholder"
+            },
+            formatText(placeholder)
+          )
+        ] : formatText(cellLabel)
+      )
+    ];
+  };
+}
+function createToolbarToolRender(defaultProps, callBack) {
+  return (renderOpts, params) => {
+    const { name, attrs } = renderOpts;
+    const args = (callBack && callBack(renderOpts, params)) ?? {};
+    const Component = getComponent(name);
+    return [
+      h(Component, {
+        ...attrs,
+        ...createProps(renderOpts, null, defaultProps),
+        ...args,
+        ...createEvents(renderOpts, params)
+      })
+    ];
+  };
+}
+const AutoComplete = {
+  autofocus: "input.ant-input",
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1()
+};
+const COMPONENT_NAME = "Button";
+function createEditRender$1() {
+  return (renderOpts, params) => {
+    const { attrs } = renderOpts;
+    const Component = getComponent(COMPONENT_NAME);
+    return [
+      h(Component, {
+        ...attrs,
+        ...createProps(renderOpts, null),
+        ...createEvents(renderOpts, params)
+      })
+    ];
+  };
+}
+function createDefaultRender() {
+  return (renderOpts, params) => {
+    const { attrs } = renderOpts;
+    const Component = getComponent(COMPONENT_NAME);
+    return [
+      h(Component, {
+        ...attrs,
+        ...createProps(renderOpts, null),
+        ...createEvents(renderOpts, params)
+      }, cellText(renderOpts.content))
+    ];
+  };
+}
+function createFormItemRender() {
+  return (renderOpts, params) => {
+    const { attrs, content } = renderOpts;
+    const { property, $form, data } = params;
+    const props = createProps(renderOpts, null);
+    const Component = getComponent(COMPONENT_NAME);
+    return [
+      h(
+        Component,
+        {
+          ...attrs,
+          ...props,
+          ...createEvents(
+            renderOpts,
+            params,
+            (value) => XEUtils.set(data, property, value),
+            () => {
+              $form.updateStatus({
+                ...params,
+                field: property
+              });
+            }
+          )
+        },
+        {
+          default: () => cellText(content || props.content)
+        }
+      )
+    ];
+  };
+}
+function createToolbarButtonRender() {
+  return (renderOpts, params) => {
+    const { attrs } = renderOpts;
+    const { button } = params;
+    const props = createProps(renderOpts, null);
+    const Component = getComponent(COMPONENT_NAME);
+    return [
+      h(
+        Component,
+        {
+          ...attrs,
+          ...props,
+          ...createEvents(renderOpts, params)
+        },
+        {
+          default: () => cellText(button?.content || props.content)
+        }
+      )
+    ];
+  };
+}
+const Button = {
+  renderEdit: createEditRender$1(),
+  renderDefault: createDefaultRender(),
+  renderItemContent: createFormItemRender(),
+  renderToolbarButton: createToolbarButtonRender()
+};
+function createEditButtonRender() {
+  return (renderOpts, params) => {
+    const buttonEditRender = createEditRender$1();
+    const { children } = renderOpts;
+    if (children) {
+      return children.map(
+        (childRenderOpts) => buttonEditRender(childRenderOpts, params)[0]
+      );
+    }
+    return [];
+  };
+}
+function createDefaultButtonRender() {
+  return (renderOpts, params) => {
+    const buttonDefaultRender = createDefaultRender();
+    const { children } = renderOpts;
+    if (children) {
+      return children.map(
+        (childRenderOpts) => buttonDefaultRender(childRenderOpts, params)[0]
+      );
+    }
+    return [];
+  };
+}
+function createButtonItemRender() {
+  return (renderOpts, params) => {
+    const buttonItemRender = createFormItemRender();
+    const { children } = renderOpts;
+    if (children) {
+      return children.map(
+        (childRenderOpts) => buttonItemRender(childRenderOpts, params)[0]
+      );
+    }
+    return [];
+  };
+}
+const ButtonGroup = {
+  renderEdit: createEditButtonRender(),
+  renderDefault: createDefaultButtonRender(),
+  renderItemContent: createButtonItemRender()
+};
+function matchCascaderData(index, list, values, labels) {
+  const val = values[index];
+  if (list && values.length > index) {
+    XEUtils.each(list, (item) => {
+      if (item.value === val) {
+        labels.push(item.label);
+        matchCascaderData(++index, item.children, values, labels);
+      }
+    });
+  }
+}
+function getCascaderCellValue(renderOpts, params) {
+  const { props = {} } = renderOpts;
+  const { row, column } = params;
+  const cellValue = XEUtils.get(row, column.field);
+  const values = cellValue || [];
+  const labels = [];
+  matchCascaderData(0, props.options, values, labels);
+  return (props.showAllLevels === false ? labels.slice(labels.length - 1, labels.length) : labels).join(` ${props.separator || "/"} `);
+}
+const Cascader = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getCascaderCellValue),
+  renderItemContent: createFormItemRender$1()
+};
+const Checkbox = {
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1(),
+  renderCell: createEditRender$2()
+};
+const CheckboxGroup = {
+  renderItemContent: createFormItemRender$1()
+};
+function getDatePickerCellValue(renderOpts, params, defaultFormat) {
+  const { props = {} } = renderOpts;
+  const { row, column } = params;
+  let cellValue = XEUtils.get(row, column.field);
+  if (cellValue && dayjs.isDayjs(cellValue)) {
+    cellValue = cellValue.format(props.format || defaultFormat);
+  }
+  return cellValue;
+}
+const DatePicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getDatePickerCellValue, () => {
+    return ["YYYY-MM-DD"];
+  }),
+  renderItemContent: createFormItemRender$1()
+};
+function createEmptyRender() {
+  return (renderOpts) => {
+    const { name, attrs, props } = renderOpts;
+    const Component = getComponent(name);
+    return [
+      h(
+        "div",
+        {
+          class: "flex items-center justify-center"
+        },
+        h(Component, {
+          ...attrs,
+          ...props
+        })
+      )
+    ];
+  };
+}
+const Empty = {
+  renderEmpty: createEmptyRender()
+};
+const Input = {
+  autofocus: "input.ant-input",
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1()
+};
+function createRenderCell(renderOpts, params) {
+  const { row, column } = params;
+  const cellValue = XEUtils.get(row, column.field);
+  return `${cellValue}`.replace(/[0-9]\d{0,2}(?=(\d{3})+$)/g, "$&,");
+}
+const InputNumber = {
+  autofocus: "input.ant-input-number-input",
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1(),
+  renderCell: createRenderCell
+};
+const InputSearch = {
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1(),
+  renderToolbarTool: createToolbarToolRender()
+};
+const MonthPicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getDatePickerCellValue, () => {
+    return ["YYYY-MM"];
+  }),
+  renderItemContent: createFormItemRender$1()
+};
+const RadioGroup = {
+  renderItemContent: createFormItemRender$1()
+};
+function getRangePickerCellValue(renderOpts, params) {
+  const { props = {} } = renderOpts;
+  const { row, column } = params;
+  let cellValue = XEUtils.get(row, column.field);
+  if (cellValue) {
+    cellValue = XEUtils.map(
+      cellValue,
+      (date) => date.format(props.format || "YYYY-MM-DD")
+    ).join(" ~ ");
+  }
+  return cellValue;
+}
+const RangePicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getRangePickerCellValue),
+  renderItemContent: createFormItemRender$1()
+};
+const Rate = {
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender$2(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1()
+};
+function renderOptions(options, optionProps) {
+  const labelProp = optionProps.label || "label";
+  const valueProp = optionProps.value || "value";
+  return XEUtils.map(options, (item, oIndex) => {
+    return h(
+      SelectOption,
+      {
+        key: oIndex,
+        value: item[valueProp],
+        disabled: item.disabled
+      },
+      {
+        default: () => cellText(item[labelProp])
+      }
+    );
+  });
+}
+function createEditRender() {
+  return (renderOpts, params) => {
+    const { options = [], name, optionGroups, optionProps = {}, optionGroupProps = {} } = renderOpts;
+    const { row, column, $table } = params;
+    const { attrs } = renderOpts;
+    const cellValue = XEUtils.get(row, column.field);
+    const props = createProps(renderOpts, cellValue);
+    const ons = createEvents(
+      renderOpts,
+      params,
+      (value) => {
+        XEUtils.set(row, column.field, value);
+      },
+      () => {
+        $table.updateStatus(params);
+      }
+    );
+    const Component = getComponent(name);
+    if (optionGroups) {
+      const groupOptions = optionGroupProps.options || "options";
+      const groupLabel = optionGroupProps.label || "label";
+      return [
+        h(
+          Component,
+          {
+            ...attrs,
+            ...props,
+            ...ons,
+            class: "w-full"
+          },
+          {
+            default: () => {
+              return XEUtils.map(optionGroups, (group, gIndex) => {
+                return h(
+                  SelectOptGroup,
+                  {
+                    key: gIndex
+                  },
+                  {
+                    label: () => {
+                      return h("span", {}, group[groupLabel]);
+                    },
+                    default: () => renderOptions(group[groupOptions], optionProps)
+                  }
+                );
+              });
+            }
+          }
+        )
+      ];
+    }
+    return [
+      h(
+        Component,
+        {
+          ...props,
+          ...attrs,
+          ...ons,
+          class: "w-full"
+        },
+        {
+          default: () => renderOptions(options, optionProps)
+        }
+      )
+    ];
+  };
+}
+function getSelectCellValue(renderOpts, params) {
+  const { options = [], optionGroups, props = {}, optionProps = {}, optionGroupProps = {} } = renderOpts;
+  const { row, column } = params;
+  const labelProp = optionProps.label || "label";
+  const valueProp = optionProps.value || "value";
+  const groupOptions = optionGroupProps.options || "options";
+  const cellValue = XEUtils.get(row, column.field);
+  if (!isEmptyValue(cellValue)) {
+    return XEUtils.map(
+      props.mode === "multiple" ? cellValue : [cellValue],
+      optionGroups ? (value) => {
+        let selectItem;
+        for (let index = 0; index < optionGroups.length; index++) {
+          selectItem = XEUtils.find(optionGroups[index][groupOptions], (item) => item[valueProp] === value);
+          if (selectItem) {
+            break;
+          }
+        }
+        return selectItem ? selectItem[labelProp] : value;
+      } : (value) => {
+        const selectItem = XEUtils.find(options, (item) => item[valueProp] === value);
+        return selectItem ? selectItem[labelProp] : value;
+      }
+    ).join(", ");
+  }
+  return "";
+}
+function createFilterRender$1() {
+  return (renderOpts, params) => {
+    const { name, options = [], optionGroups, optionProps = {}, optionGroupProps = {} } = renderOpts;
+    const groupOptions = optionGroupProps.options || "options";
+    const groupLabel = optionGroupProps.label || "label";
+    const { column } = params;
+    const { attrs } = renderOpts;
+    const Component = getComponent(name);
+    return [
+      h(
+        "div",
+        {
+          class: "vxe-table--filter-antd-wrapper"
+        },
+        optionGroups ? column.filters.map((option, oIndex) => {
+          const optionValue = option.data;
+          const props = createProps(renderOpts, optionValue);
+          return h(
+            Component,
+            {
+              key: oIndex,
+              ...attrs,
+              ...props,
+              ...createEvents(
+                renderOpts,
+                params,
+                (value) => {
+                  option.data = value;
+                },
+                () => {
+                  const { $panel } = params;
+                  $panel.changeOption(
+                    null,
+                    props.mode === "multiple" ? option.data && option.data.length > 0 : !XEUtils.eqNull(option.data),
+                    option
+                  );
+                }
+              )
+            },
+            {
+              default: () => {
+                return XEUtils.map(optionGroups, (group, gIndex) => {
+                  return h(
+                    SelectOptGroup,
+                    {
+                      key: gIndex
+                    },
+                    {
+                      label: () => {
+                        return h("span", {}, group[groupLabel]);
+                      },
+                      default: () => renderOptions(group[groupOptions], optionProps)
+                    }
+                  );
+                });
+              }
+            }
+          );
+        }) : column.filters.map((option, oIndex) => {
+          const optionValue = option.data;
+          const props = createProps(renderOpts, optionValue);
+          return h(
+            Component,
+            {
+              key: oIndex,
+              ...attrs,
+              ...props,
+              ...createEvents(
+                renderOpts,
+                params,
+                (value) => {
+                  option.data = value;
+                },
+                () => {
+                  const { $panel } = params;
+                  $panel.changeOption(
+                    null,
+                    props.mode === "multiple" ? option.data && option.data.length > 0 : !XEUtils.eqNull(option.data),
+                    option
+                  );
+                }
+              )
+            },
+            {
+              default: () => renderOptions(options, optionProps)
+            }
+          );
+        })
+      )
+    ];
+  };
+}
+function createDefaultFilterMethod() {
+  return (params) => {
+    const { option, row, column } = params;
+    const { data } = option;
+    const { field, filterRender: renderOpts } = column;
+    const { props = {} } = renderOpts;
+    const cellValue = XEUtils.get(row, field);
+    if (props.mode === "multiple") {
+      if (XEUtils.isArray(cellValue)) {
+        return XEUtils.includeArrays(cellValue, data);
+      }
+      return data.indexOf(cellValue) > -1;
+    }
+    return cellValue == data;
+  };
+}
+const Select = {
+  renderEdit: createEditRender(),
+  renderCell: createCellRender(getSelectCellValue),
+  renderFilter: createFilterRender$1(),
+  defaultFilterMethod: createDefaultFilterMethod(),
+  renderItemContent: createFormItemRender$1()
+};
+function createFilterRender() {
+  return (renderOpts, params) => {
+    const { column } = params;
+    const { name, attrs } = renderOpts;
+    const Component = getComponent(name);
+    return [
+      h(
+        "div",
+        {
+          class: "vxe-table--filter-antd-wrapper"
+        },
+        column.filters.map((option, oIndex) => {
+          const optionValue = option.data;
+          return h(Component, {
+            key: oIndex,
+            ...attrs,
+            ...createProps(renderOpts, optionValue),
+            ...createEvents(
+              renderOpts,
+              params,
+              (value) => {
+                option.data = value;
+              },
+              () => {
+                const { $panel } = params;
+                $panel.changeOption(null, XEUtils.isBoolean(option.data), option);
+              }
+            )
+          });
+        })
+      )
+    ];
+  };
+}
+const Switch = {
+  renderDefault: createDefaultRender$1(),
+  renderEdit: createEditRender$2(),
+  renderFilter: createFilterRender(),
+  defaultFilterMethod: createDefaultFilterRender(),
+  renderItemContent: createFormItemRender$1(),
+  renderCell: createEditRender$2()
+};
+const TimePicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getDatePickerCellValue, () => {
+    return ["HH:mm:ss"];
+  }),
+  renderItemContent: createFormItemRender$1()
+};
+function getTreeSelectCellValue(renderOpts, params) {
+  const { props = {} } = renderOpts;
+  const { treeData, treeCheckable } = props;
+  const { row, column } = params;
+  const cellValue = XEUtils.get(row, column.field);
+  if (!isEmptyValue(cellValue)) {
+    return XEUtils.map(
+      treeCheckable ? cellValue : [cellValue],
+      (value) => {
+        const matchObj = XEUtils.findTree(treeData, (item) => item.value === value, {
+          children: "children"
+        });
+        return matchObj ? matchObj.item.title : value;
+      }
+    ).join(", ");
+  }
+  return cellValue;
+}
+const TreeSelect = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getTreeSelectCellValue),
+  renderItemContent: createFormItemRender$1()
+};
+const WeekPicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getDatePickerCellValue, () => {
+    return ["YYYY-WW\u5468"];
+  }),
+  renderItemContent: createFormItemRender$1()
+};
+const YearPicker = {
+  renderEdit: createEditRender$2(),
+  renderCell: createCellRender(getDatePickerCellValue, () => {
+    return ["YYYY"];
+  }),
+  renderItemContent: createFormItemRender$1()
+};
+function getEventTargetNode(evnt, container, className) {
+  let targetElem, target = evnt.target;
+  while (target && target.nodeType && target !== document) {
+    if (className && target.className && target.className.split && target.className.split(" ").indexOf(className) > -1) {
+      targetElem = target;
+    } else if (target === container) {
+      return { flag: className ? !!targetElem : true, container, targetElem };
+    }
+    target = target.parentNode;
+  }
+  return { flag: false };
+}
+function handleClearEvent(params) {
+  const { $event } = params;
+  const bodyElem = document.body;
+  if (getEventTargetNode($event, bodyElem, "ant-select-dropdown").flag || getEventTargetNode($event, bodyElem, "ant-cascader-menus").flag || getEventTargetNode($event, bodyElem, "ant-calendar-picker-container").flag || getEventTargetNode($event, bodyElem, "ant-time-picker-panel").flag) {
+    return false;
+  }
+}
+const VXETablePluginAntd = {
+  install(vxetablecore) {
+    const { interceptor, renderer } = vxetablecore;
+    renderer.mixin({
+      AutoComplete,
+      Button,
+      ButtonGroup,
+      Cascader,
+      Checkbox,
+      CheckboxGroup,
+      DatePicker,
+      Empty,
+      InputNumber,
+      Input,
+      InputSearch,
+      MonthPicker,
+      RadioGroup,
+      RangePicker,
+      Rate,
+      Select,
+      Switch,
+      TimePicker,
+      TreeSelect,
+      WeekPicker,
+      YearPicker
+    });
+    interceptor.add("event.clearFilter", handleClearEvent);
+    interceptor.add("event.clearActived", handleClearEvent);
+    interceptor.add("event.clearAreas", handleClearEvent);
+  }
+};
+if (typeof window !== "undefined" && window.VXETable && window.VXETable.use) {
+  window.VXETable.use(VXETablePluginAntd);
+}
+function useTableComps(app) {
+  VXETable.use(VXETablePluginAntd);
+  app.use(Edit).use(Form).use(Table).use(Grid).use(Tooltip).use(Filter);
+}
+function useVxeTable(props) {
+  const tableRef = ref(null);
+  const $table = ref(null);
+  const loadedRef = ref(false);
+  function registerTable(instance) {
+    if (unref(loadedRef) && isProd() && instance === unref(tableRef))
+      return;
+    tableRef.value = instance;
+    loadedRef.value = true;
+    instance.setProps(props);
+    watch(
+      () => unref(instance.tableInstance),
+      (v) => {
+        $table.value = v;
+      },
+      {
+        immediate: true
+      }
+    );
+    onUnmounted(() => {
+      tableRef.value = null;
+      loadedRef.value = null;
+    });
+  }
+  return [registerTable, $table];
+}
+const basicProps = {
+  ...tableProps,
+  columns: Array,
+  importConfig: {
+    type: Object,
+    default: () => ({})
+  },
+  size: String,
+  tableClass: {
+    type: String,
+    default: ""
+  },
+  tableStyle: {
+    type: Object,
+    default: () => ({})
+  }
+};
+function useHeader(propsRef, slots) {
+  const { t } = useI18n("UI");
+  const TABLE_TOOLS = [
+    { t: "\u65B0\u589E", label: t("ADD"), preIcon: "mdi:plus", type: "primary", auth: "add", onClick: () => unref(propsRef)?.onOpenAddDialog() },
+    { t: "\u5220\u9664", label: t("DELETE"), preIcon: "mdi:delete-outline", auth: "delete", onClick: () => unref(propsRef)?.onDeletes() }
+  ];
+  const { toolbar = TABLE_TOOLS, authPrefix = null } = unref(propsRef);
+  const hideTitle = computed(() => {
+    return (!toolbar || !toolbar.filter((it) => it.show ?? true).length) && !slots.toolbar && !slots.headerTop;
+  });
+  return {
+    toolbar,
+    authPrefix,
+    hideTitle
+  };
+}
+function useProps() {
+  const themeStore = useThemeStore();
+  function getSize(size) {
+    if (size)
+      return size;
+    const gSize = themeStore.themeConf.headOptions.size;
+    switch (gSize) {
+      case "large":
+        return "medium";
+      case "middle":
+        return "small";
+      case "small":
+        return "mini";
+      default:
+        return null;
+    }
+  }
+  function addDefaultProps(conf) {
+    conf.columns = (conf.columns ?? []).map((column) => {
+      if (column.editRender?.name === "InputNumber") {
+        column.editRender.props = {
+          formatter: (value) => `${value}`.replace(/[0-9]\d{0,2}(?=(\d{3})+$)/g, "$&,"),
+          ...column.editRender?.props || {}
+        };
+      }
+      return column;
+    });
+    conf.rowConfig = {
+      keyField: "id",
+      isHover: true,
+      ...conf.rowConfig ?? {}
+    };
+    return conf;
+  }
+  function setKeepSource(conf) {
+    return conf.scrollY || conf.scrollX || conf.columns?.filter((it) => it.editRender).length > 0 ? true : conf.keepSource || false;
+  }
+  function handleConf(conf) {
+    const keepSource = setKeepSource(conf);
+    return {
+      minHeight: "auto",
+      ...addDefaultProps(conf),
+      size: getSize(conf.size),
+      keepSource
+    };
+  }
+  return {
+    handleConf
+  };
+}
+const _hoisted_1 = { class: "w-full h-full flex flex-col" };
+const _hoisted_2 = { class: "py-2" };
+const _hoisted_3 = /* @__PURE__ */ createElementVNode("span", { class: "block pb-2" }, "\u62B1\u6B49, \u627E\u4E0D\u5230\u60A8\u60F3\u8981\u7684\u6570\u636E~", -1);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: basicProps,
+  emits: ["register"],
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const tableElRef = ref(null);
+    const attrs = useAttrs();
+    const appStore = useAppStore();
+    const innerPropsRef = ref();
+    const { handleConf } = useProps();
+    const getBindValue = computed(() => {
+      let conf = mergeConf(
+        {
+          emptyRender: {
+            name: "empty"
+          }
+        },
+        unref(appStore.appConf).ui.vxeTable,
+        attrs,
+        props,
+        unref(innerPropsRef)
+      );
+      return handleConf(conf);
+    });
+    function setProps(props2) {
+      console.log(props2);
+      innerPropsRef.value = {
+        ...unref(innerPropsRef),
+        ...props2
+      };
+    }
+    const slots = useSlots();
+    const {
+      toolbar,
+      hideTitle,
+      authPrefix
+    } = useHeader(getBindValue, slots);
+    emits("register", {
+      tableInstance: tableElRef,
+      setProps
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          !unref(hideTitle) ? (openBlock(), createBlock(unref(DtTableHeader), {
+            key: 0,
+            tableSetting: false,
+            toolbar: unref(toolbar),
+            authPrefix: unref(authPrefix)
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "toolbar"),
+              renderSlot(_ctx.$slots, "headerTop")
+            ]),
+            _: 3
+          }, 8, ["toolbar", "authPrefix"])) : createCommentVNode("", true)
+        ]),
+        createVNode(unref(Grid), mergeProps({
+          ref_key: "tableElRef",
+          ref: tableElRef
+        }, unref(getBindValue)), createSlots({
+          empty: withCtx(() => [
+            createVNode(unref(Icon), {
+              name: "svg ui-table-empty",
+              size: 250,
+              className: "w-72 m-auto -mt-10"
+            }),
+            _hoisted_3
+          ]),
+          _: 2
+        }, [
+          renderList(Object.keys(_ctx.$slots), (item) => {
+            return {
+              name: item,
+              fn: withCtx((data) => [
+                renderSlot(_ctx.$slots, item, normalizeProps(guardReactiveProps(data || {})))
+              ])
+            };
+          })
+        ]), 1040)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as DtVxeTable,
+  useTableComps,
+  useVxeTable
+};