fec-dev-designer 1.0.0

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

@@ -0,0 +1,58 @@
+import { watch as c } from "vue";
+import s from "./index.js";
+import { isObject as u } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import d from "../../../../../../lodash-es/debounce.js";
+const o = {
+  rowKey: "rowKey",
+  defaultExpandAll: "defaultExpandAll",
+  selectOnIndeterminate: "selectOnIndeterminate",
+  indent: "indent",
+  lazy: "lazy",
+  "treeProps.hasChildren": {
+    key: "lazyColumnIdentifier",
+    default: "hasChildren"
+  },
+  "treeProps.children": {
+    key: "childrenColumnName",
+    default: "children"
+  },
+  "treeProps.checkStrictly": {
+    key: "checkStrictly",
+    default: !1
+  }
+};
+function S(l, r) {
+  if (!l)
+    throw new Error("Table is required.");
+  const e = s();
+  return e.toggleAllSelection = d(e._toggleAllSelection, 10), Object.keys(o).forEach((t) => {
+    a(i(r, t), t, e);
+  }), f(e, r), e;
+}
+function f(l, r) {
+  Object.keys(o).forEach((e) => {
+    c(
+      () => i(r, e),
+      (t) => {
+        a(t, e, l);
+      }
+    );
+  });
+}
+function a(l, r, e) {
+  let t = l, n = o[r];
+  u(n) && (t = t || n.default, n = n.key), e.states[n].value = t;
+}
+function i(l, r) {
+  if (r.includes(".")) {
+    const e = r.split(".");
+    let t = l;
+    return e.forEach((n) => {
+      t = t[n];
+    }), t;
+  } else
+    return l[r];
+}
+export {
+  S as createStore
+};

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

