ep-craft 0.1.36 → 0.1.38

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

@@ -0,0 +1,77 @@
+import { createVNode as i, renderSlot as H, mergeProps as T } from "vue";
+import "../components/cell.js";
+import v from "../components/header-cell.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "../header-row.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 "../header.js";
+import { enforceUnit as x, componentToSlot as B, tryCall as C } from "../utils.js";
+import "../row.js";
+import { placeholderSign as I } from "../private.js";
+import L from "../components/sort-icon.js";
+import "../components/expand-icon.js";
+import { SortOrder as s, Alignment as S, oppositeOrderMap as N } from "../constants.js";
+const le = (o, {
+  slots: g
+}) => {
+  const {
+    column: e,
+    ns: r,
+    t: h,
+    style: y,
+    onColumnSorted: b
+  } = o, d = x(y);
+  if (e.placeholderSign === I)
+    return i("div", {
+      class: r.em("header-row-cell", "placeholder"),
+      style: d
+    }, null);
+  const {
+    headerCellRenderer: k,
+    headerClass: R,
+    sortable: a
+  } = e, c = {
+    ...o,
+    class: r.e("header-cell-text")
+  }, m = B(k), A = m ? m(c) : H(g, "default", c, () => [i(v, c, null)]), {
+    sortBy: p,
+    sortState: f,
+    headerCellProps: O
+  } = o;
+  let l, t, n;
+  if (f) {
+    const u = f[e.key];
+    l = !!N[u], t = l ? u : s.ASC;
+  } else
+    l = e.key === p.key, t = l ? p.order : s.ASC;
+  t === s.ASC ? n = "ascending" : t === s.DESC ? n = "descending" : n = void 0;
+  const P = [r.e("header-cell"), C(R, o, ""), e.align === S.CENTER && r.is("align-center"), e.align === S.RIGHT && r.is("align-right"), a && r.is("sortable")], E = {
+    ...C(O, o),
+    onClick: e.sortable ? b : void 0,
+    ariaSort: a ? n : void 0,
+    class: P,
+    style: d,
+    "data-key": e.key
+  };
+  return i("div", T(E, {
+    role: "columnheader"
+  }), [A, a && i(L, {
+    class: [r.e("sort-icon"), l && r.is("sorting")],
+    sortOrder: t,
+    ariaLabel: h("el.table.sortLabel", {
+      column: e.title || ""
+    })
+  }, null)]);
+};
+export {
+  le as default
+};

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

@@ -0,0 +1,9 @@
+import type { FunctionalComponent } from 'vue';
+import type { UseNamespaceReturn } from '../../../../hooks';
+import type { TableV2HeaderRendererParams } from '../components';
+import type { TableV2Props } from '../table';
+type HeaderRendererProps = TableV2HeaderRendererParams & Pick<TableV2Props, 'headerClass' | 'headerProps'> & {
+    ns: UseNamespaceReturn;
+};
+declare const HeaderRenderer: FunctionalComponent<HeaderRendererProps>;
+export default HeaderRenderer;

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

@@ -0,0 +1,53 @@
+import { createVNode as l, isVNode as u } from "vue";
+import "../components/cell.js";
+import "../components/header-cell.js";
+import b from "../components/header-row.js";
+import "@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 "../header.js";
+import { tryCall as p } from "../utils.js";
+import "../row.js";
+import "../../../icon/index.js";
+import "../components/expand-icon.js";
+function j(r) {
+  return typeof r == "function" || Object.prototype.toString.call(r) === "[object Object]" && !u(r);
+}
+const v = ({
+  columns: r,
+  columnsStyles: m,
+  headerIndex: o,
+  style: a,
+  // derived from root
+  headerClass: c,
+  headerProps: n,
+  ns: e
+}, {
+  slots: t
+}) => {
+  const i = {
+    columns: r,
+    headerIndex: o
+  }, d = [e.e("header-row"), p(c, i, ""), e.is("customized", !!t.header)], f = {
+    ...p(n, i),
+    columnsStyles: m,
+    class: d,
+    columns: r,
+    headerIndex: o,
+    style: a
+  };
+  return l(b, f, j(t) ? t : {
+    default: () => [t]
+  });
+};
+export {
+  v as default
+};

package/dist/components/table-v2/src/renderers/left-table.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionalComponent, Ref } from 'vue';
+import type { TableV2GridProps } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+type LeftTableProps = TableV2GridProps & {
+    leftTableRef: Ref<TableGridInstance | undefined>;
+};
+declare const LeftTable: FunctionalComponent<LeftTableProps>;
+export default LeftTable;

package/dist/components/table-v2/src/renderers/left-table.js

