ep-craft 0.1.37 → 0.1.39

package/dist/components/table-v2/src/components/header.d.ts

@@ -0,0 +1,105 @@
+import type { CSSProperties, UnwrapRef } from 'vue';
+import type { TableV2HeaderProps } from '../header';
+import type { UseColumnsReturn } from '../composables/use-columns';
+declare const TableV2Header: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedHeaderData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+    readonly rowWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedHeaderData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+    readonly rowWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("../../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {
+    readonly rowHeight: number;
+    readonly headerHeight: import("../../../../utils").EpPropMergeType<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default TableV2Header;
+export type TableV2HeaderInstance = InstanceType<typeof TableV2Header> & {
+    /**
+     * @description scroll to position based on the provided value
+     */
+    scrollToLeft: (left?: number) => void;
+};
+export type TableV2HeaderRendererParams = {
+    class: string;
+    columns: TableV2HeaderProps['columns'];
+    columnsStyles: UnwrapRef<UseColumnsReturn['columnsStyles']>;
+    headerIndex: number;
+    style: CSSProperties;
+};
+export type TableV2HeaderRowRendererParams = {
+    rowData: any;
+    rowIndex: number;
+} & Omit<TableV2HeaderRendererParams, 'headerIndex'>;

package/dist/components/table-v2/src/components/header.js

@@ -0,0 +1,98 @@
+import { defineComponent as C, inject as E, ref as H, computed as l, unref as n, onUpdated as V, createVNode as p, nextTick as _ } from "vue";
+import { useNamespace as b } from "../../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import { castArray as I } from "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 { tableV2HeaderProps as A } from "../header.js";
+import { enforceUnit as m } from "../utils.js";
+import { TABLE_V2_GRID_INJECTION_KEY as O } from "../tokens.js";
+const D = "EpTableV2Header", Q = /* @__PURE__ */ C({
+  name: D,
+  props: A,
+  setup(e, {
+    slots: r,
+    expose: g
+  }) {
+    const d = b("table-v2"), a = E(O), u = H(), y = l(() => m({
+      width: e.width,
+      height: e.height
+    })), N = l(() => m({
+      width: e.rowWidth,
+      height: e.height
+    })), x = l(() => I(n(e.headerHeight))), w = (o) => {
+      const t = n(u);
+      _(() => {
+        t != null && t.scroll && t.scroll({
+          left: o
+        });
+      });
+    }, T = () => {
+      const o = d.e("fixed-header-row"), {
+        columns: t,
+        fixedHeaderData: i,
+        rowHeight: h
+      } = e;
+      return i == null ? void 0 : i.map((s, c) => {
+        var f;
+        const v = m({
+          height: h,
+          width: "100%"
+        });
+        return (f = r.fixed) == null ? void 0 : f.call(r, {
+          class: o,
+          columns: t,
+          rowData: s,
+          rowIndex: -(c + 1),
+          style: v
+        });
+      });
+    }, R = () => {
+      const o = d.e("dynamic-header-row"), {
+        columns: t
+      } = e;
+      return n(x).map((i, h) => {
+        var c;
+        const s = m({
+          width: "100%",
+          height: i
+        });
+        return (c = r.dynamic) == null ? void 0 : c.call(r, {
+          class: o,
+          columns: t,
+          headerIndex: h,
+          style: s
+        });
+      });
+    };
+    return V(() => {
+      a != null && a.value && w(a.value);
+    }), g({
+      /**
+       * @description scroll to position based on the provided value
+       */
+      scrollToLeft: w
+    }), () => {
+      if (!(e.height <= 0))
+        return p("div", {
+          ref: u,
+          class: e.class,
+          style: n(y),
+          role: "rowgroup"
+        }, [p("div", {
+          style: n(N),
+          class: d.e("header")
+        }, [R(), T()])]);
+    };
+  }
+});
+export {
+  Q as default
+};

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

@@ -0,0 +1,11 @@
+import EpTableCell from './cell';
+import EpHeaderCell from './header-cell';
+import EpTableV2HeaderRow from './header-row';
+import EpTableV2Header from './header';
+import EpTableV2Row from './row';
+import EpSortIcon from './sort-icon';
+import EpExpandIcon from './expand-icon';
+export { EpExpandIcon as ExpandIcon, EpTableV2Header as Header, EpHeaderCell as HeaderCell, EpTableV2HeaderRow as HeaderRow, EpTableV2Row as Row, EpSortIcon as SortIcon, EpTableCell as TableCell, };
+export type { TableV2HeaderInstance, TableV2HeaderRendererParams, } from './header';
+export type { TableV2HeaderRowCellRendererParams, TableV2HeaderRowRendererParams, } from './header-row';
+export type { TableV2RowCellRenderParam, TableV2RowSlotProps } from './row';

package/dist/components/table-v2/src/components/row.d.ts

@@ -0,0 +1,166 @@
+import type { CSSProperties, VNode } from 'vue';
+import type { RowEventHandlers, TableV2RowProps } from '../row';
+declare const TableV2Row: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").KeyType, CSSProperties>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly depth: NumberConstructor;
+    readonly expandColumnKey: StringConstructor;
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly isScrolling: BooleanConstructor;
+    readonly onRowExpand: {
+        readonly type: import("vue").PropType<import("../row").RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHover: {
+        readonly type: import("vue").PropType<import("../row").RowHoverHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHeightChange: {
+        readonly type: import("vue").PropType<import("../row").RowHeightChangeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowEventHandlers: {
+        readonly type: import("vue").PropType<RowEventHandlers>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowKey: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType)) | null)[], unknown, unknown, "id", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").KeyType, CSSProperties>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly depth: NumberConstructor;
+    readonly expandColumnKey: StringConstructor;
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly isScrolling: BooleanConstructor;
+    readonly onRowExpand: {
+        readonly type: import("vue").PropType<import("../row").RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHover: {
+        readonly type: import("vue").PropType<import("../row").RowHoverHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHeightChange: {
+        readonly type: import("vue").PropType<import("../row").RowHeightChangeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowEventHandlers: {
+        readonly type: import("vue").PropType<RowEventHandlers>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowKey: import("../../../../utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType)) | null)[], unknown, unknown, "id", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {
+    readonly estimatedRowHeight: number;
+    readonly isScrolling: boolean;
+    readonly rowKey: import("../../../../utils").EpPropMergeType<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType)) | null)[], unknown, unknown>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default TableV2Row;
+export type TableV2RowCellRenderParam = {
+    column: TableV2RowProps['columns'][number];
+    columns: TableV2RowProps['columns'];
+    columnIndex: number;
+    depth: number;
+    style: CSSProperties;
+    rowData: any;
+    rowIndex: number;
+    isScrolling: boolean;
+    expandIconProps?: {
+        rowData: any;
+        rowIndex: number;
+        onExpand: (expand: boolean) => void;
+    };
+};
+export type TableV2RowSlotProps = {
+    cells: VNode[];
+    columns: TableV2RowProps['columns'];
+    depth: number;
+    style: TableV2RowProps['style'];
+    rowData: any;
+    rowIndex: number;
+    isScrolling: boolean;
+};

package/dist/components/table-v2/src/components/row.js

@@ -0,0 +1,176 @@
+import { defineComponent as M, unref as d, createVNode as I, mergeProps as R, inject as N, ref as S, computed as E, onMounted as H, nextTick as K } from "vue";
+import { isNumber as P } from "../../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isArray as T, isFunction as V } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { tableV2RowProps as C } from "../row.js";
+import { TableV2InjectionKey as j } from "../tokens.js";
+import { placeholderSign as k } from "../private.js";
+const D = (n) => {
+  const {
+    isScrolling: g
+  } = N(j), f = S(!1), w = S(), h = E(() => P(n.estimatedRowHeight) && n.rowIndex >= 0), y = (c = !1) => {
+    const r = d(w);
+    if (!r) return;
+    const {
+      columns: s,
+      onRowHeightChange: l,
+      rowKey: m,
+      rowIndex: a,
+      style: o
+    } = n, {
+      height: t
+    } = r.getBoundingClientRect();
+    f.value = !0, K(() => {
+      if (c || t !== Number.parseInt(o.height)) {
+        const e = s[0], i = (e == null ? void 0 : e.placeholderSign) === k;
+        l == null || l({
+          rowKey: m,
+          height: t,
+          rowIndex: a
+        }, e && !i && e.fixed);
+      }
+    });
+  }, p = E(() => {
+    const {
+      rowData: c,
+      rowIndex: r,
+      rowKey: s,
+      onRowHover: l
+    } = n, m = n.rowEventHandlers || {}, a = {};
+    return Object.entries(m).forEach(([o, t]) => {
+      V(t) && (a[o] = (e) => {
+        t({
+          event: e,
+          rowData: c,
+          rowIndex: r,
+          rowKey: s
+        });
+      });
+    }), l && [{
+      name: "onMouseleave",
+      hovered: !1
+    }, {
+      name: "onMouseenter",
+      hovered: !0
+    }].forEach(({
+      name: o,
+      hovered: t
+    }) => {
+      const e = a[o];
+      a[o] = (i) => {
+        l({
+          event: i,
+          hovered: t,
+          rowData: c,
+          rowIndex: r,
+          rowKey: s
+        }), e == null || e(i);
+      };
+    }), a;
+  }), b = (c) => {
+    const {
+      onRowExpand: r,
+      rowData: s,
+      rowIndex: l,
+      rowKey: m
+    } = n;
+    r == null || r({
+      expanded: c,
+      rowData: s,
+      rowIndex: l,
+      rowKey: m
+    });
+  };
+  return H(() => {
+    d(h) && y(!0);
+  }), {
+    isScrolling: g,
+    measurable: h,
+    measured: f,
+    rowRef: w,
+    eventHandlers: p,
+    onExpand: b
+  };
+}, O = "EpTableV2TableRow", L = /* @__PURE__ */ M({
+  name: O,
+  props: C,
+  setup(n, {
+    expose: g,
+    slots: f,
+    attrs: w
+  }) {
+    const {
+      eventHandlers: h,
+      isScrolling: y,
+      measurable: p,
+      measured: b,
+      rowRef: c,
+      onExpand: r
+    } = D(n);
+    return g({
+      /**
+       * @description manually dispatching expand action on row.
+       */
+      onExpand: r
+    }), () => {
+      const {
+        columns: s,
+        columnsStyles: l,
+        expandColumnKey: m,
+        depth: a,
+        rowData: o,
+        rowIndex: t,
+        style: e
+      } = n;
+      let i = s.map((u, x) => {
+        const v = T(o.children) && o.children.length > 0 && u.key === m;
+        return f.cell({
+          column: u,
+          columns: s,
+          columnIndex: x,
+          depth: a,
+          style: l[u.key],
+          rowData: o,
+          rowIndex: t,
+          isScrolling: d(y),
+          expandIconProps: v ? {
+            rowData: o,
+            rowIndex: t,
+            onExpand: r
+          } : void 0
+        });
+      });
+      if (f.row && (i = f.row({
+        cells: i.map((u) => T(u) && u.length === 1 ? u[0] : u),
+        style: e,
+        columns: s,
+        depth: a,
+        rowData: o,
+        rowIndex: t,
+        isScrolling: d(y)
+      })), d(p)) {
+        const {
+          height: u,
+          ...x
+        } = e || {}, v = d(b);
+        return I("div", R({
+          ref: c,
+          class: n.class,
+          style: v ? e : x,
+          role: "row"
+        }, w, d(h)), [i]);
+      }
+      return I("div", R(w, {
+        ref: c,
+        class: n.class,
+        style: e,
+        role: "row"
+      }, d(h)), [i]);
+    };
+  }
+});
+export {
+  L as default
+};

package/dist/components/table-v2/src/components/sort-icon.d.ts

@@ -0,0 +1,9 @@
+import { SortOrder } from '../constants';
+import type { FunctionalComponent, HTMLAttributes } from 'vue';
+export type SortIconProps = {
+    sortOrder: SortOrder;
+    ariaLabel?: string;
+    class?: HTMLAttributes['class'];
+};
+declare const SortIcon: FunctionalComponent<SortIconProps>;
+export default SortIcon;

package/dist/components/table-v2/src/components/sort-icon.js

@@ -0,0 +1,21 @@
+import { createVNode as r } from "vue";
+import { EpIcon as l } from "../../../icon/index.js";
+import { SortUp as e, SortDown as a } from "@element-plus/icons-vue";
+import { SortOrder as n } from "../constants.js";
+const s = (t) => {
+  const {
+    sortOrder: o
+  } = t;
+  return r("button", {
+    type: "button",
+    "aria-label": t.ariaLabel,
+    class: t.class
+  }, [r(l, {
+    size: 14
+  }, {
+    default: () => [o === n.ASC ? r(e, null, null) : r(a, null, null)]
+  })]);
+};
+export {
+  s as default
+};

package/dist/components/table-v2/src/composables/index.d.ts

@@ -0,0 +1,11 @@
+export { useScrollbar } from './use-scrollbar';
+export type { ScrollPos } from './use-scrollbar';
+export { useColumns } from './use-columns';
+export type { UseColumnsReturn } from './use-columns';
+export { useData } from './use-data';
+export type { UseDataReturn } from './use-data';
+export { useRow } from './use-row';
+export type { UseRowReturn } from './use-row';
+export { useStyles } from './use-styles';
+export type { UseStyleReturn } from './use-styles';
+export type { Alignment as ScrollStrategy } from '../../../virtual-list';