ep-craft 0.1.37 → 0.1.39

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
+};

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

@@ -0,0 +1,236 @@
+import type { UnwrapRef } from 'vue';
+import type { ResetAfterIndex } from '../../virtual-list/src/components/dynamic-size-grid';
+import type { GridDefaultSlotParams, GridScrollOptions, Alignment as ScrollStrategy } from '../../virtual-list';
+import type { TableV2GridProps } from './grid';
+declare const TableGrid: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerWidth: {
+        readonly type: import("vue").PropType<number>;
+        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 bodyWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly scrollbarStartGap: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly class: StringConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly containerStyle: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly getRowHeight: {
+        readonly type: import("vue").PropType<import("../../virtual-list").ItemSize>;
+        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 onRowsRendered: {
+        readonly type: import("vue").PropType<(params: import("./grid").onRowRenderedParams) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(...args: any[]) => void>;
+        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 columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerWidth: {
+        readonly type: import("vue").PropType<number>;
+        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 bodyWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly scrollbarStartGap: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("../../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly class: StringConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly containerStyle: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly getRowHeight: {
+        readonly type: import("vue").PropType<import("../../virtual-list").ItemSize>;
+        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 onRowsRendered: {
+        readonly type: import("vue").PropType<(params: import("./grid").onRowRenderedParams) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(...args: any[]) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {
+    readonly useIsScrolling: boolean;
+    readonly scrollbarAlwaysOn: boolean;
+    readonly cache: number;
+    readonly estimatedRowHeight: number;
+    readonly scrollbarStartGap: number;
+    readonly scrollbarEndGap: number;
+    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>;
+    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 TableGrid;
+export type TableGridRowSlotParams = {
+    columns: TableV2GridProps['columns'];
+    rowData: any;
+} & GridDefaultSlotParams;
+export type TableGridInstance = InstanceType<typeof TableGrid> & UnwrapRef<{
+    forceUpdate: () => void;
+    /**
+     * @description fetch total height
+     */
+    totalHeight: number;
+    /**
+     * @description scrollTo a position
+     * @param { number | ScrollToOptions } arg1
+     * @param { number } arg2
+     */
+    scrollTo(leftOrOptions: number | GridScrollOptions, top?: number): void;
+    /**
+     * @description scroll vertically to position y
+     */
+    scrollToTop(scrollTop: number): void;
+    /**
+     * @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(row: number, strategy: ScrollStrategy): void;
+    /**
+     * @description reset rendered state after row index
+     * @param { number } rowIndex
+     * @param { boolean } forceUpdate
+     */
+    resetAfterRowIndex: ResetAfterIndex;
+}>;