@@ -0,0 +1,22 @@
+import { createVNode as f, mergeProps as n, isVNode as c } from "vue";
+import i from "../table-grid.js";
+function l(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !c(e);
+}
+const b = (e, {
+  slots: t
+}) => {
+  if (!e.columns.length) return;
+  const {
+    leftTableRef: r,
+    ...o
+  } = e;
+  return f(i, n({
+    ref: r
+  }, o), l(t) ? t : {
+    default: () => [t]
+  });
+};
+export {
+  b as default
+};

package/dist/components/table-v2/src/renderers/main-table.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionalComponent, Ref } from 'vue';
+import type { TableV2GridProps } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+export type MainTableRendererProps = TableV2GridProps & {
+    mainTableRef: Ref<TableGridInstance | undefined>;
+};
+declare const MainTable: FunctionalComponent<MainTableRendererProps>;
+export default MainTable;

package/dist/components/table-v2/src/renderers/main-table.js

@@ -0,0 +1,21 @@
+import { createVNode as n, mergeProps as a, isVNode as i } from "vue";
+import c from "../table-grid.js";
+function f(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !i(e);
+}
+const l = (e, {
+  slots: t
+}) => {
+  const {
+    mainTableRef: r,
+    ...o
+  } = e;
+  return n(c, a({
+    ref: r
+  }, o), f(t) ? t : {
+    default: () => [t]
+  });
+};
+export {
+  l as default
+};

package/dist/components/table-v2/src/renderers/overlay.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleFunctionalComponent } from '../types';
+declare const Overlay: SimpleFunctionalComponent;
+export default Overlay;

package/dist/components/table-v2/src/renderers/overlay.js

@@ -0,0 +1,14 @@
+import { createVNode as l } from "vue";
+const d = (a, {
+  slots: e
+}) => {
+  var r;
+  return l("div", {
+    class: a.class,
+    style: a.style
+  }, [(r = e.default) == null ? void 0 : r.call(e)]);
+};
+d.displayName = "EpTableV2Overlay";
+export {
+  d as default
+};

package/dist/components/table-v2/src/renderers/right-table.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionalComponent, Ref } from 'vue';
+import type { TableV2GridProps } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+type RightTableProps = TableV2GridProps & {
+    rightTableRef: Ref<TableGridInstance | undefined>;
+};
+declare const RightTable: FunctionalComponent<RightTableProps>;
+export default RightTable;

package/dist/components/table-v2/src/renderers/right-table.js

@@ -0,0 +1,22 @@
+import { createVNode as n, mergeProps as i, isVNode as c } from "vue";
+import f from "../table-grid.js";
+function a(e) {
+  return typeof e == "function" || Object.prototype.toString.call(e) === "[object Object]" && !c(e);
+}
+const b = (e, {
+  slots: t
+}) => {
+  if (!e.columns.length) return;
+  const {
+    rightTableRef: r,
+    ...o
+  } = e;
+  return n(f, i({
+    ref: r
+  }, o), a(t) ? t : {
+    default: () => [t]
+  });
+};
+export {
+  b as default
+};

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

@@ -0,0 +1,11 @@
+import type { ComponentInternalInstance, FunctionalComponent, UnwrapNestedRefs } from 'vue';
+import type { UseNamespaceReturn } from '../../../../hooks';
+import type { UseTableReturn } from '../use-table';
+import type { TableV2Props } from '../table';
+import type { TableGridRowSlotParams } from '../table-grid';
+type RowRendererProps = TableGridRowSlotParams & Pick<TableV2Props, 'expandColumnKey' | 'estimatedRowHeight' | 'rowProps' | 'rowClass' | 'rowKey' | 'rowEventHandlers'> & UnwrapNestedRefs<Pick<UseTableReturn, 'depthMap' | 'expandedRowKeys' | 'hasFixedColumns' | 'onRowHovered' | 'onRowExpanded' | 'columnsStyles'>> & {
+    ns: UseNamespaceReturn;
+    tableInstance?: ComponentInternalInstance;
+};
+declare const RowRenderer: FunctionalComponent<RowRendererProps>;
+export default RowRenderer;

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

