ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table-body/events-helper.js

@@ -0,0 +1,126 @@
+import { inject as Y, ref as M, h as F } from "vue";
+import { debounce as I } from "lodash-unified";
+import "@vue/shared";
+import "@vueuse/core";
+import { isGreaterThan as h } from "../../../../utils/numbers.js";
+import { hasClass as O, addClass as Q, removeClass as U } from "../../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { getCell as f, getColumnByCell as L, createTablePopper as V, removePopper as m } from "../util.js";
+import { TABLE_INJECTION_KEY as X } from "../tokens.js";
+function dt(a) {
+  const r = Y(X), k = M(""), v = M(F("div")), u = (t, e, l) => {
+    var i, d;
+    const o = r, n = f(t);
+    let s = null;
+    const c = (i = o == null ? void 0 : o.vnode.el) == null ? void 0 : i.dataset.prefix;
+    n && (s = L(
+      {
+        columns: ((d = a.store) == null ? void 0 : d.states.columns.value) ?? []
+      },
+      n,
+      c
+    ), s && (o == null || o.emit(`cell-${l}`, e, s, n, t))), o == null || o.emit(`row-${l}`, e, s, t);
+  }, y = (t, e) => {
+    u(t, e, "dblclick");
+  }, P = (t, e) => {
+    var l;
+    (l = a.store) == null || l.commit("setCurrentRow", e), u(t, e, "click");
+  }, S = (t, e) => {
+    u(t, e, "contextmenu");
+  }, b = I((t) => {
+    var e;
+    (e = a.store) == null || e.commit("setHoverRow", t);
+  }, 30), W = I(() => {
+    var t;
+    (t = a.store) == null || t.commit("setHoverRow", null);
+  }, 30), $ = (t) => {
+    const e = window.getComputedStyle(t, null), l = Number.parseInt(e.paddingLeft, 10) || 0, o = Number.parseInt(e.paddingRight, 10) || 0, n = Number.parseInt(e.paddingTop, 10) || 0, s = Number.parseInt(e.paddingBottom, 10) || 0;
+    return {
+      left: l,
+      right: o,
+      top: n,
+      bottom: s
+    };
+  }, p = (t, e, l) => {
+    var n;
+    let o = (n = e == null ? void 0 : e.target) == null ? void 0 : n.parentNode;
+    for (; t > 1 && (o = o == null ? void 0 : o.nextSibling, !(!o || o.nodeName !== "TR")); )
+      l(o, "hover-row hover-fixed-row"), t--;
+  };
+  return {
+    handleDoubleClick: y,
+    handleClick: P,
+    handleContextMenu: S,
+    handleMouseEnter: b,
+    handleMouseLeave: W,
+    handleCellMouseEnter: (t, e, l) => {
+      var w, x, N, R, E, T, B;
+      if (!r) return;
+      const o = r, n = f(t), s = (w = o == null ? void 0 : o.vnode.el) == null ? void 0 : w.dataset.prefix;
+      let c = null;
+      if (n) {
+        if (c = L(
+          {
+            columns: ((x = a.store) == null ? void 0 : x.states.columns.value) ?? []
+          },
+          n,
+          s
+        ), !c)
+          return;
+        n.rowSpan > 1 && p(n.rowSpan, t, Q);
+        const g = o.hoverState = {
+          cell: n,
+          column: c,
+          row: e
+        };
+        o == null || o.emit(
+          "cell-mouse-enter",
+          g.row,
+          g.column,
+          g.cell,
+          t
+        );
+      }
+      if (!l) {
+        ((N = m) == null ? void 0 : N.trigger) === n && ((R = m) == null || R());
+        return;
+      }
+      const i = t.target.querySelector(
+        ".cell"
+      );
+      if (!(O(i, `${s}-tooltip`) && i.childNodes.length && ((E = i.textContent) != null && E.trim())))
+        return;
+      const d = document.createRange();
+      d.setStart(i, 0), d.setEnd(i, i.childNodes.length);
+      const { width: _, height: j } = d.getBoundingClientRect(), { width: C, height: q } = i.getBoundingClientRect(), { top: z, left: A, right: D, bottom: G } = $(i), J = A + D, K = z + G;
+      h(_ + J, C) || h(j + K, q) || // When using a high-resolution screen, it is possible that a returns cellChild.scrollWidth value of 1921 and
+      // cellChildWidth returns a value of 1920.994140625. #16856 #16673
+      h(i.scrollWidth, C) ? V(
+        l,
+        ((n == null ? void 0 : n.innerText) || (n == null ? void 0 : n.textContent)) ?? "",
+        e,
+        c,
+        n,
+        o
+      ) : ((T = m) == null ? void 0 : T.trigger) === n && ((B = m) == null || B());
+    },
+    handleCellMouseLeave: (t) => {
+      const e = f(t);
+      if (!e) return;
+      e.rowSpan > 1 && p(e.rowSpan, t, U);
+      const l = r == null ? void 0 : r.hoverState;
+      r == null || r.emit(
+        "cell-mouse-leave",
+        l == null ? void 0 : l.row,
+        l == null ? void 0 : l.column,
+        l == null ? void 0 : l.cell,
+        t
+      );
+    },
+    tooltipContent: k,
+    tooltipTrigger: v
+  };
+}
+export {
+  dt as default
+};

