fec-dev-designer 1.0.0

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

@@ -0,0 +1,178 @@
+import { inject as X, computed as Z, h as M } from "vue";
+import { getRowIdentity as _ } from "../util.js";
+import { TABLE_INJECTION_KEY as D } from "../tokens.js";
+import $ from "./events-helper.js";
+import ee from "./styles-helper.js";
+import le from "./td-wrapper.js";
+import { useNamespace as ne } from "../../../../hooks/use-namespace/index.js";
+import { isBoolean as k, isPropAbsent as te } from "../../../../utils/types.js";
+import oe from "../../../../../../lodash-es/merge.js";
+function ve(r) {
+  const c = X(D), x = ne("table"), {
+    handleDoubleClick: S,
+    handleClick: j,
+    handleContextMenu: R,
+    handleMouseEnter: W,
+    handleMouseLeave: q,
+    handleCellMouseEnter: A,
+    handleCellMouseLeave: B,
+    tooltipContent: F,
+    tooltipTrigger: J
+  } = $(r), {
+    getRowStyle: P,
+    getRowClass: Y,
+    getCellStyle: w,
+    getCellClass: G,
+    getSpan: H,
+    getColspanRealWidth: I
+  } = ee(r);
+  let N = -1;
+  const Q = Z(() => {
+    var l;
+    return (l = r.store) == null ? void 0 : l.states.columns.value.findIndex(
+      ({ type: t }) => t === "default"
+    );
+  }), b = (l, t) => {
+    var n;
+    const f = (n = c == null ? void 0 : c.props) == null ? void 0 : n.rowKey;
+    return f ? _(l, f) : t;
+  }, K = (l, t, n, f = !1) => {
+    const { tooltipEffect: T, tooltipOptions: h, store: m } = r, { indent: z, columns: C } = m.states, y = [];
+    let L = !0;
+    return n && (y.push(x.em("row", `level-${n.level}`)), L = !!n.display), t === 0 && (N = -1), r.stripe && L && N++, y.push(...Y(l, t, N)), M(
+      "tr",
+      {
+        style: [L ? null : { display: "none" }, P(l, t)],
+        class: y,
+        key: b(l, t),
+        onDblclick: (e) => S(e, l),
+        onClick: (e) => j(e, l),
+        onContextmenu: (e) => R(e, l),
+        onMouseenter: () => W(t),
+        onMouseleave: q
+      },
+      C.value.map((e, o) => {
+        const { rowspan: a, colspan: i } = H(l, e, t, o);
+        if (!a || !i)
+          return null;
+        const u = Object.assign({}, e);
+        u.realWidth = I(
+          C.value,
+          i,
+          o
+        );
+        const p = {
+          store: m,
+          _self: r.context || c,
+          column: u,
+          row: l,
+          $index: t,
+          cellIndex: o,
+          expanded: f
+        };
+        o === Q.value && n && (p.treeNode = {
+          indent: n.level && n.level * z.value,
+          level: n.level
+        }, k(n.expanded) && (p.treeNode.expanded = n.expanded, "loading" in n && (p.treeNode.loading = n.loading), "noLazyChildren" in n && (p.treeNode.noLazyChildren = n.noLazyChildren)));
+        const g = `${b(l, t)},${o}`, v = u.columnKey || u.rawColumnKey || "", E = e.showOverflowTooltip && oe(
+          {
+            effect: T
+          },
+          h,
+          e.showOverflowTooltip
+        );
+        return M(
+          le,
+          {
+            style: w(t, o, l, e),
+            class: G(t, o, l, e, i - 1),
+            key: `${v}${g}`,
+            rowspan: a,
+            colspan: i,
+            onMouseenter: (d) => A(
+              d,
+              l,
+              E
+            ),
+            onMouseleave: B
+          },
+          {
+            default: () => U(o, e, p)
+          }
+        );
+      })
+    );
+  }, U = (l, t, n) => t.renderCell(n);
+  return {
+    wrappedRowRender: (l, t) => {
+      const n = r.store, { isRowExpanded: f, assertRowKey: T } = n, { treeData: h, lazyTreeNodeMap: m, childrenColumnName: z, rowKey: C } = n.states, y = n.states.columns.value;
+      if (y.some(({ type: s }) => s === "expand")) {
+        const s = f(l), e = K(l, t, void 0, s), o = c == null ? void 0 : c.renderExpanded;
+        if (!o)
+          return console.error("[Element Error]renderExpanded is required."), e;
+        const a = [[e]];
+        return (c.props.preserveExpandedContent || s) && a[0].push(
+          M(
+            "tr",
+            {
+              key: `expanded-row__${e.key}`,
+              style: { display: s ? "" : "none" }
+            },
+            [
+              M(
+                "td",
+                {
+                  colspan: y.length,
+                  class: `${x.e("cell")} ${x.e("expanded-cell")}`
+                },
+                [o({ row: l, $index: t, store: n, expanded: s })]
+              )
+            ]
+          )
+        ), a;
+      } else if (Object.keys(h.value).length) {
+        T();
+        const s = _(l, C.value);
+        let e = h.value[s], o = null;
+        e && (o = {
+          expanded: e.expanded,
+          level: e.level,
+          display: !0,
+          noLazyChildren: void 0,
+          loading: void 0
+        }, k(e.lazy) && (o && k(e.loaded) && e.loaded && (o.noLazyChildren = !(e.children && e.children.length)), o.loading = e.loading));
+        const a = [K(l, t, o ?? void 0)];
+        if (e) {
+          let i = 0;
+          const u = (g, v) => {
+            g && g.length && v && g.forEach((E) => {
+              const d = {
+                display: v.display && v.expanded,
+                level: v.level + 1,
+                expanded: !1,
+                noLazyChildren: !1,
+                loading: !1
+              }, O = _(E, C.value);
+              if (te(O))
+                throw new Error("For nested data item, row-key is required.");
+              if (e = { ...h.value[O] }, e && (d.expanded = e.expanded, e.level = e.level || d.level, e.display = !!(e.expanded && d.display), k(e.lazy) && (k(e.loaded) && e.loaded && (d.noLazyChildren = !(e.children && e.children.length)), d.loading = e.loading)), i++, a.push(K(E, t + i, d)), e) {
+                const V = m.value[O] || E[z.value];
+                u(V, e);
+              }
+            });
+          };
+          e.display = !0;
+          const p = m.value[s] || l[z.value];
+          u(p, e);
+        }
+        return a;
+      } else
+        return K(l, t, void 0);
+    },
+    tooltipContent: F,
+    tooltipTrigger: J
+  };
+}
+export {
+  ve as default
+};

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

