ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/store/watcher.js

@@ -0,0 +1,483 @@
+import { getCurrentInstance as tt, toRefs as lt, ref as r, computed as ge, watch as J, unref as nt } from "vue";
+import { isArray as X, isString as ye, hasOwn as at } from "@vue/shared";
+import { castArray as ot } from "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { getKeysMap as Ce, getRowIdentity as E, toggleRowStatus as B, getColumnByKey as st, getColumnById as ct, orderBy as ut } from "../util.js";
+import rt from "./expand.js";
+import it from "./current.js";
+import dt from "./tree.js";
+const ft = (o, x) => {
+  const c = x.sortingColumn;
+  return !c || ye(c.sortable) ? o : ut(
+    o,
+    x.sortProp,
+    x.sortOrder,
+    c.sortMethod,
+    c.sortBy
+  );
+}, H = (o) => {
+  const x = [];
+  return o.forEach((c) => {
+    c.children && c.children.length > 0 ? x.push.apply(x, H(c.children)) : x.push(c);
+  }), x;
+};
+function Et() {
+  var ve;
+  const o = tt(), { size: x } = lt((ve = o.proxy) == null ? void 0 : ve.$props), c = r(null), m = r([]), Y = r([]), Z = r(!1), b = r([]), ee = r([]), L = r([]), R = r([]), T = r([]), xe = r([]), Se = r([]), we = r([]), Ee = [], te = r(0), le = r(0), ne = r(0), M = r(!1), i = r([]), O = r({}), Re = r(!1), ae = r(!1), S = r(null), Ie = r(null), A = r({}), U = r(null), k = r(null), W = r(null), q = r(null), be = r(null);
+  let N = [];
+  const z = ge(() => c.value ? Ce(i.value, c.value) : void 0), Q = (e) => {
+    var a;
+    const { childrenColumnName: t, lazyTreeNodeMap: n } = o.store.states, l = e[t.value] ?? [];
+    if (!c.value) return l;
+    const s = E(e, c.value);
+    return [...((a = n.value) == null ? void 0 : a[s]) ?? [], ...l];
+  };
+  J(
+    m,
+    () => {
+      var e;
+      o.state && (ce(!1), o.props.tableLayout === "auto" && ((e = o.refs.tableHeaderRef) == null || e.updateFixedColumnStyle()));
+    },
+    {
+      deep: !0
+    }
+  );
+  const Me = () => {
+    if (!c.value) throw new Error("[ElTable] prop row-key is required");
+  }, oe = (e) => {
+    var t;
+    (t = e.children) == null || t.forEach((n) => {
+      n.fixed = e.fixed, oe(n);
+    });
+  }, se = () => {
+    b.value.forEach((a) => {
+      oe(a);
+    }), R.value = b.value.filter(
+      (a) => [!0, "left"].includes(a.fixed)
+    );
+    const e = b.value.find(
+      (a) => a.type === "selection"
+    );
+    let t;
+    e && e.fixed !== "right" && !R.value.includes(e) && b.value.indexOf(e) === 0 && R.value.length && (R.value.unshift(e), t = !0), T.value = b.value.filter(
+      (a) => a.fixed === "right"
+    );
+    const n = b.value.filter(
+      (a) => (t ? a.type !== "selection" : !0) && !a.fixed
+    );
+    ee.value = Array.from(R.value).concat(n).concat(T.value);
+    const l = H(n), s = H(R.value), u = H(T.value);
+    te.value = l.length, le.value = s.length, ne.value = u.length, L.value = Array.from(s).concat(l).concat(u), Z.value = R.value.length > 0 || T.value.length > 0;
+  }, ce = (e, t = !1) => {
+    e && se(), t ? o.state.doLayout() : o.state.debouncedUpdateLayout();
+  }, $ = (e) => z.value ? !!z.value[E(e, c.value)] : i.value.includes(e), K = ge(() => {
+    const e = /* @__PURE__ */ new Map();
+    if (!c.value || !S.value) return e;
+    let t = 0;
+    const n = (l) => {
+      X(l) && l.forEach((s) => {
+        const u = E(s, c.value);
+        e.set(u, t), t += 1;
+        const a = Q(s);
+        a.length && n(a);
+      });
+    };
+    return n(m.value || []), e;
+  }), F = (e = {}) => {
+    const { emitChange: t = !0 } = e;
+    if (g.checkStrictly.value || !c.value) {
+      O.value = {}, N = [];
+      return;
+    }
+    const n = c.value, l = e.rowIndexMap ?? K.value, s = S.value, u = /* @__PURE__ */ new WeakMap(), a = (C) => {
+      const p = u.get(C);
+      if (p) return p;
+      const w = E(C, n);
+      return u.set(C, w), w;
+    }, v = {}, h = [], d = new Set(
+      i.value.map((C) => a(C))
+    ), f = [];
+    let y = !1;
+    const et = (C, p, w) => {
+      const I = d.has(p);
+      w && !I ? (f.push(C), d.add(p), y = !0) : !w && I && (d.delete(p), y = !0);
+    }, he = (C) => {
+      let p = 0, w = 0;
+      return X(C) ? (C.forEach((I) => {
+        const P = a(I), pe = Q(I);
+        let j = 0, V = 0;
+        if (pe.length) {
+          const D = he(pe);
+          j = D.selectedCount, V = D.selectableCount;
+        }
+        const me = s ? s.call(null, I, l.get(P) ?? 0) : !0;
+        if (me && V > 0) {
+          const D = j === V;
+          !D && !(j === 0) && (v[P] = !0, h.push(I)), et(I, P, D);
+        }
+        me && (w += 1, d.has(P) && (p += 1)), p += j, w += V;
+      }), { selectedCount: p, selectableCount: w }) : { selectedCount: p, selectableCount: w };
+    };
+    if (he(m.value || []), y) {
+      const C = i.value.filter(
+        (p) => d.has(a(p))
+      );
+      f.forEach((p) => {
+        d.has(a(p)) && C.push(p);
+      }), i.value = C;
+    }
+    O.value = v, N = h, y && t && o.emit(
+      "selection-change",
+      i.value ? i.value.slice() : []
+    );
+  }, ke = () => {
+    M.value = !1;
+    const e = i.value;
+    i.value = [], O.value = {}, N = [], e.length && o.emit("selection-change", []);
+  }, ze = () => {
+    var t, n;
+    let e;
+    if (c.value) {
+      e = [];
+      const l = (n = (t = o == null ? void 0 : o.store) == null ? void 0 : t.states) == null ? void 0 : n.childrenColumnName.value, s = Ce(m.value, c.value, !0, l), { lazyTreeNodeMap: u } = o.store.states;
+      u.value && Object.entries(u.value).forEach(
+        ([a, v]) => {
+          s[a] && v.forEach((h) => {
+            const d = E(h, c.value);
+            s[d] || (s[d] = { row: h, index: -1 });
+          });
+        }
+      );
+      for (const a in z.value)
+        at(z.value, a) && !s[a] && e.push(z.value[a].row);
+    } else
+      e = i.value.filter((l) => !m.value.includes(l));
+    if (e.length) {
+      const l = i.value.filter(
+        (s) => !e.includes(s)
+      );
+      i.value = l, F({ emitChange: !1 }), o.emit("selection-change", [...l]);
+    }
+  }, Fe = () => (i.value || []).slice(), Le = () => N.slice(), _ = (e, t, n) => {
+    var d;
+    if (!c.value || g.checkStrictly.value || !g.lazy.value)
+      return;
+    const { lazyTreeNodeMap: l, childrenColumnName: s } = o.store.states, u = E(e, c.value), a = ((d = l.value) == null ? void 0 : d[u]) ?? [], v = e[s.value] ?? [], h = {
+      children: s.value,
+      checkStrictly: !1
+    };
+    for (const f of a) {
+      const y = n.get(E(f, c.value)) ?? 0;
+      B(
+        i.value,
+        f,
+        t,
+        h,
+        S.value,
+        y,
+        c.value
+      ), _(f, t, n);
+    }
+    for (const f of v)
+      _(f, t, n);
+  }, Oe = (e, t, n = !0, l = !1) => {
+    var a, v, h, d;
+    const s = {
+      children: (v = (a = o == null ? void 0 : o.store) == null ? void 0 : a.states) == null ? void 0 : v.childrenColumnName.value,
+      checkStrictly: (d = (h = o == null ? void 0 : o.store) == null ? void 0 : h.states) == null ? void 0 : d.checkStrictly.value
+    };
+    if (B(
+      i.value,
+      e,
+      t,
+      s,
+      l ? void 0 : S.value,
+      m.value.indexOf(e),
+      c.value
+    )) {
+      if (g.lazy.value && !g.checkStrictly.value) {
+        const y = t ?? $(e);
+        _(e, y, K.value), F({
+          emitChange: !1,
+          rowIndexMap: K.value
+        });
+      } else
+        F({ emitChange: !1 });
+      const f = (i.value || []).slice();
+      n && o.emit("select", f, e), o.emit("selection-change", f);
+    }
+  }, Te = () => {
+    var v, h;
+    const e = ae.value ? !M.value : !(M.value || i.value.length);
+    M.value = e;
+    let t = !1, n = 0;
+    const l = (h = (v = o == null ? void 0 : o.store) == null ? void 0 : v.states) == null ? void 0 : h.rowKey.value, { childrenColumnName: s } = o.store.states, u = {
+      children: s.value,
+      checkStrictly: !1
+      // Disable checkStrictly when selecting all
+    };
+    m.value.forEach((d, f) => {
+      const y = f + n;
+      B(
+        i.value,
+        d,
+        e,
+        u,
+        S.value,
+        y,
+        l
+      ) && (t = !0), n += ue(E(d, l));
+    });
+    const a = K.value;
+    if (g.lazy.value && !g.checkStrictly.value && l)
+      for (const d of Object.values(g.lazyTreeNodeMap.value))
+        for (const f of d) {
+          const y = a.get(E(f, l)) ?? 0;
+          B(
+            i.value,
+            f,
+            e,
+            u,
+            S.value,
+            y,
+            l
+          ) && (t = !0), _(f, e, a);
+        }
+    F({
+      emitChange: !1,
+      rowIndexMap: a
+    }), t && o.emit(
+      "selection-change",
+      i.value ? [...i.value] : []
+    ), o.emit("select-all", (i.value || []).slice());
+  }, G = () => {
+    var s;
+    if (((s = m.value) == null ? void 0 : s.length) === 0) {
+      M.value = !1;
+      return;
+    }
+    let e = 0, t = 0;
+    const n = (u) => {
+      for (const a of u) {
+        const v = S.value && S.value.call(null, a, e);
+        if ($(a))
+          t++;
+        else if (!S.value || v)
+          return !1;
+        e++;
+        const h = Q(a);
+        if (h.length && !n(h))
+          return !1;
+      }
+      return !0;
+    }, l = n(m.value || []);
+    M.value = t === 0 ? !1 : l;
+  }, Ae = (e) => {
+    if (!c.value) return !1;
+    const t = E(e, c.value);
+    return !!O.value[t];
+  }, ue = (e) => {
+    var s;
+    if (!o || !o.store) return 0;
+    const { treeData: t } = o.store.states;
+    let n = 0;
+    const l = (s = t.value[e]) == null ? void 0 : s.children;
+    return l && (n += l.length, l.forEach((u) => {
+      n += ue(u);
+    })), n;
+  }, Ne = (e, t) => {
+    const n = {};
+    return ot(e).forEach((l) => {
+      A.value[l.id] = t, n[l.columnKey || l.id] = t;
+    }), n;
+  }, re = (e, t, n) => {
+    k.value && k.value !== e && (k.value.order = null), k.value = e, W.value = t, q.value = n;
+  }, ie = () => {
+    let e = nt(Y);
+    Object.keys(A.value).forEach((t) => {
+      const n = A.value[t];
+      if (!n || n.length === 0) return;
+      const l = ct(
+        {
+          columns: L.value
+        },
+        t
+      );
+      l && l.filterMethod && (e = e.filter((s) => n.some(
+        (u) => l.filterMethod.call(null, u, s, l)
+      )));
+    }), U.value = e;
+  }, de = () => {
+    m.value = ft(U.value ?? [], {
+      sortingColumn: k.value,
+      sortProp: W.value,
+      sortOrder: q.value
+    });
+  }, Ke = (e = void 0) => {
+    e != null && e.filter || ie(), de();
+  }, _e = (e) => {
+    const { tableHeaderRef: t } = o.refs;
+    if (!t) return;
+    const n = Object.assign({}, t.filterPanels), l = Object.keys(n);
+    if (l.length)
+      if (ye(e) && (e = [e]), X(e)) {
+        const s = e.map(
+          (u) => st(
+            {
+              columns: L.value
+            },
+            u
+          )
+        );
+        l.forEach((u) => {
+          const a = s.find((v) => v.id === u);
+          a && (a.filteredValue = []);
+        }), o.store.commit("filterChange", {
+          column: s,
+          values: [],
+          silent: !0,
+          multi: !0
+        });
+      } else
+        l.forEach((s) => {
+          const u = L.value.find((a) => a.id === s);
+          u && (u.filteredValue = []);
+        }), A.value = {}, o.store.commit("filterChange", {
+          column: {},
+          values: [],
+          silent: !0
+        });
+  }, De = () => {
+    k.value && (re(null, null, null), o.store.commit("changeSortCondition", {
+      silent: !0
+    }));
+  }, {
+    setExpandRowKeys: Pe,
+    toggleRowExpansion: fe,
+    updateExpandRows: je,
+    states: Ve,
+    isRowExpanded: Be
+  } = rt({
+    data: m,
+    rowKey: c
+  }), {
+    updateTreeExpandKeys: He,
+    toggleTreeExpansion: Ue,
+    updateTreeData: We,
+    updateKeyChildren: qe,
+    loadOrToggle: Qe,
+    states: g
+  } = dt({
+    data: m,
+    rowKey: c
+  }), {
+    updateCurrentRowData: $e,
+    updateCurrentRow: Ge,
+    setCurrentRowKey: Je,
+    states: Xe
+  } = it({
+    data: m,
+    rowKey: c
+  }), Ye = (e) => {
+    Pe(e), He(e);
+  }, Ze = (e, t) => {
+    L.value.some(({ type: l }) => l === "expand") ? fe(e, t) : Ue(e, t);
+  };
+  return J(
+    () => g.checkStrictly.value,
+    (e) => {
+      e ? (O.value = {}, N = []) : F({ emitChange: !1 }), G();
+    }
+  ), J(
+    () => g.lazyTreeNodeMap.value,
+    () => {
+      var l;
+      if (!g.lazy.value || g.checkStrictly.value || !c.value)
+        return;
+      const e = K.value, t = i.value.length;
+      for (const s of Object.keys(g.lazyTreeNodeMap.value))
+        (l = z.value) != null && l[s] && _(
+          z.value[s].row,
+          !0,
+          e
+        );
+      const n = i.value.length !== t;
+      F({
+        emitChange: !n,
+        rowIndexMap: e
+      }), G(), n && o.emit("selection-change", [...i.value]);
+    }
+  ), {
+    assertRowKey: Me,
+    updateColumns: se,
+    scheduleLayout: ce,
+    isSelected: $,
+    clearSelection: ke,
+    cleanSelection: ze,
+    getSelectionRows: Fe,
+    getHalfSelectionRows: Le,
+    toggleRowSelection: Oe,
+    _toggleAllSelection: Te,
+    toggleAllSelection: null,
+    updateAllSelected: G,
+    updateSelectionByChildren: F,
+    getRowIndeterminate: Ae,
+    updateFilters: Ne,
+    updateCurrentRow: Ge,
+    updateSort: re,
+    execFilter: ie,
+    execSort: de,
+    execQuery: Ke,
+    clearFilter: _e,
+    clearSort: De,
+    toggleRowExpansion: fe,
+    setExpandRowKeysAdapter: Ye,
+    setCurrentRowKey: Je,
+    toggleRowExpansionAdapter: Ze,
+    isRowExpanded: Be,
+    updateExpandRows: je,
+    updateCurrentRowData: $e,
+    loadOrToggle: Qe,
+    updateTreeData: We,
+    updateKeyChildren: qe,
+    states: {
+      tableSize: x,
+      rowKey: c,
+      data: m,
+      _data: Y,
+      isComplex: Z,
+      _columns: b,
+      originColumns: ee,
+      columns: L,
+      fixedColumns: R,
+      rightFixedColumns: T,
+      leafColumns: xe,
+      fixedLeafColumns: Se,
+      rightFixedLeafColumns: we,
+      updateOrderFns: Ee,
+      leafColumnsLength: te,
+      fixedLeafColumnsLength: le,
+      rightFixedLeafColumnsLength: ne,
+      isAllSelected: M,
+      selection: i,
+      selectionIndeterminate: O,
+      reserveSelection: Re,
+      selectOnIndeterminate: ae,
+      selectable: S,
+      rowExpandable: Ie,
+      filters: A,
+      filteredData: U,
+      sortingColumn: k,
+      sortProp: W,
+      sortOrder: q,
+      hoverRow: be,
+      ...Ve,
+      ...g,
+      ...Xe
+    }
+  };
+}
+export {
+  Et as default
+};