x-next 1.11.0 → 1.12.0

package/dist/es/components/table/dom-listeners.js

@@ -0,0 +1,23 @@
+const n = () => Function, t = {
+  tabindex: [String, Number],
+  onClick: n(),
+  onDblclick: n(),
+  onContextmenu: n(),
+  onMouseenter: n(),
+  onMouseleave: n(),
+  onDragstart: n(),
+  onDragend: n(),
+  onDragenter: n(),
+  onDragover: n(),
+  onDrop: n(),
+  onKeydown: n(),
+  onFocus: n(),
+  onPointerdown: n(),
+  onPointermove: n(),
+  onPointerup: n(),
+  onPointercancel: n()
+}, r = (e) => Object.fromEntries(Object.keys(t).map((o) => [o, e[o]]));
+export {
+  r as getTableDomListeners,
+  t as tableDomListeners
+};

package/dist/es/components/table/hooks/use-column-resize.js

@@ -1,27 +1,36 @@
-import { ref as v, reactive as f, onBeforeUnmount as h } from "vue";
-import { off as i, on as s } from "../../../_utils/dom.js";
-const g = (c, w) => {
-  const e = v(""), l = f({}), a = (u, n) => {
-    n.preventDefault(), e.value = u, s(window, "mousemove", m), s(window, "mouseup", o), s(window, "contextmenu", o);
-  }, o = () => {
-    e.value = "", i(window, "mousemove", m), i(window, "mouseup", o), i(window, "contextmenu", o);
+import { ref as d, reactive as g, onBeforeUnmount as v } from "vue";
+import { off as c, on as l } from "../../../_utils/dom.js";
+const y = (r, h, f = () => 40) => {
+  const u = d(""), s = g({}), a = (e, o) => {
+    o.preventDefault(), u.value = e, l(window, "mousemove", w), l(window, "mouseup", n), l(window, "contextmenu", n);
+  }, n = () => {
+    u.value = "", c(window, "mousemove", w), c(window, "mouseup", n), c(window, "contextmenu", n);
   };
-  h(o);
-  const m = (u) => {
-    const n = c.value[e.value];
-    if (n) {
-      const { clientX: d } = u, { x: r } = n.getBoundingClientRect();
-      let t = Math.ceil(d - r);
-      t < 40 && (t = 40), l[e.value] = t, w("columnResize", e.value, t);
+  v(n);
+  const m = (e, o) => {
+    const t = Math.max(40, f(e), Math.ceil(o));
+    s[e] = t, h("columnResize", e, t);
+  }, p = (e, o) => {
+    var i;
+    if (o.key !== "ArrowLeft" && o.key !== "ArrowRight") return;
+    o.preventDefault(), o.stopPropagation();
+    const t = s[e] ?? ((i = r.value[e]) == null ? void 0 : i.getBoundingClientRect().width) ?? 40;
+    m(e, t + (o.key === "ArrowLeft" ? -10 : 10));
+  }, w = (e) => {
+    const o = r.value[u.value];
+    if (o) {
+      const { clientX: t } = e, { x: i } = o.getBoundingClientRect();
+      m(u.value, t - i);
     }
   };
   return {
-    resizingColumn: e,
-    columnWidth: l,
+    resizingColumn: u,
+    columnWidth: s,
     handleThMouseDown: a,
-    handleThMouseUp: o
+    handleThMouseUp: n,
+    handleThKeyDown: p
   };
 };
 export {
-  g as useColumnResize
+  y as useColumnResize
 };

package/dist/es/components/table/hooks/use-column-sorter.js

@@ -1,37 +1,30 @@
-import { computed as n } from "vue";
-const h = ({
-  column: t,
-  tableCtx: o
+import { computed as o } from "vue";
+const S = ({
+  column: n,
+  tableCtx: t
 }) => {
-  const a = n(() => {
-    var e;
-    if (t.value.dataIndex && t.value.dataIndex === ((e = o.sorter) == null ? void 0 : e.field))
-      return o.sorter.direction;
-  }), r = n(
-    () => {
-      var e, s;
-      return ((s = (e = t.value) == null ? void 0 : e.sortable) == null ? void 0 : s.sortDirections) ?? [];
-    }
-  ), u = n(() => r.value.length > 0), i = n(() => r.value.includes("ascend")), c = n(
-    () => r.value.includes("descend")
-  ), d = n(() => a.value ? a.value === r.value[0] ? r.value[1] ?? "" : "" : r.value[0] ?? "");
+  const d = o(() => {
+    var e, i;
+    const r = (e = t.sorters) == null ? void 0 : e.find((l) => l.field === n.value.dataIndex);
+    if (r) return r.direction;
+    if (n.value.dataIndex && n.value.dataIndex === ((i = t.sorter) == null ? void 0 : i.field))
+      return t.sorter.direction;
+  }), s = o(() => {
+    var r, e;
+    return ((e = (r = n.value) == null ? void 0 : r.sortable) == null ? void 0 : e.sortDirections) ?? [];
+  }), u = o(() => s.value.length > 0), c = o(() => s.value.includes("ascend")), v = o(() => s.value.includes("descend")), a = o(() => d.value ? d.value === s.value[0] ? s.value[1] ?? "" : "" : s.value[0] ?? "");
   return {
-    sortOrder: a,
+    sortOrder: d,
     hasSorter: u,
-    hasAscendBtn: i,
-    hasDescendBtn: c,
-    nextSortOrder: d,
-    handleClickSorter: (e) => {
-      var s;
-      t.value.dataIndex && ((s = o.onSorterChange) == null || s.call(
-        o,
-        t.value.dataIndex,
-        d.value,
-        e
-      ));
+    hasAscendBtn: c,
+    hasDescendBtn: v,
+    nextSortOrder: a,
+    handleClickSorter: (r) => {
+      var e;
+      n.value.dataIndex && ((e = t.onSorterChange) == null || e.call(t, n.value.dataIndex, a.value, r));
     }
   };
 };
 export {
-  h as useColumnSorter
+  S as useColumnSorter
 };

package/dist/es/components/table/hooks/use-drag.js

@@ -1,39 +1,42 @@
-import { computed as s, reactive as c } from "vue";
-const T = (n) => {
-  const g = s(() => {
-    if (n.value)
-      return n.value.type === "handle" ? "handle" : "row";
-  }), t = c({
+import { computed as l, reactive as h } from "vue";
+const T = (g) => {
+  const f = l(() => {
+    if (g.value)
+      return g.value.type === "handle" ? "handle" : "row";
+  }), t = h({
     dragging: !1,
     sourceKey: "",
     sourcePath: [],
     targetPath: [],
     data: {}
-  }), d = () => {
+  }), r = () => {
     t.dragging = !1, t.sourceKey = "", t.sourcePath = [], t.targetPath = [], t.data = {};
+  }, s = (a, e, n, c) => {
+    if (a.dataTransfer && (a.dataTransfer.effectAllowed = "move", a.target && a.target.tagName === "TD")) {
+      const { parentElement: o } = a.target;
+      o && o.tagName === "TR" && a.dataTransfer.setDragImage(o, 0, 0);
+    }
+    d(e, n, c);
+  }, d = (a, e, n) => {
+    t.dragging = !0, t.sourceKey = a, t.sourcePath = e, t.targetPath = [...e], t.data = n;
   };
   return {
-    dragType: g,
+    beginDrag: d,
+    clearDragState: r,
+    dragType: f,
     dragState: t,
-    handleDragStart: (a, r, o, f) => {
-      if (a.dataTransfer && (a.dataTransfer.effectAllowed = "move", a.target && a.target.tagName === "TD")) {
-        const { parentElement: e } = a.target;
-        e && e.tagName === "TR" && a.dataTransfer.setDragImage(e, 0, 0);
-      }
-      t.dragging = !0, t.sourceKey = r, t.sourcePath = o, t.targetPath = [...o], t.data = f;
-    },
-    handleDragEnter: (a, r) => {
-      a.dataTransfer && (a.dataTransfer.dropEffect = "move"), t.targetPath.toString() !== r.toString() && (t.targetPath = r), a.preventDefault();
+    handleDragStart: s,
+    handleDragEnter: (a, e) => {
+      a.dataTransfer && (a.dataTransfer.dropEffect = "move"), t.targetPath.toString() !== e.toString() && (t.targetPath = e), a.preventDefault();
     },
     handleDragover: (a) => {
       a.dataTransfer && (a.dataTransfer.dropEffect = "move"), a.preventDefault();
     },
     handleDragEnd: (a) => {
-      var r;
-      ((r = a.dataTransfer) == null ? void 0 : r.dropEffect) === "none" && d();
+      r();
     },
     handleDrop: (a) => {
-      d(), a.preventDefault();
+      r(), a.preventDefault();
     }
   };
 };

package/dist/es/components/table/hooks/use-filter.js

@@ -1,53 +1,53 @@
-import { ref as o, watch as c, computed as u } from "vue";
-import { isEqual as x } from "../../../_utils/is-equal.js";
-const m = ({
-  columns: i,
-  onFilterChange: f
+import { ref as u, watch as c, computed as x } from "vue";
+const F = ({
+  columns: r,
+  onFilterChange: n
 }) => {
-  const r = o(s(i.value));
-  c(i, (a) => {
-    const t = s(a);
-    x(t, r.value) || (r.value = t);
+  const l = u(I(r.value));
+  c(r, (a, i) => {
+    const t = new Set(
+      i.filter((e) => e.filterable).map((e) => e.dataIndex)
+    ), d = {};
+    for (const e of a)
+      if (e.dataIndex && e.filterable) {
+        const o = t.has(e.dataIndex) ? l.value[e.dataIndex] : e.filterable.defaultFilteredValue;
+        o !== void 0 && (d[e.dataIndex] = o);
+      }
+    l.value = d;
   });
-  const d = u(() => {
-    var t;
+  const f = x(() => {
+    var i;
     const a = {};
-    for (const l of i.value)
-      if (l.dataIndex) {
-        const e = ((t = l.filterable) == null ? void 0 : t.filteredValue) ?? r.value[l.dataIndex];
-        e && (a[l.dataIndex] = e);
+    for (const t of r.value)
+      if (t.dataIndex) {
+        const d = ((i = t.filterable) == null ? void 0 : i.filteredValue) ?? l.value[t.dataIndex];
+        d && (a[t.dataIndex] = d);
       }
     return a;
-  });
+  }), s = (a, i) => {
+    const t = i ? [].concat(i) : [], d = { ...l.value };
+    for (const e of r.value)
+      if (e.dataIndex && e.filterable && (t.length === 0 || t.includes(e.dataIndex))) {
+        const o = a ? e.filterable.defaultFilteredValue ?? [] : [];
+        d[e.dataIndex] = o;
+      }
+    l.value = d;
+    for (const e of r.value)
+      e.dataIndex && e.filterable && (t.length === 0 || t.includes(e.dataIndex)) && n(e.dataIndex, d[e.dataIndex]);
+  };
   return {
-    _filters: r,
-    computedFilters: d,
-    resetFilters: (a) => {
-      const t = a ? [].concat(a) : [], l = {};
-      for (const e of i.value)
-        if (e.dataIndex && e.filterable && (t.length === 0 || t.includes(e.dataIndex))) {
-          const n = e.filterable.defaultFilteredValue ?? [];
-          l[e.dataIndex] = n, f(e.dataIndex, n);
-        }
-      r.value = l;
-    },
-    clearFilters: (a) => {
-      const t = a ? [].concat(a) : [], l = {};
-      for (const e of i.value)
-        if (e.dataIndex && e.filterable && (t.length === 0 || t.includes(e.dataIndex))) {
-          const n = [];
-          l[e.dataIndex] = n, f(e.dataIndex, n);
-        }
-      r.value = l;
-    }
+    _filters: l,
+    computedFilters: f,
+    resetFilters: (a) => s(!0, a),
+    clearFilters: (a) => s(!1, a)
   };
-}, s = (i) => {
-  var r;
-  const f = {};
-  for (const d of i)
-    d.dataIndex && ((r = d.filterable) != null && r.defaultFilteredValue) && (f[d.dataIndex] = d.filterable.defaultFilteredValue);
-  return f;
+}, I = (r) => {
+  var l;
+  const n = {};
+  for (const f of r)
+    f.dataIndex && ((l = f.filterable) != null && l.defaultFilteredValue) && (n[f.dataIndex] = f.filterable.defaultFilteredValue);
+  return n;
 };
 export {
-  m as useFilter
+  F as useFilter
 };

package/dist/es/components/table/hooks/use-keyboard-navigation.js

@@ -0,0 +1,69 @@
+import { ref as E, watch as N, nextTick as p } from "vue";
+const D = ({
+  enabled: b,
+  rows: x,
+  root: C,
+  scrollToRow: I,
+  mountedKeys: o
+}) => {
+  const i = E();
+  N(x, (a) => {
+    i.value && !a.some((r) => {
+      var e;
+      return r.record.key === ((e = i.value) == null ? void 0 : e.key) && !r.detail;
+    }) && (i.value = void 0);
+  });
+  const y = (a) => {
+    var e;
+    const r = Array.from(
+      ((e = C.value) == null ? void 0 : e.querySelectorAll("[data-x-table-row]")) ?? []
+    ).find((t) => t.dataset.xTableRow === String(a));
+    return Array.from((r == null ? void 0 : r.children) ?? []).filter(
+      (t) => t instanceof HTMLElement && t.hasAttribute("data-x-table-cell-index")
+    );
+  };
+  return { getCellProps: (a, r, e) => {
+    var n, u;
+    if (!b.value) return {};
+    const t = i.value && (!(o != null && o.value) || o.value.includes(i.value.key)) ? i.value : {
+      key: ((n = o == null ? void 0 : o.value) == null ? void 0 : n[0]) ?? ((u = x.value.find((c) => !c.detail)) == null ? void 0 : u.record.key),
+      column: e
+    };
+    return {
+      "data-x-table-cell-index": r,
+      tabindex: t.key === a && t.column === r ? 0 : -1,
+      onFocus: (c) => {
+        c.target === c.currentTarget && (i.value = { key: a, column: r });
+      }
+    };
+  }, handleCellKeydown: async (a, r, e) => {
+    var w, A;
+    if (!b.value || e.target !== e.currentTarget || e.altKey || e.metaKey || e.shiftKey || !["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End"].includes(e.key))
+      return;
+    e.preventDefault();
+    const t = x.value.filter((l) => !l.detail);
+    let n = t.findIndex((l) => l.record.key === a);
+    if (n < 0) return;
+    const u = y(a), c = u.findIndex((l) => Number(l.dataset.xTableCellIndex) === r), s = e.key === "ArrowDown" || e.key === "ArrowRight" || e.key === "End";
+    let f = r;
+    for (e.key === "ArrowLeft" || e.key === "ArrowRight" ? f = Number(
+      ((w = u[c + (s ? 1 : -1)]) == null ? void 0 : w.dataset.xTableCellIndex) ?? r
+    ) : e.key === "Home" || e.key === "End" ? (f = s ? Number.MAX_SAFE_INTEGER : 0, e.ctrlKey && (n = s ? t.length - 1 : 0)) : n += s ? 1 : -1; t[n]; ) {
+      const l = t[n], T = x.value.indexOf(l);
+      y(l.record.key).length || (I(T), await p());
+      const k = y(l.record.key), d = f === Number.MAX_SAFE_INTEGER ? k.at(-1) : e.key === "Home" ? k[0] : k.find((g) => {
+        const h = Number(g.dataset.xTableCellIndex);
+        return h <= f && h + Number(g.getAttribute("colspan") ?? 1) > f;
+      });
+      if (d) {
+        i.value = { key: l.record.key, column: Number(d.dataset.xTableCellIndex) }, d.focus(), (A = d.scrollIntoView) == null || A.call(d, { block: "nearest", inline: "nearest" });
+        return;
+      }
+      if (e.key !== "ArrowUp" && e.key !== "ArrowDown") return;
+      n += s ? 1 : -1;
+    }
+  } };
+};
+export {
+  D as useKeyboardNavigation
+};

package/dist/es/components/table/hooks/use-row-selection.js

@@ -1,54 +1,58 @@
-import { computed as v, ref as f } from "vue";
-import { getLeafKeys as R } from "../utils.js";
-import { union as n } from "../../../_utils/array.js";
+import { computed as d, ref as S } from "vue";
+import { getLeafKeys as h } from "../utils.js";
+import { union as o } from "../../../_utils/array.js";
 const j = ({
-  selectedKeys: p,
-  defaultSelectedKeys: w,
-  rowSelection: u,
-  currentAllRowKeys: h,
+  selectedKeys: f,
+  defaultSelectedKeys: p,
+  rowSelection: v,
+  currentAllRowKeys: w,
   currentAllEnabledRowKeys: y,
   emit: s
 }) => {
   var K;
-  const o = v(() => {
+  const u = d(() => {
     var e;
-    return ((e = u.value) == null ? void 0 : e.type) === "radio";
-  }), a = f(
-    w.value ?? ((K = u.value) == null ? void 0 : K.defaultSelectedRowKeys) ?? []
-  ), c = v(
+    return ((e = v.value) == null ? void 0 : e.type) === "radio";
+  }), n = S(
+    p.value ?? ((K = v.value) == null ? void 0 : K.defaultSelectedRowKeys) ?? []
+  ), a = d(
     () => {
       var e;
-      return p.value ?? ((e = u.value) == null ? void 0 : e.selectedRowKeys) ?? a.value;
+      return f.value ?? ((e = v.value) == null ? void 0 : e.selectedRowKeys) ?? n.value;
     }
-  ), S = v(
-    () => c.value.filter((e) => h.value.includes(e))
+  ), r = d(
+    () => a.value.filter((e) => w.value.includes(e))
   );
   return {
-    isRadio: o,
-    selectedRowKeys: c,
-    currentSelectedRowKeys: S,
+    isRadio: u,
+    selectedRowKeys: a,
+    currentSelectedRowKeys: r,
     handleSelectAll: (e) => {
-      const l = n(c.value, y.value, !e);
-      a.value = l, s("selectAll", e), s("selectionChange", l), s("update:selectedKeys", l);
+      if (u.value) return;
+      const l = o(a.value, y.value, !e);
+      n.value = l, s("selectAll", e), s("selectionChange", l), s("update:selectedKeys", l);
     },
     handleSelect: (e, l) => {
-      const t = o.value ? [l.key] : n(c.value, [l.key], !e);
-      a.value = t, s("select", t, l.key, l.raw), s("selectionChange", t), s("update:selectedKeys", t);
+      if (l.disabled) return;
+      const t = u.value ? e ? [l.key] : a.value.filter((c) => c !== l.key) : o(a.value, [l.key], !e);
+      n.value = t, s("select", t, l.key, l.raw), s("selectionChange", t), s("update:selectedKeys", t);
     },
     handleSelectAllLeafs: (e, l) => {
-      const t = n(c.value, R(e), !l);
-      a.value = t, s("select", t, e.key, e.raw), s("selectionChange", t), s("update:selectedKeys", t);
+      if (e.disabled) return;
+      const t = o(a.value, h(e), !l);
+      n.value = t, s("select", t, e.key, e.raw), s("selectionChange", t), s("update:selectedKeys", t);
     },
     select: (e, l = !0) => {
-      const t = [].concat(e), d = o.value ? t : n(c.value, t, !l);
-      a.value = d, s("selectionChange", d), s("update:selectedKeys", d);
+      const t = [].concat(e), c = u.value ? l ? t.slice(0, 1) : a.value.filter((i) => !t.includes(i)) : o(a.value, t, !l);
+      n.value = c, s("selectionChange", c), s("update:selectedKeys", c);
     },
     selectAll: (e = !0) => {
-      const l = n(c.value, y.value, !e);
-      a.value = l, s("selectionChange", l), s("update:selectedKeys", l);
+      if (u.value) return;
+      const l = o(a.value, y.value, !e);
+      n.value = l, s("selectionChange", l), s("update:selectedKeys", l);
     },
     clearSelected: () => {
-      a.value = [], s("selectionChange", []), s("update:selectedKeys", []);
+      n.value = [], s("selectionChange", []), s("update:selectedKeys", []);
     }
   };
 };

package/dist/es/components/table/hooks/use-sorter.js

@@ -1,53 +1,101 @@
-import { ref as f, watch as l, computed as n } from "vue";
-import { isString as u } from "../../../_utils/is.js";
-import { isEqual as c } from "../../../_utils/is-equal.js";
-const m = ({
-  columns: o,
-  onSorterChange: a
+import { ref as S, watch as h, computed as p } from "vue";
+import { isString as O } from "../../../_utils/is.js";
+const F = ({
+  columns: d,
+  onSorterChange: f
 }) => {
-  const t = f(i(o.value));
-  l(o, (r) => {
-    const e = i(r);
-    c(e, t.value) || (t.value = e);
+  const r = S(x(d.value)), e = S(u(d.value));
+  e.value.length && (r.value = void 0), h(d, (a, l) => {
+    if (e.value = e.value.filter(
+      (i) => a.some((t) => {
+        var o;
+        return t.dataIndex === i.field && ((o = t.sortable) == null ? void 0 : o.sortPriority) !== void 0;
+      })
+    ), r.value && !a.some((i) => {
+      var t;
+      return i.dataIndex === ((t = r.value) == null ? void 0 : t.field) && i.sortable;
+    }) && (r.value = void 0), !r.value && !e.value.length) {
+      const i = new Set(
+        l.filter((o) => o.sortable).map((o) => o.dataIndex)
+      ), t = a.filter((o) => !i.has(o.dataIndex));
+      e.value = u(t), e.value.length || (r.value = x(t));
+    }
   });
-  const s = n(() => {
-    var r;
-    for (const e of o.value)
-      if (e.dataIndex && e.sortable) {
-        const d = u(e.sortable.sortOrder) ? e.sortable.sortOrder : ((r = t.value) == null ? void 0 : r.field) === e.dataIndex ? t.value.direction : "";
-        if (d)
-          return {
-            field: e.dataIndex,
-            direction: d
+  const s = p(() => {
+    var l, i;
+    const a = [];
+    for (const t of d.value)
+      if (t.dataIndex && t.sortable) {
+        const o = O(t.sortable.sortOrder) ? t.sortable.sortOrder : ((l = r.value) == null ? void 0 : l.field) === t.dataIndex ? r.value.direction : ((i = e.value.find((v) => v.field === t.dataIndex)) == null ? void 0 : i.direction) ?? "";
+        if (o) {
+          const v = {
+            field: t.dataIndex,
+            direction: o
           };
+          if (t.sortable.sortPriority === void 0) return [v];
+          a.push(v);
+        }
       }
-  });
+    return a.sort((t, o) => {
+      const v = (n) => {
+        var I, b;
+        return ((b = (I = d.value.find((y) => y.dataIndex === n)) == null ? void 0 : I.sortable) == null ? void 0 : b.sortPriority) ?? 0;
+      };
+      return v(o.field) - v(t.field);
+    });
+  }), c = p(() => s.value[0]);
   return {
-    _sorter: t,
-    computedSorter: s,
+    _sorter: r,
+    computedSorter: c,
+    computedSorters: s,
+    setSorter: (a, l) => {
+      var t;
+      const i = d.value.find((o) => o.dataIndex === a);
+      ((t = i == null ? void 0 : i.sortable) == null ? void 0 : t.sortPriority) !== void 0 ? (r.value = void 0, e.value = s.value.filter(
+        (o) => o.field !== a && d.value.some(
+          (v) => {
+            var n;
+            return v.dataIndex === o.field && ((n = v.sortable) == null ? void 0 : n.sortPriority) !== void 0;
+          }
+        )
+      ), l && e.value.push({ field: a, direction: l })) : (e.value = [], r.value = l ? { field: a, direction: l } : void 0);
+    },
     resetSorters: () => {
-      let r;
-      for (const e of o.value)
-        e.dataIndex && e.sortable && (!r && e.sortable.defaultSortOrder && (r = {
-          field: e.dataIndex,
-          direction: e.sortable.defaultSortOrder
-        }), a(e.dataIndex, e.sortable.defaultSortOrder ?? ""));
-      t.value = r;
+      var a;
+      e.value = u(d.value), r.value = e.value.length ? void 0 : x(d.value);
+      for (const l of d.value)
+        l.dataIndex && l.sortable && f(
+          l.dataIndex,
+          ((a = s.value.find((i) => i.field === l.dataIndex)) == null ? void 0 : a.direction) ?? ""
+        );
     },
     clearSorters: () => {
-      for (const r of o.value)
-        r.dataIndex && r.sortable && a(r.dataIndex, "");
+      r.value = void 0, e.value = [];
+      for (const a of d.value)
+        a.dataIndex && a.sortable && f(a.dataIndex, "");
     }
   };
-}, i = (o) => {
-  var a;
-  for (const t of o)
-    if (t.dataIndex && ((a = t.sortable) != null && a.defaultSortOrder))
+}, u = (d) => {
+  var r;
+  const f = d.find((e) => {
+    var s;
+    return e.dataIndex && ((s = e.sortable) == null ? void 0 : s.defaultSortOrder);
+  });
+  return ((r = f == null ? void 0 : f.sortable) == null ? void 0 : r.sortPriority) === void 0 ? [] : d.flatMap(
+    (e) => {
+      var s;
+      return e.dataIndex && ((s = e.sortable) == null ? void 0 : s.sortPriority) !== void 0 && e.sortable.defaultSortOrder ? [{ field: e.dataIndex, direction: e.sortable.defaultSortOrder }] : [];
+    }
+  );
+}, x = (d) => {
+  var f;
+  for (const r of d)
+    if (r.dataIndex && ((f = r.sortable) != null && f.defaultSortOrder))
       return {
-        field: t.dataIndex,
-        direction: t.sortable.defaultSortOrder
+        field: r.dataIndex,
+        direction: r.sortable.defaultSortOrder
       };
 };
 export {
-  m as useSorter
+  F as useSorter
 };