@@ -0,0 +1,98 @@
+import { createVNode as _, mergeProps as k, isVNode as B } from "vue";
+import "../components/cell.js";
+import "../components/header-cell.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "../header-row.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 "../header.js";
+import { tryCall as w } from "../utils.js";
+import F from "../components/row.js";
+import "../../../icon/index.js";
+import "../components/expand-icon.js";
+function L(n) {
+  return typeof n == "function" || Object.prototype.toString.call(n) === "[object Object]" && !B(n);
+}
+const ne = (n, {
+  slots: s
+}) => {
+  const {
+    columns: d,
+    columnsStyles: u,
+    depthMap: y,
+    expandColumnKey: m,
+    expandedRowKeys: f,
+    estimatedRowHeight: h,
+    hasFixedColumns: x,
+    rowData: o,
+    rowIndex: e,
+    style: K,
+    isScrolling: M,
+    rowProps: R,
+    rowClass: v,
+    rowKey: E,
+    rowEventHandlers: g,
+    ns: i,
+    onRowHovered: b,
+    onRowExpanded: C
+  } = n, P = w(v, {
+    columns: d,
+    rowData: o,
+    rowIndex: e
+  }, ""), S = w(R, {
+    columns: d,
+    rowData: o,
+    rowIndex: e
+  }), t = o[E], p = y[t] || 0, l = !!m, c = e < 0, j = [i.e("row"), P, i.is("expanded", l && f.includes(t)), i.is("fixed", !p && c), i.is("customized", !!s.row), {
+    [i.e(`row-depth-${p}`)]: l && e >= 0
+  }], r = x ? b : void 0, V = {
+    ...S,
+    columns: d,
+    columnsStyles: u,
+    class: j,
+    depth: p,
+    expandColumnKey: m,
+    estimatedRowHeight: c ? void 0 : h,
+    isScrolling: M,
+    rowIndex: e,
+    rowData: o,
+    rowKey: t,
+    rowEventHandlers: g,
+    style: K
+  };
+  return _(F, k(V, {
+    onRowExpand: C,
+    onMouseenter: (a) => {
+      r == null || r({
+        hovered: !0,
+        rowKey: t,
+        event: a,
+        rowData: o,
+        rowIndex: e
+      });
+    },
+    onMouseleave: (a) => {
+      r == null || r({
+        hovered: !1,
+        rowKey: t,
+        event: a,
+        rowData: o,
+        rowIndex: e
+      });
+    },
+    rowkey: t
+  }), L(s) ? s : {
+    default: () => [s]
+  });
+};
+export {
+  ne as default
+};

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

@@ -0,0 +1,101 @@
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { FixedDirection, KeyType, RowCommonParams } from './types';
+export type RowExpandParams = {
+    expanded: boolean;
+    rowKey: KeyType;
+} & RowCommonParams;
+export type RowHoverParams = {
+    event?: MouseEvent;
+    hovered: boolean;
+    rowKey: KeyType;
+} & Partial<RowCommonParams>;
+export type RowEventHandlerParams = {
+    rowKey: KeyType;
+    event: Event;
+} & RowCommonParams;
+export type RowHeightChangedParams = {
+    rowKey: KeyType;
+    height: number;
+    rowIndex: number;
+};
+export type RowExpandHandler = (params: RowExpandParams) => void;
+export type RowHoverHandler = (params: RowHoverParams) => void;
+export type RowEventHandler = (params: RowEventHandlerParams) => void;
+export type RowHeightChangeHandler = (row: RowHeightChangedParams, fixedDirection: boolean | FixedDirection | undefined) => void;
+export type RowEventHandlers = {
+    onClick?: RowEventHandler;
+    onContextmenu?: RowEventHandler;
+    onDblclick?: RowEventHandler;
+    onMouseenter?: RowEventHandler;
+    onMouseleave?: RowEventHandler;
+};
+export declare const tableV2RowProps: {
+    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<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<RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHover: {
+        readonly type: import("vue").PropType<RowHoverHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHeightChange: {
+        readonly type: import("vue").PropType<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) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => 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;
+    };
+};
+export type TableV2RowProps = ExtractPropTypes<typeof tableV2RowProps>;
+export type TableV2RowPropsPublic = ExtractPublicPropTypes<typeof tableV2RowProps>;

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

@@ -0,0 +1,53 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { virtualizedGridProps as o } from "../../virtual-list/src/props.js";
+import { rowKey as r, expandColumnKey as i, columns as p } from "./common.js";
+const c = t({
+  class: String,
+  columns: p,
+  columnsStyles: {
+    type: e(Object),
+    required: !0
+  },
+  depth: Number,
+  expandColumnKey: i,
+  estimatedRowHeight: {
+    ...o.estimatedRowHeight,
+    default: void 0
+  },
+  isScrolling: Boolean,
+  onRowExpand: {
+    type: e(Function)
+  },
+  onRowHover: {
+    type: e(Function)
+  },
+  onRowHeightChange: {
+    type: e(Function)
+  },
+  rowData: {
+    type: e(Object),
+    required: !0
+  },
+  rowEventHandlers: {
+    type: e(Object)
+  },
+  rowIndex: {
+    type: Number,
+    required: !0
+  },
+  /**
+   * Unique item key
+   */
+  rowKey: r,
+  style: {
+    type: e(Object)
+  }
+});
+export {
+  c as tableV2RowProps
+};