@@ -0,0 +1,88 @@
+import { inject as C } from "vue";
+import { getFixedColumnOffset as m, ensurePosition as p, getFixedColumnsClass as h } from "../util.js";
+import { TABLE_INJECTION_KEY as w } from "../tokens.js";
+import { useNamespace as S } from "../../../../hooks/use-namespace/index.js";
+import { isFunction as c, isString as d, isArray as v, isObject as y } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+function B(u) {
+  const n = C(w), f = S("table");
+  return {
+    getRowStyle: (o, s) => {
+      const t = n == null ? void 0 : n.props.rowStyle;
+      return c(t) ? t.call(null, {
+        row: o,
+        rowIndex: s
+      }) : t || null;
+    },
+    getRowClass: (o, s, t) => {
+      var r;
+      const e = [f.e("row")];
+      n != null && n.props.highlightCurrentRow && o === ((r = u.store) == null ? void 0 : r.states.currentRow.value) && e.push("current-row"), u.stripe && t % 2 === 1 && e.push(f.em("row", "striped"));
+      const l = n == null ? void 0 : n.props.rowClassName;
+      return d(l) ? e.push(l) : c(l) && e.push(
+        l.call(null, {
+          row: o,
+          rowIndex: s
+        })
+      ), e;
+    },
+    getCellStyle: (o, s, t, r) => {
+      const e = n == null ? void 0 : n.props.cellStyle;
+      let l = e ?? {};
+      c(e) && (l = e.call(null, {
+        rowIndex: o,
+        columnIndex: s,
+        row: t,
+        column: r
+      }));
+      const i = m(
+        s,
+        u == null ? void 0 : u.fixed,
+        u.store
+      );
+      return p(i, "left"), p(i, "right"), Object.assign({}, l, i);
+    },
+    getCellClass: (o, s, t, r, e) => {
+      const l = h(
+        f.b(),
+        s,
+        u == null ? void 0 : u.fixed,
+        u.store,
+        void 0,
+        e
+      ), i = [r.id, r.align, r.className, ...l], a = n == null ? void 0 : n.props.cellClassName;
+      return d(a) ? i.push(a) : c(a) && i.push(
+        a.call(null, {
+          rowIndex: o,
+          columnIndex: s,
+          row: t,
+          column: r
+        })
+      ), i.push(f.e("cell")), i.filter((g) => !!g).join(" ");
+    },
+    getSpan: (o, s, t, r) => {
+      let e = 1, l = 1;
+      const i = n == null ? void 0 : n.props.spanMethod;
+      if (c(i)) {
+        const a = i({
+          row: o,
+          column: s,
+          rowIndex: t,
+          columnIndex: r
+        });
+        v(a) ? (e = a[0], l = a[1]) : y(a) && (e = a.rowspan, l = a.colspan);
+      }
+      return { rowspan: e, colspan: l };
+    },
+    getColspanRealWidth: (o, s, t) => {
+      if (s < 1)
+        return o[t].realWidth;
+      const r = o.map(({ realWidth: e, width: l }) => e || l).slice(t, t + s);
+      return Number(
+        r.reduce((e, l) => Number(e) + Number(l), -1)
+      );
+    }
+  };
+}
+export {
+  B as default
+};

