ep-craft 0.1.7 → 0.1.9

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

@@ -0,0 +1,17 @@
+let e = /* @__PURE__ */ function(t) {
+  return t.ASC = "asc", t.DESC = "desc", t;
+}({}), c = /* @__PURE__ */ function(t) {
+  return t.LEFT = "left", t.CENTER = "center", t.RIGHT = "right", t;
+}({}), r = /* @__PURE__ */ function(t) {
+  return t.LEFT = "left", t.RIGHT = "right", t;
+}({});
+const s = {
+  asc: "desc",
+  desc: "asc"
+};
+export {
+  c as Alignment,
+  r as FixedDir,
+  e as SortOrder,
+  s as oppositeOrderMap
+};

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

@@ -0,0 +1,47 @@
+import { buildProps as i, definePropType as r } from "../../../utils/vue/props/runtime.js";
+import { virtualizedGridProps as t, virtualizedListProps as l } from "../../virtual-list/src/props.js";
+import { styleType as o, classType as s, requiredNumber as e, fixedDataType as d, dataType as p, columns as c } from "./common.js";
+import { tableV2RowProps as a } from "./row.js";
+import { tableV2HeaderProps as n } from "./header.js";
+const w = i({
+  columns: c,
+  data: p,
+  fixedData: d,
+  estimatedRowHeight: a.estimatedRowHeight,
+  /**
+  * Size related attributes
+  */
+  width: e,
+  height: e,
+  headerWidth: e,
+  headerHeight: n.headerHeight,
+  bodyWidth: e,
+  rowHeight: e,
+  /**
+  * Special attributes
+  */
+  cache: l.cache,
+  useIsScrolling: Boolean,
+  scrollbarAlwaysOn: t.scrollbarAlwaysOn,
+  scrollbarStartGap: t.scrollbarStartGap,
+  scrollbarEndGap: t.scrollbarEndGap,
+  /**
+  * CSS attributes
+  */
+  class: s,
+  style: o,
+  containerStyle: o,
+  getRowHeight: {
+    type: r(Function),
+    required: !0
+  },
+  rowKey: a.rowKey,
+  /**
+  * Event handlers
+  */
+  onRowsRendered: { type: r(Function) },
+  onScroll: { type: r(Function) }
+});
+export {
+  w as tableV2GridProps
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/header-row.js

@@ -0,0 +1,15 @@
+import { buildProps as r, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import { columns as t } from "./common.js";
+const s = r({
+  class: String,
+  columns: t,
+  columnsStyles: {
+    type: e(Object),
+    required: !0
+  },
+  headerIndex: Number,
+  style: { type: e(Object) }
+});
+export {
+  s as tableV2HeaderRowProps
+};

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

@@ -0,0 +1,28 @@
+import { buildProps as t, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import { columns as a } from "./common.js";
+const r = {
+  type: Number,
+  required: !0
+}, o = t({
+  class: String,
+  columns: a,
+  fixedHeaderData: { type: e(Array) },
+  headerData: {
+    type: e(Array),
+    required: !0
+  },
+  headerHeight: {
+    type: e([Number, Array]),
+    default: 50
+  },
+  rowWidth: r,
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  height: r,
+  width: r
+});
+export {
+  o as tableV2HeaderProps
+};

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

@@ -0,0 +1,4 @@
+const e = Symbol("placeholder");
+export {
+  e as placeholderSign
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/cell.js

@@ -0,0 +1,59 @@
+import { isFunction as G, isObject as N } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { placeholderSign as U } from "../private.js";
+import { enforceUnit as q, tryCall as B, componentToSlot as H } from "../utils.js";
+import J from "../components/cell.js";
+import K from "../components/expand-icon.js";
+import { createVNode as a, renderSlot as M, mergeProps as x } from "vue";
+import Q from "../../../../../../lodash-es/get.js";
+const W = ({ columns: i, column: e, columnIndex: s, depth: C, expandIconProps: d, isScrolling: R, rowData: t, rowIndex: r, style: P, expandedRowKeys: S, ns: l, t: v, cellProps: L, expandColumnKey: f, indentSize: $, iconSize: o, rowKey: j }, { slots: k }) => {
+  const g = q(P);
+  if (e.placeholderSign === U) return a("div", {
+    class: l.em("row-cell", "placeholder"),
+    style: g
+  }, null);
+  const { cellRenderer: O, dataKey: T, dataGetter: h } = e, b = G(h) ? h({
+    columns: i,
+    column: e,
+    columnIndex: s,
+    rowData: t,
+    rowIndex: r
+  }) : Q(t, T ?? ""), V = B(L, {
+    cellData: b,
+    columns: i,
+    column: e,
+    columnIndex: s,
+    rowIndex: r,
+    rowData: t
+  }), c = {
+    class: l.e("cell-text"),
+    columns: i,
+    column: e,
+    columnIndex: s,
+    cellData: b,
+    isScrolling: R,
+    rowData: t,
+    rowIndex: r
+  }, y = H(O), A = y ? y(c) : M(k, "default", c, () => [a(J, c, null)]), E = [
+    l.e("row-cell"),
+    e.class,
+    e.align === "center" && l.is("align-center"),
+    e.align === "right" && l.is("align-right")
+  ], F = r >= 0 && f && e.key === f, n = r >= 0 && S.includes(t[j]);
+  let p;
+  const m = `margin-inline-start: ${C * $}px;`;
+  return F && (N(d) ? p = a(K, x(d, {
+    class: [l.e("expand-icon"), l.is("expanded", n)],
+    size: o,
+    expanded: n,
+    ariaLabel: v(n ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
+    style: m,
+    expandable: !0
+  }), null) : p = a("div", { style: [m, `width: ${o}px; height: ${o}px;`].join(" ") }, null)), a("div", x({
+    class: E,
+    style: g
+  }, V, { role: "cell" }), [p, A]);
+};
+W.inheritAttrs = !1;
+export {
+  W as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/empty.js

@@ -0,0 +1,13 @@
+import { ElEmpty as a } from "../../../empty/index.js";
+import { renderSlot as r, createVNode as t } from "vue";
+const s = (l, { slots: e }) => {
+  const o = r(e, "default", {}, () => [t(a, null, null)]);
+  return t("div", {
+    class: l.class,
+    style: l.style
+  }, [o]);
+};
+s.displayName = "ElTableV2Empty";
+export {
+  s as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/footer.js

@@ -0,0 +1,12 @@
+import { createVNode as t } from "vue";
+const d = (a, { slots: e }) => {
+  var r;
+  return t("div", {
+    class: a.class,
+    style: a.style
+  }, [(r = e.default) == null ? void 0 : r.call(e)]);
+};
+d.displayName = "ElTableV2Footer";
+export {
+  d as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.js

@@ -0,0 +1,46 @@
+import { oppositeOrderMap as P } from "../constants.js";
+import { placeholderSign as R } from "../private.js";
+import { enforceUnit as x, componentToSlot as B, tryCall as h } from "../utils.js";
+import H from "../components/header-cell.js";
+import L from "../components/sort-icon.js";
+import { createVNode as n, renderSlot as w, mergeProps as I } from "vue";
+const j = (r, { slots: u }) => {
+  const { column: e, ns: l, t: y, style: C, onColumnSorted: S } = r, i = x(C);
+  if (e.placeholderSign === R) return n("div", {
+    class: l.em("header-row-cell", "placeholder"),
+    style: i
+  }, null);
+  const { headerCellRenderer: p, headerClass: b, sortable: a } = e, c = {
+    ...r,
+    class: l.e("header-cell-text")
+  }, d = B(p), k = d ? d(c) : w(u, "default", c, () => [n(H, c, null)]), { sortBy: m, sortState: f, headerCellProps: v } = r;
+  let o, t, s;
+  if (f) {
+    const g = f[e.key];
+    o = !!P[g], t = o ? g : "asc";
+  } else
+    o = e.key === m.key, t = o ? m.order : "asc";
+  t === "asc" ? s = "ascending" : t === "desc" ? s = "descending" : s = void 0;
+  const O = [
+    l.e("header-cell"),
+    h(b, r, ""),
+    e.align === "center" && l.is("align-center"),
+    e.align === "right" && l.is("align-right"),
+    a && l.is("sortable")
+  ];
+  return n("div", I({
+    ...h(v, r),
+    onClick: e.sortable ? S : void 0,
+    ariaSort: a ? s : void 0,
+    class: O,
+    style: i,
+    "data-key": e.key
+  }, { role: "columnheader" }), [k, a && n(L, {
+    class: [l.e("sort-icon"), o && l.is("sorting")],
+    sortOrder: t,
+    ariaLabel: y("el.table.sortLabel", { column: e.title || "" })
+  }, null)]);
+};
+export {
+  j as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/header.js

@@ -0,0 +1,27 @@
+import { tryCall as c } from "../utils.js";
+import l from "../components/header-row.js";
+import { createVNode as m, isVNode as u } from "vue";
+function b(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !u(e);
+}
+const w = ({ columns: e, columnsStyles: i, headerIndex: t, style: n, headerClass: d, headerProps: f, ns: o }, { slots: r }) => {
+  const a = {
+    columns: e,
+    headerIndex: t
+  }, p = [
+    o.e("header-row"),
+    c(d, a, ""),
+    o.is("customized", !!r.header)
+  ];
+  return m(l, {
+    ...c(f, a),
+    columnsStyles: i,
+    class: p,
+    columns: e,
+    headerIndex: t,
+    style: n
+  }, b(r) ? r : { default: () => [r] });
+};
+export {
+  w as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/left-table.js

@@ -0,0 +1,13 @@
+import f from "../table-grid.js";
+import { createVNode as n, mergeProps as c, isVNode as i } from "vue";
+function l(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !i(e);
+}
+const b = (e, { slots: t }) => {
+  if (!e.columns.length) return;
+  const { leftTableRef: r, ...o } = e;
+  return n(f, c({ ref: r }, o), l(t) ? t : { default: () => [t] });
+};
+export {
+  b as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/main-table.js

@@ -0,0 +1,12 @@
+import n from "../table-grid.js";
+import { createVNode as a, mergeProps as i, isVNode as c } from "vue";
+function f(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !c(e);
+}
+const l = (e, { slots: t }) => {
+  const { mainTableRef: r, ...o } = e;
+  return a(n, i({ ref: r }, o), f(t) ? t : { default: () => [t] });
+};
+export {
+  l as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/overlay.js

@@ -0,0 +1,12 @@
+import { createVNode as r } from "vue";
+const d = (a, { slots: e }) => {
+  var l;
+  return r("div", {
+    class: a.class,
+    style: a.style
+  }, [(l = e.default) == null ? void 0 : l.call(e)]);
+};
+d.displayName = "ElTableV2Overlay";
+export {
+  d as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/right-table.js

@@ -0,0 +1,13 @@
+import n from "../table-grid.js";
+import { createVNode as i, mergeProps as c, isVNode as f } from "vue";
+function a(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !f(e);
+}
+const b = (e, { slots: t }) => {
+  if (!e.columns.length) return;
+  const { rightTableRef: r, ...o } = e;
+  return i(n, c({ ref: r }, o), a(t) ? t : { default: () => [t] });
+};
+export {
+  b as default
+};

package/dist/node_modules/element-plus/es/components/table-v2/src/renderers/row.js

@@ -0,0 +1,63 @@
+import { tryCall as u } from "../utils.js";
+import _ from "../components/row.js";
+import { createVNode as k, mergeProps as B, isVNode as F } from "vue";
+function L(r) {
+  return typeof r == "function" || Object.prototype.toString.call(r) === "[object Object]" && !F(r);
+}
+const I = (r, { slots: d }) => {
+  const { columns: a, columnsStyles: m, depthMap: y, expandColumnKey: i, expandedRowKeys: h, estimatedRowHeight: x, hasFixedColumns: f, rowData: o, rowIndex: e, style: v, isScrolling: K, rowProps: M, rowClass: R, rowKey: E, rowEventHandlers: g, ns: s, onRowHovered: b, onRowExpanded: C } = r, P = u(R, {
+    columns: a,
+    rowData: o,
+    rowIndex: e
+  }, ""), S = u(M, {
+    columns: a,
+    rowData: o,
+    rowIndex: e
+  }), n = o[E], l = y[n] || 0, w = !!i, p = e < 0, j = [
+    s.e("row"),
+    P,
+    s.is("expanded", w && h.includes(n)),
+    s.is("fixed", !l && p),
+    s.is("customized", !!d.row),
+    { [s.e(`row-depth-${l}`)]: w && e >= 0 }
+  ], t = f ? b : void 0, V = {
+    ...S,
+    columns: a,
+    columnsStyles: m,
+    class: j,
+    depth: l,
+    expandColumnKey: i,
+    estimatedRowHeight: p ? void 0 : x,
+    isScrolling: K,
+    rowIndex: e,
+    rowData: o,
+    rowKey: n,
+    rowEventHandlers: g,
+    style: v
+  };
+  return k(_, B(V, {
+    onRowExpand: C,
+    onMouseenter: (c) => {
+      t == null || t({
+        hovered: !0,
+        rowKey: n,
+        event: c,
+        rowData: o,
+        rowIndex: e
+      });
+    },
+    onMouseleave: (c) => {
+      t == null || t({
+        hovered: !1,
+        rowKey: n,
+        event: c,
+        rowData: o,
+        rowIndex: e
+      });
+    },
+    rowkey: n
+  }), L(d) ? d : { default: () => [d] });
+};
+export {
+  I as default
+};

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

@@ -0,0 +1,38 @@
+import { buildProps as t, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import { virtualizedGridProps as o } from "../../virtual-list/src/props.js";
+import { rowKey as r, expandColumnKey as i, columns as n } from "./common.js";
+const l = t({
+  class: String,
+  columns: n,
+  columnsStyles: {
+    type: e(Object),
+    required: !0
+  },
+  depth: Number,
+  expandColumnKey: i,
+  estimatedRowHeight: {
+    ...o.estimatedRowHeight,
+    default: void 0
+  },
+  isScrolling: Boolean,
+  onRowExpand: { type: e(Function) },
+  onRowHover: { type: e(Function) },
+  onRowHeightChange: { type: e(Function) },
+  rowData: {
+    type: e(Object),
+    required: !0
+  },
+  rowEventHandlers: { type: e(Object) },
+  rowIndex: {
+    type: Number,
+    required: !0
+  },
+  /**
+  * Unique item key
+  */
+  rowKey: r,
+  style: { type: e(Object) }
+});
+export {
+  l as tableV2RowProps
+};

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

@@ -0,0 +1,167 @@
+import { isNumber as W } from "../../../utils/types.js";
+import Q from "../../virtual-list/src/components/fixed-size-grid.js";
+import X from "../../virtual-list/src/components/dynamic-size-grid.js";
+import { sum as Z } from "./utils.js";
+import { TableV2InjectionKey as p, TABLE_V2_GRID_INJECTION_KEY as $ } from "./tokens.js";
+import { tableV2GridProps as O } from "./grid.js";
+import ee from "./components/header.js";
+import { defineComponent as te, inject as oe, provide as re, onActivated as le, nextTick as ce, unref as l, createVNode as L, ref as A, computed as m, watch as ae } from "vue";
+import { isObject as ne } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const ie = "ElTableV2Grid", de = (r) => {
+  const a = A(), n = A(), i = A(0), u = m(() => {
+    const { data: e, rowHeight: t, estimatedRowHeight: o } = r;
+    if (!o)
+      return e.length * t;
+  }), s = m(() => {
+    const { fixedData: e, rowHeight: t } = r;
+    return ((e == null ? void 0 : e.length) || 0) * t;
+  }), h = m(() => Z(r.headerHeight)), T = m(() => {
+    const { height: e } = r;
+    return Math.max(0, e - l(h) - l(s));
+  }), H = m(() => l(h) + l(s) > 0), R = ({ data: e, rowIndex: t }) => e[t][r.rowKey];
+  function b({ rowCacheStart: e, rowCacheEnd: t, rowVisibleStart: o, rowVisibleEnd: c }) {
+    var d;
+    (d = r.onRowsRendered) == null || d.call(r, {
+      rowCacheStart: e,
+      rowCacheEnd: t,
+      rowVisibleStart: o,
+      rowVisibleEnd: c
+    });
+  }
+  function y(e, t) {
+    var o;
+    (o = n.value) == null || o.resetAfterRowIndex(e, t);
+  }
+  function g(e, t) {
+    const o = l(a), c = l(n);
+    ne(e) ? (o == null || o.scrollToLeft(e.scrollLeft), i.value = e.scrollLeft, c == null || c.scrollTo(e)) : (o == null || o.scrollToLeft(e), i.value = e, c == null || c.scrollTo({
+      scrollLeft: e,
+      scrollTop: t
+    }));
+  }
+  function I(e) {
+    var t;
+    (t = l(n)) == null || t.scrollTo({ scrollTop: e });
+  }
+  function x(e, t) {
+    const o = l(n);
+    if (!o) return;
+    const c = i.value;
+    o.scrollToItem(e, 0, t), c && g({ scrollLeft: c });
+  }
+  function G() {
+    var e, t;
+    (e = l(n)) == null || e.$forceUpdate(), (t = l(a)) == null || t.$forceUpdate();
+  }
+  return ae(() => r.bodyWidth, () => {
+    var e;
+    W(r.estimatedRowHeight) && ((e = n.value) == null || e.resetAfter({ columnIndex: 0 }, !1));
+  }), {
+    bodyRef: n,
+    forceUpdate: G,
+    fixedRowHeight: s,
+    gridHeight: T,
+    hasHeader: H,
+    headerHeight: h,
+    headerRef: a,
+    totalHeight: u,
+    itemKey: R,
+    onItemRendered: b,
+    resetAfterRowIndex: y,
+    scrollTo: g,
+    scrollToTop: I,
+    scrollToRow: x,
+    scrollLeft: i
+  };
+}, Re = /* @__PURE__ */ te({
+  name: ie,
+  props: O,
+  setup(r, { slots: a, expose: n }) {
+    const { ns: i } = oe(p), { bodyRef: u, fixedRowHeight: s, gridHeight: h, hasHeader: T, headerRef: H, headerHeight: R, totalHeight: b, forceUpdate: y, itemKey: g, onItemRendered: I, resetAfterRowIndex: x, scrollTo: G, scrollToTop: e, scrollToRow: t, scrollLeft: o } = de(r);
+    re($, o), le(async () => {
+      var f;
+      await ce();
+      const d = (f = u.value) == null ? void 0 : f.states.scrollTop;
+      d && e(Math.round(d) + 1);
+    }), n({
+      forceUpdate: y,
+      /**
+      * @description fetch total height
+      */
+      totalHeight: b,
+      /**
+      * @description scroll to a position
+      */
+      scrollTo: G,
+      /**
+      * @description scroll vertically to position y
+      */
+      scrollToTop: e,
+      /**
+      * @description scroll to a given row
+      * @params row {Number} which row to scroll to
+      * @params strategy {ScrollStrategy} use what strategy to scroll to
+      */
+      scrollToRow: t,
+      /**
+      * @description reset rendered state after row index
+      */
+      resetAfterRowIndex: x
+    });
+    const c = () => r.bodyWidth;
+    return () => {
+      const { cache: d, columns: f, data: w, fixedData: D, useIsScrolling: K, scrollbarAlwaysOn: M, scrollbarEndGap: V, scrollbarStartGap: _, style: U, rowHeight: E, bodyWidth: j, estimatedRowHeight: z, headerWidth: P, height: k, width: S, getRowHeight: B, onScroll: F } = r, v = W(z), J = v ? X : Q, Y = l(R);
+      return L("div", {
+        role: "table",
+        class: [i.e("table"), r.class],
+        style: U
+      }, [L(J, {
+        ref: u,
+        data: w,
+        useIsScrolling: K,
+        itemKey: g,
+        columnCache: 0,
+        columnWidth: v ? c : j,
+        totalColumn: 1,
+        totalRow: w.length,
+        rowCache: d,
+        rowHeight: v ? B : E,
+        width: S,
+        height: l(h),
+        class: i.e("body"),
+        role: "rowgroup",
+        scrollbarStartGap: _,
+        scrollbarEndGap: V,
+        scrollbarAlwaysOn: M,
+        onScroll: F,
+        onItemRendered: I,
+        perfMode: !1
+      }, { default: (C) => {
+        var N;
+        const q = w[C.rowIndex];
+        return (N = a.row) == null ? void 0 : N.call(a, {
+          ...C,
+          columns: f,
+          rowData: q
+        });
+      } }), l(T) && L(ee, {
+        ref: H,
+        class: i.e("header-wrapper"),
+        columns: f,
+        headerData: w,
+        headerHeight: r.headerHeight,
+        fixedHeaderData: D,
+        rowWidth: P,
+        rowHeight: E,
+        width: S,
+        height: Math.min(Y + l(s), k)
+      }, {
+        dynamic: a.header,
+        fixed: a.row
+      })]);
+    };
+  }
+});
+export {
+  Re as default
+};