vue-devui 1.0.0-pre.0 → 1.0.0-rc.2

package/table/index.es.js

@@ -1,1969 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import { computed, ref, watch, defineComponent, inject, createVNode, mergeProps, toRef, provide, toRefs, onMounted, onUnmounted, Teleport, Transition, renderSlot, isVNode, nextTick, unref, Fragment, shallowRef, getCurrentInstance, withDirectives, createTextVNode, resolveDirective, reactive, onBeforeMount, h, onBeforeUnmount, render } from "vue";
-import { offset, autoPlacement, arrow, computePosition } from "@floating-ui/dom";
-import { onClickOutside } from "@vueuse/core";
-const TableProps = {
-  data: {
-    type: Array,
-    default: []
-  },
-  striped: {
-    type: Boolean,
-    default: false
-  },
-  scrollable: {
-    type: Boolean,
-    default: false
-  },
-  maxWidth: {
-    type: String
-  },
-  maxHeight: {
-    type: String
-  },
-  tableWidth: {
-    type: String
-  },
-  tableHeight: {
-    type: String
-  },
-  size: {
-    type: String,
-    validator(value) {
-      return value === "sm" || value === "md" || value === "lg";
-    }
-  },
-  rowHoveredHighlight: {
-    type: Boolean,
-    default: true
-  },
-  fixHeader: {
-    type: Boolean,
-    default: false
-  },
-  checkable: {
-    type: Boolean,
-    default: true
-  },
-  tableLayout: {
-    type: String,
-    default: "auto",
-    validator(v) {
-      return v === "fixed" || v === "auto";
-    }
-  },
-  showLoading: {
-    type: Boolean,
-    default: false
-  },
-  headerBg: {
-    type: Boolean,
-    default: false
-  }
-};
-const TABLE_TOKEN = Symbol();
-function useTable(props) {
-  const classes = computed(() => ({
-    "devui-table": true,
-    "devui-table-striped": props.striped,
-    "header-bg": props.headerBg,
-    "table-layout-auto": props.tableLayout === "auto"
-  }));
-  const style = computed(() => ({
-    maxHeight: props.maxHeight,
-    maxWidth: props.maxWidth,
-    height: props.tableHeight,
-    width: props.tableWidth
-  }));
-  return { classes, style };
-}
-const useFixedColumn = (column) => {
-  const stickyCell = computed(() => {
-    const col = column.value;
-    if (col.fixedLeft) {
-      return `devui-sticky-cell left`;
-    }
-    if (col.fixedRight) {
-      return `devui-sticky-cell right`;
-    }
-    return void 0;
-  });
-  const offsetStyle = computed(() => {
-    const col = column.value;
-    if (col.fixedLeft) {
-      return `left:${col.fixedLeft}`;
-    }
-    if (col.fixedRight) {
-      return `right:${col.fixedRight}`;
-    }
-    return void 0;
-  });
-  return {
-    stickyCell,
-    offsetStyle
-  };
-};
-function createStore(dataSource) {
-  const _data = ref([]);
-  watch(dataSource, (value) => {
-    _data.value = [...value];
-  }, { deep: true, immediate: true });
-  const { _columns, insertColumn, removeColumn, sortColumn } = createColumnGenerator();
-  const { _checkAll, _checkList, _halfChecked, getCheckedRows } = createSelection(dataSource, _data);
-  const { sortData } = createSorter(dataSource, _data);
-  const { filterData, resetFilterData } = createFilter(dataSource, _data);
-  const { isFixedLeft } = createFixedLogic(_columns);
-  return {
-    states: {
-      _data,
-      _columns,
-      _checkList,
-      _checkAll,
-      _halfChecked,
-      isFixedLeft
-    },
-    insertColumn,
-    sortColumn,
-    removeColumn,
-    getCheckedRows,
-    sortData,
-    filterData,
-    resetFilterData
-  };
-}
-const createColumnGenerator = () => {
-  const _columns = ref([]);
-  const insertColumn = (column) => {
-    _columns.value.push(column);
-    _columns.value.sort((a, b) => a.order - b.order);
-  };
-  const sortColumn = () => {
-    _columns.value.sort((a, b) => a.order > b.order ? 1 : -1);
-  };
-  const removeColumn = (column) => {
-    const i = _columns.value.findIndex((v) => v === column);
-    if (i === -1) {
-      return;
-    }
-    _columns.value.splice(i, 1);
-  };
-  return { _columns, insertColumn, removeColumn, sortColumn };
-};
-const createSelection = (dataSource, _data) => {
-  const _checkList = ref([]);
-  const _checkAllRecord = ref(false);
-  const _checkAll = computed({
-    get: () => _checkAllRecord.value,
-    set: (val) => {
-      _checkAllRecord.value = val;
-      for (let i = 0; i < _checkList.value.length; i++) {
-        _checkList.value[i] = val;
-      }
-    }
-  });
-  const _halfChecked = ref(false);
-  watch(dataSource, (value) => {
-    _checkList.value = new Array(value.length).fill(false);
-  }, { deep: true, immediate: true });
-  watch(_checkList, (list) => {
-    if (list.length === 0) {
-      return;
-    }
-    let allTrue = true;
-    let allFalse = true;
-    for (let i = 0; i < list.length; i++) {
-      allTrue && (allTrue = list[i]);
-      allFalse && (allFalse = !list[i]);
-    }
-    _checkAllRecord.value = allTrue;
-    _halfChecked.value = !(allFalse || allTrue);
-  }, { immediate: true, deep: true });
-  const getCheckedRows = () => {
-    return _data.value.filter((_, index2) => _checkList.value[index2]);
-  };
-  return {
-    _checkList,
-    _checkAll,
-    _halfChecked,
-    getCheckedRows
-  };
-};
-const createSorter = (dataSource, _data) => {
-  const sortData = (field, direction, compareFn = (fieldKey, a, b) => a[fieldKey] > b[fieldKey]) => {
-    if (direction === "ASC") {
-      _data.value = _data.value.sort((a, b) => compareFn(field, a, b) ? 1 : -1);
-    } else if (direction === "DESC") {
-      _data.value = _data.value.sort((a, b) => !compareFn(field, a, b) ? 1 : -1);
-    } else {
-      _data.value = [...dataSource.value];
-    }
-  };
-  return { sortData };
-};
-const createFilter = (dataSource, _data) => {
-  const fieldSet = /* @__PURE__ */ new Set();
-  const filterData = (field, results) => {
-    fieldSet.add(field);
-    const fields = [...fieldSet];
-    _data.value = dataSource.value.filter((item) => {
-      return fields.reduce((prev, fieldKey) => {
-        return prev && results.indexOf(item[fieldKey]) !== -1;
-      }, true);
-    });
-  };
-  const resetFilterData = () => {
-    fieldSet.clear();
-    _data.value = [...dataSource.value];
-  };
-  return { filterData, resetFilterData };
-};
-const createFixedLogic = (columns) => {
-  const isFixedLeft = computed(() => {
-    return columns.value.reduce((prev, current) => prev || !!current.fixedLeft, false);
-  });
-  return { isFixedLeft };
-};
-var ColGroup = defineComponent({
-  name: "DColGroup",
-  setup() {
-    const parent = inject(TABLE_TOKEN);
-    const columns = parent.store.states._columns;
-    return () => parent.props.tableLayout === "fixed" ? createVNode("colgroup", null, [parent.props.checkable ? createVNode("col", {
-      "width": 36
-    }, null) : null, columns.value.map((column, index2) => {
-      return createVNode("col", {
-        "key": index2,
-        "width": column.realWidth
-      }, null);
-    })]) : null;
-  }
-});
-var checkbox = "";
-const commonProps = {
-  name: {
-    type: String,
-    default: void 0
-  },
-  halfchecked: {
-    type: Boolean,
-    default: false
-  },
-  isShowTitle: {
-    type: Boolean,
-    default: true
-  },
-  title: {
-    type: String
-  },
-  color: {
-    type: String,
-    default: void 0
-  },
-  showAnimation: {
-    type: Boolean,
-    default: true
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  },
-  beforeChange: {
-    type: Function,
-    default: void 0
-  }
-};
-const checkboxProps = __spreadProps(__spreadValues({}, commonProps), {
-  halfchecked: {
-    type: Boolean,
-    default: false
-  },
-  checked: {
-    type: Boolean,
-    default: false
-  },
-  value: {
-    type: String
-  },
-  label: {
-    type: String,
-    default: void 0
-  },
-  title: {
-    type: String,
-    default: void 0
-  },
-  "onUpdate:checked": {
-    type: Function,
-    default: void 0
-  },
-  onChange: {
-    type: Function,
-    default: void 0
-  },
-  modelValue: {
-    type: Boolean
-  },
-  "onUpdate:modelValue": {
-    type: Function
-  }
-});
-const checkboxGroupProps = __spreadProps(__spreadValues({}, commonProps), {
-  modelValue: {
-    type: Array,
-    required: true
-  },
-  direction: {
-    type: String,
-    default: "column"
-  },
-  itemWidth: {
-    type: Number,
-    default: void 0
-  },
-  options: {
-    type: Array,
-    default: () => []
-  },
-  onChange: {
-    type: Function,
-    default: void 0
-  },
-  "onUpdate:modelValue": {
-    type: Function,
-    default: void 0
-  }
-});
-const checkboxGroupInjectionKey = Symbol("d-checkbox-group");
-var Checkbox = defineComponent({
-  name: "DCheckbox",
-  props: checkboxProps,
-  emits: ["change", "update:checked", "update:modelValue"],
-  setup(props, ctx) {
-    const checkboxGroupConf = inject(checkboxGroupInjectionKey, null);
-    const isChecked = computed(() => props.checked || props.modelValue);
-    const mergedDisabled = computed(() => {
-      return (checkboxGroupConf == null ? void 0 : checkboxGroupConf.disabled.value) || props.disabled;
-    });
-    const mergedChecked = computed(() => {
-      var _a, _b;
-      return (_b = (_a = checkboxGroupConf == null ? void 0 : checkboxGroupConf.isItemChecked) == null ? void 0 : _a.call(checkboxGroupConf, props.value)) != null ? _b : isChecked.value;
-    });
-    const mergedIsShowTitle = computed(() => {
-      var _a;
-      return (_a = checkboxGroupConf == null ? void 0 : checkboxGroupConf.isShowTitle.value) != null ? _a : props.isShowTitle;
-    });
-    const mergedShowAnimation = computed(() => {
-      var _a;
-      return (_a = checkboxGroupConf == null ? void 0 : checkboxGroupConf.showAnimation.value) != null ? _a : props.showAnimation;
-    });
-    const mergedColor = computed(() => {
-      var _a;
-      return (_a = checkboxGroupConf == null ? void 0 : checkboxGroupConf.color.value) != null ? _a : props.color;
-    });
-    const itemWidth = checkboxGroupConf == null ? void 0 : checkboxGroupConf.itemWidth.value;
-    const direction = checkboxGroupConf == null ? void 0 : checkboxGroupConf.direction.value;
-    const canChange = (isChecked2, val) => {
-      var _a;
-      if (mergedDisabled.value) {
-        return Promise.resolve(false);
-      }
-      const beforeChange = (_a = props.beforeChange) != null ? _a : checkboxGroupConf == null ? void 0 : checkboxGroupConf.beforeChange;
-      if (beforeChange) {
-        const res = beforeChange(isChecked2, val);
-        if (typeof res === "boolean") {
-          return Promise.resolve(res);
-        }
-        return res;
-      }
-      return Promise.resolve(true);
-    };
-    const toggle = () => {
-      const current = !isChecked.value;
-      checkboxGroupConf == null ? void 0 : checkboxGroupConf.toggleGroupVal(props.value);
-      ctx.emit("update:checked", current);
-      ctx.emit("update:modelValue", current);
-      ctx.emit("change", current);
-    };
-    const handleClick = () => {
-      canChange(!isChecked.value, props.label).then((res) => res && toggle());
-    };
-    return {
-      itemWidth,
-      direction,
-      mergedColor,
-      mergedDisabled,
-      mergedIsShowTitle,
-      mergedChecked,
-      mergedShowAnimation,
-      handleClick
-    };
-  },
-  render() {
-    var _a;
-    const {
-      itemWidth,
-      direction,
-      mergedChecked,
-      mergedDisabled,
-      mergedIsShowTitle,
-      mergedShowAnimation,
-      halfchecked,
-      title,
-      label,
-      handleClick,
-      name,
-      value,
-      mergedColor,
-      $slots
-    } = this;
-    const wrapperCls = {
-      "devui-checkbox-column-margin": direction === "column",
-      "devui-checkbox-wrap": typeof itemWidth !== "undefined"
-    };
-    const wrapperStyle = itemWidth ? [`width: ${itemWidth}px`] : [];
-    const checkboxCls = {
-      "devui-checkbox": true,
-      active: mergedChecked,
-      halfchecked,
-      disabled: mergedDisabled,
-      unchecked: !mergedChecked
-    };
-    const labelTitle = mergedIsShowTitle ? title || label : "";
-    const bgImgStyle = mergedColor && halfchecked || mergedColor ? `linear-gradient(${mergedColor}, ${mergedColor})` : "";
-    const spanStyle = [`border-color:${(mergedChecked || halfchecked) && mergedColor ? mergedColor : ""}`, `background-image:${bgImgStyle}`, `background-color:${mergedColor && halfchecked ? mergedColor : ""}`];
-    const spanCls = {
-      "devui-checkbox-material": true,
-      "custom-color": mergedColor,
-      "devui-checkbox-no-label": !label && !$slots.default,
-      "devui-no-animation": !mergedShowAnimation,
-      "devui-checkbox-default-background": !halfchecked
-    };
-    const polygonCls = {
-      "devui-tick": true,
-      "devui-no-animation": !mergedShowAnimation
-    };
-    const stopPropagation = ($event) => $event.stopPropagation();
-    const inputProps = {
-      indeterminate: halfchecked
-    };
-    return createVNode("div", {
-      "class": wrapperCls,
-      "style": wrapperStyle
-    }, [createVNode("div", {
-      "class": checkboxCls
-    }, [createVNode("label", {
-      "title": labelTitle,
-      "onClick": handleClick
-    }, [createVNode("input", mergeProps({
-      "name": name || value,
-      "class": "devui-checkbox-input",
-      "type": "checkbox"
-    }, inputProps, {
-      "checked": mergedChecked,
-      "disabled": mergedDisabled,
-      "onClick": stopPropagation,
-      "onChange": stopPropagation
-    }), null), createVNode("span", {
-      "style": spanStyle,
-      "class": spanCls
-    }, [createVNode("span", {
-      "class": "devui-checkbox-halfchecked-bg"
-    }, null), createVNode("svg", {
-      "viewBox": "0 0 16 16",
-      "version": "1.1",
-      "xmlns": "http://www.w3.org/2000/svg",
-      "class": "devui-checkbox-tick"
-    }, [createVNode("g", {
-      "stroke": "none",
-      "stroke-width": "1",
-      "fill": "none",
-      "fill-rule": "evenodd"
-    }, [createVNode("polygon", {
-      "fill-rule": "nonzero",
-      "points": "5.17391304 6.56521739 7.7173913 9.10869565 11.826087 5 13 6.17391304 7.7173913 11.4565217 4 7.73913043",
-      "class": polygonCls
-    }, null)])])]), label || ((_a = $slots.default) == null ? void 0 : _a.call($slots))])])]);
-  }
-});
-var checkboxGroup = "";
-var CheckboxGroup = defineComponent({
-  name: "DCheckboxGroup",
-  props: checkboxGroupProps,
-  emits: ["change", "update:modelValue"],
-  setup(props, ctx) {
-    const valList = toRef(props, "modelValue");
-    const defaultOpt = {
-      checked: false,
-      isShowTitle: true,
-      halfchecked: false,
-      showAnimation: true,
-      disabled: false
-    };
-    const toggleGroupVal = (val) => {
-      let index2 = -1;
-      if (typeof valList.value[0] === "string") {
-        index2 = valList.value.findIndex((item) => item === val);
-      } else if (typeof valList.value[0] === "object") {
-        index2 = valList.value.findIndex((item) => item.value === val);
-      }
-      if (index2 === -1) {
-        if (typeof props.options[0] === "object") {
-          const newOne = props.options.find((item) => item.value === val);
-          const res2 = [...valList.value, newOne];
-          ctx.emit("update:modelValue", res2);
-          ctx.emit("change", res2);
-          return;
-        }
-        const res = [...valList.value, val];
-        ctx.emit("update:modelValue", res);
-        ctx.emit("change", res);
-        return;
-      }
-      valList.value.splice(index2, 1);
-      ctx.emit("update:modelValue", valList.value);
-      ctx.emit("change", valList.value);
-    };
-    const isItemChecked = (itemVal) => {
-      if (typeof valList.value[0] === "string") {
-        return valList.value.includes(itemVal);
-      } else if (typeof valList.value[0] === "object") {
-        return valList.value.some((item) => item.value === itemVal);
-      }
-    };
-    provide(checkboxGroupInjectionKey, {
-      disabled: toRef(props, "disabled"),
-      isShowTitle: toRef(props, "isShowTitle"),
-      color: toRef(props, "color"),
-      showAnimation: toRef(props, "showAnimation"),
-      beforeChange: props.beforeChange,
-      isItemChecked,
-      toggleGroupVal,
-      itemWidth: toRef(props, "itemWidth"),
-      direction: toRef(props, "direction")
-    });
-    return {
-      defaultOpt
-    };
-  },
-  render() {
-    var _a;
-    const {
-      direction,
-      $slots,
-      defaultOpt,
-      options
-    } = this;
-    let children = (_a = $slots.default) == null ? void 0 : _a.call($slots);
-    if ((options == null ? void 0 : options.length) > 0) {
-      children = options.map((opt) => {
-        let mergedOpt = null;
-        if (typeof opt === "string") {
-          mergedOpt = Object.assign({}, defaultOpt, {
-            label: opt,
-            value: opt
-          });
-        } else if (typeof opt === "object") {
-          mergedOpt = Object.assign({}, defaultOpt, __spreadProps(__spreadValues({}, opt), {
-            label: opt.name
-          }));
-        }
-        return createVNode(Checkbox, mergedOpt, null);
-      });
-    }
-    return createVNode("div", {
-      "class": "devui-checkbox-group"
-    }, [createVNode("div", {
-      "class": {
-        "devui-checkbox-list-inline": direction === "row"
-      }
-    }, [children])]);
-  }
-});
-Checkbox.install = function(app) {
-  app.component(Checkbox.name, Checkbox);
-};
-CheckboxGroup.install = function(app) {
-  app.component(CheckboxGroup.name, CheckboxGroup);
-};
-var sort = "";
-const Sort = defineComponent({
-  props: {
-    modelValue: {
-      type: String,
-      default: ""
-    },
-    "onUpdate:modelValue": {
-      type: Function
-    }
-  },
-  emits: ["update:modelValue"],
-  setup(props, ctx) {
-    const changeDirection = () => {
-      let direction = "";
-      if (props.modelValue === "ASC") {
-        direction = "DESC";
-      } else if (props.modelValue === "DESC") {
-        direction = "";
-      } else {
-        direction = "ASC";
-      }
-      ctx.emit("update:modelValue", direction);
-    };
-    return () => createVNode("span", {
-      "onClick": changeDirection,
-      "class": "sort-clickable"
-    }, [createVNode("i", {
-      "class": ["datatable-svg", {
-        "sort-icon-default": !props.modelValue,
-        "sort-icon-asc": props.modelValue === "ASC",
-        "sort-icon-desc": props.modelValue === "DESC"
-      }]
-    }, [createVNode("svg", {
-      "width": "16px",
-      "height": "16px",
-      "viewBox": "0 0 16 16",
-      "version": "1.1",
-      "xmlns": "http://www.w3.org/2000/svg",
-      "xmlns:xlink": "http://www.w3.org/1999/xlink"
-    }, [createVNode("defs", null, [createVNode("circle", {
-      "id": "sort-svg-path-1",
-      "cx": "8",
-      "cy": "8",
-      "r": "8"
-    }, null), createVNode("filter", {
-      "x": "-34.4%",
-      "y": "-21.9%",
-      "width": "168.8%",
-      "height": "168.8%",
-      "filterUnits": "objectBoundingBox",
-      "id": "filter-2"
-    }, [createVNode("feOffset", {
-      "dx": "0",
-      "dy": "2",
-      "in": "SourceAlpha",
-      "result": "shadowOffsetOuter1"
-    }, null), createVNode("feGaussianBlur", {
-      "stdDeviation": "1.5",
-      "in": "shadowOffsetOuter1",
-      "result": "shadowBlurOuter1"
-    }, null), createVNode("feColorMatrix", {
-      "values": "0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.085309222 0",
-      "type": "matrix",
-      "in": "shadowBlurOuter1"
-    }, null)])]), createVNode("g", {
-      "stroke": "none",
-      "stroke-width": "1",
-      "fill": "none",
-      "fill-rule": "evenodd"
-    }, [createVNode("use", {
-      "fill-rule": "evenodd",
-      "xlink:href": "#sort-svg-path-1"
-    }, null), createVNode("polygon", {
-      "points": "8 4 11 7 5 7"
-    }, null), createVNode("polygon", {
-      "points": "8 12 5 9 11 9"
-    }, null)])])])]);
-  }
-});
-const dropdownProps = {
-  visible: {
-    type: Boolean,
-    default: false
-  },
-  trigger: {
-    type: String,
-    default: "click"
-  },
-  closeScope: {
-    type: String,
-    default: "all"
-  },
-  position: {
-    type: Array,
-    default: ["bottom"]
-  },
-  align: {
-    type: String,
-    default: null
-  },
-  offset: {
-    type: [Number, Object],
-    default: 4
-  },
-  closeOnMouseLeaveMenu: {
-    type: Boolean,
-    default: false
-  }
-};
-function getElement(element) {
-  if (element instanceof Element) {
-    return element;
-  }
-  if (element && typeof element === "object" && element.$el instanceof Element) {
-    return element.$el;
-  }
-  return null;
-}
-const dropdownMap = /* @__PURE__ */ new Map();
-function subscribeEvent(dom, type, callback) {
-  dom == null ? void 0 : dom.addEventListener(type, callback);
-  return () => {
-    dom == null ? void 0 : dom.removeEventListener(type, callback);
-  };
-}
-const useDropdownEvent = ({ id, isOpen, origin, dropdownRef, props, emit }) => {
-  let overlayEnter = false;
-  let originEnter = false;
-  const { trigger, closeScope, closeOnMouseLeaveMenu } = toRefs(props);
-  const toggle = (status) => {
-    isOpen.value = status;
-    emit("toggle", isOpen.value);
-  };
-  const handleLeave = async (elementType, e) => {
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    if (elementType === "origin" && overlayEnter || elementType === "dropdown" && originEnter) {
-      return;
-    }
-    if (e) {
-      [...dropdownMap.values()].reverse().forEach((item) => {
-        setTimeout(() => {
-          var _a;
-          (_a = item.toggle) == null ? void 0 : _a.call(item);
-        }, 0);
-      });
-    }
-    toggle(false);
-  };
-  watch([trigger, origin, dropdownRef], ([triggerVal, originVal, dropdownEl], ov, onInvalidate) => {
-    const originEl = getElement(originVal);
-    const subscriptions = [];
-    setTimeout(() => {
-      subscriptions.push(subscribeEvent(document, "click", (e) => {
-        const dropdownValues = [...dropdownMap.values()];
-        if (!isOpen.value || closeScope.value === "none" || dropdownEl.contains(e.target) && closeScope.value === "blank" || dropdownValues.some((item) => {
-          var _a;
-          return (_a = item.toggleEl) == null ? void 0 : _a.contains(e.target);
-        }) && dropdownValues.some((item) => {
-          var _a;
-          return (_a = item.menuEl) == null ? void 0 : _a.contains(e.target);
-        })) {
-          return;
-        }
-        [...dropdownMap.values()].reverse().forEach((item) => {
-          setTimeout(() => {
-            var _a, _b;
-            if (!((_a = item.toggleEl) == null ? void 0 : _a.contains(e.target))) {
-              (_b = item.toggle) == null ? void 0 : _b.call(item);
-            }
-          }, 0);
-        });
-        overlayEnter = false;
-      }));
-    }, 0);
-    if (triggerVal === "click") {
-      subscriptions.push(subscribeEvent(originEl, "click", () => toggle(!isOpen.value)), subscribeEvent(dropdownEl, "mouseleave", (e) => {
-        var _a;
-        if (closeOnMouseLeaveMenu.value && !((_a = dropdownMap.get(id).child) == null ? void 0 : _a.contains(e.relatedTarget))) {
-          handleLeave("dropdown", e);
-        }
-      }));
-    } else if (triggerVal === "hover") {
-      subscriptions.push(subscribeEvent(originEl, "mouseenter", () => {
-        originEnter = true;
-        toggle(true);
-      }), subscribeEvent(originEl, "mouseleave", () => {
-        originEnter = false;
-        handleLeave("origin");
-      }), subscribeEvent(dropdownEl, "mouseenter", () => {
-        overlayEnter = true;
-        isOpen.value = true;
-      }), subscribeEvent(dropdownEl, "mouseleave", (e) => {
-        var _a;
-        overlayEnter = false;
-        if (e.relatedTarget && ((originEl == null ? void 0 : originEl.contains(e.relatedTarget)) || ((_a = dropdownMap.get(id).child) == null ? void 0 : _a.contains(e.relatedTarget)))) {
-          return;
-        }
-        handleLeave("dropdown", e);
-      }));
-    }
-    onInvalidate(() => subscriptions.forEach((v) => v()));
-  });
-};
-function useDropdown(id, visible, isOpen, origin, dropdownRef, popDirection, emit) {
-  const calcPopDirection = (dropdownEl) => {
-    const elementHeight = dropdownEl.offsetHeight;
-    const bottomDistance = window.innerHeight - origin.value.getBoundingClientRect().bottom;
-    const isBottomEnough = bottomDistance >= elementHeight;
-    if (!isBottomEnough) {
-      popDirection.value = "top";
-    } else {
-      popDirection.value = "bottom";
-    }
-  };
-  watch(visible, (newVal, oldVal) => {
-    if (oldVal === void 0) {
-      return;
-    }
-    isOpen.value = newVal;
-    emit("toggle", isOpen.value);
-  }, { immediate: true });
-  watch([isOpen, dropdownRef], ([isOpenVal, dropdownEl]) => {
-    var _a;
-    if (isOpenVal) {
-      dropdownMap.set(id, __spreadProps(__spreadValues({}, dropdownMap.get(id)), {
-        menuEl: dropdownEl,
-        toggle: () => {
-          isOpen.value = false;
-          emit("toggle", isOpen.value);
-        }
-      }));
-      for (const value of dropdownMap.values()) {
-        if ((_a = value.menuEl) == null ? void 0 : _a.contains(origin.value)) {
-          value.child = dropdownEl;
-        }
-      }
-    }
-    if (dropdownEl) {
-      calcPopDirection(dropdownEl);
-    }
-  });
-  onMounted(() => {
-    dropdownMap.set(id, { toggleEl: origin.value });
-  });
-  onUnmounted(() => {
-    dropdownMap.delete(id);
-  });
-}
-var overlay = "";
-function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
-}
-const CommonOverlay = defineComponent({
-  setup(props, ctx) {
-    return () => {
-      let _slot;
-      return createVNode(Teleport, {
-        "to": "#d-overlay-anchor"
-      }, {
-        default: () => [createVNode(Transition, {
-          "name": "devui-overlay-fade"
-        }, _isSlot(_slot = renderSlot(ctx.slots, "default")) ? _slot : {
-          default: () => [_slot]
-        })]
-      });
-    };
-  }
-});
-const overlayProps = {
-  visible: {
-    type: Boolean
-  },
-  backgroundBlock: {
-    type: Boolean,
-    default: false
-  },
-  backgroundClass: {
-    type: String,
-    default: ""
-  },
-  backgroundStyle: {
-    type: [String, Object]
-  },
-  onBackdropClick: {
-    type: Function
-  },
-  backdropClose: {
-    type: Boolean,
-    default: true
-  },
-  hasBackdrop: {
-    type: Boolean,
-    default: true
-  }
-};
-const overlayEmits = ["update:visible", "backdropClick"];
-const fixedOverlayProps = __spreadProps(__spreadValues({}, overlayProps), {
-  overlayStyle: {
-    type: [String, Object],
-    default: void 0
-  }
-});
-const flexibleOverlayProps = {
-  modelValue: {
-    type: Boolean,
-    default: false
-  },
-  origin: {
-    type: Object,
-    require: true
-  },
-  position: {
-    type: Array,
-    default: ["bottom"]
-  },
-  offset: {
-    type: [Number, Object],
-    default: 8
-  },
-  align: {
-    type: String,
-    default: null
-  },
-  showArrow: {
-    type: Boolean,
-    default: false
-  },
-  isArrowCenter: {
-    type: Boolean,
-    default: true
-  }
-};
-function useOverlayLogic(props, ctx) {
-  const backgroundClass = computed(() => {
-    return [
-      "devui-overlay-background",
-      props.backgroundClass,
-      !props.hasBackdrop ? "devui-overlay-background__disabled" : "devui-overlay-background__color"
-    ];
-  });
-  const overlayClass = computed(() => {
-    return "devui-overlay";
-  });
-  const handleBackdropClick = (event) => {
-    var _a;
-    event.preventDefault();
-    (_a = props.onBackdropClick) == null ? void 0 : _a.call(props);
-    if (props.backdropClose) {
-      ctx.emit("update:visible", false);
-    }
-  };
-  const handleOverlayBubbleCancel = (event) => event.cancelBubble = true;
-  onMounted(() => {
-    const body2 = document.body;
-    const originOverflow = body2.style.overflow;
-    const originPosition = body2.style.position;
-    watch([() => props.visible, () => props.backgroundBlock], ([visible, backgroundBlock]) => {
-      if (backgroundBlock) {
-        const top = body2.getBoundingClientRect().y;
-        if (visible) {
-          body2.style.overflowY = "scroll";
-          body2.style.position = visible ? "fixed" : "";
-          body2.style.top = `${top}px`;
-        } else {
-          body2.style.overflowY = originOverflow;
-          body2.style.position = originPosition;
-          body2.style.top = "";
-          window.scrollTo(0, -top);
-        }
-      }
-    });
-    onUnmounted(() => {
-      document.body.style.overflow = originOverflow;
-    });
-  });
-  return {
-    backgroundClass,
-    overlayClass,
-    handleBackdropClick,
-    handleOverlayBubbleCancel
-  };
-}
-defineComponent({
-  name: "DFixedOverlay",
-  props: fixedOverlayProps,
-  emits: overlayEmits,
-  setup(props, ctx) {
-    const {
-      backgroundClass,
-      overlayClass,
-      handleBackdropClick,
-      handleOverlayBubbleCancel
-    } = useOverlayLogic(props, ctx);
-    return () => createVNode(CommonOverlay, null, {
-      default: () => [props.visible && createVNode("div", {
-        "class": backgroundClass.value,
-        "style": props.backgroundStyle,
-        "onClick": handleBackdropClick
-      }, [createVNode("div", {
-        "class": overlayClass.value,
-        "style": props.overlayStyle,
-        "onClick": handleOverlayBubbleCancel
-      }, [renderSlot(ctx.slots, "default")])])]
-    });
-  }
-});
-function getScrollParent(element) {
-  const overflowRegex = /(auto|scroll|hidden)/;
-  for (let parent = element; parent = parent.parentElement; parent.parentElement !== document.body) {
-    const style = window.getComputedStyle(parent);
-    if (overflowRegex.test(style.overflow + style.overflowX + style.overflowY)) {
-      return parent;
-    }
-  }
-  return window;
-}
-function adjustArrowPosition(isArrowCenter, point, placement, originRect) {
-  let { x, y } = point;
-  if (!isArrowCenter) {
-    const { width, height } = originRect;
-    if (x && placement.includes("start")) {
-      x = 12;
-    }
-    if (x && placement.includes("end")) {
-      x = Math.round(width - 24);
-    }
-    if (y && placement.includes("start")) {
-      y = 10;
-    }
-    if (y && placement.includes("end")) {
-      y = height - 14;
-    }
-  }
-  return { x, y };
-}
-function useOverlay(props, emit) {
-  const overlayRef = ref();
-  const arrowRef = ref();
-  const updateArrowPosition = (arrowEl, placement, point, overlayEl) => {
-    const { x, y } = adjustArrowPosition(props.isArrowCenter, point, placement, overlayEl.getBoundingClientRect());
-    const staticSide = {
-      top: "bottom",
-      right: "left",
-      bottom: "top",
-      left: "right"
-    }[placement.split("-")[0]];
-    Object.assign(arrowEl.style, {
-      left: x ? `${x}px` : "",
-      top: y ? `${y}px` : "",
-      right: "",
-      bottom: "",
-      [staticSide]: "-4px"
-    });
-  };
-  const updatePosition = async () => {
-    const hostEl = props.origin;
-    const overlayEl = unref(overlayRef.value);
-    const arrowEl = unref(arrowRef.value);
-    const middleware = [
-      offset(props.offset),
-      autoPlacement({
-        alignment: props.align,
-        allowedPlacements: props.position
-      })
-    ];
-    props.showArrow && middleware.push(arrow({ element: arrowEl }));
-    const { x, y, placement, middlewareData } = await computePosition(hostEl, overlayEl, {
-      strategy: "fixed",
-      middleware
-    });
-    emit("positionChange", placement);
-    Object.assign(overlayEl.style, { top: `${y}px`, left: `${x}px` });
-    props.showArrow && updateArrowPosition(arrowEl, placement, middlewareData.arrow, overlayEl);
-  };
-  watch(() => props.modelValue, () => {
-    const originParent = getScrollParent(props.origin);
-    if (props.modelValue && props.origin) {
-      nextTick(updatePosition);
-      originParent.addEventListener("scroll", updatePosition);
-      originParent !== window && window.addEventListener("scroll", updatePosition);
-      window.addEventListener("resize", updatePosition);
-    } else {
-      originParent.removeEventListener("scroll", updatePosition);
-      originParent !== window && window.removeEventListener("scroll", updatePosition);
-      window.removeEventListener("resize", updatePosition);
-    }
-  });
-  onUnmounted(() => {
-    const originParent = getScrollParent(props.origin);
-    originParent.removeEventListener("scroll", updatePosition);
-    originParent !== window && window.removeEventListener("scroll", updatePosition);
-    window.removeEventListener("resize", updatePosition);
-  });
-  return { arrowRef, overlayRef };
-}
-var flexibleOverlay = "";
-const FlexibleOverlay = defineComponent({
-  name: "DFlexibleOverlay",
-  inheritAttrs: false,
-  props: flexibleOverlayProps,
-  emits: ["update:modelValue", "positionChange"],
-  setup(props, {
-    slots,
-    attrs,
-    emit
-  }) {
-    const {
-      arrowRef,
-      overlayRef
-    } = useOverlay(props, emit);
-    return () => {
-      var _a;
-      return props.modelValue && createVNode("div", mergeProps({
-        "ref": overlayRef,
-        "class": "devui-flexible-overlay"
-      }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots), props.showArrow && createVNode("div", {
-        "ref": arrowRef,
-        "class": "devui-flexible-overlay-arrow"
-      }, null)]);
-    };
-  }
-});
-var dropdown = "";
-let dropdownId = 1;
-var Dropdown = defineComponent({
-  name: "DDropdown",
-  inheritAttrs: false,
-  props: dropdownProps,
-  emits: ["toggle"],
-  setup(props, {
-    slots,
-    attrs,
-    emit
-  }) {
-    const {
-      visible,
-      position,
-      align,
-      offset: offset2
-    } = toRefs(props);
-    const origin = ref();
-    const dropdownRef = ref();
-    const id = `dropdown_${dropdownId++}`;
-    const isOpen = ref(false);
-    const currentPosition = ref("bottom");
-    const handlePositionChange = (pos) => {
-      currentPosition.value = pos.includes("top") || pos.includes("end") ? "top" : "bottom";
-    };
-    const styles = computed(() => ({
-      transformOrigin: currentPosition.value === "top" ? "0% 100%" : "0% 0%"
-    }));
-    const classes = computed(() => ({
-      "fade-in-bottom": isOpen.value && currentPosition.value === "bottom",
-      "fade-in-top": isOpen.value && currentPosition.value === "top"
-    }));
-    useDropdownEvent({
-      id,
-      isOpen,
-      origin,
-      dropdownRef,
-      props,
-      emit
-    });
-    useDropdown(id, visible, isOpen, origin, dropdownRef, currentPosition, emit);
-    return () => {
-      var _a;
-      return createVNode(Fragment, null, [createVNode("div", {
-        "ref": origin,
-        "class": "devui-dropdown-toggle"
-      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), createVNode(Teleport, {
-        "to": "body"
-      }, {
-        default: () => [createVNode(Transition, {
-          "name": `devui-dropdown-fade-${currentPosition.value}`
-        }, {
-          default: () => [createVNode(FlexibleOverlay, {
-            "modelValue": isOpen.value,
-            "onUpdate:modelValue": ($event) => isOpen.value = $event,
-            "origin": origin.value,
-            "position": position.value,
-            "align": align.value,
-            "offset": offset2.value,
-            "onPositionChange": handlePositionChange,
-            "class": classes.value,
-            "style": styles.value
-          }, {
-            default: () => {
-              var _a2;
-              return [createVNode("div", mergeProps({
-                "ref": dropdownRef,
-                "class": "devui-dropdown-menu-wrap"
-              }, attrs), [(_a2 = slots.menu) == null ? void 0 : _a2.call(slots)])];
-            }
-          })]
-        })]
-      })]);
-    };
-  }
-});
-const dropdownMenuProps = {
-  modelValue: {
-    type: Boolean,
-    default: false
-  },
-  origin: {
-    type: Object,
-    require: true
-  },
-  position: {
-    type: Array,
-    default: ["bottom"]
-  },
-  align: {
-    type: String,
-    default: null
-  },
-  offset: {
-    type: [Number, Object],
-    default: 4
-  },
-  clickOutside: {
-    type: Function,
-    default: () => true
-  }
-};
-defineComponent({
-  name: "DDropdownMenu",
-  inheritAttrs: false,
-  props: dropdownMenuProps,
-  emits: ["update:modelValue"],
-  setup(props, {
-    slots,
-    attrs,
-    emit
-  }) {
-    const {
-      modelValue,
-      origin,
-      position,
-      align,
-      offset: offset2,
-      clickOutside
-    } = toRefs(props);
-    const dropdownMenuRef = ref(null);
-    onClickOutside(dropdownMenuRef, (value) => {
-      var _a;
-      if (((_a = clickOutside.value) == null ? void 0 : _a.call(clickOutside)) && !origin.value.contains(value.target)) {
-        emit("update:modelValue", false);
-      }
-    });
-    const currentPosition = ref("bottom");
-    const handlePositionChange = (pos) => {
-      currentPosition.value = pos.split("-")[0] === "top" ? "top" : "bottom";
-    };
-    const styles = computed(() => ({
-      transformOrigin: currentPosition.value === "top" ? "0% 100%" : "0% 0%"
-    }));
-    return () => createVNode(Teleport, {
-      "to": "body"
-    }, {
-      default: () => [createVNode(Transition, {
-        "name": `devui-dropdown-fade-${currentPosition.value}`
-      }, {
-        default: () => [createVNode(FlexibleOverlay, {
-          "modelValue": modelValue.value,
-          "onUpdate:modelValue": ($event) => modelValue.value = $event,
-          "origin": origin == null ? void 0 : origin.value,
-          "position": position.value,
-          "align": align.value,
-          "offset": offset2.value,
-          "onPositionChange": handlePositionChange,
-          "style": styles.value
-        }, {
-          default: () => {
-            var _a;
-            return [createVNode("div", mergeProps({
-              "ref": dropdownMenuRef,
-              "class": "devui-dropdown-menu-wrap"
-            }, attrs), [(_a = slots.default) == null ? void 0 : _a.call(slots)])];
-          }
-        })]
-      })]
-    });
-  }
-});
-var filter = "";
-const Filter = defineComponent({
-  props: {
-    modelValue: {
-      type: Array,
-      default: []
-    },
-    "onUpdate:modelValue": {
-      type: Function
-    },
-    customTemplate: {
-      type: Function
-    },
-    filterList: {
-      type: Array,
-      required: true
-    },
-    filterMultiple: {
-      type: Boolean,
-      default: true
-    }
-  },
-  emits: ["update:modelValue"],
-  setup(props) {
-    const filterOrigin = ref(null);
-    const onUpdateChecked = (config, value) => {
-      const checkedList = props.modelValue;
-      const update = props["onUpdate:modelValue"];
-      const contained = !!checkedList.find((item) => item === config.value);
-      if (value && !contained) {
-        update == null ? void 0 : update([...checkedList, config.value]);
-      } else if (!value && contained) {
-        update == null ? void 0 : update(checkedList.filter((item) => config.value !== item));
-      }
-    };
-    const updateSingleChecked = (config) => {
-      var _a;
-      (_a = props["onUpdate:modelValue"]) == null ? void 0 : _a.call(props, [config.value]);
-    };
-    const dropdownContent = computed(() => {
-      const checkedList = props.modelValue;
-      const isContained = (config) => !!checkedList.find((item) => item === config.value);
-      return () => createVNode("ul", {
-        "class": "devui-dropdown-menu data-table-column-filter-content",
-        "style": "padding:10px"
-      }, [props.filterList.map((item, index2) => {
-        return createVNode("li", {
-          "style": index2 > 0 ? "margin-top:10px" : ""
-        }, [props.filterMultiple ? createVNode(Checkbox, {
-          "modelValue": isContained(item),
-          "onUpdate:modelValue": (value) => onUpdateChecked(item, value)
-        }, {
-          default: () => [item.name]
-        }) : createVNode("span", {
-          "onClick": () => updateSingleChecked(item)
-        }, [item.name])]);
-      })]);
-    });
-    return () => createVNode(Fragment, null, [createVNode("span", {
-      "ref": filterOrigin
-    }, [createVNode("i", {
-      "class": ["filter-icon", {
-        "filter-icon-active": true
-      }]
-    }, [createVNode("svg", {
-      "width": "16px",
-      "height": "16px",
-      "viewBox": "0 0 16 16",
-      "version": "1.1",
-      "xmlns": "http://www.w3.org/2000/svg",
-      "xmlns:xlink": "http://www.w3.org/1999/xlink"
-    }, [createVNode("g", {
-      "stroke": "none",
-      "stroke-width": "1",
-      "fill": "none",
-      "fill-rule": "evenodd"
-    }, [createVNode("g", null, [createVNode("polygon", {
-      "points": "10.0085775 7 10.0085775 15 6 13 6 7 2 3 2 1 14 1 14 3"
-    }, null)])])])])]), createVNode(Dropdown, {
-      "origin": filterOrigin.value,
-      "closeScope": "blank"
-    }, {
-      default: () => {
-        var _a, _b;
-        return [(_b = (_a = props.customTemplate) == null ? void 0 : _a.call(props, {
-          value: props.modelValue,
-          onChange: props["onUpdate:modelValue"]
-        })) != null ? _b : dropdownContent.value()];
-      }
-    })]);
-  }
-});
-var header = "";
-var body = "";
-const useSort = (store, column) => {
-  const directionRef = ref("DESC");
-  watch([directionRef, column], ([direction, column2]) => {
-    if (column2.sortable) {
-      store.sortData(column2.field, direction, column2.compareFn);
-    }
-  }, { immediate: true });
-  return directionRef;
-};
-const useFliter = (store, column) => {
-  const filteredRef = shallowRef();
-  watch(filteredRef, (results) => {
-    store.filterData(column.value.field, results);
-  });
-  return filteredRef;
-};
-var TableHeader = defineComponent({
-  name: "DTableHeader",
-  setup() {
-    const table2 = inject(TABLE_TOKEN);
-    const {
-      _checkAll: checkAll,
-      _halfChecked: halfChecked,
-      _columns: columns,
-      isFixedLeft
-    } = table2.store.states;
-    const thAttrs = computed(() => isFixedLeft.value ? {
-      class: "devui-sticky-cell left",
-      style: "left:0;"
-    } : null);
-    const checkbox2 = computed(() => table2.props.checkable ? createVNode("th", thAttrs.value, [createVNode(Checkbox, {
-      "style": "padding:10px;",
-      "modelValue": checkAll.value,
-      "onUpdate:modelValue": ($event) => checkAll.value = $event,
-      "halfchecked": halfChecked.value
-    }, null)]) : null);
-    return () => {
-      return createVNode("thead", {
-        "class": "devui-thead"
-      }, [createVNode("tr", null, [checkbox2.value, columns.value.map((column, index2) => createVNode(Th, {
-        "key": index2,
-        "column": column
-      }, null))])]);
-    };
-  }
-});
-const Th = defineComponent({
-  props: {
-    column: {
-      type: Object,
-      required: true
-    }
-  },
-  setup(props) {
-    const table2 = inject(TABLE_TOKEN);
-    const {
-      column
-    } = toRefs(props);
-    const directionRef = useSort(table2.store, column);
-    const filteredRef = useFliter(table2.store, column);
-    const {
-      stickyCell,
-      offsetStyle
-    } = useFixedColumn(column);
-    return () => createVNode("th", {
-      "class": stickyCell.value,
-      "style": offsetStyle.value
-    }, [createVNode("div", {
-      "class": "header-container"
-    }, [props.column.renderHeader(), props.column.filterable && createVNode(Filter, {
-      "modelValue": filteredRef.value,
-      "onUpdate:modelValue": ($event) => filteredRef.value = $event,
-      "filterList": props.column.filterList,
-      "customTemplate": props.column.customFilterTemplate
-    }, null)]), props.column.sortable && createVNode(Sort, {
-      "modelValue": directionRef.value,
-      "onUpdate:modelValue": ($event) => directionRef.value = $event
-    }, null)]);
-  }
-});
-var TableBody = defineComponent({
-  name: "DTableBody",
-  setup() {
-    const table2 = inject(TABLE_TOKEN);
-    const {
-      _data: data,
-      _columns: columns,
-      _checkList: checkList,
-      isFixedLeft
-    } = table2.store.states;
-    const hoverEnabled = computed(() => table2.props.rowHoveredHighlight);
-    const tdAttrs = computed(() => isFixedLeft.value ? {
-      class: "devui-sticky-cell left",
-      style: "left:0;"
-    } : null);
-    const renderCheckbox = (index2) => table2.props.checkable ? createVNode("td", tdAttrs.value, [createVNode(Checkbox, {
-      "modelValue": checkList.value[index2],
-      "onUpdate:modelValue": ($event) => checkList.value[index2] = $event
-    }, null)]) : null;
-    return () => createVNode("tbody", {
-      "class": "devui-tbody"
-    }, [data.value.map((row, rowIndex) => {
-      return createVNode("tr", {
-        "key": rowIndex,
-        "class": {
-          "hover-enabled": hoverEnabled.value
-        }
-      }, [renderCheckbox(rowIndex), columns.value.map((column, index2) => createVNode(TD, {
-        "column": column,
-        "index": index2,
-        "row": row
-      }, null))]);
-    })]);
-  }
-});
-const TD = defineComponent({
-  props: {
-    column: {
-      type: Object
-    },
-    row: {
-      type: Object
-    },
-    index: {
-      type: Number
-    }
-  },
-  setup(props) {
-    const column = toRef(props, "column");
-    const {
-      stickyCell,
-      offsetStyle
-    } = useFixedColumn(column);
-    return () => createVNode("td", {
-      "class": stickyCell.value,
-      "style": offsetStyle.value
-    }, [column.value.renderCell(props.row, props.index)]);
-  }
-});
-var FixHeader = defineComponent({
-  props: {
-    classes: {
-      type: Object,
-      default: () => ({})
-    },
-    isEmpty: {
-      type: Boolean
-    }
-  },
-  setup(props) {
-    return () => {
-      return createVNode("div", {
-        "class": "devui-table-view"
-      }, [createVNode("div", {
-        "style": "overflow:hidden scroll;"
-      }, [createVNode("table", {
-        "class": props.classes,
-        "cellpadding": "0",
-        "cellspacing": "0"
-      }, [createVNode(ColGroup, null, null), createVNode(TableHeader, null, null)])]), createVNode("div", {
-        "class": "scroll-view"
-      }, [createVNode("table", {
-        "class": props.classes,
-        "cellpadding": "0",
-        "cellspacing": "0"
-      }, [createVNode(ColGroup, null, null), !props.isEmpty && createVNode(TableBody, {
-        "style": "flex: 1"
-      }, null)])])]);
-    };
-  }
-});
-var NormalHeader = defineComponent({
-  props: {
-    classes: {
-      type: Object,
-      default: () => ({})
-    },
-    isEmpty: {
-      type: Boolean
-    }
-  },
-  setup(props) {
-    return () => {
-      return createVNode("table", {
-        "class": props.classes,
-        "cellpadding": "0",
-        "cellspacing": "0"
-      }, [createVNode(ColGroup, null, null), createVNode(TableHeader, {
-        "style": "position:relative"
-      }, null), !props.isEmpty && createVNode(TableBody, null, null)]);
-    };
-  }
-});
-var table = "";
-var Table = defineComponent({
-  name: "DTable",
-  props: TableProps,
-  setup(props, ctx) {
-    const table2 = getCurrentInstance();
-    const store = createStore(toRef(props, "data"));
-    table2.store = store;
-    provide(TABLE_TOKEN, table2);
-    const {
-      classes,
-      style
-    } = useTable(props);
-    const isEmpty2 = computed(() => props.data.length === 0);
-    ctx.expose({
-      getCheckedRows() {
-        return store.getCheckedRows();
-      }
-    });
-    return () => withDirectives(createVNode("div", {
-      "class": "devui-table-wrapper",
-      "style": style.value
-    }, [ctx.slots.default(), props.fixHeader ? createVNode(FixHeader, {
-      "classes": classes.value,
-      "is-empty": isEmpty2.value
-    }, null) : createVNode(NormalHeader, {
-      "classes": classes.value,
-      "is-empty": isEmpty2.value
-    }, null), isEmpty2.value && createVNode("div", {
-      "class": "devui-table-empty"
-    }, [createTextVNode("No Data")])]), [[resolveDirective("dLoading"), props.showLoading]]);
-  }
-});
-const TableColumnProps = {
-  header: {
-    type: String,
-    default: ""
-  },
-  field: {
-    type: String,
-    default: ""
-  },
-  width: {
-    type: [String, Number],
-    default: ""
-  },
-  minWidth: {
-    type: [String, Number],
-    default: 80
-  },
-  formatter: {
-    type: Function
-  },
-  order: {
-    type: Number,
-    default: 0
-  },
-  sortable: {
-    type: Boolean,
-    default: false
-  },
-  compareFn: {
-    type: Function,
-    default: (field, a, b) => a[field] < b[field]
-  },
-  filterable: {
-    type: Boolean,
-    default: false
-  },
-  filterMultiple: {
-    type: Boolean,
-    default: false
-  },
-  filterList: {
-    type: Array,
-    default: []
-  },
-  fixedLeft: {
-    type: String
-  },
-  fixedRight: {
-    type: String
-  }
-};
-function formatWidth(width) {
-  if (typeof width === "number") {
-    return width;
-  }
-  return parseInt(width, 10) || 0;
-}
-function formatMinWidth(minWidth) {
-  return formatWidth(minWidth) || 80;
-}
-function defaultRenderHeader() {
-  return h("span", { class: "title" }, this.header);
-}
-function createColumn(props, templates) {
-  const {
-    field,
-    header: header2,
-    sortable,
-    width,
-    minWidth,
-    formatter,
-    compareFn,
-    filterable,
-    filterList,
-    filterMultiple,
-    order,
-    fixedLeft,
-    fixedRight
-  } = props;
-  const column = reactive({});
-  function defaultRenderCell(rowData, index2) {
-    var _a, _b;
-    const value = rowData[this.field];
-    if (templates.default) {
-      return templates.default(rowData);
-    }
-    if (this.formatter) {
-      return this.formatter(rowData, value, index2);
-    }
-    return (_b = (_a = value == null ? void 0 : value.toString) == null ? void 0 : _a.call(value)) != null ? _b : "";
-  }
-  watch([field, header2, order], ([fieldVal, headerVal, orderVal]) => {
-    column.field = fieldVal;
-    column.header = headerVal;
-    column.order = orderVal;
-  }, { immediate: true });
-  watch([sortable, compareFn], ([sortableVal, compareFnVal]) => {
-    column.sortable = sortableVal;
-    column.compareFn = compareFnVal;
-  });
-  watch([filterable, filterList, filterMultiple], ([filterableVal, filterListVal, filterMultipleVal]) => {
-    column.filterable = filterableVal;
-    column.filterMultiple = filterMultipleVal;
-    column.filterList = filterListVal;
-  }, { immediate: true });
-  watch([fixedLeft, fixedRight], ([left, right]) => {
-    column.fixedLeft = left;
-    column.fixedRight = right;
-  }, { immediate: true });
-  watch([width, minWidth], ([widthVal, minWidthVal]) => {
-    column.width = formatWidth(widthVal);
-    column.minWidth = formatMinWidth(minWidthVal);
-    column.realWidth = column.width || column.minWidth;
-  });
-  onBeforeMount(() => {
-    column.renderHeader = defaultRenderHeader;
-    column.renderCell = defaultRenderCell;
-    column.formatter = formatter.value;
-    column.customFilterTemplate = templates.customFilterTemplate;
-    column.subColumns = templates.subColumns;
-  });
-  return column;
-}
-var Column = defineComponent({
-  name: "DColumn",
-  props: TableColumnProps,
-  setup(props, ctx) {
-    const column = createColumn(toRefs(props), ctx.slots);
-    const parent = inject(TABLE_TOKEN);
-    onMounted(() => {
-      parent.store.insertColumn(column);
-      watch(() => column.order, () => {
-        parent.store.sortColumn();
-      });
-    });
-    onBeforeUnmount(() => {
-      parent.store.removeColumn(column);
-    });
-  },
-  render() {
-    return null;
-  }
-});
-class View {
-  constructor() {
-    __publicField(this, "top", "50%");
-    __publicField(this, "left", "50%");
-  }
-}
-const componentProps = {
-  message: String,
-  backdrop: Boolean,
-  view: {
-    type: Object,
-    default: () => new View()
-  },
-  zIndex: Number,
-  isFull: {
-    type: Boolean,
-    default: false
-  }
-};
-class LoadingProps {
-  constructor() {
-    __publicField(this, "target");
-    __publicField(this, "message");
-    __publicField(this, "loadingTemplateRef");
-    __publicField(this, "backdrop", true);
-    __publicField(this, "positionType", "relative");
-    __publicField(this, "view", new View());
-    __publicField(this, "zIndex");
-  }
-}
-var loading = "";
-var Loading = defineComponent({
-  name: "DLoading",
-  inheritAttrs: false,
-  props: componentProps,
-  setup(props) {
-    const style = {
-      top: props.view.top,
-      left: props.view.left,
-      zIndex: props.zIndex
-    };
-    if (!props.message) {
-      style.background = "none";
-    }
-    const isShow = ref(false);
-    const open = () => {
-      isShow.value = true;
-    };
-    const close = () => {
-      isShow.value = false;
-    };
-    return {
-      style,
-      isShow,
-      open,
-      close
-    };
-  },
-  render() {
-    var _a;
-    const {
-      isShow,
-      isFull,
-      backdrop,
-      style,
-      message,
-      $slots
-    } = this;
-    return isShow && createVNode("div", {
-      "class": ["devui-loading-contanier", isFull ? "devui-loading--full" : ""]
-    }, [((_a = $slots.default) == null ? void 0 : _a.call($slots)) || createVNode("div", {
-      "class": "devui-loading-wrapper"
-    }, [backdrop ? createVNode("div", {
-      "class": "devui-loading-mask"
-    }, null) : null, createVNode("div", {
-      "style": style,
-      "class": "devui-loading-area"
-    }, [createVNode("div", {
-      "class": "devui-busy-default-spinner"
-    }, [createVNode("div", {
-      "class": "devui-loading-bar1"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar2"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar3"
-    }, null), createVNode("div", {
-      "class": "devui-loading-bar4"
-    }, null)]), message ? createVNode("span", {
-      "class": "devui-loading-text"
-    }, [message]) : null])])]);
-  }
-});
-const COMPONENT_CONTAINER_SYMBOL = Symbol("dev_component_container");
-function createComponent(Component, props, children = null) {
-  const vnode = h(Component, __spreadValues({}, props), children);
-  const container = document.createElement("div");
-  vnode[COMPONENT_CONTAINER_SYMBOL] = container;
-  render(vnode, container);
-  return vnode.component;
-}
-function unmountComponent(ComponnetInstance) {
-  render(null, ComponnetInstance == null ? void 0 : ComponnetInstance.vnode[COMPONENT_CONTAINER_SYMBOL]);
-}
-const loadingConstructor = defineComponent(Loading);
-const cacheInstance = /* @__PURE__ */ new WeakSet();
-const isEmpty = (val) => {
-  if (!val)
-    return true;
-  if (Array.isArray(val))
-    return val.length === 0;
-  if (val instanceof Set || val instanceof Map)
-    return val.size === 0;
-  if (val instanceof Promise)
-    return false;
-  if (typeof val === "object") {
-    try {
-      return Object.keys(val).length === 0;
-    } catch (e) {
-      return false;
-    }
-  }
-  return false;
-};
-const getType = (vari) => {
-  return Object.prototype.toString.call(vari).slice(8, -1).toLowerCase();
-};
-const isPromise = (value) => {
-  const type = getType(value);
-  switch (type) {
-    case "promise":
-      return [value];
-    case "array":
-      if (value.some((val) => getType(val) !== "promise")) {
-        console.error(new TypeError("Binding values should all be of type Promise"));
-        return "error";
-      }
-      return value;
-    default:
-      return false;
-  }
-};
-const unmount = (el) => {
-  cacheInstance.delete(el);
-  el.instance.proxy.close();
-  unmountComponent(el.instance);
-};
-const toggleLoading = (el, binding) => {
-  if (binding.value) {
-    const vals = isPromise(binding.value);
-    if (vals === "error")
-      return;
-    el.instance.proxy.open();
-    el.appendChild(el.mask);
-    cacheInstance.add(el);
-    if (vals) {
-      Promise.all(vals).catch((err) => {
-        console.error(new Error("Promise handling errors"), err);
-      }).finally(() => {
-        unmount(el);
-      });
-    }
-  } else {
-    unmount(el);
-  }
-};
-const removeAttribute = (el) => {
-  el.removeAttribute("zindex");
-  el.removeAttribute("positiontype");
-  el.removeAttribute("backdrop");
-  el.removeAttribute("message");
-  el.removeAttribute("view");
-  el.removeAttribute("loadingtemplateref");
-};
-const handleProps = (el, vprops) => {
-  const props = __spreadValues(__spreadValues({}, new LoadingProps()), vprops);
-  const loadingTemplateRef = props.loadingTemplateRef;
-  const loadingInstance = createComponent(loadingConstructor, __spreadValues({}, props), loadingTemplateRef ? () => loadingTemplateRef : null);
-  el.style.position = props.positionType;
-  el.options = props;
-  el.instance = loadingInstance;
-  el.mask = loadingInstance.proxy.$el;
-};
-const loadingDirective = {
-  mounted: function(el, binding, vnode) {
-    handleProps(el, vnode.props);
-    removeAttribute(el);
-    !isEmpty(binding.value) && toggleLoading(el, binding);
-  },
-  updated: function(el, binding, vnode) {
-    if (!isEmpty(binding.value) && cacheInstance.has(el) || isEmpty(binding.value) && !cacheInstance.has(el))
-      return;
-    !cacheInstance.has(el) && handleProps(el, vnode.props);
-    removeAttribute(el);
-    toggleLoading(el, binding);
-  }
-};
-defineComponent(Loading);
-Table.install = function(app) {
-  app.directive("dLoading", loadingDirective);
-  app.component(Table.name, Table);
-  app.component(Column.name, Column);
-};
-var index = {
-  title: "Table \u8868\u683C",
-  category: "\u6570\u636E\u5C55\u793A",
-  status: "10%",
-  install(app) {
-    app.use(Table);
-  }
-};
-export { Column, Table, index as default };