package/es/node_modules/element-plus/es/components/table/src/table-body/td-wrapper.js

@@ -0,0 +1,28 @@
+import { defineComponent as o, openBlock as p, createElementBlock as t, renderSlot as a } from "vue";
+import n from "../../../../_virtual/plugin-vue_export-helper.js";
+const s = ["colspan", "rowspan"], l = o({
+  name: "TableTdWrapper",
+  __name: "td-wrapper",
+  props: {
+    colspan: {
+      type: Number,
+      default: 1
+    },
+    rowspan: {
+      type: Number,
+      default: 1
+    }
+  },
+  setup(e) {
+    return (r, c) => (p(), t("td", {
+      colspan: e.colspan,
+      rowspan: e.rowspan
+    }, [
+      a(r.$slots, "default")
+    ], 8, s));
+  }
+});
+var u = /* @__PURE__ */ n(l, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/table/src/table-body/td-wrapper.vue"]]);
+export {
+  u as default
+};

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

@@ -0,0 +1,62 @@
+var r = {
+  type: {
+    type: String,
+    default: "default"
+  },
+  label: String,
+  className: String,
+  labelClassName: String,
+  property: String,
+  prop: String,
+  width: {
+    type: [String, Number],
+    default: ""
+  },
+  minWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  renderHeader: Function,
+  sortable: {
+    type: [Boolean, String],
+    default: !1
+  },
+  sortMethod: Function,
+  sortBy: [String, Function, Array],
+  resizable: {
+    type: Boolean,
+    default: !0
+  },
+  columnKey: String,
+  align: String,
+  headerAlign: String,
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  tooltipFormatter: Function,
+  fixed: [Boolean, String],
+  formatter: Function,
+  selectable: Function,
+  reserveSelection: Boolean,
+  filterMethod: Function,
+  filteredValue: Array,
+  filters: Array,
+  filterPlacement: String,
+  filterMultiple: {
+    type: Boolean,
+    default: !0
+  },
+  filterClassName: String,
+  index: [Number, Function],
+  sortOrders: {
+    type: Array,
+    default: () => ["ascending", "descending", null],
+    validator: (e) => e.every(
+      (t) => ["ascending", "descending", null].includes(t)
+    )
+  }
+};
+export {
+  r as default
+};

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

@@ -0,0 +1,125 @@
+import { defineComponent as E, getCurrentInstance as M, ref as N, computed as S, onBeforeMount as A, onMounted as W, onBeforeUnmount as $, Fragment as B, h as g } from "vue";
+import { ElCheckbox as k } from "../../../checkbox/index.js";
+import { cellStarts as D } from "../config.js";
+import { mergeOptions as H, compose as K } from "../util.js";
+import R from "./watcher-helper.js";
+import U from "./render-helper.js";
+import V from "./defaults.js";
+import { isUndefined as b } from "../../../../utils/types.js";
+import { isArray as I, isString as z } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+let G = 1;
+var re = E({
+  name: "ElTableColumn",
+  components: {
+    ElCheckbox: k
+  },
+  props: V,
+  setup(e, { slots: m }) {
+    const a = M(), o = N({}), t = S(() => {
+      let l = a.parent;
+      for (; l && !l.tableId; )
+        l = l.parent;
+      return l;
+    }), { registerNormalWatchers: v, registerComplexWatchers: s } = R(
+      t,
+      e
+    ), {
+      columnId: n,
+      isSubColumn: d,
+      realHeaderAlign: x,
+      columnOrTableParent: h,
+      setColumnWidth: P,
+      setColumnForcedProps: y,
+      setColumnRenders: w,
+      getPropsData: O,
+      getColumnElIndex: F,
+      realAlign: T,
+      updateColumnOrder: C
+    } = U(e, m, t), r = h.value;
+    n.value = `${"tableId" in r && r.tableId || "columnId" in r && r.columnId}_column_${G++}`, A(() => {
+      d.value = t.value !== r;
+      const l = e.type || "default", u = e.sortable === "" ? !0 : e.sortable, i = l === "selection" ? !1 : b(e.showOverflowTooltip) ? r.props.showOverflowTooltip : e.showOverflowTooltip, p = b(e.tooltipFormatter) ? r.props.tooltipFormatter : e.tooltipFormatter, f = {
+        ...D[l],
+        id: n.value,
+        type: l,
+        property: e.prop || e.property,
+        align: T,
+        headerAlign: x,
+        showOverflowTooltip: i,
+        tooltipFormatter: p,
+        filterable: e.filters || e.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        filterClassName: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        sortable: u,
+        index: e.index,
+        rawColumnKey: a.vnode.key
+      };
+      let c = O([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], ["sortMethod", "sortBy", "sortOrders"], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement",
+        "filterClassName"
+      ]);
+      c = H(f, c), c = K(
+        w,
+        P,
+        y
+      )(c), o.value = c, v(), s();
+    }), W(() => {
+      var l, u;
+      const i = h.value, p = d.value ? (l = i.vnode.el) == null ? void 0 : l.children : (u = i.refs.hiddenColumns) == null ? void 0 : u.children, f = () => F(p || [], a.vnode.el);
+      o.value.getColumnIndex = f, f() > -1 && t.value.store.commit(
+        "insertColumn",
+        o.value,
+        d.value ? "columnConfig" in i && i.columnConfig.value : null,
+        C
+      );
+    }), $(() => {
+      const l = o.value.getColumnIndex;
+      (l ? l() : -1) > -1 && t.value.store.commit(
+        "removeColumn",
+        o.value,
+        d.value ? "columnConfig" in r && r.columnConfig.value : null,
+        C
+      );
+    }), a.columnId = n.value, a.columnConfig = o;
+  },
+  render() {
+    var e, m, a;
+    try {
+      const o = (m = (e = this.$slots).default) == null ? void 0 : m.call(e, {
+        row: {},
+        column: {},
+        $index: -1
+      }), t = [];
+      if (I(o))
+        for (const s of o)
+          ((a = s.type) == null ? void 0 : a.name) === "ElTableColumn" || s.shapeFlag & 2 ? t.push(s) : s.type === B && I(s.children) && s.children.forEach((n) => {
+            (n == null ? void 0 : n.patchFlag) !== 1024 && !z(n == null ? void 0 : n.children) && t.push(n);
+          });
+      return g("div", t);
+    } catch {
+      return g("div", []);
+    }
+  }
+});
+export {
+  re as default
+};

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

