ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table-header/utils-helper.d.ts

@@ -0,0 +1,10 @@
+import type { DefaultRow } from '../table/defaults';
+import type { TableColumnCtx } from '../table-column/defaults';
+import type { TableHeaderProps } from '.';
+export declare const convertToRows: <T extends DefaultRow>(originColumns: TableColumnCtx<T>[]) => TableColumnCtx<T>[][];
+declare function useUtils<T extends DefaultRow>(props: TableHeaderProps<T>): {
+    isGroup: import("vue").ComputedRef<boolean>;
+    toggleAllSelection: (event: Event) => void;
+    columnRows: import("vue").ComputedRef<TableColumnCtx<T>[][]>;
+};
+export default useUtils;

package/dist/components/table/src/table-header/utils-helper.js

@@ -0,0 +1,45 @@
+import { inject as h, computed as n } from "vue";
+import { TABLE_INJECTION_KEY as f } from "../tokens.js";
+const p = (r) => {
+  const t = [];
+  return r.forEach((l) => {
+    l.children ? (t.push(l), t.push.apply(t, p(l.children))) : t.push(l);
+  }), t;
+}, v = (r) => {
+  let t = 1;
+  const l = (e, o) => {
+    if (o && (e.level = o.level + 1, t < e.level && (t = e.level)), e.children) {
+      let i = 0;
+      e.children.forEach((a) => {
+        l(a, e), i += a.colSpan;
+      }), e.colSpan = i;
+    } else
+      e.colSpan = 1;
+  };
+  r.forEach((e) => {
+    e.level = 1, l(e, void 0);
+  });
+  const s = [];
+  for (let e = 0; e < t; e++)
+    s.push([]);
+  return p(r).forEach((e) => {
+    e.children ? (e.rowSpan = 1, e.children.forEach((o) => o.isSubColumn = !0)) : e.rowSpan = t - e.level + 1, s[e.level - 1].push(e);
+  }), s;
+};
+function d(r) {
+  const t = h(f), l = n(() => v(r.store.states.originColumns.value));
+  return {
+    isGroup: n(() => {
+      const e = l.value.length > 1;
+      return e && t && (t.state.isGroup.value = !0), e;
+    }),
+    toggleAllSelection: (e) => {
+      e.stopPropagation(), t == null || t.store.commit("toggleAllSelection");
+    },
+    columnRows: l
+  };
+}
+export {
+  v as convertToRows,
+  d as default
+};

package/dist/components/table/src/table-layout.d.ts

@@ -0,0 +1,37 @@
+import type { Ref } from 'vue';
+import type { TableColumnCtx } from './table-column/defaults';
+import type { TableHeader } from './table-header';
+import type { DefaultRow, Table } from './table/defaults';
+import type { Store } from './store';
+declare class TableLayout<T extends DefaultRow> {
+    observers: TableHeader[];
+    table: Table<T>;
+    store: Store<T>;
+    columns: TableColumnCtx<T>[];
+    fit: boolean;
+    showHeader: boolean;
+    heightMap: Record<string, string | number | null>;
+    height: Ref<null | number>;
+    scrollX: Ref<boolean>;
+    scrollY: Ref<boolean>;
+    bodyWidth: Ref<null | number>;
+    fixedWidth: Ref<null | number>;
+    rightFixedWidth: Ref<null | number>;
+    tableHeight: Ref<null | number>;
+    headerHeight: Ref<null | number>;
+    appendHeight: Ref<null | number>;
+    footerHeight: Ref<null | number>;
+    gutterWidth: number;
+    constructor(options: Record<string, any>);
+    updateScrollY(): boolean;
+    setHeight(value: string | number | null, prop?: string): void;
+    setMaxHeight(value: string | number | null): void;
+    getFlattenColumns(): TableColumnCtx<T>[];
+    updateElsHeight(): void;
+    headerDisplayNone(elm: HTMLElement): boolean;
+    updateColumnsWidth(): void;
+    addObserver(observer: TableHeader): void;
+    removeObserver(observer: TableHeader): void;
+    notifyObservers(event: string): void;
+}
+export default TableLayout;

package/dist/components/table/src/table-layout.js

