ep-craft 0.1.37 → 0.1.39

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

@@ -0,0 +1,128 @@
+import type { CSSProperties, Ref } from 'vue';
+import type { TableV2Props } from '../table';
+import type { AnyColumns, Column, KeyType } from '../types';
+declare function useColumns(props: TableV2Props, columns: Ref<AnyColumns>, fixed: Ref<boolean>): {
+    columns: import("vue").ComputedRef<{
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    }[]>;
+    columnsStyles: import("vue").ComputedRef<Record<KeyType, CSSProperties>>;
+    columnsTotalWidth: import("vue").ComputedRef<number>;
+    fixedColumnsOnLeft: import("vue").ComputedRef<{
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    }[]>;
+    fixedColumnsOnRight: import("vue").ComputedRef<{
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    }[]>;
+    hasFixedColumns: import("vue").ComputedRef<number>;
+    mainColumns: import("vue").ComputedRef<AnyColumns>;
+    normalColumns: import("vue").ComputedRef<{
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    }[]>;
+    visibleColumns: import("vue").ComputedRef<{
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    }[]>;
+    getColumn: (key: KeyType) => {
+        key: KeyType;
+        align?: import("../types").Alignment;
+        class?: string | import("../types").ClassNameGetter<any> | undefined;
+        dataKey?: KeyType;
+        fixed?: true | import("../types").FixedDirection;
+        flexGrow?: CSSProperties["flexGrow"];
+        flexShrink?: CSSProperties["flexShrink"];
+        title?: string;
+        hidden?: boolean;
+        headerClass?: string | import("../types").HeaderClassGetter<any> | undefined;
+        maxWidth?: number;
+        minWidth?: number;
+        style?: CSSProperties;
+        sortable?: boolean;
+        width: number;
+        cellRenderer?: import("../types").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("../types").HeaderCellRenderer<any> | undefined;
+    } | undefined;
+    getColumnStyle: (key: KeyType) => CSSProperties;
+    updateColumnWidth: (column: Column<any>, width: number) => void;
+    onColumnSorted: (e: MouseEvent) => void;
+};
+export { useColumns };
+export type UseColumnsReturn = ReturnType<typeof useColumns>;

package/dist/components/table-v2/src/composables/use-columns.js

@@ -0,0 +1,73 @@
+import { computed as o, unref as r } from "vue";
+import { isObject as T } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { SortOrder as W, oppositeOrderMap as C } from "../constants.js";
+import { placeholderSign as x } from "../private.js";
+import { calcColumnStyle as j } from "./utils.js";
+function _(n, y, S) {
+  const u = o(
+    () => r(y).map((t, e) => ({
+      ...t,
+      key: t.key ?? t.dataKey ?? e
+    }))
+  ), i = o(() => r(u).filter((t) => !t.hidden)), s = o(
+    () => r(i).filter(
+      (t) => t.fixed === "left" || t.fixed === !0
+    )
+  ), l = o(
+    () => r(i).filter((t) => t.fixed === "right")
+  ), c = o(
+    () => r(i).filter((t) => !t.fixed)
+  ), g = o(() => {
+    const t = [];
+    return r(s).forEach((e) => {
+      t.push({
+        ...e,
+        placeholderSign: x
+      });
+    }), r(c).forEach((e) => {
+      t.push(e);
+    }), r(l).forEach((e) => {
+      t.push({
+        ...e,
+        placeholderSign: x
+      });
+    }), t;
+  }), p = o(() => r(s).length || r(l).length), d = o(() => r(u).reduce(
+    (t, e) => (t[e.key] = j(e, r(S), n.fixed), t),
+    {}
+  )), k = o(() => r(i).reduce(
+    (t, e) => t + e.width,
+    0
+  )), f = (t) => r(u).find((e) => e.key === t), O = (t) => r(d)[t], E = (t, e) => {
+    t.width = e;
+  };
+  function b(t) {
+    var h;
+    const { key: e } = t.currentTarget.dataset;
+    if (!e) return;
+    const { sortState: a, sortBy: w } = n;
+    let m = W.ASC;
+    T(a) ? m = C[a[e]] : m = C[w.order], (h = n.onColumnSort) == null || h.call(n, { column: f(e), key: e, order: m });
+  }
+  return {
+    columns: u,
+    columnsStyles: d,
+    columnsTotalWidth: k,
+    fixedColumnsOnLeft: s,
+    fixedColumnsOnRight: l,
+    hasFixedColumns: p,
+    mainColumns: g,
+    normalColumns: c,
+    visibleColumns: i,
+    getColumn: f,
+    getColumnStyle: O,
+    updateColumnWidth: E,
+    onColumnSorted: b
+  };
+}
+export {
+  _ as useColumns
+};

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

