ep-craft 0.1.37 → 0.1.39

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

@@ -0,0 +1,105 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { ItemSize } from '../../virtual-list';
+export type onRowRenderedParams = {
+    rowCacheStart: number;
+    rowCacheEnd: number;
+    rowVisibleStart: number;
+    rowVisibleEnd: number;
+};
+export declare const tableV2GridProps: {
+    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<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: 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;
+    };
+};
+export type TableV2GridProps = ExtractPropTypes<typeof tableV2GridProps>;
+export type TableV2GridPropsPublic = ExtractPublicPropTypes<typeof tableV2GridProps>;

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

@@ -0,0 +1,56 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as a, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { virtualizedGridProps as t, virtualizedListProps as l } from "../../virtual-list/src/props.js";
+import { styleType as o, classType as p, requiredNumber as r, fixedDataType as s, dataType as d, columns as c } from "./common.js";
+import { tableV2HeaderProps as n } from "./header.js";
+import { tableV2RowProps as i } from "./row.js";
+const G = a({
+  columns: c,
+  data: d,
+  fixedData: s,
+  estimatedRowHeight: i.estimatedRowHeight,
+  /**
+   * Size related attributes
+   */
+  width: r,
+  height: r,
+  headerWidth: r,
+  headerHeight: n.headerHeight,
+  bodyWidth: r,
+  rowHeight: r,
+  /**
+   * Special attributes
+   */
+  cache: l.cache,
+  useIsScrolling: Boolean,
+  scrollbarAlwaysOn: t.scrollbarAlwaysOn,
+  scrollbarStartGap: t.scrollbarStartGap,
+  scrollbarEndGap: t.scrollbarEndGap,
+  /**
+   * CSS attributes
+   */
+  class: p,
+  style: o,
+  containerStyle: o,
+  getRowHeight: {
+    type: e(Function),
+    required: !0
+  },
+  rowKey: i.rowKey,
+  /**
+   * Event handlers
+   */
+  onRowsRendered: {
+    type: e(Function)
+  },
+  onScroll: {
+    type: e(Function)
+  }
+});
+export {
+  G as tableV2GridProps
+};

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

@@ -0,0 +1,13 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+export declare const tableV2HeaderCell: {
+    class: StringConstructor;
+    columnIndex: NumberConstructor;
+    column: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2HeaderCell = ExtractPropTypes<typeof tableV2HeaderCell>;
+export type TableV2HeaderCellPublic = ExtractPublicPropTypes<typeof tableV2HeaderCell>;

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

@@ -0,0 +1,26 @@
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { KeyType } from './types';
+export declare const tableV2HeaderRowProps: {
+    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 headerIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2HeaderRowProps = ExtractPropTypes<typeof tableV2HeaderRowProps>;
+export type TableV2HeaderRowPropsPublic = ExtractPublicPropTypes<typeof tableV2HeaderRowProps>;

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

@@ -0,0 +1,20 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as r, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { columns as t } from "./common.js";
+const d = r({
+  class: String,
+  columns: t,
+  columnsStyles: {
+    type: e(Object),
+    required: !0
+  },
+  headerIndex: Number,
+  style: { type: e(Object) }
+});
+export {
+  d as tableV2HeaderRowProps
+};

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

@@ -0,0 +1,44 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+export declare const tableV2HeaderProps: {
+    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;
+    };
+};
+export type TableV2HeaderProps = ExtractPropTypes<typeof tableV2HeaderProps>;
+export type TableV2HeaderPropsPublic = ExtractPublicPropTypes<typeof tableV2HeaderProps>;

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

@@ -0,0 +1,35 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t, definePropType as r } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import { columns as i } from "./common.js";
+const e = {
+  type: Number,
+  required: !0
+}, h = t({
+  class: String,
+  columns: i,
+  fixedHeaderData: {
+    type: r(Array)
+  },
+  headerData: {
+    type: r(Array),
+    required: !0
+  },
+  headerHeight: {
+    type: r([Number, Array]),
+    default: 50
+  },
+  rowWidth: e,
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  height: e,
+  width: e
+});
+export {
+  h as tableV2HeaderProps
+};

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

@@ -0,0 +1 @@
+export declare const placeholderSign: unique symbol;

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

@@ -0,0 +1,4 @@
+const e = Symbol("placeholder");
+export {
+  e as placeholderSign
+};

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

@@ -0,0 +1,11 @@
+import type { FunctionalComponent, UnwrapNestedRefs } from 'vue';
+import type { TableV2RowCellRenderParam } from '../components';
+import type { Translator, UseNamespaceReturn } from '../../../../hooks';
+import type { UseTableReturn } from '../use-table';
+import type { TableV2Props } from '../table';
+type CellRendererProps = TableV2RowCellRenderParam & Pick<TableV2Props, 'cellProps' | 'expandColumnKey' | 'indentSize' | 'iconSize' | 'rowKey'> & UnwrapNestedRefs<Pick<UseTableReturn, 'expandedRowKeys'>> & {
+    ns: UseNamespaceReturn;
+    t: Translator;
+};
+declare const CellRenderer: FunctionalComponent<CellRendererProps>;
+export default CellRenderer;

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

