ep-craft 0.1.37 → 0.1.39

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

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

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

@@ -0,0 +1,27 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes, StyleValue } from 'vue';
+export declare const tableV2CellProps: {
+    readonly class: StringConstructor;
+    readonly cellData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly column: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnIndex: NumberConstructor;
+    readonly style: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: NumberConstructor;
+};
+export type TableV2CellProps = ExtractPropTypes<typeof tableV2CellProps>;
+export type TableV2CellPropsPublic = ExtractPublicPropTypes<typeof tableV2CellProps>;

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

@@ -0,0 +1,42 @@
+import type { CSSProperties } from 'vue';
+import type { Column, KeyType } from './types';
+export type AnyColumn = Column<any>;
+/**
+ * @Note even though we can use `string[] | string` as the type but for
+ * convenience here we only use `string` as the acceptable value here.
+ */
+export declare const classType: StringConstructor;
+export declare const columns: {
+    readonly type: import("vue").PropType<AnyColumn[]>;
+    readonly required: true;
+};
+export declare const column: {
+    readonly type: import("vue").PropType<AnyColumn>;
+};
+export declare const fixedDataType: {
+    readonly type: import("vue").PropType<any[]>;
+};
+export declare const dataType: {
+    readonly required: true;
+    readonly type: import("vue").PropType<any[]>;
+};
+export declare const expandColumnKey: StringConstructor;
+export declare const expandKeys: {
+    readonly type: import("vue").PropType<KeyType[]>;
+    readonly default: () => never[];
+};
+export declare const requiredNumber: {
+    readonly type: NumberConstructor;
+    readonly required: true;
+};
+export declare const rowKey: {
+    readonly type: import("vue").PropType<KeyType>;
+    readonly default: "id";
+};
+/**
+ * @note even though we can use `StyleValue` but that would be difficult for us to mapping them,
+ * so we only use `CSSProperties` as the acceptable value here.
+ */
+export declare const styleType: {
+    type: import("vue").PropType<CSSProperties>;
+};

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

