ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table/defaults.js

@@ -0,0 +1,236 @@
+import "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useSizeProp as e } from "../../../../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";
+const s = {
+  /**
+   * @description table data
+   */
+  data: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * @description size of Table
+   */
+  size: e,
+  width: [String, Number],
+  /**
+   * @description table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
+   */
+  height: [String, Number],
+  /**
+   * @description table's max-height. The legal value is a number or the height in px
+   */
+  maxHeight: [String, Number],
+  /**
+   * @description whether width of column automatically fits its container
+   */
+  fit: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether Table is striped
+   */
+  stripe: Boolean,
+  /**
+   * @description whether Table has vertical border
+   */
+  border: Boolean,
+  /**
+   * @description key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
+   */
+  rowKey: [String, Function],
+  /**
+   * @description whether Table header is visible
+   */
+  showHeader: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether to display a summary row
+   */
+  showSummary: Boolean,
+  /**
+   * @description displayed text for the first column of summary row
+   */
+  sumText: String,
+  /**
+   * @description custom summary method
+   */
+  summaryMethod: Function,
+  /**
+   * @description function that returns custom class names for a row, or a string assigning class names for every row
+   */
+  rowClassName: [String, Function],
+  /**
+   * @description function that returns custom style for a row, or an object assigning custom style for every row
+   */
+  rowStyle: [Object, Function],
+  /**
+   * @description function that returns custom class names for a cell, or a string assigning class names for every cell
+   */
+  cellClassName: [String, Function],
+  /**
+   * @description function that returns custom style for a cell, or an object assigning custom style for every cell
+   */
+  cellStyle: [Object, Function],
+  /**
+   * @description function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
+   */
+  headerRowClassName: [String, Function],
+  /**
+   * @description function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
+   */
+  headerRowStyle: [Object, Function],
+  /**
+   * @description function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
+   */
+  headerCellClassName: [String, Function],
+  /**
+   * @description function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
+   */
+  headerCellStyle: [Object, Function],
+  /**
+   * @description whether current row is highlighted
+   */
+  highlightCurrentRow: Boolean,
+  /**
+   * @description key of current row, a set only prop
+   */
+  currentRowKey: [String, Number],
+  /**
+   * @description displayed text when data is empty. You can customize this area with `#empty`
+   */
+  emptyText: String,
+  /**
+   * @description set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
+   */
+  expandRowKeys: Array,
+  /**
+   * @description whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
+   */
+  defaultExpandAll: Boolean,
+  /**
+   * @description enable expandable rows, works when the table has a column type="expand"
+   */
+  rowExpandable: {
+    type: Function
+  },
+  /**
+   * @description set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
+   */
+  defaultSort: Object,
+  /**
+   * @description the `effect` of the overflow tooltip
+   */
+  tooltipEffect: String,
+  /**
+   * @description the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
+   */
+  tooltipOptions: Object,
+  /**
+   * @description method that returns rowspan and colspan
+   */
+  spanMethod: Function,
+  /**
+   * @description controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
+   */
+  selectOnIndeterminate: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description horizontal indentation of tree data
+   */
+  indent: {
+    type: Number,
+    default: 16
+  },
+  /**
+   * @description configuration for rendering nested data
+   */
+  treeProps: {
+    type: Object,
+    default: () => ({
+      hasChildren: "hasChildren",
+      children: "children",
+      checkStrictly: !1
+    })
+  },
+  /**
+   * @description whether to lazy loading data
+   */
+  lazy: Boolean,
+  /**
+   * @description method for loading child row data, only works when `lazy` is true
+   */
+  load: Function,
+  style: {
+    type: [String, Object, Array, Boolean],
+    default: () => ({})
+  },
+  className: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description sets the algorithm used to lay out table cells, rows, and columns
+   */
+  tableLayout: {
+    type: String,
+    default: "fixed"
+  },
+  /**
+   * @description always show scrollbar
+   */
+  scrollbarAlwaysOn: Boolean,
+  /**
+   * @description ensure main axis minimum-size doesn't follow the content
+   */
+  flexible: Boolean,
+  /**
+   * @description whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
+   */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+   * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+   */
+  tooltipFormatter: Function,
+  appendFilterPanelTo: String,
+  scrollbarTabindex: {
+    type: [Number, String],
+    default: void 0
+  },
+  /**
+   * @description whether to allow drag the last column
+   */
+  allowDragLastColumn: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether to preserve expanded row content in DOM when collapsed
+   */
+  preserveExpandedContent: Boolean,
+  /**
+   * @description whether to use native scrollbars
+   */
+  nativeScrollbar: Boolean
+};
+export {
+  s as tableProps
+};

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