@@ -0,0 +1,106 @@
+import { getCurrentInstance as V, ref as d, watchEffect as x, computed as b, unref as W, h as p, Fragment as k, createTextVNode as H, renderSlot as y, Comment as S } from "vue";
+import { defaultRenderCell as j, treeCellPrefix as M, cellForced as U, getDefaultClassName as _ } from "../config.js";
+import { parseWidth as q, parseMinWidth as z, ensureValidVNode as B } from "../util.js";
+import { useNamespace as G } from "../../../../hooks/use-namespace/index.js";
+import { isUndefined as N } from "../../../../utils/types.js";
+import { debugWarn as J } from "../../../../utils/error.js";
+import { isArray as I } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+function le(l, a, h) {
+  const i = V(), w = d(""), E = d(!1), o = d(), m = d(), g = G("table");
+  x(() => {
+    o.value = l.align ? `is-${l.align}` : null, o.value;
+  }), x(() => {
+    m.value = l.headerAlign ? `is-${l.headerAlign}` : o.value, m.value;
+  });
+  const P = b(() => {
+    let e = i.vnode.vParent || i.parent;
+    for (; e && !e.tableId && !e.columnId; )
+      e = e.vnode.vParent || e.parent;
+    return e;
+  }), $ = b(() => {
+    const { store: e } = i.parent;
+    if (!e)
+      return !1;
+    const { treeData: r } = e.states, t = r.value;
+    return t && Object.keys(t).length > 0;
+  }), v = d(q(l.width)), C = d(z(l.minWidth)), O = (e) => (v.value && (e.width = v.value), C.value && (e.minWidth = C.value), !v.value && C.value && (e.width = void 0), e.minWidth || (e.minWidth = 80), e.realWidth = Number(
+    N(e.width) ? e.minWidth : e.width
+  ), e), A = (e) => {
+    const r = e.type, t = U[r] || {};
+    Object.keys(t).forEach((s) => {
+      const u = t[s];
+      s !== "className" && !N(u) && (e[s] = u);
+    });
+    const n = _(r);
+    if (n) {
+      const s = `${W(g.namespace)}-${n}`;
+      e.className = e.className ? `${e.className} ${s}` : s;
+    }
+    return e;
+  }, R = (e) => {
+    I(e) ? e.forEach((t) => r(t)) : r(e);
+    function r(t) {
+      var n;
+      ((n = t == null ? void 0 : t.type) == null ? void 0 : n.name) === "ElTableColumn" && (t.vParent = i);
+    }
+  };
+  return {
+    columnId: w,
+    realAlign: o,
+    isSubColumn: E,
+    realHeaderAlign: m,
+    columnOrTableParent: P,
+    setColumnWidth: O,
+    setColumnForcedProps: A,
+    setColumnRenders: (e) => {
+      l.renderHeader ? J(
+        "TableColumn",
+        "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header."
+      ) : e.type !== "selection" && (e.renderHeader = (t) => {
+        if (i.columnConfig.value.label, a.header) {
+          const n = a.header(t);
+          if (B(n))
+            return p(k, n);
+        }
+        return H(e.label);
+      }), a["filter-icon"] && (e.renderFilterIcon = (t) => y(a, "filter-icon", t)), a.expand && (e.renderExpand = (t) => y(a, "expand", t));
+      let r = e.renderCell;
+      return e.type === "expand" ? (e.renderCell = (t) => p(
+        "div",
+        {
+          class: "cell"
+        },
+        [r(t)]
+      ), h.value.renderExpanded = (t) => a.default ? a.default(t) : a.default) : (r = r || j, e.renderCell = (t) => {
+        let n = null;
+        if (a.default) {
+          const f = a.default(t);
+          n = f.some((F) => F.type !== S) ? f : r(t);
+        } else
+          n = r(t);
+        const { columns: s } = h.value.store.states, u = s.value.findIndex(
+          (f) => f.type === "default"
+        ), T = $.value && t.cellIndex === u, D = M(t, T), c = {
+          class: "cell",
+          style: {}
+        };
+        return e.showOverflowTooltip && (c.class = `${c.class} ${W(g.namespace)}-tooltip`, c.style = {
+          width: `${(t.column.realWidth || Number(t.column.width)) - 1}px`
+        }), R(n), p("div", c, [D, n]);
+      }), e;
+    },
+    getPropsData: (...e) => e.reduce(
+      (r, t) => (I(t) && t.forEach((n) => {
+        r[n] = l[n];
+      }), r),
+      {}
+    ),
+    getColumnElIndex: (e, r) => Array.prototype.indexOf.call(e, r),
+    updateColumnOrder: () => {
+      h.value.store.commit("updateColumnOrder", i.columnConfig.value);
+    }
+  };
+}
+export {
+  le as default
+};

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