@@ -0,0 +1,14 @@
+import type { TableV2Props } from '../table';
+import type { KeyType } from '../types';
+import type { UseRowReturn } from './use-row';
+type UseDataProps = {
+    expandedRowKeys: UseRowReturn['expandedRowKeys'];
+    lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex'];
+    resetAfterIndex: UseRowReturn['resetAfterIndex'];
+};
+export declare const useData: (props: TableV2Props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }: UseDataProps) => {
+    data: import("vue").ComputedRef<any[]>;
+    depthMap: import("vue").Ref<Record<KeyType, number>, Record<KeyType, number>>;
+};
+export type UseDataReturn = ReturnType<typeof useData>;
+export {};

package/dist/components/table-v2/src/composables/use-data.js

@@ -0,0 +1,33 @@
+import { ref as g, computed as l, unref as f, watch as x } from "vue";
+import { isArray as E } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+const A = (c, { expandedRowKeys: p, lastRenderedRowIndex: u, resetAfterIndex: m }) => {
+  const s = g({}), y = l(() => {
+    const e = {}, { data: r, rowKey: n } = c, o = f(p);
+    if (!o || !o.length) return r;
+    const h = [], i = /* @__PURE__ */ new Set();
+    o.forEach((t) => i.add(t));
+    let a = r.slice();
+    for (a.forEach((t) => e[t[n]] = 0); a.length > 0; ) {
+      const t = a.shift();
+      h.push(t), i.has(t[n]) && E(t.children) && t.children.length > 0 && (a = [...t.children, ...a], t.children.forEach(
+        (w) => e[w[n]] = e[t[n]] + 1
+      ));
+    }
+    return s.value = e, h;
+  }), d = l(() => {
+    const { data: e, expandColumnKey: r } = c;
+    return r ? f(y) : e;
+  });
+  return x(d, (e, r) => {
+    e !== r && (u.value = -1, m(0, !0));
+  }), {
+    data: d,
+    depthMap: s
+  };
+};
+export {
+  A as useData
+};

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

@@ -0,0 +1,31 @@
+import type { ComponentInternalInstance, Ref, ShallowRef } from 'vue';
+import type { TableV2Props } from '../table';
+import type { RowExpandParams, RowHeightChangedParams, RowHoverParams } from '../row';
+import type { FixedDirection, KeyType } from '../types';
+import type { onRowRenderedParams } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+import type { UseNamespaceReturn } from '../../../../hooks';
+type Heights = Record<KeyType, number>;
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseRowProps = {
+    mainTableRef: GridInstanceRef;
+    leftTableRef: GridInstanceRef;
+    rightTableRef: GridInstanceRef;
+    tableInstance: ComponentInternalInstance;
+    ns: UseNamespaceReturn;
+    isScrolling: ShallowRef<boolean>;
+};
+export declare const useRow: (props: TableV2Props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling, }: UseRowProps) => {
+    expandedRowKeys: Ref<KeyType[], KeyType[]>;
+    lastRenderedRowIndex: Ref<number, number>;
+    isDynamic: import("vue").ComputedRef<boolean>;
+    isResetting: ShallowRef<boolean, boolean>;
+    rowHeights: Ref<Heights, Heights>;
+    resetAfterIndex: (index: number, forceUpdate?: boolean) => void;
+    onRowExpanded: ({ expanded, rowData, rowIndex, rowKey, }: RowExpandParams) => void;
+    onRowHovered: ({ hovered, rowKey }: RowHoverParams) => void;
+    onRowsRendered: (params: onRowRenderedParams) => void;
+    onRowHeightChange: ({ rowKey, height, rowIndex }: RowHeightChangedParams, fixedDir: FixedDirection) => void;
+};
+export type UseRowReturn = ReturnType<typeof useRow>;
+export {};

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