@@ -0,0 +1,101 @@
+import { createVNode as i, renderSlot as F, mergeProps as R } from "vue";
+import { get as H } from "lodash-unified";
+import { isFunction as U, isObject as q } from "@vue/shared";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import B from "../components/cell.js";
+import "../components/header-cell.js";
+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 J, tryCall as K, componentToSlot as M } from "../utils.js";
+import "../row.js";
+import { placeholderSign as Q } from "../private.js";
+import "../../../icon/index.js";
+import { Alignment as x } from "../constants.js";
+import W from "../components/expand-icon.js";
+const X = ({
+  // renderer props
+  columns: o,
+  column: e,
+  columnIndex: p,
+  depth: C,
+  expandIconProps: m,
+  isScrolling: P,
+  rowData: t,
+  rowIndex: r,
+  // from use-table
+  style: S,
+  expandedRowKeys: T,
+  ns: l,
+  t: v,
+  // derived props
+  cellProps: E,
+  expandColumnKey: d,
+  indentSize: L,
+  iconSize: a,
+  rowKey: $
+}, {
+  slots: j
+}) => {
+  const f = J(S);
+  if (e.placeholderSign === Q)
+    return i("div", {
+      class: l.em("row-cell", "placeholder"),
+      style: f
+    }, null);
+  const {
+    cellRenderer: k,
+    dataKey: A,
+    dataGetter: g
+  } = e, b = U(g) ? g({
+    columns: o,
+    column: e,
+    columnIndex: p,
+    rowData: t,
+    rowIndex: r
+  }) : H(t, A ?? ""), G = K(E, {
+    cellData: b,
+    columns: o,
+    column: e,
+    columnIndex: p,
+    rowIndex: r,
+    rowData: t
+  }), s = {
+    class: l.e("cell-text"),
+    columns: o,
+    column: e,
+    columnIndex: p,
+    cellData: b,
+    isScrolling: P,
+    rowData: t,
+    rowIndex: r
+  }, h = M(k), N = h ? h(s) : F(j, "default", s, () => [i(B, s, null)]), O = [l.e("row-cell"), e.class, e.align === x.CENTER && l.is("align-center"), e.align === x.RIGHT && l.is("align-right")], V = r >= 0 && d && e.key === d, c = r >= 0 && T.includes(t[$]);
+  let n;
+  const y = `margin-inline-start: ${C * L}px;`;
+  return V && (q(m) ? n = i(W, R(m, {
+    class: [l.e("expand-icon"), l.is("expanded", c)],
+    size: a,
+    expanded: c,
+    ariaLabel: v(c ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
+    style: y,
+    expandable: !0
+  }), null) : n = i("div", {
+    style: [y, `width: ${a}px; height: ${a}px;`].join(" ")
+  }, null)), i("div", R({
+    class: O,
+    style: f
+  }, G, {
+    role: "cell"
+  }), [n, N]);
+};
+X.inheritAttrs = !1;
+export {
+  X as default
+};

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

@@ -0,0 +1,7 @@
+import type { CSSProperties, FunctionalComponent, HTMLAttributes } from 'vue';
+type EmptyRendererProps = {
+    class?: HTMLAttributes['class'];
+    style?: CSSProperties;
+};
+declare const Footer: FunctionalComponent<EmptyRendererProps>;
+export default Footer;

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

@@ -0,0 +1,15 @@
+import { renderSlot as a, createVNode as e } from "vue";
+import { EpEmpty as r } from "../../../empty/index.js";
+const s = (t, {
+  slots: l
+}) => {
+  const o = a(l, "default", {}, () => [e(r, null, null)]);
+  return e("div", {
+    class: t.class,
+    style: t.style
+  }, [o]);
+};
+s.displayName = "EpTableV2Empty";
+export {
+  s as default
+};

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

@@ -0,0 +1,7 @@
+import type { CSSProperties, FunctionalComponent, HTMLAttributes } from 'vue';
+type FooterRendererProps = {
+    class?: HTMLAttributes['class'];
+    style: CSSProperties;
+};
+declare const Footer: FunctionalComponent<FooterRendererProps>;
+export default Footer;

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

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

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

@@ -0,0 +1,14 @@
+import type { FunctionalComponent, UnwrapNestedRefs } from 'vue';
+import type { Translator, UseNamespaceReturn } from '../../../../hooks';
+import type { TableV2HeaderRowCellRendererParams } from '../components';
+import type { UseTableReturn } from '../use-table';
+import type { TableV2Props } from '../table';
+export type HeaderCellRendererProps = TableV2HeaderRowCellRendererParams & UnwrapNestedRefs<Pick<UseTableReturn, 'onColumnSorted'>> & Pick<TableV2Props, 'sortBy' | 'sortState' | 'headerCellProps'> & {
+    ns: UseNamespaceReturn;
+    t: Translator;
+};
+declare const HeaderCellRenderer: FunctionalComponent<HeaderCellRendererProps>;
+export default HeaderCellRenderer;
+export type HeaderCellSlotProps = HeaderCellRendererProps & {
+    class: string;
+};

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