@dt-frames/ui 3.0.1 → 4.0.1

package/es/components/vxe_table/index.js

@@ -1,1162 +0,0 @@
-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
-};