@farris/ui-vue 1.0.0-beta.2 → 1.0.0-beta.4

package/data-grid/index.esm.js

@@ -0,0 +1,1535 @@
+import { ref as D, watch as ce, computed as R, createVNode as S, resolveComponent as ye, Fragment as we, createTextVNode as be, defineComponent as Ce, onMounted as Se, nextTick as xe, onUnmounted as We } from "vue";
+const qe = {
+  enable: { type: Boolean, default: !0 },
+  index: { type: Number, default: 1 },
+  mode: { type: String, default: "server" },
+  showGoto: { type: Boolean, default: !1 },
+  showIndex: { type: Boolean, default: !0 },
+  showLimits: { type: Boolean, default: !1 },
+  showPageInfo: { type: Boolean, default: !0 },
+  size: { type: Number, default: 20 },
+  sizeLimits: { type: Array, default: [10, 20, 30, 50, 100] },
+  total: { type: Number, default: 0 }
+}, Ue = {
+  enable: { type: Boolean, default: !1 },
+  fields: { type: Array, default: [] },
+  mode: { type: String, default: "client" },
+  multiSort: { type: Boolean, default: !1 }
+}, Je = {
+  customGroupRow: { type: Function, default: () => {
+  } },
+  customGroupRowStyle: { type: Function, default: () => {
+  } },
+  customSummaryStyle: { type: Function, default: () => {
+  } },
+  enable: { type: Boolean, default: !1 },
+  groupColSpan: { type: Number, default: 1 },
+  groupFields: { type: Array, default: [] },
+  showGroupedColumn: { type: Boolean, default: !0 },
+  showGroupPanel: { type: Boolean, default: !1 },
+  showSummary: { type: Boolean, default: !1 },
+  summaryPosition: { type: String, default: "separate" }
+}, Qe = {
+  enable: { type: Boolean, default: !1 },
+  filterStyle: { type: String, default: "filter-column" },
+  mode: { type: String, default: "server" },
+  showSummary: { type: Boolean, default: !0 }
+}, Ze = {
+  wrapHeadings: { type: Boolean, default: !1 }
+}, Ie = {
+  enable: { type: Boolean, default: !1 },
+  heading: { type: String, default: "\u5E8F\u53F7" },
+  width: { type: Number, default: 36 }
+}, et = {
+  customRowStyle: { type: Function, default: () => {
+  } },
+  disable: { type: Function, default: () => {
+  } },
+  height: { type: Number, default: 28 },
+  showHovering: { type: Boolean, default: !0 },
+  wrapContent: { type: Boolean, default: !1 }
+}, tt = {
+  enable: { type: Boolean, default: !1 },
+  customSummaryStyle: { type: Function, default: () => {
+  } },
+  groupFields: { type: Array, default: [] },
+  mode: { type: String, default: "client" },
+  position: { type: String, default: "bottom" }
+}, at = {
+  fitColumns: { type: Boolean, default: !1 },
+  fitMode: { type: String, default: "average" },
+  groups: { type: Array, defaut: [] },
+  reorderColumn: { type: Boolean, default: !1 },
+  resizeColumn: { type: Boolean, default: !0 },
+  resizeColumnOnDoubleClick: { type: Boolean, default: !0 }
+}, lt = {
+  checkOnSelect: { type: Boolean, default: !1 },
+  clearSelectionOnEmpty: { type: Boolean, default: !0 },
+  customSelectionItem: { type: Function, default: () => {
+  } },
+  enabelSelectRow: { type: Boolean, default: !0 },
+  keepSelectingOnClick: { type: Boolean, default: !0 },
+  keepSelectingOnPaging: { type: Boolean, default: !0 },
+  multiSelect: { type: Boolean, default: !1 },
+  focusSelection: { type: String, default: "current" },
+  selectOnCheck: { type: Boolean, default: !1 },
+  showCheckbox: { type: Boolean, default: !1 },
+  showSelectAll: { type: Boolean, default: !1 },
+  showSelection: { type: Boolean, default: !1 }
+}, nt = {
+  selectOnEditing: { type: Boolean, default: !1 },
+  editMode: { type: String, default: "cell" }
+}, Oe = {
+  columns: { type: Array, default: [] },
+  columnOption: { type: Object },
+  data: { type: Array, default: [] },
+  disable: { type: Boolean, default: !1 },
+  editable: { type: Boolean, default: !1 },
+  editOption: { type: Object },
+  filter: { type: Object },
+  fit: { type: Boolean, default: !1 },
+  group: { type: Object },
+  header: { type: Object },
+  height: { type: Number, default: 300 },
+  id: { type: String, default: "" },
+  idField: { type: String, default: "id", require: !0 },
+  mergeCell: { type: Boolean, default: !1 },
+  pagination: { type: Object },
+  rowNumber: { type: Object },
+  rowOption: { type: Object },
+  selection: { type: Object },
+  showBorder: { type: Boolean, default: !1 },
+  showFooter: { type: Boolean, default: !1 },
+  showHeader: { type: Boolean, default: !0 },
+  showOptions: { type: Boolean, default: !1 },
+  showScrollBar: { type: String, default: "auto" },
+  showStripe: { type: Boolean, default: !0 },
+  sort: { type: Object },
+  summary: { type: Object },
+  virtualized: { type: Boolean, default: !1 },
+  width: { type: Number, default: 800 }
+};
+var q = /* @__PURE__ */ ((t) => (t[t.readonly = 0] = "readonly", t[t.editable = 1] = "editable", t[t.editing = 2] = "editing", t))(q || {}), ee = /* @__PURE__ */ ((t) => (t[t.data = 0] = "data", t[t.group = 1] = "group", t[t.summary = 2] = "summary", t))(ee || {});
+function He(t, g, d, m, O, w, B) {
+  var G, f;
+  const j = D(t.mergeCell), h = D(t.rowOption), M = ((G = h.value) == null ? void 0 : G.height) || 28, c = ((f = h.value) == null ? void 0 : f.wrapContent) || !1, r = D(O - 1 + w), b = D(0);
+  function n(_, H, x) {
+    const F = H && H.data[x];
+    if (F && F.data === _.data) {
+      const p = F && F.spannedBy || F;
+      p.rowSpan++, p.spanned = p.spanned || [], p.spanned.push(_), _.colSpan = 0, _.rowSpan = 0, _.spannedBy = p;
+    }
+  }
+  function u(_, H, x, F, W, p) {
+    const e = _.__fv_data_index__, l = {
+      index: F,
+      dataIndex: e,
+      top: W,
+      layer: -1,
+      type: ee.data,
+      pre: H,
+      data: {},
+      setRef: (i) => {
+        l.ref = i;
+      }
+    };
+    if (!c) {
+      l.height = M, _.__fv_data_height__ = l.height;
+      const i = l.pre;
+      if (i) {
+        const v = (i.__fv_data_position__ || 0) + (i.__fv_data_height__ || 0);
+        l.top = v, _.__fv_data_position__ = v;
+      }
+    }
+    return p.forEach((i, v) => {
+      const s = {
+        colSpan: 1,
+        rowSpan: 1,
+        index: v,
+        field: i.field,
+        mode: i.readonly ? q.readonly : q.editable,
+        data: _[i.field],
+        parent: l,
+        getEditor($) {
+          return B.getEditor($, i);
+        },
+        setRef: ($) => {
+          if (c && $) {
+            const P = s.parent;
+            s.cellHeight !== $.offsetHeight && (s.cellHeight = $.offsetHeight), s.cellHeight && s.cellHeight > (P.height || 0) && (P.height = s.cellHeight, _.__fv_data_height__ = P.height);
+            const C = P.pre;
+            if (C) {
+              const z = (C.__fv_data_position__ || 0) + (C.__fv_data_height__ || 0);
+              P.top = z, _.__fv_data_position__ = z;
+            }
+          }
+        },
+        update: ($) => {
+          $ !== void 0 && (_[i.field] = $, s.data = _[i.field]);
+        }
+      };
+      j.value && n(s, x, i.field), l.data[i.field] = s;
+    }), l;
+  }
+  function o(_, H, x, F) {
+    const { dataView: W } = m, p = [], e = F ? Date.now().toString() : "";
+    for (let l = _, i = 0; l < H; l++, i++) {
+      const v = W.value[l], s = W.value[l - 1] || x, $ = p[i - 1], P = s ? (s.__fv_data_position__ || 0) + (s.__fv_data_height__ || 0) : 0, C = v.__fv_data_grid_group_row__ ? d.renderGroupRow(v, s, l, P, g.value) : v.__fv_data_grid_group_summary__ ? d.renderSummaryRow(v, s, l, P, g.value) : u(v, s, $, l, P, g.value);
+      C.refreshKey = e, p.push(C);
+    }
+    return b.value = p[0].index, r.value = p[p.length - 1].index, p;
+  }
+  function a(_, H, x) {
+    const F = H.groupField || "", { groupValue: W } = H;
+    m[_](F, W);
+    const { dataView: p } = m, e = x[0].index, l = Math.min(e + O + w + 1, p.value.length);
+    return o(e, l);
+  }
+  return { getVisualData: o, maxVisibleRowIndex: r, minVisibleRowIndex: b, toggleGroupRow: a };
+}
+function $e(t, g) {
+  var b;
+  const d = ((b = t.rowOption) == null ? void 0 : b.height) || 28, m = D(g.value.primaryColumnsWidth);
+  function O(n) {
+    const u = {};
+    return n.reduce(
+      (o, a, G) => {
+        const f = G < n.length - 1 ? n[G + 1] : null;
+        return G === 0 && (o[a.field] = { left: 0, width: 0 }), o[a.field].width = a.actualWidth || 0, f && (o[f.field] = {
+          left: o[a.field].left + (a.actualWidth || 0),
+          width: 0
+        }), o;
+      },
+      u
+    ), u;
+  }
+  function w(n, u, o) {
+    const a = d * (o + 1), f = u[n.field].left - a + u[n.field].width, _ = n.parent.height ? `${n.parent.height}px` : "";
+    return {
+      left: `${a}px`,
+      width: `${f}px`,
+      height: `${_}`
+    };
+  }
+  function B(n, u, o) {
+    return {
+      right: "0px",
+      height: `${n.parent.height ? `${n.parent.height}px` : ""}`
+    };
+  }
+  function j(n, u) {
+    const o = n.parent.height ? `${n.parent.height}px` : "";
+    return {
+      left: `${u[n.field].left}px`,
+      width: `${u[n.field].width}px`,
+      height: `${o}`
+    };
+  }
+  function h(n, u, o) {
+    const G = (u.spanned || []).reduce((_, H) => _ + (H.parent.height || 0), 0) + (n.height || 0);
+    return {
+      top: `${n.top}px`,
+      left: `${o[u.field].left}px`,
+      width: `${o[u.field].width}px`,
+      height: `${G}px`,
+      padding: `calc(${G / 2}px - 1rem) 0`
+    };
+  }
+  function M(n, u) {
+    return `${n.type}_r_${n.index}_c_${u}_${n.refreshKey || ""}`;
+  }
+  function c(n) {
+    return `${n.type}_r_${n.index}_${n.refreshKey || ""}`;
+  }
+  function r(n) {
+    const u = n.height ? `${n.height}px` : "";
+    return {
+      top: `${n.top}px`,
+      width: `${m.value}px`,
+      height: `${u}`
+    };
+  }
+  return ce(g, () => {
+    m.value = g.value.primaryColumnsWidth;
+  }), {
+    calculateCellPositionInRow: O,
+    cellKey: M,
+    cellPosition: j,
+    groupCellPosition: w,
+    rowKey: c,
+    rowPosition: r,
+    rowSpanCellPosition: h,
+    summaryCellPosition: B
+  };
+}
+function De(t, g, d, m, O, w, B, j) {
+  var K;
+  const { dataView: h } = g, { getVisualData: M, maxVisibleRowIndex: c, minVisibleRowIndex: r } = O, b = D(m.value.primaryColumnsWidth), n = D(m.value.leftColumnsWidth), u = D(m.value.rightColumnsWidth), o = ((K = t.rowOption) == null ? void 0 : K.height) || 28, a = D(0), G = D(0);
+  let f = 0, _ = w - 1;
+  const H = D(0), x = D(0), F = D(0), W = o * w, p = R(() => h.value.length * o), e = R(() => h.value.length > w + B ? Math.floor((w + B) / h.value.length * x.value) : x.value), l = R(() => Math.floor(F.value / b.value * H.value)), i = 0, v = 0, s = R(() => H.value - (n.value + b.value + u.value + j.value));
+  function $() {
+    const E = c.value < h.value.length ? h.value[c.value] : h.value[h.value.length - 1];
+    return (E.__fv_data_position__ || 0) + (E.__fv_data_height__ || 0) + Math.max(h.value.length - 1 - c.value, 0) * o;
+  }
+  function P(E) {
+    const V = h.value.find((X) => X.__fv_data_position__ > E);
+    return V ? V.__fv_index__ - 1 : 0;
+  }
+  function C(E) {
+    const V = Math.max(f - B, 0), X = Math.min(_ + B + 1, h.value.length), U = h.value[V - 1], de = M(V, X, U, E);
+    de.length && (d.value = [...de]);
+  }
+  function z(E) {
+    let V = a.value + E;
+    V > i && (V = i);
+    const X = V > i, U = $(), de = U > x.value;
+    de && V < x.value - U && (V = x.value - U), (!de || X) && (V = i), a.value !== V && (a.value = V, f = P(Math.abs(a.value)), _ = f + w, (f < r.value || _ > c.value - B / 2) && C());
+  }
+  function N(E) {
+    let V = G.value + E;
+    V > v && (V = v), V < s.value && (V = s.value), G.value !== V && (G.value = V);
+  }
+  ce(F, () => {
+    N(0);
+  }), ce(m, () => {
+    b.value = m.value.primaryColumnsWidth, n.value = m.value.leftColumnsWidth, u.value = m.value.rightColumnsWidth;
+  });
+  function L(E) {
+    E.preventDefault(), E.stopPropagation();
+    const V = (E.wheelDeltaY || E.deltaY) / 10, X = (E.wheelDeltaX || E.deltaX) / 10;
+    z(V), N(X);
+  }
+  const Y = R(() => ({
+    height: `${h.value.length * o}px`,
+    width: `${n.value}px`,
+    transform: `translateY(${a.value}px)`
+  })), J = R(() => ({
+    transform: `translateY(${a.value}px)`
+  })), Q = R(() => ({
+    height: `${h.value.length * o}px`,
+    width: `${b.value}px`,
+    transform: `translate(${G.value}px, ${a.value}px)`
+  })), te = R(() => ({
+    transform: `translate(${G.value}px, ${a.value}px)`
+  })), oe = R(() => ({
+    height: `${h.value.length * o}px`,
+    width: `${u.value}px`,
+    transform: `translateY(${a.value}px)`
+  })), ae = R(() => ({
+    transform: `translateY(${a.value}px)`
+  })), le = R(() => ({
+    height: `${h.value.length * o}px`,
+    width: `${j.value}px`,
+    transform: `translateY(${a.value}px)`
+  })), ne = R(() => ({
+    width: `${n.value}px`
+  })), fe = R(() => ({
+    transform: `translateX(${G.value}px)`
+  })), he = R(() => ({
+    width: `${u.value}px`
+  })), ve = R(() => {
+    const E = $();
+    return a.value / (x.value - E) * (x.value - e.value);
+  }), pe = R(() => ({
+    height: `${e.value}px`,
+    top: `${ve.value}px`
+  })), se = R(() => G.value / s.value * (H.value - l.value)), ue = R(() => ({
+    width: `${l.value}px`,
+    left: `${se.value}px`
+  })), ie = D(!1), Z = D(-1), I = D(-1);
+  let re;
+  function y(E) {
+    if (ie.value && I.value !== -1) {
+      const V = I.value - E.pageX, X = H.value - l.value;
+      if (Math.abs(V) <= X) {
+        const U = V / (F.value - l.value) * (b.value - F.value);
+        N(U), I.value = E.pageX;
+      }
+    }
+  }
+  function A(E) {
+    if (ie.value && Z.value !== -1) {
+      const V = Z.value - E.pageY, X = W - e.value;
+      if (Math.abs(V) <= X) {
+        const U = V / (W - e.value) * (p.value - W);
+        z(U), Z.value = E.pageY;
+      }
+    }
+  }
+  function k(E) {
+    ie.value = !1, Z.value = -1, I.value = -1, document.removeEventListener("mouseup", k), re && (re.removeEventListener("mousemove", y), re.removeEventListener("mousemove", A)), document.body.style.userSelect = "";
+  }
+  function T(E, V, X) {
+    ie.value = !0;
+    const U = X === "horizontal" ? y : A;
+    X === "vertical" && (Z.value = E.pageY), X === "horizontal" && (I.value = E.pageX), V.value && (V.value.addEventListener("mousemove", U), re = V.value, document.addEventListener("mouseup", k), document.body.style.userSelect = "none");
+  }
+  return {
+    onMouseDownScrollThumb: T,
+    onWheel: L,
+    dataGridWidth: H,
+    gridDataStyle: Q,
+    gridHeaderColumnsStyle: fe,
+    gridMergedDataStyle: te,
+    gridSideStyle: le,
+    viewPortWidth: F,
+    viewPortHeight: x,
+    horizontalScrollThumbStyle: ue,
+    leftFixedGridDataStyle: Y,
+    leftFixedGridHeaderColumnsStyle: ne,
+    leftFixedGridMergedDataStyle: J,
+    reCalculateVisualDataRows: C,
+    rightFixedGridDataStyle: oe,
+    rightFixedGridHeaderColumnsStyle: he,
+    rightFixedGridMergedDataStyle: ae,
+    verticalScrollThumbStyle: pe
+  };
+}
+function Ge(t) {
+  const g = D(t.idField), d = D(-1), m = D("");
+  function O(h) {
+    return {
+      "fv-grid-row": h.type === ee.data,
+      "fv-grid-group-row": h.type === ee.group,
+      "fv-grid-summary-row": h.type === ee.summary,
+      "fv-grid-row-hover": h.index === d.value,
+      "fv-grid-row-selected": h.data[g.value].data === m.value,
+      "fv-grid-row-odd": h.dataIndex % 2 > 0,
+      "fv-grid-row-even": h.dataIndex % 2 === 0
+    };
+  }
+  function w(h, M) {
+    m.value = M.data[g.value].data;
+  }
+  function B(h, M) {
+    d.value = M.index;
+  }
+  function j(h) {
+    return {
+      "fv-grid-sidebar-row": !0,
+      "fv-grid-sidebar-row-hover": h.index === d.value,
+      "fv-grid-sidebar-row-selected": h.data[g.value].data === m.value,
+      "fv-grid-sidebar-row-odd": h.dataIndex % 2 > 0,
+      "fv-grid-sidebar-row-even": h.dataIndex % 2 === 0
+    };
+  }
+  return { gridRowClass: O, onClickRow: w, onMouseoverRow: B, sidebarRowClass: j };
+}
+function je(t) {
+  const d = D({
+    defaultColumnWidth: 120,
+    headerDepth: 1,
+    leftColumns: [],
+    leftColumnsWidth: 0,
+    leftHeaderColumns: [],
+    primaryColumns: [],
+    primaryColumnsWidth: 0,
+    primaryHeaderColumns: [],
+    rightColumns: [],
+    rightColumnsWidth: 0,
+    rightHeaderColumns: [],
+    summaryColumns: []
+  }), m = D(t.summary), O = R(() => {
+    const h = m.value;
+    return (h == null ? void 0 : h.groupFields) || [];
+  });
+  function w(h) {
+    const M = /* @__PURE__ */ new Map();
+    return O.value && O.value.reduce((c, r) => (c.set(r, !0), c), M), h.reduce((c, r) => (r.fixed === "left" ? (d.value.leftColumns.push(r), d.value.leftColumnsWidth += r.actualWidth || 120) : r.fixed === "right" ? (d.value.rightColumns.push(r), d.value.rightColumnsWidth += r.actualWidth || 120) : (d.value.primaryColumns.push(r), d.value.primaryColumnsWidth += r.actualWidth || 120), M.has(r.field) && d.value.summaryColumns.push(r), c), d), d;
+  }
+  w(t.columns);
+  const B = R(() => d.value.leftColumns.length > 0), j = R(() => d.value.rightColumns.length > 0);
+  return { columnContext: d, hasLeftFixedColumn: B, hasRightFixedColumn: j };
+}
+function Fe(t, g) {
+  var M;
+  const d = D((M = t.columnOption) == null ? void 0 : M.groups);
+  function m(c, r, b, n, u) {
+    const o = {
+      actualWidth: 0,
+      children: [],
+      depth: 1,
+      field: c.field,
+      layer: 1,
+      left: 0,
+      parent: b,
+      resizable: !1,
+      title: c.title || ""
+    }, a = n || o;
+    if (c.group) {
+      let G = 1;
+      c.group.reduce((f, _) => {
+        if (typeof _ == "string") {
+          const H = r.get(_);
+          H && (u.fieldToRootMap.set(_, a), f.actualWidth += H.actualWidth, f.children.push(H));
+        } else {
+          const H = m(_, r, f, a, u);
+          G = Math.max(G, H.depth), f.actualWidth += H.actualWidth, f.children.push(H);
+        }
+        return f;
+      }, o), o.depth += G;
+    }
+    return g.value.headerDepth = Math.max(g.value.headerDepth, o.depth), o;
+  }
+  function O(c) {
+    const r = {
+      groupedCells: /* @__PURE__ */ new Map(),
+      fieldToRootMap: /* @__PURE__ */ new Map()
+    };
+    return d.value && d.value.reduce((b, n) => {
+      const u = m(n, c, null, null, r);
+      return b.groupedCells.set(n.field, u), b;
+    }, r), r;
+  }
+  function w(c) {
+    if (!c || c.length === 0)
+      return 0;
+    const r = c[0];
+    return r.children && r.children.length > 0 && (r.left = w(r.children)), r.left;
+  }
+  function B(c, r) {
+    const b = g.value.headerDepth;
+    c.forEach((n) => {
+      n.layer = r ? r.layer + 1 : 1;
+      const u = n.children && n.children.length === 0;
+      n.depth = u ? b - (n.layer - 1) : 1, n.left = u ? n.left : w(n.children), n.children && B(n.children, n);
+    });
+  }
+  function j(c, r) {
+    const b = /* @__PURE__ */ new Map();
+    return c.forEach((n) => {
+      const u = r.fieldToRootMap.get(n.field), o = u != null;
+      o && !b.has(u.field) && b.set(u.field, u), o || b.set(n.field, n);
+    }), B(Array.from(b.values())), b;
+  }
+  function h(c) {
+    let r = /* @__PURE__ */ new Map(), b = 0;
+    if (c.reduce((n, u) => (n.set(u.field, {
+      actualWidth: u.actualWidth || 0,
+      children: [],
+      depth: 1,
+      layer: 1,
+      left: b,
+      field: u.field,
+      parent: null,
+      resizable: u.resizable || !1,
+      title: u.title
+    }), b += u.actualWidth || 0, n), r), d.value) {
+      const n = O(r);
+      r = j(r, n);
+    }
+    return r;
+  }
+  return { getGridHeaderCells: h };
+}
+function Be(t, g) {
+  var H, x, F, W, p;
+  const { getGridHeaderCells: d } = Fe(t, g), m = 120, O = 32, w = D(((H = t.rowNumber) == null ? void 0 : H.enable) || !1), B = D(((x = t.selection) == null ? void 0 : x.multiSelect) || !1), j = D(
+    0 + (w.value && ((F = t.rowNumber) == null ? void 0 : F.width) || 0) + (B.value ? O : 0)
+  ), h = D(((W = t.columnOption) == null ? void 0 : W.fitColumns) || !1), M = D(h.value && ((p = t.columnOption) == null ? void 0 : p.fitMode) || "none");
+  function c(e, l, i) {
+    const v = parseInt(e.width, 10) / 100;
+    return i * v;
+  }
+  function r(e, l, i) {
+    return typeof e.width == "string" ? c(e, l, i) : e.width || m;
+  }
+  function b(e, l) {
+    const i = [], v = [];
+    let s = 0;
+    e.value.primaryColumns.forEach((C) => {
+      typeof C.width == "string" ? v.push(C) : (C.width = C.width || m, s += C.width, i.push(C));
+    });
+    const $ = l * (i.length / e.value.primaryColumns.length);
+    i.forEach((C) => {
+      const z = $ * (C.width / s);
+      C.actualWidth = z, e.value.primaryColumnsWidth += C.actualWidth;
+    });
+    const P = l - $;
+    v.forEach((C) => {
+      const z = c(C, e.value, P);
+      C.actualWidth = z, e.value.primaryColumnsWidth += C.actualWidth;
+    });
+  }
+  function n(e, l) {
+    const i = l / (e.value.primaryColumns.length || 1);
+    e.value.primaryColumns.forEach((v) => {
+      v.actualWidth = i, e.value.primaryColumnsWidth += v.actualWidth;
+    });
+  }
+  function u(e, l) {
+    const i = [], v = [], s = /* @__PURE__ */ new WeakMap();
+    let $ = 0, P = 0;
+    if (e.value.primaryColumns.forEach((z) => {
+      if (typeof z.width == "string") {
+        const N = c(z, e.value, l);
+        s.set(z, N), $ += N, v.push(z);
+      } else
+        z.width = z.width || m, P += z.width, i.push(z);
+    }), l - $ > P) {
+      const z = l - $;
+      v.forEach((N) => {
+        N.actualWidth = s.get(N) || m, e.value.primaryColumnsWidth += N.actualWidth;
+      }), i.forEach((N) => {
+        N.actualWidth = z * (N.width / P), e.value.primaryColumnsWidth += N.actualWidth;
+      });
+    } else
+      b(e, l);
+  }
+  function o(e, l) {
+    e.value.primaryColumns.forEach((i) => {
+      i.actualWidth = r(i, e.value, l), e.value.primaryColumnsWidth += i.actualWidth;
+    });
+  }
+  const a = {
+    average: n,
+    expand: u,
+    none: o,
+    percentage: b
+  };
+  function G(e) {
+    e.value.leftHeaderColumns = Array.from(d(e.value.leftColumns).values()), e.value.primaryHeaderColumns = Array.from(d(e.value.primaryColumns).values()), e.value.rightHeaderColumns = Array.from(d(e.value.rightColumns).values());
+  }
+  function f(e) {
+    e.value.leftColumnsWidth = 0, e.value.primaryColumnsWidth = 0, e.value.rightColumnsWidth = 0, e.value.leftColumns.forEach((l) => {
+      e.value.leftColumnsWidth += l.actualWidth || 0;
+    }), e.value.primaryColumns.forEach((l) => {
+      e.value.primaryColumnsWidth += l.actualWidth || 0;
+    }), e.value.rightColumns.forEach((l) => {
+      e.value.rightColumnsWidth += l.actualWidth || 0;
+    }), e.value = Object.assign({}, e.value);
+  }
+  function _(e, l, i) {
+    if (l) {
+      e.value.leftColumnsWidth = 0, e.value.primaryColumnsWidth = 0, e.value.rightColumnsWidth = 0;
+      const v = l.clientWidth - j.value;
+      e.value.leftColumns.forEach((P) => {
+        P.actualWidth = r(P, e.value, v), e.value.leftColumnsWidth += P.actualWidth;
+      }), e.value.rightColumns.forEach((P) => {
+        P.actualWidth = r(P, e.value, v), e.value.rightColumnsWidth += P.actualWidth;
+      });
+      const s = v - e.value.leftColumnsWidth - e.value.rightColumnsWidth, $ = a[M.value];
+      $ && $(e, s), i.value = s, G(e), e.value = Object.assign({}, e.value);
+    }
+  }
+  return { calculateColumnHeaders: G, calculateColumnsSize: _, calculateColumnsWidth: f };
+}
+function Me(t) {
+  var M, c, r;
+  const d = D(((M = t.rowNumber) == null ? void 0 : M.enable) || !1), m = D(((c = t.selection) == null ? void 0 : c.showCheckbox) || !1), O = D(d.value && ((r = t.rowNumber) == null ? void 0 : r.width) || 0), w = D(m.value ? 50 : 0), B = R(() => w.value + O.value);
+  function j(b) {
+    return {
+      top: `${b.top}px`,
+      width: `${B.value}px`,
+      height: `${b.height || ""}px`
+    };
+  }
+  const h = R(() => ({
+    width: `${B.value}px`
+  }));
+  return { showRowCheckbox: m, showRowNumer: d, sidebarCellPosition: j, sidebarCornerCellStyle: h, sidebarWidth: B };
+}
+function me(t) {
+  const g = D(t.idField), d = D(t.summary), m = D(t.group), O = R(() => {
+    const a = d.value;
+    return (a == null ? void 0 : a.groupFields) || [];
+  }), w = R(() => {
+    const a = d.value;
+    return a && a.enable && a.groupFields && a.groupFields.length > 0;
+  }), B = R(() => {
+    const a = m.value;
+    return a && a.showSummary;
+  }), j = /* @__PURE__ */ new Map();
+  let h = [], M = "";
+  function c(a, G, f, _) {
+    const H = _[f];
+    H && (G.reduce((x, F, W) => {
+      const p = F[H];
+      let e = x.get(p);
+      if (!e) {
+        const l = O.value.reduce((i, v) => (i.set(v, 0), i), /* @__PURE__ */ new Map());
+        e = { field: H, value: p, layer: f, details: [], groupSummaries: l }, x.set(p, e);
+      }
+      return O.value && O.value.forEach((l) => {
+        if (e) {
+          const i = e.groupSummaries.get(l) || 0;
+          e.groupSummaries.set(l, i + F[l]);
+        }
+      }), e.details.push(F), x;
+    }, a), f < _.length - 1 && a.forEach((x, F) => {
+      x.nestGroup = /* @__PURE__ */ new Map(), c(x.nestGroup, x.details, f + 1, _), x.details = [];
+    }));
+  }
+  function r(a) {
+    const G = [];
+    return a.forEach((f) => {
+      const _ = {
+        __fv_data_grid_group_collapse__: !1,
+        __fv_data_grid_group_field__: f.field,
+        __fv_data_grid_group_layer__: f.layer,
+        __fv_data_grid_group_row__: !0,
+        __fv_data_grid_group_value__: f.value
+      };
+      let H = 0;
+      if (G.push(_), f.nestGroup) {
+        const x = r(f.nestGroup);
+        G.push(...x), H += x.length;
+      }
+      if (f.details && f.details.length && (G.push(...f.details), H += f.details.length), B.value) {
+        const x = {
+          __fv_data_grid_group_field__: f.field,
+          __fv_data_grid_group_layer__: f.layer,
+          __fv_data_grid_group_summary__: !0
+        };
+        x[g.value] = `summary_of_${f.field}_${f.value}`, x[f.field] = Array.from(f.groupSummaries.entries()).reduce(
+          (F, [W, p]) => `${F} ${W} total:${p} `,
+          ""
+        ), G.push(x);
+      }
+      f.groupSummaries && f.groupSummaries.size && f.groupSummaries.forEach((x, F) => {
+        _[F] = x;
+      }), _[g.value] = `group_of_${f.field}_${f.value}`, _[f.field] = `${f.field}:${f.value} (${H})`;
+    }), G.forEach((f, _) => {
+      f.__fv_data_index__ = _;
+    }), G;
+  }
+  function b(a, G) {
+    if (!a || a.length === 0)
+      return G;
+    const f = a.join(",");
+    return f !== M && (j.clear(), h = [], M = f, c(j, G, 0, a), h = r(j)), h;
+  }
+  function n(a, G, f, _, H) {
+    const x = a.__fv_data_grid_group_collapse__, F = a.__fv_data_grid_group_field__, W = a.__fv_data_grid_group_value__, p = a.__fv_data_index__, e = a.__fv_data_grid_group_layer__, l = {
+      collapse: x,
+      data: {},
+      dataIndex: p,
+      groupField: F,
+      groupValue: W,
+      layer: e,
+      index: f,
+      pre: G,
+      top: _,
+      type: ee.group,
+      setRef: (s) => {
+        l.ref = s;
+      }
+    }, i = {
+      colSpan: 0,
+      rowSpan: 0,
+      index: -1,
+      field: g.value,
+      data: a[g.value],
+      parent: l,
+      mode: q.readonly,
+      getEditor: (s) => s.data,
+      setRef: (s) => {
+        if (s) {
+          const $ = i.parent;
+          i.cellHeight !== s.offsetHeight && (i.cellHeight = s.offsetHeight), i.cellHeight && i.cellHeight > ($.height || 0) && ($.height = i.cellHeight, a.__fv_data_height__ = $.height);
+          const P = $.pre;
+          if (P) {
+            const C = (P.__fv_data_position__ || 0) + (P.__fv_data_height__ || 0);
+            $.top = C, a.__fv_data_position__ = C;
+          }
+        }
+      },
+      update: () => {
+      }
+    };
+    l.data[g.value] = i;
+    const v = {
+      colSpan: H.length,
+      rowSpan: 1,
+      index: 1,
+      field: F,
+      data: a[F],
+      parent: l,
+      mode: q.readonly,
+      getEditor: (s) => s.data,
+      setRef: (s) => {
+        if (s) {
+          const $ = v.parent;
+          v.cellHeight !== s.offsetHeight && (v.cellHeight = s.offsetHeight), v.cellHeight && v.cellHeight > ($.height || 0) && ($.height = v.cellHeight, a.__fv_data_height__ = $.height);
+          const P = $.pre;
+          if (P) {
+            const C = (P.__fv_data_position__ || 0) + (P.__fv_data_height__ || 0);
+            $.top = C, a.__fv_data_position__ = C;
+          }
+        }
+      },
+      update: () => {
+      }
+    };
+    if (l.data[F] = v, w.value) {
+      let s = v.colSpan;
+      const $ = O.value.reduce((P, C) => (P.set(C, !0), P), /* @__PURE__ */ new Map());
+      H.reduce((P, C, z) => {
+        if ($.has(C.field)) {
+          const N = {
+            colSpan: 1,
+            rowSpan: 1,
+            index: z,
+            field: C.field,
+            data: a[C.field],
+            parent: l,
+            mode: q.readonly,
+            getEditor: (L) => L.data,
+            setRef: (L) => {
+              if (L) {
+                const Y = N.parent;
+                N.cellHeight !== L.offsetHeight && (N.cellHeight = L.offsetHeight), N.cellHeight && N.cellHeight > (Y.height || 0) && (Y.height = N.cellHeight, a.__fv_data_height__ = Y.height);
+                const J = Y.pre;
+                if (J) {
+                  const Q = (J.__fv_data_position__ || 0) + (J.__fv_data_height__ || 0);
+                  Y.top = Q, a.__fv_data_position__ = Q;
+                }
+              }
+            },
+            update: () => {
+            }
+          };
+          l.data[C.field] = N, s - 1 > z && (s = z);
+        }
+        return P;
+      }, l), v.colSpan = s;
+    }
+    return l;
+  }
+  function u(a, G, f, _, H) {
+    const x = a.__fv_data_grid_group_field__, F = a.__fv_data_index__, W = a.__fv_data_grid_group_layer__, p = {
+      data: {},
+      dataIndex: F,
+      groupField: x,
+      groupValue: null,
+      layer: W,
+      index: f,
+      pre: G,
+      top: _,
+      type: ee.summary,
+      setRef: (i) => {
+        p.ref = i;
+      }
+    }, e = {
+      colSpan: 0,
+      rowSpan: 0,
+      index: -1,
+      field: g.value,
+      data: a[g.value],
+      parent: p,
+      mode: q.readonly,
+      getEditor: (i) => i.data,
+      setRef: (i) => {
+        if (i) {
+          const v = e.parent;
+          e.cellHeight !== i.offsetHeight && (e.cellHeight = i.offsetHeight), e.cellHeight && e.cellHeight > (v.height || 0) && (v.height = e.cellHeight, a.__fv_data_height__ = v.height);
+          const s = v.pre;
+          if (s) {
+            const $ = (s.__fv_data_position__ || 0) + (s.__fv_data_height__ || 0);
+            v.top = $, a.__fv_data_position__ = $;
+          }
+        }
+      },
+      update: () => {
+      }
+    };
+    p.data[g.value] = e;
+    const l = {
+      colSpan: H.length,
+      rowSpan: 1,
+      index: 1,
+      field: x,
+      data: a[x],
+      parent: p,
+      mode: q.readonly,
+      getEditor: (i) => i.data,
+      setRef: (i) => {
+        if (i) {
+          const v = l.parent;
+          l.cellHeight !== i.offsetHeight && (l.cellHeight = i.offsetHeight), l.cellHeight && l.cellHeight > (v.height || 0) && (v.height = l.cellHeight, a.__fv_data_height__ = v.height);
+          const s = v.pre;
+          if (s) {
+            const $ = (s.__fv_data_position__ || 0) + (s.__fv_data_height__ || 0);
+            v.top = $, a.__fv_data_position__ = $;
+          }
+        }
+      },
+      update: () => {
+      }
+    };
+    return p.data[x] = l, p;
+  }
+  function o(a) {
+    return {
+      "f-icon": !0,
+      "f-icon-arrow-chevron-down": !0,
+      "fv-grid-group-row-icon-collapse": a.collapse
+    };
+  }
+  return { collpaseGroupIconClass: o, renderGroupedData: b, renderGroupRow: n, renderSummaryRow: u };
+}
+function Pe(t) {
+  var x, F;
+  const g = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), m = D(((x = t.group) == null ? void 0 : x.groupFields) || []), O = D(((F = t.group) == null ? void 0 : F.enable) || !1), w = D(t.data), B = me(t), j = D(t.summary), h = R(() => {
+    const W = j.value;
+    return (W == null ? void 0 : W.groupFields) || [];
+  }), M = h.value.reduce((W, p) => (W.set(p, 0), W), /* @__PURE__ */ new Map()), c = R(() => w.value.length), r = D(t.pagination), b = R(() => {
+    var W;
+    return ((W = r.value) == null ? void 0 : W.size) || w.value.length;
+  }), n = D(1);
+  function u() {
+    let W = w.value;
+    O.value && (W = B.renderGroupedData(m.value, w.value));
+    const p = (n.value - 1) * b.value, e = Math.min(p + b.value, c.value);
+    let l = 0;
+    const i = [];
+    for (let v = p; v < e; v++) {
+      const s = W[v];
+      s.__fv_data_grid_group_row__ ? (l = 0, s.__fv_data_index__ = "") : s.__fv_data_grid_group_summary__ ? s.__fv_data_index__ = "" : (l++, s.__fv_data_index__ = l), s.__fv_index__ = v, h.value.forEach(($) => {
+        const P = M.get($) || 0;
+        M.set($, P + s[$]);
+      }), i.push(s);
+    }
+    return i;
+  }
+  const o = D(u());
+  function a(W, p = !1) {
+    const e = p ? u() : o.value;
+    return o.value = e.filter((l, i) => W.reduce((v, s) => v && s(l), !0)).map((l, i) => {
+      if (l.__fv_data_grid_group_row__) {
+        const v = `group_of_${l.__fv_data_grid_group_field__}_${l.__fv_data_grid_group_value__}`;
+        l.__fv_data_grid_group_collapse__ = !!g.get(v);
+      }
+      return l.__fv_index__ = i, l;
+    }), o.value;
+  }
+  function G(W, p) {
+    const e = `group_of_${W}_${p}`;
+    g.set(e, !0);
+    const l = (i) => i[W] !== p;
+    return d.set(`collapse_${W}_${p}`, l), a(Array.from(d.values()));
+  }
+  function f(W, p) {
+    const e = `group_of_${W}_${p}`;
+    return g.set(e, !1), d.delete(`collapse_${W}_${p}`), a(Array.from(d.values()), !0);
+  }
+  function _(W, p, e) {
+    return (W && W.length ? o.value.filter((i, v) => W.reduce((s, $) => s && $(i), !0)) : o.value).slice(p, e);
+  }
+  function H(W) {
+    if (W * b.value < c.value) {
+      n.value = W;
+      const e = u();
+      o.value = e;
+    }
+  }
+  return { collapse: G, dataView: o, expand: f, getRange: _, navigatePageTo: H, summaries: M, totalItems: c };
+}
+function Ee(t) {
+  return S(ye("f-date-picker"), {
+    modelValue: t.data,
+    onDatePicked: (g) => t.update(g)
+  }, null);
+}
+function ke(t) {
+  const g = R(() => ({
+    height: "100%",
+    resize: "none"
+  }));
+  return S("textarea", {
+    class: "form-control",
+    name: "text-area-cell-editor",
+    onInput: (d) => {
+      var m;
+      return t.update((m = d.target) == null ? void 0 : m.value);
+    },
+    style: g.value,
+    title: t.data,
+    value: t.data
+  }, null);
+}
+function ge(t) {
+  return S("input", {
+    class: "form-control",
+    name: "text-cell-editor",
+    title: t.data,
+    type: "text",
+    value: t.data,
+    onChange: (g) => {
+      var d;
+      return t.update((d = g.target) == null ? void 0 : d.value);
+    }
+  }, null);
+}
+function Re(t) {
+  var c;
+  const g = D(t.editable), d = D(((c = t.rowOption) == null ? void 0 : c.wrapContent) || !1);
+  ce(
+    () => t.editable,
+    () => {
+      g.value = t.editable;
+    }
+  );
+  const m = /* @__PURE__ */ new Map([
+    ["boolean", "checkbox"],
+    ["datetime", "date-picker"],
+    ["number", "text-editor"],
+    ["string", "text-editor"],
+    ["text", "text-area"]
+  ]), O = /* @__PURE__ */ new Map([
+    ["checkbox", ge],
+    ["date-picker", Ee],
+    ["text-editor", ge],
+    ["text-area", ke]
+  ]);
+  let w;
+  function B(r) {
+    r.mode = q.editing, w = r;
+  }
+  function j(r) {
+    r.mode = q.editable;
+  }
+  function h(r, b) {
+    g.value && b.mode === q.editable && w !== b && (w && j(w), B(b));
+  }
+  function M(r, b) {
+    const n = b.dataType;
+    let u = b.editor || m.get(n) || "text-editor";
+    !d.value && u === "text-area" && (u = "text-editor");
+    const o = O.get(u);
+    return o ? o(r) : r.data;
+  }
+  return { getEditor: M, onClickCell: h };
+}
+function ze(t, g, d, m, O, w, B, j, h, M) {
+  const {
+    calculateCellPositionInRow: c,
+    cellKey: r,
+    cellPosition: b,
+    rowKey: n,
+    rowPosition: u,
+    rowSpanCellPosition: o,
+    groupCellPosition: a,
+    summaryCellPosition: G
+  } = d, {
+    collpaseGroupIconClass: f
+  } = w, {
+    gridRowClass: _,
+    onClickRow: H,
+    onMouseoverRow: x
+  } = B, {
+    onClickCell: F
+  } = O, {
+    toggleGroupRow: W
+  } = j, {
+    columnContext: p,
+    hasLeftFixedColumn: e,
+    hasRightFixedColumn: l
+  } = m, {
+    onMouseDownScrollThumb: i,
+    onWheel: v,
+    dataGridWidth: s,
+    gridDataStyle: $,
+    gridMergedDataStyle: P,
+    gridSideStyle: C,
+    viewPortHeight: z,
+    viewPortWidth: N,
+    horizontalScrollThumbStyle: L,
+    leftFixedGridDataStyle: Y,
+    leftFixedGridMergedDataStyle: J,
+    rightFixedGridDataStyle: Q,
+    rightFixedGridMergedDataStyle: te,
+    verticalScrollThumbStyle: oe
+  } = h;
+  function ae(y, A) {
+    A.collapse = !A.collapse, M.value = W(A.collapse ? "collapse" : "expand", A, M.value);
+  }
+  function le(y, A) {
+    const k = [];
+    if (y.groupField && A[y.groupField]) {
+      for (let K = 0; K <= y.layer; K++)
+        k.push(S("div", {
+          class: "fv-grid-group-row-icon",
+          onClick: (E) => ae(E, y)
+        }, [S("span", {
+          class: f(y)
+        }, null)]));
+      const T = y.data[y.groupField];
+      k.push(S("div", {
+        ref: T.setRef,
+        key: r(y, y.layer + 1),
+        class: "fv-grid-cell",
+        style: a(T, A, y.layer)
+      }, [T.data])), Object.values(y.data).filter((K) => K.field !== y.groupField && K.colSpan !== 0).forEach((K) => {
+        k.push(S("div", {
+          ref: K.setRef,
+          key: r(y, K.index),
+          class: "fv-grid-cell",
+          style: b(K, A)
+        }, [K.data]));
+      });
+    }
+    return k;
+  }
+  function ne(y, A) {
+    return y.layer > -1 && S("div", {
+      ref: y.setRef,
+      key: n(y),
+      class: _(y),
+      style: u(y),
+      onClick: (k) => H(k, y),
+      onMouseover: (k) => x(k, y)
+    }, [le(y, A)]);
+  }
+  function fe(y, A) {
+    const k = [];
+    if (y.groupField && A[y.groupField]) {
+      const T = y.data[y.groupField];
+      k.push(S("div", {
+        ref: T.setRef,
+        key: r(y, y.layer + 1),
+        class: "fv-grid-cell",
+        style: G(T, A, y.layer)
+      }, [T.data]));
+    }
+    return k;
+  }
+  function he(y, A) {
+    return y.layer > -1 && S("div", {
+      ref: y.setRef,
+      key: n(y),
+      class: _(y),
+      style: u(y),
+      onClick: (k) => H(k, y),
+      onMouseover: (k) => x(k, y)
+    }, [fe(y, A)]);
+  }
+  function ve(y, A) {
+    return S("div", {
+      ref: y.setRef,
+      key: n(y),
+      class: _(y),
+      style: u(y),
+      onClick: (k) => H(k, y),
+      onMouseover: (k) => x(k, y)
+    }, [Object.values(y.data).filter((k) => A[k.field] && k.rowSpan === 1).map((k) => S("div", {
+      ref: k.setRef,
+      key: r(y, k.index),
+      class: "fv-grid-cell",
+      style: b(k, A),
+      onClick: (T) => F(T, k)
+    }, [k.mode === q.editing ? k.getEditor(k) : k.data]))]);
+  }
+  const pe = [ve, ne, he];
+  function se(y, A) {
+    const k = c(y);
+    return M.value.map((T) => pe[T.type](T, k));
+  }
+  function ue(y) {
+    const A = c(y);
+    return M.value.map((k) => Object.values(k.data).filter((T) => A[T.field] && T.rowSpan > 1).map((T) => S("div", {
+      key: r(k, T.index),
+      class: "fv-grid-cell fv-grid-merged-cell",
+      style: o(k, T, A)
+    }, [T.data])));
+  }
+  function ie() {
+    return S("div", {
+      class: "fv-grid-content-left-fixed"
+    }, [S("div", {
+      class: "fv-grid-data",
+      style: Y.value
+    }, [se(p.value.leftColumns)]), S("div", {
+      class: "fv-grid-merge-date",
+      style: J.value
+    }, [ue(p.value.leftColumns)])]);
+  }
+  function Z() {
+    return S("div", {
+      ref: g,
+      class: "fv-grid-content-primary"
+    }, [S("div", {
+      class: "fv-grid-data",
+      style: $.value
+    }, [se(p.value.primaryColumns)]), S("div", {
+      class: "fv-grid-merge-date",
+      style: P.value
+    }, [ue(p.value.primaryColumns)])]);
+  }
+  function I() {
+    return S("div", {
+      class: "fv-grid-content-right-fixed"
+    }, [S("div", {
+      class: "fv-grid-data",
+      style: Q.value
+    }, [se(p.value.rightColumns)]), S("div", {
+      class: "fv-grid-merge-date",
+      style: te.value
+    }, [ue(p.value.rightColumns)])]);
+  }
+  function re() {
+    const y = [];
+    return e.value && y.push(ie()), y.push(Z()), l.value && y.push(I()), y;
+  }
+  return {
+    renderDataArea: re
+  };
+}
+function Ve(t, g, d, m) {
+  const O = D(-1), w = D(0), B = D(!1);
+  let j = "";
+  const h = R(() => ({
+    display: B.value ? "block" : "none",
+    left: `${w.value}px`
+  })), M = R(() => ({
+    display: B.value ? "block" : "none"
+  }));
+  function c(n) {
+    w.value = n.clientX - n.target.parentElement.offsetLeft;
+  }
+  function r(n) {
+    const u = g.value.primaryColumns.find((o) => o.field === j) || g.value.leftColumns.find((o) => o.field === j) || g.value.rightColumns.find((o) => o.field === j);
+    if (u) {
+      const o = n.clientX - n.target.parentElement.offsetLeft;
+      u.actualWidth = (u.actualWidth || 0) + (o - O.value), d.calculateColumnHeaders(g), d.calculateColumnsWidth(g);
+    }
+    w.value = 0, B.value = !1, m.reCalculateVisualDataRows(), document.removeEventListener("mousemove", c), document.body.style.userSelect = "", j = "";
+  }
+  function b(n, u) {
+    j = u, B.value = !0;
+    const o = n.path.find((a) => a.className.split(" ")[0] === "fv-grid");
+    w.value = n.clientX - o.offsetLeft, O.value = n.clientX - o.offsetLeft, document.addEventListener("mousemove", c), document.addEventListener("mouseup", r), document.body.style.userSelect = "none";
+  }
+  return { onClickColumnResizeBar: b, resizeHandleStyle: h, resizeOverlayStyle: M };
+}
+function Ne(t, g, d, m, O, w, B) {
+  const {
+    showRowCheckbox: j,
+    showRowNumer: h,
+    sidebarCornerCellStyle: M
+  } = O, {
+    columnContext: c,
+    hasLeftFixedColumn: r,
+    hasRightFixedColumn: b
+  } = d, {
+    onClickColumnResizeBar: n,
+    resizeHandleStyle: u,
+    resizeOverlayStyle: o
+  } = Ve(t, c, m, w), {
+    gridHeaderColumnsStyle: a,
+    leftFixedGridHeaderColumnsStyle: G,
+    rightFixedGridHeaderColumnsStyle: f
+  } = w, _ = c.value.defaultColumnWidth, H = 32, x = /* @__PURE__ */ new Map([[0, 0]]);
+  function F(C, z) {
+    const N = x.get(z) || 0, L = {
+      height: `${C.depth * H}px`,
+      left: `${C.left}px`,
+      top: `${(C.layer - 1) * H}px`,
+      width: `${C.actualWidth}px`
+    };
+    return c.value.headerDepth > 1 && (L["line-height"] = `${C.depth * H}px`), x.set(z + 1, N + (C.actualWidth || _)), L;
+  }
+  const W = R(() => ({
+    "fv-grid-header": !0,
+    "fv-grid-header-group-columns": c.value.headerDepth > 1
+  })), p = R(() => ({
+    height: `${c.value.headerDepth * H}px`
+  }));
+  function e(C, z) {
+    return S("div", {
+      class: "fv-grid-header-cell",
+      style: F(C, z)
+    }, [C.title, C.resizable && S("span", {
+      class: "fv-column-resize-bar",
+      onMousedown: (N) => n(N, C.field)
+    }, null)]);
+  }
+  function l(C) {
+    return C.map((z, N) => {
+      const L = [];
+      if (L.push(e(z, N)), z.children && z.children.length) {
+        const Y = l(z.children);
+        L.push(...Y);
+      }
+      return L;
+    });
+  }
+  function i() {
+    return S("div", {
+      class: "fv-grid-header-left-fixed"
+    }, [S("div", {
+      class: "fv-grid-header-columns",
+      style: G.value
+    }, [l(c.value.leftHeaderColumns)])]);
+  }
+  function v() {
+    return S("div", {
+      class: "fv-grid-header-right-fixed"
+    }, [S("div", {
+      class: "fv-grid-header-columns",
+      style: f.value
+    }, [l(c.value.rightHeaderColumns)])]);
+  }
+  function s() {
+    var C;
+    return S("div", {
+      class: "fv-grid-header-corner",
+      style: M.value
+    }, [j.value && S("div", {
+      class: "custom-control custom-checkbox f-checkradio-single fv-grid-sidebar-row-checkbox"
+    }, [S("input", {
+      id: "sidebar_checkall",
+      title: "sidebar_checkall",
+      type: "checkbox",
+      class: "custom-control-input"
+    }, null), S("label", {
+      class: "custom-control-label",
+      for: "sidebar_checkall"
+    }, null)]), h.value && ((C = t.rowNumber) == null ? void 0 : C.heading)]);
+  }
+  function $() {
+    return S("div", {
+      class: W.value,
+      style: p.value
+    }, [(j.value || h.value) && s(), r.value && i(), S("div", {
+      class: "fv-grid-header-primary"
+    }, [S("div", {
+      class: "fv-grid-header-columns",
+      style: a.value
+    }, [l(c.value.primaryHeaderColumns)])]), b.value && v()]);
+  }
+  function P() {
+    return S(we, null, [S("div", {
+      class: "fv-datagrid-resize-overlay",
+      style: o.value
+    }, null), S("div", {
+      class: "fv-datagrid-resize-proxy",
+      style: u.value
+    }, null)]);
+  }
+  return {
+    renderGridHeader: $,
+    renderGridColumnResizeOverlay: P
+  };
+}
+function Ae(t, g) {
+  const d = R(() => 1e4);
+  function m(w) {
+    g.navigatePageTo(w);
+  }
+  function O() {
+    return S("div", {
+      class: "fv-datagrid-pagination"
+    }, [S(ye("f-pagination"), {
+      mode: "default",
+      totalItems: d.value,
+      onPageIndexChanged: m
+    }, null)]);
+  }
+  return {
+    renderDataGridPagination: O
+  };
+}
+function Te(t, g, d, m) {
+  const {
+    onMouseoverRow: O,
+    sidebarRowClass: w
+  } = g, {
+    showRowCheckbox: B,
+    showRowNumer: j,
+    sidebarCellPosition: h,
+    sidebarWidth: M
+  } = d, {
+    gridSideStyle: c
+  } = m;
+  function r(o) {
+    return S("div", {
+      class: "custom-control custom-checkbox f-checkradio-single fv-grid-sidebar-row-checkbox"
+    }, [S("input", {
+      id: `${o.dataIndex}`,
+      title: `${o.dataIndex}`,
+      type: "checkbox",
+      class: "custom-control-input"
+    }, null), S("label", {
+      class: "custom-control-label",
+      for: `${o.dataIndex}`
+    }, null)]);
+  }
+  function b(o) {
+    return S("div", {
+      class: "fv-grid-sidebar-row-number",
+      onMouseover: (a) => O(a, o)
+    }, [o.dataIndex]);
+  }
+  function n(o) {
+    return (B.value || j.value) && o.value.map((a) => S("div", {
+      class: w(a),
+      style: h(a)
+    }, [B.value && r(a), j.value && b(a)]));
+  }
+  function u(o) {
+    return S("div", {
+      class: "fv-grid-content-side"
+    }, [S("div", {
+      class: "fv-grid-side",
+      style: c.value
+    }, [n(o)])]);
+  }
+  return {
+    renderDataGridSidebar: u
+  };
+}
+function Le(t, g, d) {
+  const {
+    columnContext: m
+  } = d, O = D(t.summary), w = R(() => {
+    const j = O.value;
+    return j && j.enable && j.groupFields && j.groupFields.length > 0;
+  });
+  function B() {
+    return w.value && S("div", {
+      class: "fv-datagrid-summary"
+    }, [S("div", {
+      class: "fv-datagird-summary-panel"
+    }, [S("span", {
+      class: "fv-datagrid-summary-title"
+    }, [be("\u5F53\u9875\u5408\u8BA1")]), S("div", {
+      class: "fv-datagrid-summary-content"
+    }, [m.value.summaryColumns.map((j) => S("div", {
+      class: "fv-datagrid-summary-field"
+    }, [S("span", {
+      class: "fv-datagrid-summary-field-title"
+    }, [`${j.title}:`]), S("span", {
+      class: "fv-datagrid-summary-field-value"
+    }, [g.summaries.get(j.field)])]))])])]);
+  }
+  return {
+    renderDataGridSummery: B
+  };
+}
+function Xe(t, g, d) {
+  const {
+    horizontalScrollThumbStyle: m,
+    onMouseDownScrollThumb: O
+  } = d;
+  function w() {
+    return S("div", {
+      class: "fv-grid-horizontal-scroll"
+    }, [S("div", {
+      class: "fv-grid-horizontal-scroll-thumb",
+      style: m.value,
+      onMousedown: (B) => O(B, g, "horizontal")
+    }, null)]);
+  }
+  return {
+    renderHorizontalScrollbar: w
+  };
+}
+function Ye(t, g, d) {
+  const {
+    verticalScrollThumbStyle: m,
+    onMouseDownScrollThumb: O
+  } = d;
+  function w() {
+    return S("div", {
+      class: "fv-grid-vertical-scroll"
+    }, [S("div", {
+      class: "fv-grid-vertical-scroll-thumb",
+      style: m.value,
+      onMousedown: (B) => O(B, g, "vertical")
+    }, null)]);
+  }
+  return {
+    renderVerticalScrollbar: w
+  };
+}
+const _e = Ce({
+  name: "FDataGrid",
+  props: Oe,
+  emits: [],
+  setup(t) {
+    var te;
+    const g = D(t.columns), d = 20, m = 0, O = D(), w = D(), B = D(t.showStripe), j = D(!1), h = D(((te = t.rowOption) == null ? void 0 : te.wrapContent) || !1), M = Pe(t), c = je(t), {
+      columnContext: r
+    } = c, b = Be(t, r), {
+      calculateColumnsSize: n
+    } = b, u = me(t), o = Re(t), a = He(t, g, u, M, d, m, o), {
+      getVisualData: G
+    } = a, f = $e(t, r), _ = Me(t), {
+      sidebarWidth: H
+    } = _, x = D(G(0, d + m)), F = De(t, M, x, r, a, d, m, H), {
+      onWheel: W,
+      dataGridWidth: p,
+      viewPortHeight: e,
+      viewPortWidth: l
+    } = F, i = Ge(t), v = R(() => ({
+      "fv-grid": !0,
+      "fv-datagrid-strip": B.value
+    })), s = R(() => ({
+      "fv-grid-content": !0,
+      "fv-grid-content-hover": j.value,
+      "fv-grid-wrap-content": h.value
+    })), {
+      renderDataArea: $
+    } = ze(t, w, f, c, o, u, i, a, F, x), {
+      renderGridHeader: P,
+      renderGridColumnResizeOverlay: C
+    } = Ne(t, O, c, b, _, F), {
+      renderDataGridPagination: z
+    } = Ae(t, M), {
+      renderDataGridSidebar: N
+    } = Te(t, i, _, F), {
+      renderDataGridSummery: L
+    } = Le(t, M, c), {
+      renderHorizontalScrollbar: Y
+    } = Xe(t, O, F), {
+      renderVerticalScrollbar: J
+    } = Ye(t, O, F);
+    function Q(oe) {
+      var ae, le, ne;
+      e.value = ((ae = w.value) == null ? void 0 : ae.clientHeight) || 0, l.value = ((le = w.value) == null ? void 0 : le.clientWidth) || 0, p.value = ((ne = O.value) == null ? void 0 : ne.clientWidth) || 0;
+    }
+    return Se(() => {
+      O.value && (window.addEventListener("resize", Q), n(r, O.value, l), xe(() => {
+        O.value && (p.value = O.value.clientWidth), w.value && (l.value = w.value.clientWidth, e.value = w.value.clientHeight);
+      }));
+    }), We(() => {
+      window.removeEventListener("resize", Q);
+    }), ce(l, () => {
+      O.value && n(r, O.value, l);
+    }), () => S("div", {
+      class: v.value,
+      style: "height:600px",
+      onWheel: W
+    }, [P(), S("div", {
+      ref: O,
+      class: s.value,
+      onMouseover: () => {
+        j.value = !0;
+      },
+      onMouseleave: () => {
+        j.value = !1;
+      }
+    }, [N(x), $(), Y(), J()]), L(), z(), C()]);
+  }
+}), it = {
+  install(t) {
+    t.component(_e.name, _e);
+  }
+};
+export {
+  _e as FDataGrid,
+  at as columnOptions,
+  Oe as dataGridProps,
+  it as default,
+  nt as editOptions,
+  Qe as filterOptions,
+  Je as groupOptions,
+  Ze as headerOptions,
+  qe as paginationOptions,
+  Ie as rowNumberOptions,
+  et as rowOptions,
+  lt as selectionOptions,
+  Ue as sortOptions,
+  tt as summaryOptions
+};