@@ -0,0 +1,2 @@
+import type { DefaultRow, Table } from './defaults';
+export default function useKeyRender<T extends DefaultRow>(table: Table<T>): void;

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

@@ -0,0 +1,18 @@
+import { onMounted as u, onUnmounted as d } from "vue";
+function l(t) {
+  let e;
+  const n = () => {
+    const o = t.vnode.el.querySelector(".hidden-columns"), r = { childList: !0, subtree: !0 }, s = t.store.states.updateOrderFns;
+    e = new MutationObserver(() => {
+      s.forEach((c) => c());
+    }), e.observe(o, r);
+  };
+  u(() => {
+    n();
+  }), d(() => {
+    e == null || e.disconnect();
+  });
+}
+export {
+  l as default
+};

package/dist/components/table/src/table/style-helper.d.ts

@@ -0,0 +1,51 @@
+import type { DefaultRow, RenderExpanded, Table, TableProps } from './defaults';
+import type { Store } from '../store';
+import type TableLayout from '../table-layout';
+declare function useStyle<T extends DefaultRow>(props: TableProps<T>, layout: TableLayout<T>, store: Store<T>, table: Table<T>): {
+    isHidden: import("vue").Ref<boolean, boolean>;
+    renderExpanded: import("vue").Ref<RenderExpanded<T> | null, RenderExpanded<T> | null>;
+    setDragVisible: (visible: boolean) => void;
+    isGroup: import("vue").Ref<boolean, boolean>;
+    handleMouseLeave: () => void;
+    handleHeaderFooterMousewheel: (_event: WheelEvent, data: any) => void;
+    tableSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    emptyBlockStyle: import("vue").ComputedRef<{
+        width: string;
+        height: string;
+    } | undefined>;
+    resizeProxyVisible: import("vue").Ref<boolean, boolean>;
+    bodyWidth: import("vue").ComputedRef<string>;
+    resizeState: import("vue").Ref<{
+        width: null | number;
+        height: null | number;
+        headerHeight: null | number;
+    }, {
+        width: null | number;
+        height: null | number;
+        headerHeight: null | number;
+    } | {
+        width: null | number;
+        height: null | number;
+        headerHeight: null | number;
+    }>;
+    doLayout: () => void;
+    tableBodyStyles: import("vue").ComputedRef<{
+        width: string;
+    }>;
+    tableLayout: import("vue").ComputedRef<"fixed" | "auto">;
+    scrollbarViewStyle: {
+        display: string;
+        verticalAlign: string;
+    };
+    scrollbarStyle: import("vue").ComputedRef<{
+        height: string;
+        maxHeight?: undefined;
+    } | {
+        maxHeight: string;
+        height?: undefined;
+    } | {
+        height?: undefined;
+        maxHeight?: undefined;
+    }>;
+};
+export default useStyle;

package/dist/components/table/src/table/style-helper.js