@@ -0,0 +1,113 @@
+import { getCurrentInstance as C, unref as d, nextTick as h } from "vue";
+import g from "./watcher.js";
+import { useNamespace as S } from "../../../../hooks/use-namespace/index.js";
+import { useLocale as _ } from "../../../../hooks/use-locale/index.js";
+import y from "../../../../../../lodash-es/isNull.js";
+function p(e, n) {
+  return e.map((u) => {
+    var f;
+    return u.id === n.id ? n : ((f = u.children) != null && f.length && (u.children = p(u.children, n)), u);
+  });
+}
+function v(e) {
+  e.forEach((n) => {
+    var u, f;
+    n.no = (u = n.getColumnIndex) == null ? void 0 : u.call(n), (f = n.children) != null && f.length && v(n.children);
+  }), e.sort((n, u) => n.no - u.no);
+}
+function T() {
+  const e = C(), n = g(), u = S("table"), { t: f } = _();
+  return {
+    ns: u,
+    t: f,
+    ...n,
+    mutations: {
+      setData(o, l) {
+        const r = d(o._data) !== l;
+        o.data.value = l, o._data.value = l, e.store.execQuery(), e.store.updateCurrentRowData(), e.store.updateExpandRows(), e.store.updateTreeData(
+          e.store.states.defaultExpandAll.value
+        ), d(o.reserveSelection) ? e.store.assertRowKey() : r ? e.store.clearSelection() : e.store.cleanSelection(), e.store.updateAllSelected(), e.$ready && e.store.scheduleLayout();
+      },
+      insertColumn(o, l, r, s) {
+        var i;
+        const t = d(o._columns);
+        let a = [];
+        r ? (r && !r.children && (r.children = []), (i = r.children) == null || i.push(l), a = p(t, r)) : (t.push(l), a = t), v(a), o._columns.value = a, o.updateOrderFns.push(s), l.type === "selection" && (o.selectable.value = l.selectable, o.reserveSelection.value = l.reserveSelection), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      updateColumnOrder(o, l) {
+        var r;
+        ((r = l.getColumnIndex) == null ? void 0 : r.call(l)) !== l.no && (v(o._columns.value), e.$ready && e.store.updateColumns());
+      },
+      removeColumn(o, l, r, s) {
+        var i;
+        const t = d(o._columns) || [];
+        if (r)
+          (i = r.children) == null || i.splice(
+            r.children.findIndex((c) => c.id === l.id),
+            1
+          ), h(() => {
+            var c;
+            ((c = r.children) == null ? void 0 : c.length) === 0 && delete r.children;
+          }), o._columns.value = p(t, r);
+        else {
+          const c = t.indexOf(l);
+          c > -1 && (t.splice(c, 1), o._columns.value = t);
+        }
+        const a = o.updateOrderFns.indexOf(s);
+        a > -1 && o.updateOrderFns.splice(a, 1), e.$ready && (e.store.updateColumns(), e.store.scheduleLayout());
+      },
+      sort(o, l) {
+        const { prop: r, order: s, init: i } = l;
+        if (r) {
+          const t = d(o.columns).find(
+            (a) => a.property === r
+          );
+          t && (t.order = s, e.store.updateSort(t, r, s), e.store.commit("changeSortCondition", { init: i }));
+        }
+      },
+      changeSortCondition(o, l) {
+        const { sortingColumn: r, sortProp: s, sortOrder: i } = o, t = d(r), a = d(s), c = d(i);
+        y(c) && (o.sortingColumn.value = null, o.sortProp.value = null);
+        const m = { filter: !0 };
+        e.store.execQuery(m), (!l || !(l.silent || l.init)) && e.emit("sort-change", {
+          column: t,
+          prop: a,
+          order: c
+        }), e.store.updateTableScrollY();
+      },
+      filterChange(o, l) {
+        const { column: r, values: s, silent: i } = l, t = e.store.updateFilters(r, s);
+        e.store.execQuery(), i || e.emit("filter-change", t), e.store.updateTableScrollY();
+      },
+      toggleAllSelection() {
+        var o, l;
+        (l = (o = e.store).toggleAllSelection) == null || l.call(o);
+      },
+      rowSelectedChanged(o, l) {
+        e.store.toggleRowSelection(l), e.store.updateAllSelected();
+      },
+      setHoverRow(o, l) {
+        o.hoverRow.value = l;
+      },
+      setCurrentRow(o, l) {
+        e.store.updateCurrentRow(l);
+      }
+    },
+    commit: function(o, ...l) {
+      const r = e.store.mutations;
+      if (r[o])
+        r[o].apply(e, [
+          e.store.states,
+          ...l
+        ]);
+      else
+        throw new Error(`Action not found: ${o}`);
+    },
+    updateTableScrollY: function() {
+      h(() => e.layout.updateScrollY.apply(e.layout));
+    }
+  };
+}
+export {
+  T as default
+};

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

@@ -0,0 +1,151 @@
+import { ref as v, getCurrentInstance as G, computed as U, watch as x, unref as H } from "vue";
+import { getRowIdentity as K, walkTreeNode as J } from "../util.js";
+import { isArray as Y } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { isUndefined as P } from "../../../../utils/types.js";
+function $(y) {
+  const f = v([]), r = v({}), q = v(16), m = v(!1), h = v({}), w = v("hasChildren"), C = v("children"), D = v(!1), u = G(), N = U(() => {
+    if (!y.rowKey.value)
+      return {};
+    const n = y.data.value || [];
+    return I(n);
+  }), R = U(() => {
+    const n = y.rowKey.value, e = Object.keys(h.value), o = {};
+    return e.length && e.forEach((l) => {
+      if (h.value[l].length) {
+        const a = { children: [] };
+        h.value[l].forEach((s) => {
+          const c = K(s, n);
+          a.children.push(c), s[w.value] && !o[c] && (o[c] = { children: [] });
+        }), o[l] = a;
+      }
+    }), o;
+  }), I = (n) => {
+    const e = y.rowKey.value, o = {};
+    return J(
+      n,
+      (l, a, s) => {
+        const c = K(l, e);
+        Y(a) ? o[c] = {
+          children: a.map((p) => K(p, e)),
+          level: s
+        } : m.value && (o[c] = {
+          children: [],
+          lazy: !0,
+          level: s
+        });
+      },
+      C.value,
+      w.value,
+      m.value
+    ), o;
+  }, g = (n = !1, e) => {
+    var o, l;
+    e || (e = (o = u.store) == null ? void 0 : o.states.defaultExpandAll.value);
+    const a = N.value, s = R.value, c = Object.keys(a), p = {};
+    if (c.length) {
+      const _ = H(r), b = [], j = (t, i) => {
+        if (n)
+          return f.value ? e || f.value.includes(i) : !!(e || t != null && t.expanded);
+        {
+          const d = e || f.value && f.value.includes(i);
+          return !!(t != null && t.expanded || d);
+        }
+      };
+      c.forEach((t) => {
+        const i = _[t], d = { ...a[t] };
+        if (d.expanded = j(i, t), d.lazy) {
+          const { loaded: z = !1, loading: E = !1 } = i || {};
+          d.loaded = !!z, d.loading = !!E, b.push(t);
+        }
+        p[t] = d;
+      });
+      const S = Object.keys(s);
+      m.value && S.length && b.length && S.forEach((t) => {
+        var i;
+        const d = _[t], z = s[t].children;
+        if (b.includes(t)) {
+          if (((i = p[t].children) == null ? void 0 : i.length) !== 0)
+            throw new Error("[ElTable]children must be an empty array.");
+          p[t].children = z;
+        } else {
+          const { loaded: E = !1, loading: F = !1 } = d || {};
+          p[t] = {
+            lazy: !0,
+            loaded: !!E,
+            loading: !!F,
+            expanded: j(d, t),
+            children: z,
+            level: void 0
+          };
+        }
+      });
+    }
+    r.value = p, (l = u.store) == null || l.updateTableScrollY();
+  };
+  x(
+    () => f.value,
+    () => {
+      g(!0);
+    }
+  ), x(
+    () => N.value,
+    () => {
+      g();
+    }
+  ), x(
+    () => R.value,
+    () => {
+      g();
+    }
+  );
+  const M = (n) => {
+    f.value = n, g();
+  }, L = (n) => m.value && n && "loaded" in n && !n.loaded, O = (n, e) => {
+    u.store.assertRowKey();
+    const o = y.rowKey.value, l = K(n, o), a = l && r.value[l];
+    if (l && a && "expanded" in a) {
+      const s = a.expanded;
+      e = P(e) ? !a.expanded : e, r.value[l].expanded = e, s !== e && u.emit("expand-change", n, e), e && L(a) && T(n, l, a), u.store.updateTableScrollY();
+    }
+  }, B = (n) => {
+    u.store.assertRowKey();
+    const e = y.rowKey.value, o = K(n, e), l = r.value[o];
+    L(l) ? T(n, o, l) : O(n, void 0);
+  }, T = (n, e, o) => {
+    const { load: l } = u.props;
+    l && !r.value[e].loaded && (r.value[e].loading = !0, l(n, o, (a) => {
+      if (!Y(a))
+        throw new TypeError("[ElTable] data must be an array");
+      r.value[e].loading = !1, r.value[e].loaded = !0, r.value[e].expanded = !0, a.length && (h.value[e] = a), u.emit("expand-change", n, !0);
+    }));
+  };
+  return {
+    loadData: T,
+    loadOrToggle: B,
+    toggleTreeExpansion: O,
+    updateTreeExpandKeys: M,
+    updateTreeData: g,
+    updateKeyChildren: (n, e) => {
+      const { lazy: o, rowKey: l } = u.props;
+      if (o) {
+        if (!l)
+          throw new Error("[Table] rowKey is required in updateKeyChild");
+        h.value[n] && (h.value[n] = e);
+      }
+    },
+    normalize: I,
+    states: {
+      expandRowKeys: f,
+      treeData: r,
+      indent: q,
+      lazy: m,
+      lazyTreeNodeMap: h,
+      lazyColumnIdentifier: w,
+      childrenColumnName: C,
+      checkStrictly: D
+    }
+  };
+}
+export {
+  $ as default
+};

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

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