@@ -0,0 +1,83 @@
+import { getCurrentInstance as M, shallowRef as u, ref as f, computed as N, unref as a, nextTick as O } from "vue";
+import { debounce as _ } from "lodash-unified";
+import { isNumber as j } from "../../../../utils/types.js";
+import "@vueuse/core";
+import "@vue/shared";
+import "@element-plus/icons-vue";
+import { FixedDir as z } from "../constants.js";
+const K = (s, {
+  mainTableRef: g,
+  leftTableRef: x,
+  rightTableRef: w,
+  tableInstance: H,
+  ns: r,
+  isScrolling: q
+}) => {
+  const E = M(), { emit: y } = E, v = u(!1), R = f(s.defaultExpandedRowKeys || []), h = f(-1), l = u(null), d = f({}), m = f({}), b = u({}), C = u({}), I = u({}), S = N(() => j(s.estimatedRowHeight));
+  function L(e) {
+    var n;
+    (n = s.onRowsRendered) == null || n.call(s, e), e.rowCacheEnd > a(h) && (h.value = e.rowCacheEnd);
+  }
+  function U({ hovered: e, rowKey: n }) {
+    if (q.value)
+      return;
+    H.vnode.el.querySelectorAll(`[rowkey="${String(n)}"]`).forEach((i) => {
+      e ? i.classList.add(r.is("hovered")) : i.classList.remove(r.is("hovered"));
+    });
+  }
+  function T({
+    expanded: e,
+    rowData: n,
+    rowIndex: o,
+    rowKey: t
+  }) {
+    var k, A;
+    const i = [...a(R)], c = i.indexOf(t);
+    e ? c === -1 && i.push(t) : c > -1 && i.splice(c, 1), R.value = i, y("update:expandedRowKeys", i), (k = s.onRowExpand) == null || k.call(s, {
+      expanded: e,
+      rowData: n,
+      rowIndex: o,
+      rowKey: t
+    }), (A = s.onExpandedRowsChange) == null || A.call(s, i), H.vnode.el.querySelector(
+      `.${r.is("hovered")}[rowkey="${String(t)}"]`
+    ) && O(() => U({ hovered: !0, rowKey: t }));
+  }
+  const D = _(() => {
+    var e, n, o, t;
+    v.value = !0, d.value = { ...a(d), ...a(m) }, $(a(l), !1), m.value = {}, l.value = null, (e = g.value) == null || e.forceUpdate(), (n = x.value) == null || n.forceUpdate(), (o = w.value) == null || o.forceUpdate(), (t = E.proxy) == null || t.$forceUpdate(), v.value = !1;
+  }, 0);
+  function $(e, n = !1) {
+    a(S) && [g, x, w].forEach((o) => {
+      const t = a(o);
+      t && t.resetAfterRowIndex(e, n);
+    });
+  }
+  function F(e, n, o) {
+    const t = a(l);
+    (t === null || t > o) && (l.value = o), m.value[e] = n;
+  }
+  function G({ rowKey: e, height: n, rowIndex: o }, t) {
+    t ? t === z.RIGHT ? I.value[e] = n : b.value[e] = n : C.value[e] = n;
+    const i = Math.max(
+      ...[b, I, C].map(
+        (c) => c.value[e] || 0
+      )
+    );
+    a(d)[e] !== i && (F(e, i, o), D());
+  }
+  return {
+    expandedRowKeys: R,
+    lastRenderedRowIndex: h,
+    isDynamic: S,
+    isResetting: v,
+    rowHeights: d,
+    resetAfterIndex: $,
+    onRowExpanded: T,
+    onRowHovered: U,
+    onRowsRendered: L,
+    onRowHeightChange: G
+  };
+};
+export {
+  K as useRow
+};

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

