ep-craft 0.1.13 → 0.1.15

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/table-v2/src/composables/use-row.js

@@ -0,0 +1,73 @@
+import { isNumber as _ } from "../../../../utils/types.js";
+import { getCurrentInstance as j, shallowRef as c, ref as f, computed as z, unref as l, nextTick as B } from "vue";
+import D from "../../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/debounce.js";
+const P = (i, { mainTableRef: m, leftTableRef: x, rightTableRef: w, tableInstance: H, ns: v, isScrolling: q }) => {
+  const E = j(), { emit: y } = E, r = c(!1), h = f(i.defaultExpandedRowKeys || []), R = f(-1), s = c(null), d = f({}), g = f({}), C = c({}), I = c({}), S = c({}), U = z(() => _(i.estimatedRowHeight));
+  function L(e) {
+    var n;
+    (n = i.onRowsRendered) == null || n.call(i, e), e.rowCacheEnd > l(R) && (R.value = e.rowCacheEnd);
+  }
+  function $({ hovered: e, rowKey: n }) {
+    q.value || H.vnode.el.querySelectorAll(`[rowkey="${String(n)}"]`).forEach((o) => {
+      e ? o.classList.add(v.is("hovered")) : o.classList.remove(v.is("hovered"));
+    });
+  }
+  function M({ expanded: e, rowData: n, rowIndex: o, rowKey: t }) {
+    var A, b;
+    const a = [...l(h)], u = a.indexOf(t);
+    e ? u === -1 && a.push(t) : u > -1 && a.splice(u, 1), h.value = a, y("update:expandedRowKeys", a), (A = i.onRowExpand) == null || A.call(i, {
+      expanded: e,
+      rowData: n,
+      rowIndex: o,
+      rowKey: t
+    }), (b = i.onExpandedRowsChange) == null || b.call(i, a), H.vnode.el.querySelector(`.${v.is("hovered")}[rowkey="${String(t)}"]`) && B(() => $({
+      hovered: !0,
+      rowKey: t
+    }));
+  }
+  const N = D(() => {
+    var e, n, o, t;
+    r.value = !0, d.value = {
+      ...l(d),
+      ...l(g)
+    }, k(l(s), !1), g.value = {}, s.value = null, (e = m.value) == null || e.forceUpdate(), (n = x.value) == null || n.forceUpdate(), (o = w.value) == null || o.forceUpdate(), (t = E.proxy) == null || t.$forceUpdate(), r.value = !1;
+  }, 0);
+  function k(e, n = !1) {
+    l(U) && [
+      m,
+      x,
+      w
+    ].forEach((o) => {
+      const t = l(o);
+      t && t.resetAfterRowIndex(e, n);
+    });
+  }
+  function O(e, n, o) {
+    const t = l(s);
+    (t === null || t > o) && (s.value = o), g.value[e] = n;
+  }
+  function T({ rowKey: e, height: n, rowIndex: o }, t) {
+    t ? t === "right" ? S.value[e] = n : C.value[e] = n : I.value[e] = n;
+    const a = Math.max(...[
+      C,
+      S,
+      I
+    ].map((u) => u.value[e] || 0));
+    l(d)[e] !== a && (O(e, a, o), N());
+  }
+  return {
+    expandedRowKeys: h,
+    lastRenderedRowIndex: R,
+    isDynamic: U,
+    isResetting: r,
+    rowHeights: d,
+    resetAfterIndex: k,
+    onRowExpanded: M,
+    onRowHovered: $,
+    onRowsRendered: L,
+    onRowHeightChange: T
+  };
+};
+export {
+  P as useRow
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/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@3.5.40/node_modules/@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@4.18.1/node_modules/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/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/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@3.5.40/node_modules/@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
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/table-v2/src/use-table.js

@@ -0,0 +1,93 @@
+import { isNumber as se } from "../../../utils/types.js";
+import { useNamespace as ie } from "../../../hooks/use-namespace/index.js";
+import { useColumns as re } from "./composables/use-columns.js";
+import { useScrollbar as ce } from "./composables/use-scrollbar.js";
+import { useRow as de } from "./composables/use-row.js";
+import { useData as fe } from "./composables/use-data.js";
+import { useStyles as me } from "./composables/use-styles.js";
+import { ref as s, toRef as x, getCurrentInstance as ue, shallowRef as he, computed as y, unref as t, watch as S } from "vue";
+import { isArray as ge } from "../../../../../../../@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+function Ce(e) {
+  const c = s(), d = s(), f = s(), { columns: v, columnsStyles: C, columnsTotalWidth: h, fixedColumnsOnLeft: g, fixedColumnsOnRight: R, hasFixedColumns: D, mainColumns: E, onColumnSorted: I } = re(e, x(e, "columns"), x(e, "fixed")), { scrollTo: W, scrollToLeft: K, scrollToTop: O, scrollToRow: A, onScroll: L, onVerticalScroll: M, scrollPos: N } = ce(e, {
+    mainTableRef: c,
+    leftTableRef: d,
+    rightTableRef: f,
+    onMaybeEndReached: le
+  }), _ = ie("table-v2"), j = ue(), w = he(!1), { expandedRowKeys: m, lastRenderedRowIndex: b, isDynamic: z, isResetting: F, rowHeights: H, resetAfterIndex: P, onRowExpanded: V, onRowHeightChange: k, onRowHovered: q, onRowsRendered: B } = de(e, {
+    mainTableRef: c,
+    leftTableRef: d,
+    rightTableRef: f,
+    tableInstance: j,
+    ns: _,
+    isScrolling: w
+  }), { data: i, depthMap: G } = fe(e, {
+    expandedRowKeys: m,
+    lastRenderedRowIndex: b,
+    resetAfterIndex: P
+  }), u = y(() => {
+    const { estimatedRowHeight: o, rowHeight: n } = e, l = t(i);
+    return se(o) ? Object.values(t(H)).reduce((a, ae) => a + ae, 0) : l.length * n;
+  }), { bodyWidth: J, fixedTableHeight: Q, mainTableHeight: T, leftTableWidth: U, rightTableWidth: X, windowHeight: Y, footerHeight: Z, emptyStyle: $, rootStyle: p, headerHeight: ee } = me(e, {
+    columnsTotalWidth: h,
+    fixedColumnsOnLeft: g,
+    fixedColumnsOnRight: R,
+    rowsHeight: u
+  }), te = s(), oe = y(() => {
+    const o = t(i).length === 0;
+    return ge(e.fixedData) ? e.fixedData.length === 0 && o : o;
+  });
+  function ne(o) {
+    const { estimatedRowHeight: n, rowHeight: l, rowKey: a } = e;
+    return n ? t(H)[t(i)[o][a]] || n : l;
+  }
+  const r = s(!1);
+  function le() {
+    const { onEndReached: o } = e;
+    if (!o) return;
+    const { scrollTop: n } = t(N), l = t(u), a = l - (n + t(Y)) + e.hScrollbarSize;
+    !r.value && t(b) >= 0 && l <= n + t(T) - t(ee) ? (r.value = !0, o(a)) : r.value = !1;
+  }
+  return S(() => t(u), () => r.value = !1), S(() => e.expandedRowKeys, (o) => m.value = o, { deep: !0 }), {
+    columns: v,
+    containerRef: te,
+    mainTableRef: c,
+    leftTableRef: d,
+    rightTableRef: f,
+    isDynamic: z,
+    isResetting: F,
+    isScrolling: w,
+    hasFixedColumns: D,
+    columnsStyles: C,
+    columnsTotalWidth: h,
+    data: i,
+    expandedRowKeys: m,
+    depthMap: G,
+    fixedColumnsOnLeft: g,
+    fixedColumnsOnRight: R,
+    mainColumns: E,
+    bodyWidth: J,
+    emptyStyle: $,
+    rootStyle: p,
+    footerHeight: Z,
+    mainTableHeight: T,
+    fixedTableHeight: Q,
+    leftTableWidth: U,
+    rightTableWidth: X,
+    showEmpty: oe,
+    getRowHeight: ne,
+    onColumnSorted: I,
+    onRowHovered: q,
+    onRowExpanded: V,
+    onRowsRendered: B,
+    onRowHeightChange: k,
+    scrollTo: W,
+    scrollToLeft: K,
+    scrollToTop: O,
+    scrollToRow: A,
+    onScroll: L,
+    onVerticalScroll: M
+  };
+}
+export {
+  Ce as useTable
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/table-v2/src/utils.js

@@ -0,0 +1,17 @@
+import { isArray as n, isFunction as c } from "../../../../../../../@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { addUnit as m } from "../../../utils/dom/style.js";
+import { isVNode as d, h as u } from "vue";
+const h = (r, o) => r + o, f = (r) => n(r) ? r.reduce(h, 0) : r, p = (r, o, t = {}) => c(r) ? r(o) : r ?? t, e = (r) => ([
+  "width",
+  "maxWidth",
+  "minWidth",
+  "height"
+].forEach((o) => {
+  r[o] = m(r[o]);
+}), r), x = (r) => d(r) ? (o) => u(r, o) : r;
+export {
+  x as componentToSlot,
+  e as enforceUnit,
+  f as sum,
+  p as tryCall
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tabs/src/composables/use-tab-nav-touch.js

@@ -0,0 +1,42 @@
+import { getClientXY as T } from "../../../../utils/dom/position.js";
+import { ref as A, computed as O } from "vue";
+import S from "../../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/isUndefined.js";
+import g from "../../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/clamp.js";
+const b = 5, R = ({ scrollable: r, navOffset: s, navSize: p, navContainerSize: D, isHorizontal: l }) => {
+  const o = A(!1), u = O(() => Math.max(p.value - D.value, 0));
+  let e, a;
+  const M = (t) => {
+    if (!r.value || t.touches.length !== 1) return;
+    const { clientX: n, clientY: c } = T(t);
+    e = {
+      startX: n,
+      startY: c,
+      startOffset: s.value
+    }, a = void 0;
+  }, X = (t) => {
+    if (!e || !r.value) return;
+    if (t.touches.length !== 1) {
+      i();
+      return;
+    }
+    const { clientX: n, clientY: c } = T(t), f = e.startX - n, h = e.startY - c, m = l.value ? f : h, Y = l.value ? h : f, v = Math.abs(m), d = Math.abs(Y);
+    if (S(a)) {
+      if (Math.max(v, d) <= b) return;
+      a = v > d;
+    }
+    if (!a) return;
+    const x = g(e.startOffset + m, 0, u.value);
+    u.value <= 0 || x === s.value || !t.cancelable || (t.preventDefault(), o.value = !0, s.value = x);
+  }, i = () => {
+    e = void 0, a = void 0, o.value = !1;
+  };
+  return {
+    isTouchScrolling: o,
+    handleTouchStart: M,
+    handleTouchMove: X,
+    handleTouchEnd: i
+  };
+};
+export {
+  R as useTabNavTouch
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tabs/src/tab-bar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,62 @@
+import { isUndefined as v } from "../../../utils/types.js";
+import { capitalize as m } from "../../../utils/strings.js";
+import { throwError as R } from "../../../utils/error.js";
+import { useNamespace as C } from "../../../hooks/use-namespace/index.js";
+import { tabsRootContextKey as O } from "./constants.js";
+import { tabBarProps as S } from "./tab-bar.js";
+import { useResizeObserver as h } from "../../../../../../../@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { defineComponent as $, inject as k, ref as _, computed as T, watch as P, nextTick as F, onBeforeUnmount as j, openBlock as A, createElementBlock as L, normalizeStyle as M, normalizeClass as U, unref as u, createCommentVNode as V } from "vue";
+const y = "ElTabBar";
+var W = /* @__PURE__ */ $({
+  name: y,
+  __name: "tab-bar",
+  props: S,
+  setup(N, { expose: g }) {
+    const r = N, o = k(O);
+    o || R(y, "<el-tabs><el-tab-bar /></el-tabs>");
+    const b = C("tabs"), p = _(), l = _(), x = T(() => {
+      var e;
+      return v(o.props.defaultValue) || !!((e = l.value) != null && e.transform);
+    }), w = () => {
+      let e = 0, s = 0;
+      const n = ["top", "bottom"].includes(o.props.tabPosition) ? "width" : "height", d = n === "width" ? "x" : "y", z = d === "x" ? "left" : "top";
+      return r.tabs.every((f) => {
+        if (v(f.paneName)) return !1;
+        const i = r.tabRefs[f.paneName];
+        if (!i) return !1;
+        if (!f.active) return !0;
+        e = i[`offset${m(z)}`], s = i[`client${m(n)}`];
+        const c = window.getComputedStyle(i);
+        return n === "width" && (s -= Number.parseFloat(c.paddingLeft) + Number.parseFloat(c.paddingRight), e += Number.parseFloat(c.paddingLeft)), !1;
+      }), {
+        [n]: `${s}px`,
+        transform: `translate${m(d)}(${e}px)`
+      };
+    }, a = () => l.value = w(), t = [], B = () => {
+      t.forEach((e) => e.stop()), t.length = 0, Object.values(r.tabRefs).forEach((e) => {
+        t.push(h(e, a));
+      });
+    };
+    P(() => r.tabs, async () => {
+      await F(), a(), B();
+    }, { immediate: !0 });
+    const E = h(p, () => a());
+    return j(() => {
+      t.forEach((e) => e.stop()), t.length = 0, E.stop();
+    }), g({
+      /** @description tab root html element */
+      ref: p,
+      /** @description method to manually update tab bar style, return the updated style */
+      update: a
+    }), (e, s) => x.value ? (A(), L("div", {
+      key: 0,
+      ref_key: "barRef",
+      ref: p,
+      class: U([u(b).e("active-bar"), u(b).is(u(o).props.tabPosition)]),
+      style: M(l.value)
+    }, null, 6)) : V("v-if", !0);
+  }
+});
+export {
+  W as default
+};