package/dist/components/table/src/table-body/index.d.ts

@@ -0,0 +1,84 @@
+import type { VNode } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    store: {
+        required: boolean;
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["store"]>;
+    };
+    stripe: BooleanConstructor;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: {
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["tooltipOptions"]>;
+    };
+    context: {
+        default: () => {};
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["context"]>;
+    };
+    rowClassName: import("vue").PropType<import("./defaults").TableBodyProps<any>["rowClassName"]>;
+    rowStyle: import("vue").PropType<import("./defaults").TableBodyProps<any>["rowStyle"]>;
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    highlight: BooleanConstructor;
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    onColumnsChange: (layout: import("../table-layout").default<import("../..").DefaultRow>) => void;
+    onScrollableChange: (layout: import("../table-layout").default<import("../..").DefaultRow>) => void;
+    wrappedRowRender: (row: any, $index: number) => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[][];
+    tooltipContent: import("vue").Ref<string, string>;
+    tooltipTrigger: import("vue").Ref<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    store: {
+        required: boolean;
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["store"]>;
+    };
+    stripe: BooleanConstructor;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: {
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["tooltipOptions"]>;
+    };
+    context: {
+        default: () => {};
+        type: import("vue").PropType<import("./defaults").TableBodyProps<any>["context"]>;
+    };
+    rowClassName: import("vue").PropType<import("./defaults").TableBodyProps<any>["rowClassName"]>;
+    rowStyle: import("vue").PropType<import("./defaults").TableBodyProps<any>["rowStyle"]>;
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    highlight: BooleanConstructor;
+}>> & Readonly<{}>, {
+    fixed: string;
+    highlight: boolean;
+    stripe: boolean;
+    context: import("../..").Table<any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/table/src/table-body/index.js

@@ -0,0 +1,77 @@
+import { defineComponent as S, h as B, getCurrentInstance as D, inject as O, watch as P, onUnmounted as _ } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import { isClient as j } from "@vueuse/core";
+import { rAF as k } from "../../../../utils/raf.js";
+import { addClass as N, removeClass as R } from "../../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { useNamespace as F } from "../../../../hooks/use-namespace/index.js";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+import J from "../layout-observer.js";
+import { removePopper as K } from "../util.js";
+import { TABLE_INJECTION_KEY as U } from "../tokens.js";
+import Y from "./render-helper.js";
+import $ from "./defaults.js";
+const ao = S({
+  name: "ElTableBody",
+  props: $,
+  setup(i) {
+    var v;
+    const t = D(), c = O(U), m = F("table"), { wrappedRowRender: d, tooltipContent: T, tooltipTrigger: y } = Y(i), { onColumnsChange: E, onScrollableChange: L } = J(c), f = [];
+    return P((v = i.store) == null ? void 0 : v.states.hoverRow, (n, A) => {
+      var C, w;
+      const h = t == null ? void 0 : t.vnode.el, l = Array.from((h == null ? void 0 : h.children) || []).filter(
+        (o) => o == null ? void 0 : o.classList.contains(`${m.e("row")}`)
+      );
+      let a = n;
+      const s = (C = l[a]) == null ? void 0 : C.childNodes;
+      if (s != null && s.length) {
+        let o = 0;
+        Array.from(s).reduce((r, p, e) => {
+          var b, g;
+          return ((b = s[e]) == null ? void 0 : b.colSpan) > 1 && (o = (g = s[e]) == null ? void 0 : g.colSpan), p.nodeName !== "TD" && o === 0 && r.push(e), o > 0 && o--, r;
+        }, []).forEach((r) => {
+          var p;
+          for (a = n; a > 0; ) {
+            const e = (p = l[a - 1]) == null ? void 0 : p.childNodes;
+            if (e[r] && e[r].nodeName === "TD" && e[r].rowSpan > 1) {
+              N(e[r], "hover-cell"), f.push(e[r]);
+              break;
+            }
+            a--;
+          }
+        });
+      } else
+        f.forEach((o) => R(o, "hover-cell")), f.length = 0;
+      !((w = i.store) != null && w.states.isComplex.value) || !j || k(() => {
+        const o = l[A], u = l[n];
+        o && !o.classList.contains("hover-fixed-row") && R(o, "hover-row"), u && N(u, "hover-row");
+      });
+    }), _(() => {
+      var n;
+      (n = K) == null || n();
+    }), {
+      ns: m,
+      onColumnsChange: E,
+      onScrollableChange: L,
+      wrappedRowRender: d,
+      tooltipContent: T,
+      tooltipTrigger: y
+    };
+  },
+  render() {
+    const { wrappedRowRender: i, store: t } = this, c = (t == null ? void 0 : t.states.data.value) || [];
+    return B("tbody", { tabIndex: -1 }, [
+      c.reduce((m, d) => m.concat(i(d, m.length)), [])
+    ]);
+  }
+});
+export {
+  ao as default
+};

package/dist/components/table/src/table-body/render-helper.d.ts

@@ -0,0 +1,18 @@
+import type { TableBodyProps } from './defaults';
+import type { DefaultRow } from '../table/defaults';
+declare function useRender<T extends DefaultRow>(props: Partial<TableBodyProps<T>>): {
+    wrappedRowRender: (row: T, $index: number) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[][];
+    tooltipContent: import("vue").Ref<string, string>;
+    tooltipTrigger: import("vue").Ref<import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>;
+};
+export default useRender;

package/dist/components/table/src/table-body/render-helper.js

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

package/dist/components/table/src/table-body/styles-helper.d.ts

@@ -0,0 +1,15 @@
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { TableBodyProps } from './defaults';
+import type { DefaultRow } from '../table/defaults';
+declare function useStyles<T extends DefaultRow>(props: Partial<TableBodyProps<T>>): {
+    getRowStyle: (row: T, rowIndex: number) => any;
+    getRowClass: (row: T, rowIndex: number, displayIndex: number) => string[];
+    getCellStyle: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>) => import("vue").CSSProperties;
+    getCellClass: (rowIndex: number, columnIndex: number, row: T, column: TableColumnCtx<T>, offset: number) => string;
+    getSpan: (row: T, column: TableColumnCtx<T>, rowIndex: number, columnIndex: number) => {
+        rowspan: number;
+        colspan: number;
+    };
+    getColspanRealWidth: (columns: TableColumnCtx<T>[], colspan: number, index: number) => number;
+};
+export default useStyles;

package/dist/components/table/src/table-body/styles-helper.js

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

package/dist/components/table/src/table-body/td-wrapper.vue.d.ts

@@ -0,0 +1,33 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    colspan: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowspan: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    colspan: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowspan: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    rowspan: number;
+    colspan: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/table/src/table-body/td-wrapper.vue.js

@@ -0,0 +1,26 @@
+import { defineComponent as n, openBlock as o, createElementBlock as t, renderSlot as r } from "vue";
+const p = ["colspan", "rowspan"], c = /* @__PURE__ */ n({
+  name: "TableTdWrapper",
+  __name: "td-wrapper",
+  props: {
+    colspan: {
+      type: Number,
+      default: 1
+    },
+    rowspan: {
+      type: Number,
+      default: 1
+    }
+  },
+  setup(e) {
+    return (a, s) => (o(), t("td", {
+      colspan: e.colspan,
+      rowspan: e.rowspan
+    }, [
+      r(a.$slots, "default")
+    ], 8, p));
+  }
+});
+export {
+  c as default
+};

package/dist/components/table/src/table-body/td-wrapper2.vue.js

@@ -0,0 +1,4 @@
+import f from "./td-wrapper.vue.js";
+export {
+  f as default
+};