@@ -0,0 +1,31 @@
+import type { Ref } from 'vue';
+import type { Alignment as ScrollStrategy } from '../../../virtual-list';
+import type { TableV2Props } from '../table';
+import type { TableGridInstance } from '../table-grid';
+export type ScrollPos = {
+    scrollLeft: number;
+    scrollTop: number;
+};
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseScrollBarProps = {
+    mainTableRef: GridInstanceRef;
+    leftTableRef: GridInstanceRef;
+    rightTableRef: GridInstanceRef;
+    onMaybeEndReached: () => void;
+};
+export type { ScrollStrategy };
+export declare const useScrollbar: (props: TableV2Props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached, }: UseScrollBarProps) => {
+    scrollPos: Ref<{
+        scrollLeft: number;
+        scrollTop: number;
+    }, ScrollPos | {
+        scrollLeft: number;
+        scrollTop: number;
+    }>;
+    scrollTo: (params: ScrollPos) => void;
+    scrollToLeft: (scrollLeft: number) => void;
+    scrollToTop: (scrollTop: number) => void;
+    scrollToRow: (row: number, strategy?: ScrollStrategy) => void;
+    onScroll: (params: ScrollPos) => void;
+    onVerticalScroll: ({ scrollTop }: ScrollPos) => void;
+};

package/dist/components/table-v2/src/composables/use-scrollbar.js

@@ -0,0 +1,53 @@
+import { ref as x, watch as P, unref as n } from "vue";
+const g = (t, {
+  mainTableRef: u,
+  leftTableRef: v,
+  rightTableRef: S,
+  onMaybeEndReached: w
+}) => {
+  const c = x({ scrollLeft: 0, scrollTop: 0 });
+  function s(o) {
+    var r, f, i;
+    const { scrollTop: l } = o;
+    (r = u.value) == null || r.scrollTo(o), (f = v.value) == null || f.scrollToTop(l), (i = S.value) == null || i.scrollToTop(l);
+  }
+  function T(o) {
+    c.value = o, s(o);
+  }
+  function e(o) {
+    c.value.scrollTop = o, s(n(c));
+  }
+  function L(o) {
+    var l, r;
+    c.value.scrollLeft = o, (r = (l = u.value) == null ? void 0 : l.scrollTo) == null || r.call(l, n(c));
+  }
+  function a(o) {
+    var l;
+    T(o), (l = t.onScroll) == null || l.call(t, o);
+  }
+  function d({ scrollTop: o }) {
+    const { scrollTop: l } = n(c);
+    o !== l && e(o);
+  }
+  function h(o, l = "auto") {
+    var r;
+    (r = u.value) == null || r.scrollToRow(o, l);
+  }
+  return P(
+    () => n(c).scrollTop,
+    (o, l) => {
+      o > l && w();
+    }
+  ), {
+    scrollPos: c,
+    scrollTo: T,
+    scrollToLeft: L,
+    scrollToTop: e,
+    scrollToRow: h,
+    onScroll: a,
+    onVerticalScroll: d
+  };
+};
+export {
+  g as useScrollbar
+};

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

@@ -0,0 +1,23 @@
+import type { CSSProperties, ComputedRef } from 'vue';
+import type { TableV2Props } from '../table';
+import type { UseColumnsReturn } from './use-columns';
+type UseStyleProps = {
+    columnsTotalWidth: UseColumnsReturn['columnsTotalWidth'];
+    fixedColumnsOnLeft: UseColumnsReturn['fixedColumnsOnLeft'];
+    fixedColumnsOnRight: UseColumnsReturn['fixedColumnsOnRight'];
+    rowsHeight: ComputedRef<number>;
+};
+export declare const useStyles: (props: TableV2Props, { columnsTotalWidth, rowsHeight, fixedColumnsOnLeft, fixedColumnsOnRight, }: UseStyleProps) => {
+    bodyWidth: ComputedRef<number>;
+    fixedTableHeight: ComputedRef<number>;
+    mainTableHeight: ComputedRef<number>;
+    leftTableWidth: ComputedRef<number>;
+    rightTableWidth: ComputedRef<number>;
+    windowHeight: ComputedRef<number>;
+    footerHeight: ComputedRef<CSSProperties>;
+    emptyStyle: ComputedRef<CSSProperties>;
+    rootStyle: ComputedRef<CSSProperties>;
+    headerHeight: ComputedRef<number>;
+};
+export type UseStyleReturn = ReturnType<typeof useStyles>;
+export {};

package/dist/components/table-v2/src/composables/use-styles.js