@@ -0,0 +1,70 @@
+import { getCurrentInstance as p, watch as u } from "vue";
+import { parseWidth as g, parseMinWidth as C } from "../util.js";
+import { hasOwn as m } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { isUndefined as v } from "../../../../utils/types.js";
+function h(a, i) {
+  return a.reduce((t, c) => (t[c] = c, t), i);
+}
+function N(a, i) {
+  const t = p();
+  return {
+    registerComplexWatchers: () => {
+      const f = ["fixed"], s = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, n = h(f, s);
+      Object.keys(n).forEach((o) => {
+        const e = s[o];
+        m(i, e) && u(
+          () => i[e],
+          (l) => {
+            let r = l;
+            e === "width" && o === "realWidth" && (r = g(l)), e === "minWidth" && o === "realMinWidth" && (r = C(l)), t.columnConfig.value[e] = r, t.columnConfig.value[o] = r;
+            const d = e === "fixed";
+            a.value.store.scheduleLayout(d);
+          }
+        );
+      });
+    },
+    registerNormalWatchers: () => {
+      const f = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "filterClassName",
+        "showOverflowTooltip",
+        "tooltipFormatter",
+        "resizable"
+      ], s = ["showOverflowTooltip"], n = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, o = h(f, n);
+      Object.keys(o).forEach((e) => {
+        const l = n[e];
+        m(i, l) && u(
+          () => i[l],
+          (r) => {
+            t.columnConfig.value[e] = r, (e === "filters" || e === "filterMethod") && (t.columnConfig.value.filterable = !!(t.columnConfig.value.filters || t.columnConfig.value.filterMethod));
+          }
+        );
+      }), s.forEach((e) => {
+        m(a.value.props, e) && u(
+          () => a.value.props[e],
+          (l) => {
+            t.columnConfig.value.type !== "selection" && v(i[e]) && (t.columnConfig.value[e] = l);
+          }
+        );
+      });
+    }
+  };
+}
+export {
+  N as default
+};