ep-craft 0.1.8 → 0.1.9

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

@@ -0,0 +1,197 @@
+import { useLocale as Oe } from "../../../hooks/use-locale/index.js";
+import { useNamespace as Ge } from "../../../hooks/use-namespace/index.js";
+import { useTable as _e } from "./use-table.js";
+import { TableV2InjectionKey as je } from "./tokens.js";
+import { tableV2Props as ke } from "./table.js";
+import ze from "./renderers/main-table.js";
+import Fe from "./renderers/left-table.js";
+import Le from "./renderers/right-table.js";
+import Ne from "./renderers/row.js";
+import G from "./renderers/cell.js";
+import Me from "./renderers/header.js";
+import _ from "./renderers/header-cell.js";
+import $e from "./renderers/footer.js";
+import De from "./renderers/empty.js";
+import Ie from "./renderers/overlay.js";
+import { defineComponent as Ae, provide as Be, unref as e, createVNode as t, mergeProps as d, isVNode as qe } from "vue";
+function m(n) {
+  return typeof n == "function" || Object.prototype.toString.call(n) === "[object Object]" && !qe(n);
+}
+const mo = /* @__PURE__ */ Ae({
+  name: "ElTableV2",
+  props: ke,
+  slots: Object,
+  setup(n, { slots: l, expose: j }) {
+    const o = Ge("table-v2"), { t: x } = Oe(), { columnsStyles: k, fixedColumnsOnLeft: z, fixedColumnsOnRight: F, mainColumns: L, mainTableHeight: N, fixedTableHeight: M, leftTableWidth: $, rightTableWidth: D, data: I, depthMap: A, expandedRowKeys: P, hasFixedColumns: B, mainTableRef: q, leftTableRef: J, rightTableRef: Q, isDynamic: U, isResetting: X, isScrolling: Y, bodyWidth: W, emptyStyle: Z, rootStyle: ee, footerHeight: oe, showEmpty: te, scrollTo: le, scrollToLeft: re, scrollToTop: ae, scrollToRow: ne, getRowHeight: b, onColumnSorted: se, onRowHeightChange: ie, onRowHovered: de, onRowExpanded: ce, onRowsRendered: me, onScroll: he, onVerticalScroll: v } = _e(n);
+    return j({
+      /**
+      * @description scroll to a given position
+      * @params params {{ scrollLeft?: number, scrollTop?: number }} where to scroll to.
+      */
+      scrollTo: le,
+      /**
+      * @description scroll to a given position horizontally
+      * @params scrollLeft {Number} where to scroll to.
+      */
+      scrollToLeft: re,
+      /**
+      * @description scroll to a given position vertically
+      * @params scrollTop { Number } where to scroll to.
+      */
+      scrollToTop: ae,
+      /**
+      * @description scroll to a given row
+      * @params row {Number} which row to scroll to
+      * @params @optional strategy {ScrollStrategy} use what strategy to scroll to
+      */
+      scrollToRow: ne
+    }), Be(je, {
+      ns: o,
+      isResetting: X,
+      isScrolling: Y
+    }), () => {
+      const { cache: u, cellProps: fe, estimatedRowHeight: h, expandColumnKey: V, fixedData: y, headerHeight: p, headerClass: be, headerProps: ue, headerCellProps: ye, sortBy: pe, sortState: ge, rowHeight: g, rowClass: we, rowEventHandlers: Se, rowKey: c, rowProps: Re, scrollbarAlwaysOn: w, indentSize: Te, iconSize: Ce, useIsScrolling: S, vScrollbarSize: f, width: He } = n, R = e(I), xe = {
+        cache: u,
+        class: o.e("main"),
+        columns: e(L),
+        data: R,
+        fixedData: y,
+        estimatedRowHeight: h,
+        bodyWidth: e(W),
+        headerHeight: p,
+        headerWidth: e(W),
+        height: e(N),
+        mainTableRef: q,
+        rowKey: c,
+        rowHeight: g,
+        scrollbarAlwaysOn: w,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: f,
+        useIsScrolling: S,
+        width: He,
+        getRowHeight: b,
+        onRowsRendered: me,
+        onScroll: he
+      }, T = e($), E = e(M), Pe = {
+        cache: u,
+        class: o.e("left"),
+        columns: e(z),
+        data: R,
+        fixedData: y,
+        estimatedRowHeight: h,
+        leftTableRef: J,
+        rowHeight: g,
+        bodyWidth: T,
+        headerWidth: T,
+        headerHeight: p,
+        height: E,
+        rowKey: c,
+        scrollbarAlwaysOn: w,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: f,
+        useIsScrolling: S,
+        width: T,
+        getRowHeight: b,
+        onScroll: v
+      }, C = e(D), We = {
+        cache: u,
+        class: o.e("right"),
+        columns: e(F),
+        data: R,
+        fixedData: y,
+        estimatedRowHeight: h,
+        rightTableRef: Q,
+        rowHeight: g,
+        bodyWidth: C,
+        headerWidth: C,
+        headerHeight: p,
+        height: E,
+        rowKey: c,
+        scrollbarAlwaysOn: w,
+        scrollbarStartGap: 2,
+        scrollbarEndGap: f,
+        width: C,
+        style: `${o.cssVarName("table-scrollbar-size")}: ${f}px`,
+        useIsScrolling: S,
+        getRowHeight: b,
+        onScroll: v
+      }, i = e(k), ve = {
+        ns: o,
+        depthMap: e(A),
+        columnsStyles: i,
+        expandColumnKey: V,
+        expandedRowKeys: e(P),
+        estimatedRowHeight: h,
+        hasFixedColumns: e(B),
+        rowProps: Re,
+        rowClass: we,
+        rowKey: c,
+        rowEventHandlers: Se,
+        onRowHovered: de,
+        onRowExpanded: ce,
+        onRowHeightChange: ie
+      }, K = {
+        cellProps: fe,
+        expandColumnKey: V,
+        indentSize: Te,
+        iconSize: Ce,
+        rowKey: c,
+        expandedRowKeys: e(P),
+        ns: o,
+        t: x
+      }, Ve = {
+        ns: o,
+        headerClass: be,
+        headerProps: ue,
+        columnsStyles: i
+      }, O = {
+        ns: o,
+        t: x,
+        sortBy: pe,
+        sortState: ge,
+        headerCellProps: ye,
+        onColumnSorted: se
+      }, a = {
+        row: (H) => t(Ne, d(H, ve), {
+          row: l.row,
+          cell: (r) => {
+            let s;
+            return l.cell ? t(G, d(r, K, { style: i[r.column.key] }), m(s = l.cell(r)) ? s : { default: () => [s] }) : t(G, d(r, K, { style: i[r.column.key] }), null);
+          }
+        }),
+        header: (H) => t(Me, d(H, Ve), {
+          header: l.header,
+          cell: (r) => {
+            let s;
+            return l["header-cell"] ? t(_, d(r, O, { style: i[r.column.key] }), m(s = l["header-cell"](r)) ? s : { default: () => [s] }) : t(_, d(r, O, { style: i[r.column.key] }), null);
+          }
+        })
+      }, Ee = [
+        n.class,
+        o.b(),
+        o.e("root"),
+        o.is("dynamic", e(U))
+      ], Ke = {
+        class: o.e("footer"),
+        style: e(oe)
+      };
+      return t("div", {
+        class: Ee,
+        style: e(ee)
+      }, [
+        t(ze, xe, m(a) ? a : { default: () => [a] }),
+        t(Fe, Pe, m(a) ? a : { default: () => [a] }),
+        t(Le, We, m(a) ? a : { default: () => [a] }),
+        l.footer && t($e, Ke, { default: l.footer }),
+        e(te) && t(De, {
+          class: o.e("empty"),
+          style: e(Z)
+        }, { default: l.empty }),
+        l.overlay && t(Ie, { class: o.e("overlay") }, { default: l.overlay })
+      ]);
+    };
+  }
+});
+export {
+  mo as default
+};

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