@@ -0,0 +1,66 @@
+import { computed as o, unref as t } from "vue";
+import { isNumber as v } from "../../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { addUnit as g } from "../../../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { sum as d, enforceUnit as H } from "../utils.js";
+const F = (i, {
+  columnsTotalWidth: l,
+  rowsHeight: s,
+  fixedColumnsOnLeft: u,
+  fixedColumnsOnRight: b
+}) => {
+  const w = o(() => {
+    const { fixed: e, width: h, vScrollbarSize: n } = i, c = h - n;
+    return e ? Math.max(Math.round(t(l)), c) : c;
+  }), a = o(() => {
+    const { height: e = 0, maxHeight: h = 0, footerHeight: n, hScrollbarSize: c } = i;
+    if (h > 0) {
+      const z = t(m), R = t(s), U = t(r) + z + R + c;
+      return Math.min(U, h - n);
+    }
+    return e - n;
+  }), x = o(() => {
+    const { maxHeight: e } = i, h = t(a);
+    if (v(e) && e > 0) return h;
+    const n = t(s) + t(r) + t(m);
+    return Math.min(h, n);
+  }), f = (e) => e.width, S = o(
+    () => d(t(u).map(f))
+  ), y = o(
+    () => d(t(b).map(f))
+  ), r = o(() => d(i.headerHeight)), m = o(() => {
+    var e;
+    return (((e = i.fixedData) == null ? void 0 : e.length) || 0) * i.rowHeight;
+  }), M = o(() => t(a) - t(r) - t(m)), T = o(() => {
+    const { style: e = {}, height: h, width: n } = i;
+    return H({
+      ...e,
+      height: h,
+      width: n
+    });
+  }), _ = o(
+    () => H({ height: i.footerHeight })
+  ), W = o(() => ({
+    top: g(t(r)),
+    bottom: g(i.footerHeight),
+    width: g(i.width)
+  }));
+  return {
+    bodyWidth: w,
+    fixedTableHeight: x,
+    mainTableHeight: a,
+    leftTableWidth: S,
+    rightTableWidth: y,
+    windowHeight: M,
+    footerHeight: _,
+    emptyStyle: W,
+    rootStyle: T,
+    headerHeight: r
+  };
+};
+export {
+  F as useStyles
+};

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

@@ -0,0 +1,3 @@
+import type { CSSProperties } from 'vue';
+import type { AnyColumns } from '../types';
+export declare const calcColumnStyle: (column: AnyColumns[number], fixedColumn: boolean, fixed: boolean) => CSSProperties;

package/dist/components/table-v2/src/composables/utils.js

@@ -0,0 +1,19 @@
+const h = (i, e, x) => {
+  const f = {
+    flexGrow: 0,
+    flexShrink: 0,
+    ...x ? {} : {
+      flexGrow: i.flexGrow ?? 0,
+      flexShrink: i.flexShrink ?? 1
+    }
+  }, t = {
+    ...i.style ?? {},
+    ...f,
+    flexBasis: "auto",
+    width: i.width
+  };
+  return e || (i.maxWidth && (t.maxWidth = i.maxWidth), i.minWidth && (t.minWidth = i.minWidth)), t;
+};
+export {
+  h as calcColumnStyle
+};

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

@@ -0,0 +1,18 @@
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export declare enum Alignment {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+export declare enum FixedDir {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const oppositeOrderMap: {
+    asc: SortOrder;
+    desc: SortOrder;
+};
+export declare const sortOrders: readonly [SortOrder.ASC, SortOrder.DESC];

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

@@ -0,0 +1,12 @@
+var e = /* @__PURE__ */ ((r) => (r.ASC = "asc", r.DESC = "desc", r))(e || {}), c = /* @__PURE__ */ ((r) => (r.LEFT = "left", r.CENTER = "center", r.RIGHT = "right", r))(c || {}), s = /* @__PURE__ */ ((r) => (r.LEFT = "left", r.RIGHT = "right", r))(s || {});
+const t = {
+  asc: "desc",
+  desc: "asc"
+  /* ASC */
+};
+export {
+  c as Alignment,
+  s as FixedDir,
+  e as SortOrder,
+  t as oppositeOrderMap
+};