@@ -0,0 +1,169 @@
+import { ref as n, watch as x, unref as N, watchEffect as J, computed as h, onMounted as Q, nextTick as Z } from "vue";
+import { useEventListener as V, useResizeObserver as A } from "@vueuse/core";
+import "../../../form/index.js";
+import { useFormSize as ee } from "../../../form/src/hooks/use-form-common-props.js";
+function le(r, o, a, i) {
+  const F = n(!1), K = n(null), p = n(!1), X = (e) => {
+    p.value = e;
+  }, c = n({
+    width: null,
+    height: null,
+    headerHeight: null
+  }), k = n(!1), P = {
+    display: "inline-block",
+    verticalAlign: "middle"
+  }, w = n(), L = n(0), y = n(0), d = n(0), g = n(0), R = n(0);
+  x(
+    () => r.height,
+    (e) => {
+      o.setHeight(e ?? null);
+    },
+    { immediate: !0 }
+  ), x(
+    () => r.maxHeight,
+    (e) => {
+      o.setMaxHeight(e ?? null);
+    },
+    { immediate: !0 }
+  ), x(
+    () => [r.currentRowKey, a.states.rowKey],
+    ([e, t]) => {
+      !N(t) || !N(e) || a.setCurrentRowKey(`${e}`);
+    },
+    {
+      immediate: !0
+    }
+  ), x(
+    () => r.data,
+    (e) => {
+      i.store.commit("setData", e);
+    },
+    {
+      immediate: !0,
+      deep: !0
+    }
+  ), J(() => {
+    r.expandRowKeys && a.setExpandRowKeysAdapter(r.expandRowKeys);
+  });
+  const q = () => {
+    i.store.commit("setHoverRow", null), i.hoverState && (i.hoverState = null);
+  }, D = (e, t) => {
+    const { pixelX: s, pixelY: f } = t;
+    Math.abs(s) >= Math.abs(f) && (i.refs.bodyWrapper.scrollLeft += t.pixelX / 5);
+  }, C = h(() => r.height || r.maxHeight || a.states.fixedColumns.value.length > 0 || a.states.rightFixedColumns.value.length > 0), U = h(() => ({
+    width: o.bodyWidth.value ? `${o.bodyWidth.value}px` : ""
+  })), W = () => {
+    C.value && o.updateElsHeight(), o.updateColumnsWidth(), !(typeof window > "u") && requestAnimationFrame($);
+  };
+  Q(async () => {
+    await Z(), a.updateColumns(), b(), requestAnimationFrame(W);
+    const e = i.vnode.el, t = i.refs.headerWrapper;
+    r.flexible && e && e.parentElement && (e.parentElement.style.minWidth = "0"), c.value = {
+      width: w.value = e.offsetWidth,
+      height: e.offsetHeight,
+      headerHeight: r.showHeader && t ? t.offsetHeight : null
+    }, a.states.columns.value.forEach((s) => {
+      s.filteredValue && s.filteredValue.length && i.store.commit("filterChange", {
+        column: s,
+        values: s.filteredValue,
+        silent: !0
+      });
+    }), i.$ready = !0;
+  });
+  const Y = (e, t) => {
+    if (!e) return;
+    const s = Array.from(e.classList).filter(
+      (f) => !f.startsWith("is-scrolling-")
+    );
+    s.push(o.scrollX.value ? t : "is-scrolling-none"), e.className = s.join(" ");
+  }, m = (e) => {
+    const { tableWrapper: t } = i.refs;
+    Y(t, e);
+  }, _ = (e) => {
+    const { tableWrapper: t } = i.refs;
+    return !!(t && t.classList.contains(e));
+  }, $ = function() {
+    if (!i.refs.scrollBarRef) return;
+    if (!o.scrollX.value) {
+      const l = "is-scrolling-none";
+      _(l) || m(l);
+      return;
+    }
+    const e = i.refs.scrollBarRef.wrapRef;
+    if (!e) return;
+    const { scrollLeft: t, offsetWidth: s, scrollWidth: f } = e, { headerWrapper: v, footerWrapper: u } = i.refs;
+    v && (v.scrollLeft = t), u && (u.scrollLeft = t);
+    const H = f - s - 1;
+    t >= H ? m("is-scrolling-right") : m(t === 0 ? "is-scrolling-left" : "is-scrolling-middle");
+  }, b = () => {
+    i.refs.scrollBarRef && (i.refs.scrollBarRef.wrapRef && V(
+      i.refs.scrollBarRef.wrapRef,
+      "scroll",
+      $,
+      {
+        passive: !0
+      }
+    ), r.fit ? A(i.vnode.el, S) : V(window, "resize", S), A(i.refs.tableInnerWrapper, () => {
+      var e, t;
+      S(), (t = (e = i.refs) == null ? void 0 : e.scrollBarRef) == null || t.update();
+    }));
+  }, S = () => {
+    var E, B, z, M;
+    const e = i.vnode.el;
+    if (!i.$ready || !e) return;
+    let t = !1;
+    const {
+      width: s,
+      height: f,
+      headerHeight: v
+    } = c.value, u = w.value = e.offsetWidth;
+    s !== u && (t = !0);
+    const H = e.offsetHeight;
+    (r.height || C.value) && f !== H && (t = !0);
+    const l = r.tableLayout === "fixed" ? i.refs.headerWrapper : (E = i.refs.tableHeaderRef) == null ? void 0 : E.$el;
+    r.showHeader && (l == null ? void 0 : l.offsetHeight) !== v && (t = !0), L.value = ((B = i.refs.tableWrapper) == null ? void 0 : B.scrollHeight) || 0, d.value = (l == null ? void 0 : l.scrollHeight) || 0, g.value = ((z = i.refs.footerWrapper) == null ? void 0 : z.offsetHeight) || 0, R.value = ((M = i.refs.appendWrapper) == null ? void 0 : M.offsetHeight) || 0, y.value = L.value - d.value - g.value - R.value, t && (c.value = {
+      width: u,
+      height: H,
+      headerHeight: r.showHeader && (l == null ? void 0 : l.offsetHeight) || 0
+    }, W());
+  }, j = ee(), G = h(() => {
+    const { bodyWidth: e, scrollY: t, gutterWidth: s } = o;
+    return e.value ? `${e.value - (t.value ? s : 0)}px` : "";
+  }), I = h(() => r.maxHeight ? "fixed" : r.tableLayout), O = h(() => {
+    if (r.data && r.data.length) return;
+    let e = "100%";
+    r.height && y.value && (e = `${y.value}px`);
+    const t = w.value;
+    return {
+      width: t ? `${t}px` : "",
+      height: e
+    };
+  }), T = h(() => r.height ? {
+    height: "100%"
+  } : r.maxHeight ? Number.isNaN(Number(r.maxHeight)) ? {
+    maxHeight: `calc(${r.maxHeight} - ${d.value + g.value}px)`
+  } : {
+    maxHeight: `${+r.maxHeight - d.value - g.value}px`
+  } : {});
+  return {
+    isHidden: F,
+    renderExpanded: K,
+    setDragVisible: X,
+    isGroup: k,
+    handleMouseLeave: q,
+    handleHeaderFooterMousewheel: D,
+    tableSize: j,
+    emptyBlockStyle: O,
+    resizeProxyVisible: p,
+    bodyWidth: G,
+    resizeState: c,
+    doLayout: W,
+    tableBodyStyles: U,
+    tableLayout: I,
+    scrollbarViewStyle: P,
+    scrollbarStyle: T
+  };
+}
+export {
+  le as default
+};

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