@@ -0,0 +1,38 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { mutable as t } from "../../../utils/typescript.js";
+import "@element-plus/icons-vue";
+import { definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+const s = String, a = {
+  type: e(Array),
+  required: !0
+}, r = {
+  type: e(Array)
+}, c = {
+  ...r,
+  required: !0
+}, d = String, l = {
+  type: e(Array),
+  default: () => t([])
+}, b = {
+  type: Number,
+  required: !0
+}, f = {
+  type: e([String, Number, Symbol]),
+  default: "id"
+}, T = {
+  type: e(Object)
+};
+export {
+  s as classType,
+  a as columns,
+  c as dataType,
+  d as expandColumnKey,
+  l as expandKeys,
+  r as fixedDataType,
+  b as requiredNumber,
+  f as rowKey,
+  T as styleType
+};

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

@@ -0,0 +1,4 @@
+import type { FunctionalComponent } from 'vue';
+import type { TableV2CellProps } from '../cell';
+declare const TableV2Cell: FunctionalComponent<TableV2CellProps>;
+export default TableV2Cell;

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

@@ -0,0 +1,20 @@
+import { renderSlot as n, createVNode as a } from "vue";
+const o = (e, {
+  slots: r
+}) => {
+  var s;
+  const {
+    cellData: t,
+    style: d
+  } = e, l = ((s = t == null ? void 0 : t.toString) == null ? void 0 : s.call(t)) || "", i = n(r, "default", e, () => [l]);
+  return a("div", {
+    class: e.class,
+    title: l,
+    style: d
+  }, [i]);
+};
+o.displayName = "EpTableV2Cell";
+o.inheritAttrs = !1;
+export {
+  o as default
+};

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

@@ -0,0 +1,15 @@
+import type { StyleValue } from 'vue';
+import type { TableV2RowCellRenderParam } from './row';
+declare const ExpandIcon: {
+    (props: TableV2RowCellRenderParam["expandIconProps"] & {
+        class?: string | string[];
+        style: StyleValue;
+        ariaLabel?: string;
+        size: number;
+        expanded: boolean;
+        expandable: boolean;
+    }): import("vue/jsx-runtime").JSX.Element;
+    inheritAttrs: boolean;
+};
+export default ExpandIcon;
+export type ExpandIconInstance = ReturnType<typeof ExpandIcon>;

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

@@ -0,0 +1,30 @@
+import { createVNode as e, mergeProps as i } from "vue";
+import { EpIcon as p } from "../../../icon/index.js";
+import { ArrowRight as c } from "@element-plus/icons-vue";
+const u = (n) => {
+  const {
+    expanded: t,
+    expandable: o,
+    onExpand: a,
+    style: r,
+    size: s,
+    ariaLabel: l
+  } = n, d = {
+    onClick: o ? () => a(!t) : void 0,
+    ariaLabel: l,
+    ariaExpanded: t,
+    class: n.class
+  };
+  return e("button", i(d, {
+    type: "button"
+  }), [e(p, {
+    size: s,
+    style: r
+  }, {
+    default: () => [e(c, null, null)]
+  })]);
+};
+u.inheritAttrs = !1;
+export {
+  u as default
+};

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

@@ -0,0 +1,4 @@
+import type { FunctionalComponent } from 'vue';
+import type { TableV2HeaderCell } from '../header-cell';
+declare const HeaderCell: FunctionalComponent<TableV2HeaderCell>;
+export default HeaderCell;

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

@@ -0,0 +1,15 @@
+import { renderSlot as i, createVNode as r } from "vue";
+const a = (e, {
+  slots: d
+}) => i(d, "default", e, () => {
+  var l, t;
+  return [r("div", {
+    class: e.class,
+    title: (l = e.column) == null ? void 0 : l.title
+  }, [(t = e.column) == null ? void 0 : t.title])];
+});
+a.displayName = "EpTableV2HeaderCell";
+a.inheritAttrs = !1;
+export {
+  a as default
+};

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

@@ -0,0 +1,59 @@
+import type { CSSProperties } from 'vue';
+import type { ColumnCellsType } from '../types';
+import type { TableV2HeaderRowProps } from '../header-row';
+declare const TableV2HeaderRow: 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 headerIndex: NumberConstructor;
+    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 headerIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default TableV2HeaderRow;
+export type TableV2HeaderRowCellRendererParams = {
+    columns: TableV2HeaderRowProps['columns'];
+    column: TableV2HeaderRowProps['columns'][number];
+    columnIndex: number;
+    headerIndex: number;
+    style: CSSProperties;
+};
+export type TableV2HeaderRowRendererParams = {
+    cells: ColumnCellsType;
+    columns: TableV2HeaderRowProps['columns'];
+    headerIndex: number;
+};

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

@@ -0,0 +1,41 @@
+import { defineComponent as i, createVNode as n } from "vue";
+import { isArray as c } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { tableV2HeaderRowProps as d } from "../header-row.js";
+const b = /* @__PURE__ */ i({
+  name: "EpTableV2HeaderRow",
+  props: d,
+  setup(l, {
+    slots: r
+  }) {
+    return () => {
+      const {
+        columns: t,
+        columnsStyles: m,
+        headerIndex: o,
+        style: s
+      } = l;
+      let a = t.map((e, p) => r.cell({
+        columns: t,
+        column: e,
+        columnIndex: p,
+        headerIndex: o,
+        style: m[e.key]
+      }));
+      return r.header && (a = r.header({
+        cells: a.map((e) => c(e) && e.length === 1 ? e[0] : e),
+        columns: t,
+        headerIndex: o
+      })), n("div", {
+        class: l.class,
+        style: s,
+        role: "row"
+      }, [a]);
+    };
+  }
+});
+export {
+  b as default
+};