ep-craft 0.1.7 → 0.1.9

package/dist/node_modules/element-plus/es/components/table/src/store/watcher.js

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

package/dist/node_modules/element-plus/es/components/table/src/table/defaults.js

@@ -0,0 +1,229 @@
+import { useSizeProp as e } from "../../../../hooks/use-size/index.js";
+const o = {
+  /**
+  * @description table data
+  */
+  data: {
+    type: Array,
+    default: () => []
+  },
+  /**
+  * @description size of Table
+  */
+  size: e,
+  width: [String, Number],
+  /**
+  * @description table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
+  */
+  height: [String, Number],
+  /**
+  * @description table's max-height. The legal value is a number or the height in px
+  */
+  maxHeight: [String, Number],
+  /**
+  * @description whether width of column automatically fits its container
+  */
+  fit: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether Table is striped
+  */
+  stripe: Boolean,
+  /**
+  * @description whether Table has vertical border
+  */
+  border: Boolean,
+  /**
+  * @description key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
+  */
+  rowKey: [String, Function],
+  /**
+  * @description whether Table header is visible
+  */
+  showHeader: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether to display a summary row
+  */
+  showSummary: Boolean,
+  /**
+  * @description displayed text for the first column of summary row
+  */
+  sumText: String,
+  /**
+  * @description custom summary method
+  */
+  summaryMethod: Function,
+  /**
+  * @description function that returns custom class names for a row, or a string assigning class names for every row
+  */
+  rowClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a row, or an object assigning custom style for every row
+  */
+  rowStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a cell, or a string assigning class names for every cell
+  */
+  cellClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a cell, or an object assigning custom style for every cell
+  */
+  cellStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
+  */
+  headerRowClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
+  */
+  headerRowStyle: [Object, Function],
+  /**
+  * @description function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
+  */
+  headerCellClassName: [String, Function],
+  /**
+  * @description function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
+  */
+  headerCellStyle: [Object, Function],
+  /**
+  * @description whether current row is highlighted
+  */
+  highlightCurrentRow: Boolean,
+  /**
+  * @description key of current row, a set only prop
+  */
+  currentRowKey: [String, Number],
+  /**
+  * @description displayed text when data is empty. You can customize this area with `#empty`
+  */
+  emptyText: String,
+  /**
+  * @description set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
+  */
+  expandRowKeys: Array,
+  /**
+  * @description whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
+  */
+  defaultExpandAll: Boolean,
+  /**
+  * @description enable expandable rows, works when the table has a column type="expand"
+  */
+  rowExpandable: { type: Function },
+  /**
+  * @description set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
+  */
+  defaultSort: Object,
+  /**
+  * @description the `effect` of the overflow tooltip
+  */
+  tooltipEffect: String,
+  /**
+  * @description the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
+  */
+  tooltipOptions: Object,
+  /**
+  * @description method that returns rowspan and colspan
+  */
+  spanMethod: Function,
+  /**
+  * @description controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
+  */
+  selectOnIndeterminate: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description horizontal indentation of tree data
+  */
+  indent: {
+    type: Number,
+    default: 16
+  },
+  /**
+  * @description configuration for rendering nested data
+  */
+  treeProps: {
+    type: Object,
+    default: () => ({
+      hasChildren: "hasChildren",
+      children: "children",
+      checkStrictly: !1
+    })
+  },
+  /**
+  * @description whether to lazy loading data
+  */
+  lazy: Boolean,
+  /**
+  * @description method for loading child row data, only works when `lazy` is true
+  */
+  load: Function,
+  style: {
+    type: [
+      String,
+      Object,
+      Array,
+      Boolean
+    ],
+    default: () => ({})
+  },
+  className: {
+    type: String,
+    default: ""
+  },
+  /**
+  * @description sets the algorithm used to lay out table cells, rows, and columns
+  */
+  tableLayout: {
+    type: String,
+    default: "fixed"
+  },
+  /**
+  * @description always show scrollbar
+  */
+  scrollbarAlwaysOn: Boolean,
+  /**
+  * @description ensure main axis minimum-size doesn't follow the content
+  */
+  flexible: Boolean,
+  /**
+  * @description whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
+  */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+  * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+  */
+  tooltipFormatter: Function,
+  appendFilterPanelTo: String,
+  scrollbarTabindex: {
+    type: [Number, String],
+    default: void 0
+  },
+  /**
+  * @description whether to allow drag the last column
+  */
+  allowDragLastColumn: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description whether to preserve expanded row content in DOM when collapsed
+  */
+  preserveExpandedContent: Boolean,
+  /**
+  * @description whether to use native scrollbars
+  */
+  nativeScrollbar: Boolean
+};
+export {
+  o as default,
+  o as tableProps
+};

package/dist/node_modules/element-plus/es/components/table/src/table/key-render-helper.js

@@ -0,0 +1,21 @@
+import { onMounted as u, onUnmounted as d } from "vue";
+function a(t) {
+  let e;
+  const n = () => {
+    const o = t.vnode.el.querySelector(".hidden-columns"), r = {
+      childList: !0,
+      subtree: !0
+    }, s = t.store.states.updateOrderFns;
+    e = new MutationObserver(() => {
+      s.forEach((c) => c());
+    }), e.observe(o, r);
+  };
+  u(() => {
+    n();
+  }), d(() => {
+    e == null || e.disconnect();
+  });
+}
+export {
+  a as default
+};