@@ -0,0 +1,16 @@
+import type { Store } from '../store';
+import type { DefaultRow } from './defaults';
+declare function useUtils<T extends DefaultRow>(store: Store<T>): {
+    setCurrentRow: (row?: T) => void;
+    getSelectionRows: () => T[];
+    getHalfSelectionRows: () => T[];
+    toggleRowSelection: (row: T, selected?: boolean, ignoreSelectable?: boolean) => void;
+    clearSelection: () => void;
+    clearFilter: (columnKeys?: string[] | string) => void;
+    toggleAllSelection: () => void;
+    toggleRowExpansion: (row: T, expanded?: boolean) => void;
+    clearSort: () => void;
+    sort: (prop: string, order: string) => void;
+    updateKeyChildren: (key: string, data: T[]) => void;
+};
+export default useUtils;

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

@@ -0,0 +1,36 @@
+function d(e) {
+  return {
+    setCurrentRow: (t) => {
+      e.commit("setCurrentRow", t);
+    },
+    getSelectionRows: () => e.getSelectionRows(),
+    getHalfSelectionRows: () => e.getHalfSelectionRows(),
+    toggleRowSelection: (t, l, o = !0) => {
+      e.toggleRowSelection(t, l, !1, o), e.updateAllSelected();
+    },
+    clearSelection: () => {
+      e.clearSelection();
+    },
+    clearFilter: (t) => {
+      e.clearFilter(t);
+    },
+    toggleAllSelection: () => {
+      e.commit("toggleAllSelection");
+    },
+    toggleRowExpansion: (t, l) => {
+      e.toggleRowExpansionAdapter(t, l);
+    },
+    clearSort: () => {
+      e.clearSort();
+    },
+    sort: (t, l) => {
+      e.commit("sort", { prop: t, order: l });
+    },
+    updateKeyChildren: (t, l) => {
+      e.updateKeyChildren(t, l);
+    }
+  };
+}
+export {
+  d as default
+};

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