@@ -0,0 +1,93 @@
+import { buildProps as i, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import { virtualizedScrollbarProps as l, virtualizedGridProps as r } from "../../virtual-list/src/props.js";
+import { requiredNumber as a, classType as d, expandKeys as n, fixedDataType as p, dataType as s, columns as c, rowKey as u } from "./common.js";
+import { tableV2RowProps as t } from "./row.js";
+import { tableV2HeaderProps as y } from "./header.js";
+import { tableV2GridProps as o } from "./grid.js";
+const x = i({
+  cache: o.cache,
+  estimatedRowHeight: t.estimatedRowHeight,
+  rowKey: u,
+  headerClass: { type: e([String, Function]) },
+  headerProps: { type: e([Object, Function]) },
+  headerCellProps: { type: e([Object, Function]) },
+  headerHeight: y.headerHeight,
+  /**
+  * Footer attributes
+  */
+  footerHeight: {
+    type: Number,
+    default: 0
+  },
+  /**
+  * Row attributes
+  */
+  rowClass: { type: e([String, Function]) },
+  rowProps: { type: e([Object, Function]) },
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  /**
+  * Cell attributes
+  */
+  cellProps: { type: e([Object, Function]) },
+  /**
+  * Data models
+  */
+  columns: c,
+  data: s,
+  dataGetter: { type: e(Function) },
+  fixedData: p,
+  /**
+  * Expanded keys
+  */
+  expandColumnKey: t.expandColumnKey,
+  expandedRowKeys: n,
+  defaultExpandedRowKeys: n,
+  /**
+  * Attributes
+  */
+  class: d,
+  fixed: Boolean,
+  style: { type: e(Object) },
+  width: a,
+  height: a,
+  maxHeight: Number,
+  useIsScrolling: Boolean,
+  indentSize: {
+    type: Number,
+    default: 12
+  },
+  iconSize: {
+    type: Number,
+    default: 12
+  },
+  hScrollbarSize: r.hScrollbarSize,
+  vScrollbarSize: r.vScrollbarSize,
+  scrollbarAlwaysOn: l.alwaysOn,
+  /**
+  * Sorting
+  */
+  sortBy: {
+    type: e(Object),
+    default: () => ({})
+  },
+  sortState: {
+    type: e(Object),
+    default: void 0
+  },
+  /**
+  * Handlers
+  */
+  onColumnSort: { type: e(Function) },
+  onExpandedRowsChange: { type: e(Function) },
+  onEndReached: { type: e(Function) },
+  onRowExpand: t.onRowExpand,
+  onScroll: o.onScroll,
+  onRowsRendered: o.onRowsRendered,
+  rowEventHandlers: t.rowEventHandlers
+});
+export {
+  x as tableV2Props
+};

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

@@ -0,0 +1,5 @@
+const e = Symbol("tableV2"), t = "tableV2GridScrollLeft";
+export {
+  t as TABLE_V2_GRID_INJECTION_KEY,
+  e as TableV2InjectionKey
+};

package/dist/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/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/element-plus/es/components/table-v2/src/utils.js

@@ -0,0 +1,17 @@
+import { isArray as n, isFunction as c } from "../../../../../@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/element-plus/es/components/tabs/index.js

@@ -0,0 +1,12 @@
+import { withInstall as a, withNoopInstall as o } from "../../utils/vue/install.js";
+import s from "./src/tabs.js";
+import { tabsEmits as f, tabsProps as i } from "./src/tabs.js";
+import t from "./src/tab-pane2.js";
+const p = a(s, { TabPane: t }), b = o(t);
+export {
+  b as ElTabPane,
+  p as ElTabs,
+  p as default,
+  f as tabsEmits,
+  i as tabsProps
+};

package/dist/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/isUndefined.js";
+import g from "../../../../../../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/element-plus/es/components/tabs/src/constants.js

@@ -0,0 +1,4 @@
+const t = Symbol("tabsRootContextKey");
+export {
+  t as tabsRootContextKey
+};

package/dist/node_modules/element-plus/es/components/tabs/src/tab-bar.js

@@ -0,0 +1,15 @@
+import { buildProps as r, definePropType as t } from "../../../utils/vue/props/runtime.js";
+import { mutable as e } from "../../../utils/typescript.js";
+const a = r({
+  tabs: {
+    type: t(Array),
+    default: () => e([])
+  },
+  tabRefs: {
+    type: t(Object),
+    default: () => e({})
+  }
+});
+export {
+  a as tabBarProps
+};

package/dist/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/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
+};

package/dist/node_modules/element-plus/es/components/tabs/src/tab-bar2.js

@@ -0,0 +1,5 @@
+import t from "./tab-bar.vue_vue_type_script_setup_true_lang.js";
+var a = t;
+export {
+  a as default
+};