great-simu/dist/index.js

elementPlus二次封装、common-ui、组件复用

import { computed as U, resolveComponent as b, createBlock as p, openBlock as g, unref as G, isRef as J, withCtx as u, renderSlot as i, createElementBlock as P, createCommentVNode as T, createVNode as A, createTextVNode as R, ref as X } from "vue";
const Y = {
  key: 0,
  class: "dialog-footer"
}, Z = {
  name: "SimuDialog",
  inheritAttrs: !1
}, _ = /* @__PURE__ */ Object.assign(Z, {
  props: {
    visible: {
      type: Boolean
    },
    showFooter: {
      type: Boolean,
      default: !0
    },
    title: {
      type: String,
      default: ""
    },
    width: {
      type: [String, Number],
      default: ""
    },
    fullscreen: {
      type: Boolean,
      default: !1
    },
    top: {
      type: String,
      default: ""
    },
    modal: {
      type: Boolean,
      default: !0
    },
    modalClass: {
      type: String
    },
    appendToBody: {
      type: Boolean,
      default: !1
    },
    appendTo: {
      type: String,
      default: "body"
    },
    lockScroll: {
      type: Boolean,
      default: !0
    },
    customClass: {
      type: String,
      default: ""
    },
    openDelay: {
      type: Number,
      default: 0
    },
    closeDelay: {
      type: Number,
      default: 0
    },
    closeOnClickModal: {
      type: Boolean,
      default: !0
    },
    closeOnPressEscape: {
      type: Boolean,
      default: !0
    },
    showClose: {
      type: Boolean,
      default: !0
    },
    beforeClose: {
      type: Function
    },
    draggable: {
      type: Boolean,
      default: !1
    },
    overflow: {
      type: Boolean,
      default: !1
    },
    center: {
      type: Boolean,
      default: !1
    },
    alignCenter: {
      type: Boolean,
      default: !1
    },
    destroyOnClose: {
      type: Boolean,
      default: !1
    },
    closeIcon: {
      type: [String, Object]
    },
    zIndex: {
      type: Number
    },
    headerAriaLevel: {
      type: String,
      default: "2"
    }
  },
  emits: [
    "update:visible",
    "close",
    "confirm",
    "open",
    "opened",
    "close",
    "closed",
    "open-auto-focus",
    "close-auto-focus"
  ],
  setup(e, { emit: l }) {
    const a = e, t = l, o = U({
      get: () => a.visible,
      set: (y) => t("update:visible", y)
    }), d = () => {
      o.value = !1;
    }, S = () => {
      t("confirm");
    }, w = () => {
      t("open");
    }, v = () => {
      t("opened");
    }, x = () => {
      t("close");
    }, k = () => {
      t("closed");
    }, O = () => {
      t("open-auto-focus");
    }, B = () => {
      t("close-auto-focus");
    };
    return (y, f) => {
      const C = b("el-button"), z = b("el-dialog");
      return g(), p(z, {
        class: "simu-dialog",
        modelValue: G(o),
        "onUpdate:modelValue": f[0] || (f[0] = (N) => J(o) ? o.value = N : null),
        title: e.title,
        width: e.width,
        fullscreen: e.fullscreen,
        top: e.top,
        modal: e.modal,
        "model-class": e.modalClass,
        "append-to-body": e.appendToBody,
        "append-to": e.appendTo,
        "lock-scroll": e.lockScroll,
        "custom-class": e.customClass,
        "open-delay": e.openDelay,
        "close-delay": e.closeDelay,
        "close-on-click-modal": e.closeOnClickModal,
        "close-on-press-escape": e.closeOnPressEscape,
        "show-close": e.showClose,
        "before-close": e.beforeClose,
        draggable: e.draggable,
        overflow: e.overflow,
        center: e.center,
        "align-center": e.alignCenter,
        "destroy-on-close": e.destroyOnClose,
        "close-icon": e.closeIcon,
        "z-index": e.zIndex,
        "header-aria-level": e.headerAriaLevel,
        onOpen: w,
        onOpened: v,
        onClose: x,
        onClosed: k,
        onOpenAutoFocus: O,
        onCloseAutoFocus: B
      }, {
        header: u(() => [
          i(y.$slots, "header")
        ]),
        default: u(() => [
          i(y.$slots, "default")
        ]),
        footer: u(() => [
          i(y.$slots, "footer", {}, () => [
            e.showFooter ? (g(), P("div", Y, [
              A(C, { onClick: d }, {
                default: u(() => f[1] || (f[1] = [
                  R("取消")
                ])),
                _: 1
              }),
              A(C, {
                type: "primary",
                onClick: S
              }, {
                default: u(() => f[2] || (f[2] = [
                  R(" 确定 ")
                ])),
                _: 1
              })
            ])) : T("", !0)
          ])
        ]),
        _: 3
      }, 8, ["modelValue", "title", "width", "fullscreen", "top", "modal", "model-class", "append-to-body", "append-to", "lock-scroll", "custom-class", "open-delay", "close-delay", "close-on-click-modal", "close-on-press-escape", "show-close", "before-close", "draggable", "overflow", "center", "align-center", "destroy-on-close", "close-icon", "z-index", "header-aria-level"]);
    };
  }
}), ee = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: _
}, Symbol.toStringTag, { value: "Module" })), te = {
  name: "SimuFormItem",
  inheritAttrs: !1
}, le = /* @__PURE__ */ Object.assign(te, {
  props: {
    col: {
      type: Number,
      default: 24
    },
    offset: {
      type: Number,
      default: 0
    },
    push: {
      type: Number,
      default: 0
    },
    pull: {
      type: Number,
      default: 0
    },
    xs: {
      type: [Number, Object]
    },
    sm: {
      type: [Number, Object]
    },
    md: {
      type: [Number, Object]
    },
    lg: {
      type: [Number, Object]
    },
    xl: {
      type: [Number, Object]
    },
    tag: {
      type: String,
      default: "div"
    },
    prop: {
      type: [String, Array]
    },
    label: {
      type: String
    },
    labelWidth: {
      type: [String, Number]
    },
    required: {
      type: Boolean
    },
    rules: {
      type: Object
    },
    error: {
      type: String
    },
    showMessage: {
      type: Boolean,
      default: !0
    },
    inlineMessage: {
      type: [String, Boolean],
      default: ""
    },
    size: {
      type: String,
      default: ""
    },
    for: {
      type: String
    },
    validateStatus: {
      type: String
    },
    disabled: {
      type: Boolean
    }
  },
  setup(e) {
    return (l, a) => {
      const t = b("el-form-item"), o = b("el-col");
      return g(), p(o, {
        span: e.col,
        offset: e.offset,
        push: e.push,
        pull: e.pull,
        xs: e.xs,
        sm: e.sm,
        md: e.md,
        lg: e.lg,
        xl: e.xl,
        tag: e.tag
      }, {
        default: u(() => [
          e.required ? (g(), p(t, {
            key: 0,
            prop: e.prop,
            label: e.label,
            labelWidth: e.labelWidth,
            required: e.required,
            rules: e.rules,
            error: e.error,
            "show-message": e.showMessage,
            "inline-message": e.inlineMessage,
            size: e.size,
            "validate-status": e.validateStatus
          }, {
            default: u(() => [
              i(l.$slots, "default")
            ]),
            label: u(() => [
              i(l.$slots, "label")
            ]),
            error: u(() => [
              i(l.$slots, "error")
            ]),
            _: 3
          }, 8, ["prop", "label", "labelWidth", "required", "rules", "error", "show-message", "inline-message", "size", "validate-status"])) : (g(), p(t, {
            key: 1,
            prop: e.prop,
            label: e.label,
            labelWidth: e.labelWidth,
            rules: e.rules,
            error: e.error,
            "show-message": e.showMessage,
            "inline-message": e.inlineMessage,
            size: e.size,
            "validate-status": e.validateStatus
          }, {
            default: u(() => [
              i(l.$slots, "default")
            ]),
            label: u(() => [
              i(l.$slots, "label")
            ]),
            error: u(() => [
              i(l.$slots, "error")
            ]),
            _: 3
          }, 8, ["prop", "label", "labelWidth", "rules", "error", "show-message", "inline-message", "size", "validate-status"]))
        ]),
        _: 3
      }, 8, ["span", "offset", "push", "pull", "xs", "sm", "md", "lg", "xl", "tag"]);
    };
  }
}), ne = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: le
}, Symbol.toStringTag, { value: "Module" })), ae = (e, l) => {
  const a = e.__vccOpts || e;
  for (const [t, o] of l)
    a[t] = o;
  return a;
}, oe = {
  name: "SimuQuery",
  inheritAttrs: !1
}, re = { class: "simu-query" };
function se(e, l, a, t, o, d) {
  return g(), P("div", re, [
    i(e.$slots, "default")
  ]);
}
const ue = /* @__PURE__ */ ae(oe, [["render", se]]), ie = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: ue
}, Symbol.toStringTag, { value: "Module" })), ce = { class: "simu-table" }, de = {
  name: "SimuTable",
  inheritAttrs: !1
}, fe = /* @__PURE__ */ Object.assign(de, {
  props: {
    showPagination: {
      type: Boolean,
      default: !0
    },
    small: {
      type: Boolean,
      default: !1
    },
    background: {
      type: Boolean,
      default: !0
    },
    pageSize: {
      type: Number
    },
    defaultPageSize: {
      type: Number
    },
    total: {
      type: Number
    },
    pageCount: {
      type: Number
    },
    pagerCount: {
      type: Number,
      default: 7
    },
    currentPage: {
      type: Number
    },
    defaultCurrentPage: {
      type: Number
    },
    layout: {
      type: String,
      default: "total,prev,pager,next,sizes"
    },
    pageSizes: {
      type: Object,
      default: () => [10, 20, 30, 40, 50, 100]
    },
    popperClass: {
      type: String,
      default: ""
    },
    prevText: {
      type: String,
      default: ""
    },
    prevIcon: {
      type: [String, Object],
      default: "ArrowLeft"
    },
    nextText: {
      type: String,
      default: ""
    },
    nextIcon: {
      type: [String, Object],
      default: "ArrowRight"
    },
    disabled: {
      type: Boolean,
      default: !1
    },
    teleported: {
      type: Boolean,
      default: !0
    },
    hideOnSinglePage: {
      type: Boolean,
      default: !1
    },
    data: {
      type: Array,
      default: () => []
    },
    height: {
      type: [String, Number]
    },
    maxHeight: {
      type: [String, Number]
    },
    stripe: {
      type: Boolean,
      default: !0
    },
    border: {
      type: Boolean,
      default: !1
    },
    size: {
      type: String
    },
    fit: {
      type: Boolean,
      default: !0
    },
    showHeader: {
      type: Boolean,
      default: !0
    },
    highlightCurrentRow: {
      type: Boolean,
      default: !1
    },
    currentRowKey: {
      type: [String, Number]
    },
    rowClassName: {
      type: [Function, String]
    },
    rowStyle: {
      type: [Function, Object]
    },
    cellClassName: {
      type: [Function, String]
    },
    cellStyle: {
      type: [Function, Object]
    },
    headerRowClassName: {
      type: [Function, String]
    },
    headerRowStyle: {
      type: [Function, Object]
    },
    headerCellClassName: {
      type: [Function, String]
    },
    headerCellStyle: {
      type: [Function, Object]
    },
    rowKey: {
      type: [Function, String]
    },
    emptyText: {
      type: String,
      default: "No Data"
    },
    defaultExpandAll: {
      type: Boolean,
      default: !1
    },
    expandRowKeys: {
      type: Object
    },
    defaultSort: {
      type: Object
    },
    tooltipEffect: {
      type: String,
      default: "dark"
    },
    tooltipOptions: {
      type: Object,
      default: () => ({
        enterable: !0,
        placement: "top",
        showArrow: !0,
        hideAfter: 200,
        popperOptions: { strategy: "fixed" }
      })
    },
    showSummary: {
      type: Boolean,
      default: !1
    },
    sumText: {
      type: String,
      default: "Sum"
    },
    summaryMethod: {
      type: Function
    },
    spanMethod: {
      type: Function
    },
    selectOnIndeterminate: {
      type: Boolean,
      default: !0
    },
    indent: {
      type: Number,
      default: 16
    },
    lazy: {
      type: Boolean,
      default: !1
    },
    load: {
      type: Function
    },
    treeProps: {
      type: Object,
      default: () => ({ hasChildren: "hasChildren", children: "children" })
    },
    tableLayout: {
      type: String,
      default: "fixed"
    },
    scrollbarAlwaysOn: {
      type: Boolean,
      default: !1
    },
    showOverflowTooltip: {
      type: [Boolean, Object]
    },
    flexible: {
      type: Boolean,
      default: !1
    }
  },
  emits: [
    "PageChange",
    "SizeChange",
    "change",
    "PrevClick",
    "NextClick",
    "select",
    "SelectAll",
    "SelectionChange",
    "CellMouseEnter",
    "CellMouseLeave",
    "CellClick",
    "CellDblclick",
    "CellContextmenu",
    "RowClick",
    "RowContextmenu",
    "RowDblclick",
    "HeaderClick",
    "HeaderContextmenu",
    "SortChange",
    "FilterChange",
    "CurrentChange",
    "HeaderDragend",
    "ExpandChange"
  ],
  setup(e, { expose: l, emit: a }) {
    const t = a, o = (n) => {
      t("SizeChange", n);
    }, d = (n) => {
      t("PageChange", n);
    }, S = (n) => {
      t("change", n);
    }, w = (n) => {
      t("PrevClick", n);
    }, v = (n) => {
      t("NextClick", n);
    }, x = (n, r) => {
      t("select", n, r);
    }, k = (n) => {
      t("SelectAll", n);
    }, O = (n) => {
      t("SelectionChange", n);
    }, B = (n, r, s, c) => {
      t("CellMouseEnter", n, r, s, c);
    }, y = (n, r, s, c) => {
      t("CellMouseLeave", n, r, s, c);
    }, f = (n, r, s, c) => {
      t("CellClick", n, r, s, c);
    }, C = (n, r, s, c) => {
      t("CellDblclick", n, r, s, c);
    }, z = (n, r, s, c) => {
      t("CellContextmenu", n, r, s, c);
    }, N = (n, r, s) => {
      t("RowClick", n, r, s);
    }, D = (n, r, s) => {
      t("RowContextmenu", n, r, s);
    }, H = (n, r, s) => {
      t("RowDblclick", n, r, s);
    }, I = (n, r) => {
      t("HeaderClick", n, r);
    }, L = (n, r) => {
      t("HeaderContextmenu", n, r);
    }, W = (n) => {
      t("SortChange", n);
    }, q = (n) => {
      t("FilterChange", n);
    }, K = (n, r) => {
      t("CurrentChange", n, r);
    }, V = (n, r, s, c) => {
      t("HeaderDragend", n, r, s, c);
    }, Q = (n, r) => {
      t("ExpandChange", n, r);
    }, F = X();
    return l({
      getTable: () => F.value
    }), (n, r) => {
      const s = b("el-table"), c = b("el-pagination");
      return g(), P("div", ce, [
        i(n.$slots, "top"),
        A(s, {
          ref_key: "tableRef",
          ref: F,
          data: e.data,
          height: e.height,
          "max-height": e.maxHeight,
          stripe: e.stripe,
          border: e.border,
          size: e.size,
          fit: e.fit,
          "show-header": e.showHeader,
          "highlight-current-row": e.highlightCurrentRow,
          "current-row-key": e.currentRowKey,
          "row-class-name": e.rowClassName,
          "row-style": e.rowStyle,
          "cell-style": e.cellStyle,
          "header-row-class-name": e.headerRowClassName,
          "header-row-style": e.headerRowStyle,
          "header-cell-class-name": e.headerCellClassName,
          "header-cell-style": e.headerCellStyle,
          "row-key": e.rowKey,
          "empty-text": e.emptyText,
          "default-expand-all": e.defaultExpandAll,
          "expand-row-keys": e.expandRowKeys,
          "default-sort": e.defaultSort,
          "tooltip-effect": e.tooltipEffect,
          "tooltip-options": e.tooltipOptions,
          "show-summary": e.showSummary,
          "sum-text": e.sumText,
          "summary-method": e.summaryMethod,
          "span-method": e.spanMethod,
          "select-on-indeterminate": e.selectOnIndeterminate,
          indent: e.indent,
          lazy: e.lazy,
          load: e.load,
          "tree-props": e.treeProps,
          "table-layout": e.tableLayout,
          "scrollbar-always-on": e.scrollbarAlwaysOn,
          "show-overflow-tooltip": e.showOverflowTooltip,
          flexible: e.flexible,
          onSelect: x,
          onSelectAll: k,
          onSelectionChange: O,
          onCellMouseEnter: B,
          onCellMouseLeave: y,
          onCellClick: f,
          onCellDblclick: C,
          onCellContextmenu: z,
          onRowClick: N,
          onRowContextmenu: D,
          onRowDblclick: H,
          onHeaderClick: I,
          onHeaderContextmenu: L,
          onSortChange: W,
          onFilterChange: q,
          onCurrentChange: K,
          onHeaderDragend: V,
          onExpandChange: Q
        }, {
          default: u(() => [
            i(n.$slots, "default")
          ]),
          append: u(() => [
            i(n.$slots, "append")
          ]),
          empty: u(() => [
            i(n.$slots, "empty")
          ]),
          _: 3
        }, 8, ["data", "height", "max-height", "stripe", "border", "size", "fit", "show-header", "highlight-current-row", "current-row-key", "row-class-name", "row-style", "cell-style", "header-row-class-name", "header-row-style", "header-cell-class-name", "header-cell-style", "row-key", "empty-text", "default-expand-all", "expand-row-keys", "default-sort", "tooltip-effect", "tooltip-options", "show-summary", "sum-text", "summary-method", "span-method", "select-on-indeterminate", "indent", "lazy", "load", "tree-props", "table-layout", "scrollbar-always-on", "show-overflow-tooltip", "flexible"]),
        e.showPagination ? (g(), p(c, {
          key: 0,
          class: "simu-pagination",
          small: e.small,
          background: e.background,
          "page-size": e.pageSize,
          "default-page-size": e.defaultPageSize,
          total: e.total,
          "page-count": e.pageCount,
          "pager-count": e.pagerCount,
          "current-page": e.currentPage,
          "default-current-page": e.defaultCurrentPage,
          layout: e.layout,
          "page-sizes": e.pageSizes,
          "popper-class": e.popperClass,
          "prev-text": e.prevText,
          "prev-icon": e.prevIcon,
          "next-text": e.nextText,
          "next-icon": e.nextIcon,
          disabled: e.disabled,
          teleported: e.teleported,
          "hide-on-single-page": e.hideOnSinglePage,
          onSizeChange: o,
          onCurrentChange: d,
          onChange: S,
          onPrevClick: w,
          onNextClick: v
        }, null, 8, ["small", "background", "page-size", "default-page-size", "total", "page-count", "pager-count", "current-page", "default-current-page", "layout", "page-sizes", "popper-class", "prev-text", "prev-icon", "next-text", "next-icon", "disabled", "teleported", "hide-on-single-page"])) : T("", !0)
      ]);
    };
  }
}), ge = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: fe
}, Symbol.toStringTag, { value: "Module" }));
function h(e) {
  return e != null && typeof e == "object" && e["@@functional/placeholder"] === !0;
}
function m(e) {
  return function l(a) {
    return arguments.length === 0 || h(a) ? l : e.apply(this, arguments);
  };
}
function ye(e) {
  return function l(a, t) {
    switch (arguments.length) {
      case 0:
        return l;
      case 1:
        return h(a) ? l : m(function(o) {
          return e(a, o);
        });
      default:
        return h(a) && h(t) ? l : h(a) ? m(function(o) {
          return e(o, t);
        }) : h(t) ? m(function(o) {
          return e(a, o);
        }) : e(a, t);
    }
  };
}
const he = Array.isArray || function(l) {
  return l != null && l.length >= 0 && Object.prototype.toString.call(l) === "[object Array]";
};
function j(e, l) {
  return Object.prototype.hasOwnProperty.call(l, e);
}
var M = Object.prototype.toString, me = /* @__PURE__ */ function() {
  return M.call(arguments) === "[object Arguments]" ? function(l) {
    return M.call(l) === "[object Arguments]";
  } : function(l) {
    return j("callee", l);
  };
}(), be = !/* @__PURE__ */ {
  toString: null
}.propertyIsEnumerable("toString"), $ = ["constructor", "valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString"], E = /* @__PURE__ */ function() {
  return arguments.propertyIsEnumerable("length");
}(), pe = function(l, a) {
  for (var t = 0; t < l.length; ) {
    if (l[t] === a)
      return !0;
    t += 1;
  }
  return !1;
}, Ce = /* @__PURE__ */ m(typeof Object.keys == "function" && !E ? function(l) {
  return Object(l) !== l ? [] : Object.keys(l);
} : function(l) {
  if (Object(l) !== l)
    return [];
  var a, t, o = [], d = E && me(l);
  for (a in l)
    j(a, l) && (!d || a !== "length") && (o[o.length] = a);
  if (be)
    for (t = $.length - 1; t >= 0; )
      a = $[t], j(a, l) && !pe(o, a) && (o[o.length] = a), t -= 1;
  return o;
}), Se = /* @__PURE__ */ m(function(l) {
  for (var a = Ce(l), t = a.length, o = [], d = 0; d < t; )
    o[d] = l[a[d]], d += 1;
  return o;
});
function we(e, l) {
  return function() {
    var a = arguments.length;
    if (a === 0)
      return l();
    var t = arguments[a - 1];
    return he(t) || typeof t[e] != "function" ? l.apply(this, arguments) : t[e].apply(t, Array.prototype.slice.call(arguments, 0, a - 1));
  };
}
var ve = /* @__PURE__ */ ye(
  /* @__PURE__ */ we("forEach", function(l, a) {
    for (var t = a.length, o = 0; o < t; )
      l(a[o]), o += 1;
    return a;
  })
);
const xe = /* @__PURE__ */ Object.assign({ "./packages/SimuDialog.vue": ee, "./packages/SimuFormItem.vue": ne, "./packages/SimuQuery.vue": ie, "./packages/SimuTable.vue": ge }), Be = {
  install(e) {
    ve((l) => e.component(l.default.name, l.default), Se(xe));
  }
};
export {
  Be as default
};