@@ -0,0 +1,39 @@
+import type { PropType } from 'vue';
+import type { Store } from '../store';
+import type { ColumnCls, ColumnStyle, DefaultRow, Table } from '../table/defaults';
+import type { TableOverflowTooltipOptions } from '../util';
+interface TableBodyProps<T extends DefaultRow> {
+    store: Store<T>;
+    stripe?: boolean;
+    context: Table<T>;
+    rowClassName: ColumnCls<T>;
+    rowStyle: ColumnStyle<T>;
+    fixed: string;
+    highlight: boolean;
+    tooltipEffect?: string;
+    tooltipOptions?: TableOverflowTooltipOptions;
+}
+declare const defaultProps: {
+    store: {
+        required: boolean;
+        type: PropType<TableBodyProps<any>["store"]>;
+    };
+    stripe: BooleanConstructor;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: {
+        type: PropType<TableBodyProps<any>["tooltipOptions"]>;
+    };
+    context: {
+        default: () => {};
+        type: PropType<TableBodyProps<any>["context"]>;
+    };
+    rowClassName: PropType<TableBodyProps<any>["rowClassName"]>;
+    rowStyle: PropType<TableBodyProps<any>["rowStyle"]>;
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    highlight: BooleanConstructor;
+};
+export type { TableBodyProps };
+export default defaultProps;

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

@@ -0,0 +1,25 @@
+const t = {
+  store: {
+    required: !0,
+    type: Object
+  },
+  stripe: Boolean,
+  tooltipEffect: String,
+  tooltipOptions: {
+    type: Object
+  },
+  context: {
+    default: () => ({}),
+    type: Object
+  },
+  rowClassName: [String, Function],
+  rowStyle: [Object, Function],
+  fixed: {
+    type: String,
+    default: ""
+  },
+  highlight: Boolean
+};
+export {
+  t as default
+};

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

@@ -0,0 +1,19 @@
+import type { TableBodyProps } from './defaults';
+import type { TableOverflowTooltipOptions } from '../util';
+import type { DefaultRow } from '../table/defaults';
+declare function useEvents<T extends DefaultRow>(props: Partial<TableBodyProps<T>>): {
+    handleDoubleClick: (event: MouseEvent, row: T) => void;
+    handleClick: (event: PointerEvent, row: T) => void;
+    handleContextMenu: (event: PointerEvent, row: T) => void;
+    handleMouseEnter: import("lodash-unified").DebouncedFunc<(index: number) => void>;
+    handleMouseLeave: import("lodash-unified").DebouncedFunc<() => void>;
+    handleCellMouseEnter: (event: MouseEvent, row: T, tooltipOptions: TableOverflowTooltipOptions) => void;
+    handleCellMouseLeave: (event: MouseEvent) => void;
+    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 useEvents;