@@ -0,0 +1,144 @@
+import { ref as a, isRef as p, nextTick as v } from "vue";
+import { isNull as x } from "lodash-unified";
+import { isNumber as n } from "../../../utils/types.js";
+import { isClient as W } from "@vueuse/core";
+import { hasOwn as w, isString as y } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { parseHeight as C } from "./util.js";
+class T {
+  constructor(t) {
+    this.observers = [], this.table = null, this.store = null, this.columns = [], this.fit = !0, this.showHeader = !0, this.heightMap = {}, this.height = a(null), this.scrollX = a(!1), this.scrollY = a(!1), this.bodyWidth = a(null), this.fixedWidth = a(null), this.rightFixedWidth = a(null), this.gutterWidth = 0;
+    for (const e in t)
+      w(t, e) && (p(this[e]) ? this[e].value = t[e] : this[e] = t[e]);
+    if (!this.table)
+      throw new Error("Table is required for Table Layout");
+    if (!this.store)
+      throw new Error("Store is required for Table Layout");
+  }
+  updateScrollY() {
+    const t = this.height.value;
+    if (x(t)) return !1;
+    const e = this.table.refs.scrollBarRef;
+    if (this.table.vnode.el && (e != null && e.wrapRef)) {
+      let s = !0;
+      const r = this.scrollY.value;
+      return s = e.wrapRef.scrollHeight > e.wrapRef.clientHeight, this.scrollY.value = s, r !== s;
+    }
+    return !1;
+  }
+  setHeight(t, e = "height") {
+    if (!W) return;
+    const s = this.table.vnode.el;
+    if (t = C(t), this.height.value = Number(t), this.heightMap[e] = t, !s && (t || t === 0)) {
+      v(() => {
+        this.heightMap[e] === t && this.setHeight(t, e);
+      });
+      return;
+    }
+    s && n(t) ? (s.style[e] = `${t}px`, this.updateElsHeight()) : s && y(t) && (s.style[e] = t, this.updateElsHeight());
+  }
+  setMaxHeight(t) {
+    this.setHeight(t, "max-height");
+  }
+  getFlattenColumns() {
+    const t = [];
+    return this.table.store.states.columns.value.forEach((s) => {
+      s.isColumnGroup ? t.push.apply(t, s.columns) : t.push(s);
+    }), t;
+  }
+  updateElsHeight() {
+    this.updateScrollY(), this.notifyObservers("scrollable");
+  }
+  headerDisplayNone(t) {
+    if (!t) return !0;
+    let e = t;
+    for (; e.tagName !== "DIV"; ) {
+      if (getComputedStyle(e).display === "none")
+        return !0;
+      e = e.parentElement;
+    }
+    return !1;
+  }
+  updateColumnsWidth() {
+    var b;
+    if (!W) return;
+    const t = this.fit, e = (b = this.table.vnode.el) == null ? void 0 : b.clientWidth;
+    let s = 0;
+    const r = this.getFlattenColumns(), h = r.filter(
+      (i) => !n(i.width)
+    );
+    if (r.forEach((i) => {
+      n(i.width) && i.realWidth && (i.realWidth = null);
+    }), h.length > 0 && t) {
+      if (r.forEach((i) => {
+        s += Number(i.width || i.minWidth || 80);
+      }), s <= e) {
+        this.scrollX.value = !1;
+        const i = e - s;
+        if (h.length === 1)
+          h[0].realWidth = Number(h[0].minWidth || 80) + i;
+        else {
+          const l = h.reduce(
+            (o, d) => o + Number(d.minWidth || 80),
+            0
+          ), g = i / l;
+          let c = 0;
+          h.forEach((o, d) => {
+            if (d === 0) return;
+            const m = Math.floor(
+              Number(o.minWidth || 80) * g
+            );
+            c += m, o.realWidth = Number(o.minWidth || 80) + m;
+          }), h[0].realWidth = Number(h[0].minWidth || 80) + i - c;
+        }
+      } else
+        this.scrollX.value = !0, h.forEach((i) => {
+          i.realWidth = Number(i.minWidth);
+        });
+      this.bodyWidth.value = Math.max(s, e), this.table.state.resizeState.value.width = this.bodyWidth.value;
+    } else
+      r.forEach((i) => {
+        !i.width && !i.minWidth ? i.realWidth = 80 : i.realWidth = Number(i.width || i.minWidth), s += i.realWidth;
+      }), this.scrollX.value = s > e, this.bodyWidth.value = s;
+    const f = this.store.states.fixedColumns.value;
+    if (f.length > 0) {
+      let i = 0;
+      f.forEach((l) => {
+        i += Number(l.realWidth || l.width);
+      }), this.fixedWidth.value = i;
+    }
+    const u = this.store.states.rightFixedColumns.value;
+    if (u.length > 0) {
+      let i = 0;
+      u.forEach((l) => {
+        i += Number(l.realWidth || l.width);
+      }), this.rightFixedWidth.value = i;
+    }
+    this.notifyObservers("columns");
+  }
+  addObserver(t) {
+    this.observers.push(t);
+  }
+  removeObserver(t) {
+    const e = this.observers.indexOf(t);
+    e !== -1 && this.observers.splice(e, 1);
+  }
+  notifyObservers(t) {
+    this.observers.forEach((s) => {
+      var r, h;
+      switch (t) {
+        case "columns":
+          (r = s.state) == null || r.onColumnsChange(this);
+          break;
+        case "scrollable":
+          (h = s.state) == null || h.onScrollableChange(this);
+          break;
+        default:
+          throw new Error(`Table Layout don't have event ${t}.`);
+      }
+    });
+  }
+}
+export {
+  T as default
+};