@honed/table 0.11.1 → 0.13.0

package/dist/index.es.js

@@ -1,692 +1,717 @@
-import { ref as ee, computed as v, reactive as Z, toValue as Y } from "vue";
-import { router as S } from "@inertiajs/vue3";
-function te(l, d, s, o = {}) {
-  return l.route ? (S.visit(l.route.url, {
-    ...o,
-    method: l.route.method
-  }), !0) : l.action && d ? (S.post(
-    d,
-    { ...s, name: l.name, type: l.type },
-    o
-  ), !0) : !1;
-}
-function _(l, d, s, o = {}, m = {}) {
-  return te(
-    l,
-    d,
-    { ...o, id: s ?? void 0 },
-    m
-  );
-}
-function ne(l, d, s, o = {}) {
-  return l.map((m) => ({
-    ...m,
-    execute: (u = {}, i = {}) => _(m, d, s, u, { ...o, ...i })
-  }));
+import { ref as ee, computed as v, reactive as Z, toValue as X } from "vue";
+import { router as b } from "@inertiajs/vue3";
+import Y from "axios";
+function N(a, m = {}, c = {}) {
+  if (!a.href || !a.method)
+    return !1;
+  if (a.type === "inertia")
+    a.method === "delete" ? b.delete(a.href, c) : b[a.method](a.href, m, c);
+  else {
+    const i = (p) => {
+      var u;
+      return (u = c.onError) == null ? void 0 : u.call(c, p);
+    };
+    a.method === "get" ? window.location.href = a.href : a.method === "delete" ? Y.delete(a.href).catch(i) : Y[a.method](a.href, m).catch(i);
+  }
+  return !0;
 }
-function le() {
-  const l = ee({
+function te() {
+  const a = ee({
     all: !1,
     only: /* @__PURE__ */ new Set(),
     except: /* @__PURE__ */ new Set()
   });
-  function d() {
-    l.value.all = !0, l.value.only.clear(), l.value.except.clear();
+  function m() {
+    a.value.all = !0, a.value.only.clear(), a.value.except.clear();
   }
-  function s() {
-    l.value.all = !1, l.value.only.clear(), l.value.except.clear();
+  function c() {
+    a.value.all = !1, a.value.only.clear(), a.value.except.clear();
   }
-  function o(...f) {
-    f.forEach((y) => l.value.except.delete(y)), f.forEach((y) => l.value.only.add(y));
+  function i(...d) {
+    d.forEach((h) => a.value.except.delete(h)), d.forEach((h) => a.value.only.add(h));
   }
-  function m(...f) {
-    f.forEach((y) => l.value.except.add(y)), f.forEach((y) => l.value.only.delete(y));
+  function p(...d) {
+    d.forEach((h) => a.value.except.add(h)), d.forEach((h) => a.value.only.delete(h));
   }
-  function u(f, y) {
-    if (i(f) || y === !1) return m(f);
-    if (!i(f) || y === !0) return o(f);
+  function u(d, h) {
+    if (s(d) || h === !1) return p(d);
+    if (!s(d) || h === !0) return i(d);
   }
-  function i(f) {
-    return l.value.all ? !l.value.except.has(f) : l.value.only.has(f);
+  function s(d) {
+    return a.value.all ? !a.value.except.has(d) : a.value.only.has(d);
   }
-  const h = v(() => l.value.all && l.value.except.size === 0), x = v(() => l.value.only.size > 0 || h.value);
-  function w(f) {
+  const r = v(() => a.value.all && a.value.except.size === 0), x = v(() => a.value.only.size > 0 || r.value);
+  function k(d) {
     return {
-      "onUpdate:modelValue": (y) => {
-        y ? o(f) : m(f);
+      "onUpdate:modelValue": (h) => {
+        h ? i(d) : p(d);
       },
-      modelValue: i(f),
-      value: f
+      modelValue: s(d),
+      value: d
     };
   }
-  function k() {
+  function _() {
     return {
-      "onUpdate:modelValue": (f) => {
-        f ? d() : s();
+      "onUpdate:modelValue": (d) => {
+        d ? m() : c();
       },
-      modelValue: h.value
+      modelValue: r.value
     };
   }
   return {
-    allSelected: h,
-    selection: l,
+    allSelected: r,
+    selection: a,
     hasSelected: x,
-    selectAll: d,
-    deselectAll: s,
-    select: o,
-    deselect: m,
+    selectAll: m,
+    deselectAll: c,
+    select: i,
+    deselect: p,
     toggle: u,
-    selected: i,
-    bind: w,
-    bindAll: k
+    selected: s,
+    bind: k,
+    bindAll: _
   };
 }
 typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
 const Q = () => {
 };
-function ae(l, d) {
-  function s(...o) {
-    return new Promise((m, u) => {
-      Promise.resolve(l(() => d.apply(this, o), { fn: d, thisArg: this, args: o })).then(m).catch(u);
+function ne(a, m) {
+  function c(...i) {
+    return new Promise((p, u) => {
+      Promise.resolve(a(() => m.apply(this, i), { fn: m, thisArg: this, args: i })).then(p).catch(u);
     });
   }
-  return s;
+  return c;
 }
-function re(l, d = {}) {
-  let s, o, m = Q;
-  const u = (h) => {
-    clearTimeout(h), m(), m = Q;
+function le(a, m = {}) {
+  let c, i, p = Q;
+  const u = (r) => {
+    clearTimeout(r), p(), p = Q;
   };
-  let i;
-  return (h) => {
-    const x = Y(l), w = Y(d.maxWait);
-    return s && u(s), x <= 0 || w !== void 0 && w <= 0 ? (o && (u(o), o = null), Promise.resolve(h())) : new Promise((k, f) => {
-      m = d.rejectOnCancel ? f : k, i = h, w && !o && (o = setTimeout(() => {
-        s && u(s), o = null, k(i());
-      }, w)), s = setTimeout(() => {
-        o && u(o), o = null, k(h());
+  let s;
+  return (r) => {
+    const x = X(a), k = X(m.maxWait);
+    return c && u(c), x <= 0 || k !== void 0 && k <= 0 ? (i && (u(i), i = null), Promise.resolve(r())) : new Promise((_, d) => {
+      p = m.rejectOnCancel ? d : _, s = r, k && !i && (i = setTimeout(() => {
+        c && u(c), i = null, _(s());
+      }, k)), c = setTimeout(() => {
+        i && u(i), i = null, _(r());
       }, x);
     });
   };
 }
-function H(l, d = 200, s = {}) {
-  return ae(
-    re(d, s),
-    l
+function K(a, m = 200, c = {}) {
+  return ne(
+    le(m, c),
+    a
   );
 }
-function oe(l, d, s = {}) {
-  if (!(l != null && l[d]))
+function ae(a, m, c = {}) {
+  if (!(a != null && a[m]))
     throw new Error("The refine must be provided with valid props and key.");
-  const o = v(() => l[d]), m = v(() => !!o.value.sort), u = v(() => !!o.value.search), i = v(() => !!o.value.match), h = v(
+  const i = v(() => a[m]), p = v(() => !!i.value._sort_key), u = v(() => !!i.value._search_key), s = v(() => !!i.value._match_key), r = v(
     () => {
-      var e;
-      return (e = o.value.filters) == null ? void 0 : e.map((n) => ({
+      var t;
+      return (t = i.value.filters) == null ? void 0 : t.map((n) => ({
         ...n,
-        apply: (a, p = {}) => P(n, a, p),
-        clear: (a = {}) => C(n, a),
-        bind: () => G(n.name)
+        apply: (o, e = {}) => A(n, o, e),
+        clear: (o = {}) => $(n, o),
+        bind: () => C(n.name)
       }));
     }
   ), x = v(
     () => {
-      var e;
-      return (e = o.value.sorts) == null ? void 0 : e.map((n) => ({
+      var t;
+      return (t = i.value.sorts) == null ? void 0 : t.map((n) => ({
         ...n,
-        apply: (a = {}) => F(n, n.direction, a),
-        clear: (a = {}) => O(a),
-        bind: () => K(n)
+        apply: (o = {}) => g(n, n.direction, o),
+        clear: (o = {}) => D(o),
+        bind: () => O(n)
       }));
     }
-  ), w = v(
+  ), k = v(
     () => {
-      var e;
-      return (e = o.value.searches) == null ? void 0 : e.map((n) => ({
+      var t;
+      return (t = i.value.searches) == null ? void 0 : t.map((n) => ({
         ...n,
-        apply: (a = {}) => A(n, a),
-        clear: (a = {}) => A(n, a),
-        bind: () => q(n)
+        apply: (o = {}) => F(n, o),
+        clear: (o = {}) => F(n, o),
+        bind: () => G(n)
       }));
     }
-  ), k = v(
-    () => h.value.filter(({ active: e }) => e)
-  ), f = v(
-    () => x.value.find(({ active: e }) => e)
-  ), y = v(
-    () => w.value.filter(({ active: e }) => e)
+  ), _ = v(
+    () => r.value.filter(({ active: t }) => t)
+  ), d = v(
+    () => x.value.find(({ active: t }) => t)
+  ), h = v(
+    () => k.value.filter(({ active: t }) => t)
   );
-  function j(e) {
-    return Array.isArray(e) ? e.join(o.value.delimiter) : e;
+  function P(t) {
+    return Array.isArray(t) ? t.join(i.value._delimiter) : t;
   }
-  function T(e) {
-    return typeof e != "string" ? e : e.trim().replace(/\s+/g, "+");
+  function L(t) {
+    return typeof t != "string" ? t : t.trim().replace(/\s+/g, "+");
   }
-  function V(e) {
-    if (!["", null, void 0, []].includes(e))
-      return e;
+  function V(t) {
+    if (!["", null, void 0, []].includes(t))
+      return t;
   }
-  function $(e) {
-    return [j, T, V].reduce(
-      (n, a) => a(n),
-      e
+  function W(t) {
+    return [P, L, V].reduce(
+      (n, o) => o(n),
+      t
     );
   }
-  function B(e, n) {
-    return n = Array.isArray(n) ? n : [n], n.includes(e) ? n.filter((a) => a !== e) : [...n, e];
+  function z(t, n) {
+    return n = Array.isArray(n) ? n : [n], n.includes(t) ? n.filter((o) => o !== t) : [...n, t];
   }
-  function M(e) {
-    return typeof e != "string" ? e : h.value.find(({ name: n }) => n === e);
+  function R(t) {
+    return typeof t != "string" ? t : r.value.find(({ name: n }) => n === t);
   }
-  function R(e, n = null) {
-    return typeof e != "string" ? e : x.value.find(
-      ({ name: a, direction: p }) => a === e && p === n
+  function T(t, n = null) {
+    return typeof t != "string" ? t : x.value.find(
+      ({ name: o, direction: e }) => o === t && e === n
     );
   }
-  function U(e) {
-    return typeof e != "string" ? e : w.value.find(({ name: n }) => n === e);
+  function j(t) {
+    return typeof t != "string" ? t : k.value.find(({ name: n }) => n === t);
   }
-  function J(e) {
-    return e ? typeof e == "string" ? k.value.some((n) => n.name === e) : e.active : !!k.value.length;
+  function q(t) {
+    return t ? typeof t == "string" ? _.value.some((n) => n.name === t) : t.active : !!_.value.length;
   }
-  function N(e) {
+  function H(t) {
     var n;
-    return e ? typeof e == "string" ? ((n = f.value) == null ? void 0 : n.name) === e : e.active : !!f.value;
+    return t ? typeof t == "string" ? ((n = d.value) == null ? void 0 : n.name) === t : t.active : !!d.value;
   }
-  function I(e) {
+  function y(t) {
     var n;
-    return e ? typeof e == "string" ? (n = y.value) == null ? void 0 : n.some((a) => a.name === e) : e.active : !!o.value.term;
+    return t ? typeof t == "string" ? (n = h.value) == null ? void 0 : n.some((o) => o.name === t) : t.active : !!i.value.term;
   }
-  function b(e, n = {}) {
-    const a = Object.fromEntries(
-      Object.entries(e).map(([p, t]) => [p, $(t)])
+  function B(t, n = {}) {
+    const o = Object.fromEntries(
+      Object.entries(t).map(([e, l]) => [e, W(l)])
     );
-    S.reload({
-      ...s,
+    b.reload({
+      ...c,
       ...n,
-      data: a
+      data: o
     });
   }
-  function P(e, n, a = {}) {
-    const p = M(e);
-    if (!p) return console.warn(`Filter [${e}] does not exist.`);
-    S.reload({
-      ...s,
-      ...a,
+  function A(t, n, o = {}) {
+    const e = R(t);
+    if (!e) return console.warn(`Filter [${t}] does not exist.`);
+    b.reload({
+      ...c,
+      ...o,
       data: {
-        [p.name]: $(n)
+        [e.name]: W(n)
       }
     });
   }
-  function F(e, n = null, a = {}) {
-    if (!m.value)
+  function g(t, n = null, o = {}) {
+    if (!p.value)
       return console.warn("Refine cannot perform sorting.");
-    const p = R(e, n);
-    if (!p) return console.warn(`Sort [${e}] does not exist.`);
-    S.reload({
-      ...s,
-      ...a,
+    const e = T(t, n);
+    if (!e) return console.warn(`Sort [${t}] does not exist.`);
+    b.reload({
+      ...c,
+      ...o,
       data: {
-        [o.value.sort]: V(p.next)
+        [i.value._sort_key]: V(e.next)
       }
     });
   }
-  function g(e, n = {}) {
+  function w(t, n = {}) {
     if (!u.value)
       return console.warn("Refine cannot perform searching.");
-    e = [T, V].reduce(
-      (a, p) => p(a),
-      e
-    ), S.reload({
-      ...s,
+    t = [L, V].reduce(
+      (o, e) => e(o),
+      t
+    ), b.reload({
+      ...c,
       ...n,
       data: {
-        [o.value.search]: e
+        [i.value._search_key]: t
       }
     });
   }
-  function A(e, n = {}) {
-    if (!i.value || !u.value)
+  function F(t, n = {}) {
+    if (!s.value || !u.value)
       return console.warn("Refine cannot perform matching.");
-    const a = U(e);
-    if (!a) return console.warn(`Match [${e}] does not exist.`);
-    const p = B(
-      a.name,
-      y.value.map(({ name: t }) => t)
+    const o = j(t);
+    if (!o) return console.warn(`Match [${t}] does not exist.`);
+    const e = z(
+      o.name,
+      h.value.map(({ name: l }) => l)
     );
-    S.reload({
-      ...s,
+    b.reload({
+      ...c,
       ...n,
       data: {
-        [o.value.match]: j(p)
+        [i.value._match_key]: P(e)
       }
     });
   }
-  function C(e, n = {}) {
-    if (e) return P(e, null, n);
-    S.reload({
-      ...s,
+  function $(t, n = {}) {
+    if (t) return A(t, null, n);
+    b.reload({
+      ...c,
       ...n,
       data: Object.fromEntries(
-        k.value.map(({ name: a }) => [a, null])
+        _.value.map(({ name: o }) => [o, null])
       )
     });
   }
-  function O(e = {}) {
-    if (!m.value)
+  function D(t = {}) {
+    if (!p.value)
       return console.warn("Refine cannot perform sorting.");
-    S.reload({
-      ...s,
-      ...e,
+    b.reload({
+      ...c,
+      ...t,
       data: {
-        [o.value.sort]: null
+        [i.value._sort_key]: null
       }
     });
   }
-  function W(e = {}) {
-    g(null, e);
+  function I(t = {}) {
+    w(null, t);
   }
-  function z(e = {}) {
-    if (!i.value)
+  function M(t = {}) {
+    if (!s.value)
       return console.warn("Refine cannot perform matching.");
-    S.reload({
-      ...s,
-      ...e,
+    b.reload({
+      ...c,
+      ...t,
       data: {
-        [o.value.match]: null
+        [i.value._match_key]: null
       }
     });
   }
-  function E(e = {}) {
+  function U(t = {}) {
     var n;
-    S.reload({
-      ...s,
-      ...e,
+    b.reload({
+      ...c,
+      ...t,
       data: {
-        [o.value.search ?? ""]: void 0,
-        [o.value.sort ?? ""]: void 0,
-        [o.value.match ?? ""]: void 0,
+        [i.value._search_key ?? ""]: void 0,
+        [i.value._sort_key ?? ""]: void 0,
+        [i.value._match_key ?? ""]: void 0,
         ...Object.fromEntries(
-          ((n = o.value.filters) == null ? void 0 : n.map((a) => [
-            a.name,
+          ((n = i.value.filters) == null ? void 0 : n.map((o) => [
+            o.name,
             void 0
           ])) ?? []
         )
       }
     });
   }
-  function G(e, n = {}) {
-    const a = M(e);
-    if (!a) return console.warn(`Filter [${e}] does not exist.`);
+  function C(t, n = {}) {
+    const o = R(t);
+    if (!o) return console.warn(`Filter [${t}] does not exist.`);
     const {
-      debounce: p = 250,
-      transform: t = (c) => c,
-      ...r
+      debounce: e = 150,
+      transform: l = (S) => S,
+      ...f
     } = n;
     return {
-      "onUpdate:modelValue": H((c) => {
-        P(a, t(c), r);
-      }, p),
-      modelValue: a.value
+      "onUpdate:modelValue": K((S) => {
+        A(o, l(S), f);
+      }, e),
+      modelValue: o.value
     };
   }
-  function K(e, n = {}) {
-    const a = R(e);
-    if (!a) return console.warn(`Sort [${e}] does not exist.`);
-    const { debounce: p = 0, transform: t, ...r } = n;
+  function O(t, n = {}) {
+    if (!p.value)
+      return console.warn("Refine cannot perform sorting.");
+    const o = T(t);
+    if (!o) return console.warn(`Sort [${t}] does not exist.`);
+    const { debounce: e = 0, transform: l, ...f } = n;
     return {
-      onClick: H(() => {
-        var c;
-        F(a, (c = f.value) == null ? void 0 : c.direction, r);
-      }, p)
+      onClick: K(() => {
+        var S;
+        g(o, (S = d.value) == null ? void 0 : S.direction, f);
+      }, e)
     };
   }
-  function X(e = {}) {
-    const { debounce: n = 700, transform: a, ...p } = e;
+  function J(t = {}) {
+    if (!u.value)
+      return console.warn("Refine cannot perform searching.");
+    const { debounce: n = 700, transform: o, ...e } = t;
     return {
-      "onUpdate:modelValue": H(
-        (t) => {
-          g(t, p);
+      "onUpdate:modelValue": K(
+        (l) => {
+          w(l, e);
         },
         n
       ),
-      modelValue: o.value.term ?? ""
+      modelValue: i.value.term ?? ""
     };
   }
-  function q(e, n = {}) {
-    const a = U(e);
-    if (!a) return console.warn(`Match [${e}] does not exist.`);
-    const { debounce: p = 0, transform: t, ...r } = n;
+  function G(t, n = {}) {
+    if (!s.value)
+      return console.warn("Refine cannot perform matching.");
+    const o = j(t);
+    if (!o) return console.warn(`Match [${t}] does not exist.`);
+    const { debounce: e = 0, transform: l, ...f } = n;
     return {
-      "onUpdate:modelValue": H((c) => {
-        A(c, r);
-      }, p),
-      modelValue: I(a),
-      value: a.name
+      "onUpdate:modelValue": K((S) => {
+        F(S, f);
+      }, e),
+      modelValue: y(o),
+      value: o.name
     };
   }
   return Z({
-    filters: h,
+    filters: r,
     sorts: x,
-    searches: w,
-    currentFilters: k,
-    currentSort: f,
-    currentSearches: y,
-    isSortable: m,
+    searches: k,
+    currentFilters: _,
+    currentSort: d,
+    currentSearches: h,
+    isSortable: p,
     isSearchable: u,
-    isMatchable: i,
-    isFiltering: J,
-    isSorting: N,
-    isSearching: I,
-    getFilter: M,
-    getSort: R,
-    getSearch: U,
-    apply: b,
-    applyFilter: P,
-    applySort: F,
-    applySearch: g,
-    applyMatch: A,
-    clearFilter: C,
-    clearSort: O,
-    clearSearch: W,
-    clearMatch: z,
-    reset: E,
-    bindFilter: G,
-    bindSort: K,
-    bindSearch: X,
-    bindMatch: q,
-    stringValue: T,
+    isMatchable: s,
+    isFiltering: q,
+    isSorting: H,
+    isSearching: y,
+    getFilter: R,
+    getSort: T,
+    getSearch: j,
+    apply: B,
+    applyFilter: A,
+    applySort: g,
+    applySearch: w,
+    applyMatch: F,
+    clearFilter: $,
+    clearSort: D,
+    clearSearch: I,
+    clearMatch: M,
+    reset: U,
+    bindFilter: C,
+    bindSort: O,
+    bindSearch: J,
+    bindMatch: G,
+    stringValue: L,
     omitValue: V,
-    toggleValue: B,
-    delimitArray: j
+    toggleValue: z,
+    delimitArray: P
   });
 }
-function ce(l, d, s = {}) {
-  if (!(l != null && l[d]))
+function ue(a, m, c = {}) {
+  if (!(a != null && a[m]))
     throw new Error("The table must be provided with valid props and key.");
-  const { recordOperations: o = {}, ...m } = {
-    only: [...s.only ?? [], d.toString()],
-    ...s
-  }, u = v(() => l[d]), i = le(), h = oe(l, d, m), x = v(() => u.value.id ?? null), w = v(() => u.value.meta), k = v(() => u.value.views ?? []), f = v(() => u.value.emptyState ?? null), y = v(() => u.value.placeholder ?? null), j = v(() => !!u.value.emptyState), T = v(() => !!u.value.page && !!u.value.record), V = v(() => !!u.value.column), $ = v(
-    () => u.value.columns.filter(({ active: t, hidden: r }) => t && !r).map((t) => {
-      var r;
+  const { recordOperations: i = {}, ...p } = {
+    only: [...c.only ?? [], m.toString()],
+    ...c
+  }, u = v(() => a[m]), s = te(), r = ae(a, m, p), x = v(() => u.value.meta), k = v(() => u.value.views ?? []), _ = v(() => u.value.state ?? null), d = v(() => u.value.placeholder ?? null), h = v(() => !!u.value.state), P = v(
+    () => !!u.value._page_key && !!u.value._record_key
+  ), L = v(() => !!u.value._column_key), V = v(
+    () => u.value.columns.filter(({ active: e, hidden: l }) => e && !l).map((e) => {
+      var l;
       return {
-        ...t,
-        isSorting: !!((r = t.sort) != null && r.active),
-        toggleSort: (c = {}) => h.applySort(t.sort, null, c)
+        ...e,
+        isSorting: !!((l = e.sort) != null && l.active),
+        toggleSort: (f = {}) => r.applySort(e.sort, null, f)
       };
     })
-  ), B = v(
-    () => u.value.columns.filter(({ hidden: t }) => !t).map((t) => ({
-      ...t,
-      toggle: (r = {}) => e(t.name, r)
+  ), W = v(
+    () => u.value.columns.filter(({ hidden: e }) => !e).map((e) => ({
+      ...e,
+      toggle: (l = {}) => G(e.name, l)
     }))
-  ), M = v(
-    () => u.value.records.map((t) => ({
+  ), z = v(
+    () => u.value.records.map((e) => ({
+      ...e,
       /** The operations available for the record */
-      operations: z(t.operations),
-      /** The classes to apply to the record */
-      class: t.class ?? null,
+      operations: e.operations.map((l) => ({
+        ...l,
+        execute: (f = {}) => U(l, e, f)
+      })),
+      /** Determine if the record is selected */
+      selected: s.selected(g(e)),
       /** Perform this operation when the record is clicked */
-      default: (r = {}) => {
-        const c = t.operations.find(
-          ({ default: L }) => L
+      default: (l = {}) => {
+        const f = e.operations.find(
+          ({ default: S }) => S
         );
-        c && G(c, t, r);
+        f && U(f, e, l);
       },
       /** Selects this record */
-      select: () => i.select(g(t)),
+      select: () => s.select(g(e)),
       /** Deselects this record */
-      deselect: () => i.deselect(g(t)),
+      deselect: () => s.deselect(g(e)),
       /** Toggles the selection of this record */
-      toggle: () => i.toggle(g(t)),
-      /** Determine if the record is selected */
-      selected: i.selected(g(t)),
+      toggle: () => s.toggle(g(e)),
       /** Bind the record to a checkbox */
-      bind: () => i.bind(g(t)),
+      bind: () => s.bind(g(e)),
       /** Get the entry of the record for the column */
-      entry: (r) => A(t, r),
+      entry: (l) => w(e, l),
       /** Get the value of the record for the column */
-      value: (r) => C(t, r),
+      value: (l) => F(e, l),
       /** Get the extra data of the record for the column */
-      extra: (r) => O(t, r)
+      extra: (l) => $(e, l)
     }))
-  ), R = v(() => !!u.value.operations.inline), U = v(() => z(u.value.operations.bulk)), J = v(() => z(u.value.operations.page)), N = v(
-    () => u.value.pages.find(({ active: t }) => t)
-  ), I = v(() => u.value.pages), b = v(() => ({
+  ), R = v(() => !!u.value.operations.inline), T = v(
+    () => u.value.operations.bulk.map((e) => ({
+      ...e,
+      execute: (l = {}) => C(e, l)
+    }))
+  ), j = v(
+    () => u.value.operations.page.map((e) => ({
+      ...e,
+      execute: (l = {}) => O(e, l)
+    }))
+  ), q = v(
+    () => u.value.pages.find(({ active: e }) => e)
+  ), H = v(() => u.value.pages), y = v(() => ({
     ...u.value.paginate,
-    next: (t = {}) => {
-      "nextLink" in b.value && b.value.nextLink && E(b.value.nextLink, t);
+    next: (e = {}) => {
+      "nextLink" in y.value && y.value.nextLink && M(y.value.nextLink, e);
     },
-    previous: (t = {}) => {
-      "prevLink" in b.value && b.value.prevLink && E(b.value.prevLink, t);
+    previous: (e = {}) => {
+      "prevLink" in y.value && y.value.prevLink && M(y.value.prevLink, e);
     },
-    first: (t = {}) => {
-      "firstLink" in b.value && b.value.firstLink && E(b.value.firstLink, t);
+    first: (e = {}) => {
+      "firstLink" in y.value && y.value.firstLink && M(y.value.firstLink, e);
     },
-    last: (t = {}) => {
-      "lastLink" in b.value && b.value.lastLink && E(b.value.lastLink, t);
+    last: (e = {}) => {
+      "lastLink" in y.value && y.value.lastLink && M(y.value.lastLink, e);
     },
     ..."links" in u.value.paginate && u.value.paginate.links ? {
-      links: u.value.paginate.links.map((t) => ({
-        ...t,
-        navigate: (r = {}) => t.url && E(t.url, r)
+      links: u.value.paginate.links.map((e) => ({
+        ...e,
+        navigate: (l = {}) => e.url && M(e.url, l)
       }))
     } : {}
-  })), P = v(
+  })), B = v(
     () => u.value.records.length > 0 && u.value.records.every(
-      (t) => i.selected(g(t))
+      (e) => s.selected(g(e))
     )
   );
-  function F(t) {
-    return typeof t == "string" ? t : t.name;
+  function A(e) {
+    return typeof e == "string" ? e : e.name;
   }
-  function g(t) {
-    var r;
-    return (r = A(t, u.value.key)) == null ? void 0 : r.v;
+  function g(e) {
+    return e._key;
   }
-  function A(t, r) {
-    const c = F(r);
-    return c in t && c !== "classes" ? t[c] : null;
+  function w(e, l) {
+    const f = A(l);
+    return e[f];
   }
-  function C(t, r) {
-    var c;
-    return ((c = A(t, r)) == null ? void 0 : c.v) ?? null;
+  function F(e, l) {
+    var f;
+    return ((f = w(e, l)) == null ? void 0 : f.v) ?? null;
   }
-  function O(t, r) {
-    var c;
-    return (c = A(t, r)) == null ? void 0 : c.e;
+  function $(e, l) {
+    var f;
+    return (f = w(e, l)) == null ? void 0 : f.e;
   }
-  function W(t, r = {}, c = {}) {
-    return _(t, u.value.endpoint, x.value, r, {
-      ...m,
-      ...c
-    });
+  function D(e) {
+    return { id: g(e) };
   }
-  function z(t) {
-    return ne(
-      t,
-      u.value.endpoint,
-      x.value,
-      m
-    );
+  function I() {
+    return {
+      all: s.selection.value.all,
+      only: Array.from(s.selection.value.only),
+      except: Array.from(s.selection.value.except)
+    };
   }
-  function E(t, r = {}) {
-    S.visit(t, {
+  function M(e, l = {}) {
+    b.visit(e, {
       preserveScroll: !0,
       preserveState: !0,
-      ...m,
-      ...r,
+      ...p,
+      ...l,
       method: "get"
     });
   }
-  function G(t, r, c = {}) {
-    var D;
-    W(
-      t,
-      {
-        record: g(r)
-      },
-      c
-    ) || (D = o == null ? void 0 : o[t.name]) == null || D.call(o, r);
-  }
-  function K(t, r = {}) {
-    W(
-      t,
-      {
-        all: i.selection.value.all,
-        only: Array.from(i.selection.value.only),
-        except: Array.from(i.selection.value.except)
-      },
-      {
-        ...r,
-        onSuccess: (c) => {
-          var L;
-          (L = r.onSuccess) == null || L.call(r, c), t.keepSelected || i.deselectAll();
-        }
+  function U(e, l, f = {}) {
+    var E;
+    N(e, D(l), {
+      ...c,
+      ...f
+    }) || (E = i == null ? void 0 : i[e.name]) == null || E.call(i, l);
+  }
+  function C(e, l = {}) {
+    return N(e, I(), {
+      ...c,
+      ...l,
+      onSuccess: (f) => {
+        var S, E;
+        (S = l.onSuccess) == null || S.call(l, f), (E = c.onSuccess) == null || E.call(c, f), e.keep || s.deselectAll();
       }
-    );
+    });
   }
-  function X(t, r = {}, c = {}) {
-    return W(t, r, c);
+  function O(e, l = {}, f = {}) {
+    return N(e, l, { ...c, ...f });
   }
-  function q(t, r = {}) {
-    if (!T.value)
+  function J(e, l = {}) {
+    if (!P.value)
       return console.warn("The table does not support pagination changes.");
-    S.reload({
-      ...m,
-      ...r,
+    b.reload({
+      ...p,
+      ...l,
       data: {
-        [u.value.record]: t.value,
-        [u.value.page]: void 0
+        [u.value._record_key]: e.value,
+        [u.value._page_key]: void 0
       }
     });
   }
-  function e(t, r = {}) {
-    if (!V.value)
+  function G(e, l = {}) {
+    if (!L.value)
       return console.warn("The table does not support column toggling.");
-    const c = F(t);
-    if (!c) return console.log(`Column [${t}] does not exist.`);
-    const L = h.toggleValue(
-      c,
-      $.value.map(({ name: D }) => D)
+    const f = A(e);
+    if (!f) return console.log(`Column [${e}] does not exist.`);
+    const S = r.toggleValue(
+      f,
+      V.value.map(({ name: E }) => E)
     );
-    S.reload({
-      ...m,
-      ...r,
+    b.reload({
+      ...p,
+      ...l,
       data: {
-        [u.value.column]: h.delimitArray(L)
+        [u.value._column_key]: r.delimitArray(S)
       }
     });
   }
-  function n() {
-    i.select(
+  function t() {
+    s.select(
       ...u.value.records.map(
-        (t) => g(t)
+        (e) => g(e)
       )
     );
   }
-  function a() {
-    i.deselect(
+  function n() {
+    s.deselect(
       ...u.value.records.map(
-        (t) => g(t)
+        (e) => g(e)
       )
     );
   }
-  function p() {
+  function o() {
     return {
-      "onUpdate:modelValue": (t) => {
-        t ? n() : a();
+      "onUpdate:modelValue": (e) => {
+        e ? t() : n();
       },
-      modelValue: P.value
+      modelValue: B.value
     };
   }
   return Z({
-    /** The identifier of the table */
-    id: x,
     /** Table-specific metadata */
-    meta: w,
+    meta: x,
     /** The views for the table */
     views: k,
     /** The empty state for the table */
-    emptyState: f,
+    emptyState: _,
     /** The placeholder for the search term.*/
-    placeholder: y,
+    placeholder: d,
     /** Whether the table is empty */
-    isEmpty: j,
+    isEmpty: h,
     /** Whether the table supports changing the number of records to display per page */
-    isPageable: T,
+    isPageable: P,
     /** Whether the table supports toggling columns */
-    isToggleable: V,
+    isToggleable: L,
     /** Get the entry of the record for the column */
-    getEntry: A,
+    getEntry: w,
     /** Get the value of the record for the column */
-    getValue: C,
+    getValue: F,
     /** Get the extra data of the record for the column */
-    getExtra: O,
+    getExtra: $,
     /** Retrieve a record's identifier */
     getRecordKey: g,
     /** The heading columns for the table */
-    headings: $,
+    headings: V,
     /** All of the table's columns */
-    columns: B,
+    columns: W,
     /** The records of the table */
-    records: M,
+    records: z,
     /** Whether the table has record operations */
     inline: R,
     /** The available bulk operations */
-    bulk: U,
+    bulk: T,
     /** The available page operations */
-    page: J,
+    page: j,
     /** The available number of records to display per page */
-    pages: I,
+    pages: H,
     /** The current record per page item */
-    currentPage: N,
+    currentPage: q,
     /** The pagination metadata */
-    paginator: b,
+    paginator: y,
     /** Execute an inline operation */
-    executeInline: G,
+    executeInline: U,
     /** Execute a bulk operation */
-    executeBulk: K,
+    executeBulk: C,
     /** Execute a page operation */
-    executePage: X,
+    executePage: O,
     /** Apply a new page by changing the number of records to display */
-    applyPage: q,
+    applyPage: J,
     /** The current selection of records */
-    selection: i.selection,
+    selection: s.selection,
     /** Select the given records */
-    select: (t) => i.select(g(t)),
+    select: (e) => s.select(g(e)),
     /** Deselect the given records */
-    deselect: (t) => i.deselect(g(t)),
+    deselect: (e) => s.deselect(g(e)),
     /** Select records on the current page */
-    selectPage: n,
+    selectPage: t,
     /** Deselect records on the current page */
-    deselectPage: a,
+    deselectPage: n,
     /** Toggle the selection of the given records */
-    toggle: (t) => i.toggle(g(t)),
+    toggle: (e) => s.toggle(g(e)),
     /** Determine if the given record is selected */
-    selected: (t) => i.selected(g(t)),
+    selected: (e) => s.selected(g(e)),
     /** Select all records */
-    selectAll: i.selectAll,
+    selectAll: s.selectAll,
     /** Deselect all records */
-    deselectAll: i.deselectAll,
+    deselectAll: s.deselectAll,
     /** Whether all records on the current page are selected */
-    isPageSelected: P,
+    isPageSelected: B,
     /** Determine if any records are selected */
-    hasSelected: i.hasSelected,
+    hasSelected: s.hasSelected,
     /** Bind the given record to a checkbox */
-    bindCheckbox: (t) => i.bind(g(t)),
+    bindCheckbox: (e) => s.bind(g(e)),
     /** Bind the select all checkbox to the current page */
-    bindPage: p,
+    bindPage: o,
     /** Bind select all records to the checkbox */
-    bindAll: i.bindAll,
-    /** Include the sorts, filters, and search query */
-    ...h
+    bindAll: s.bindAll,
+    filters: r.filters,
+    sorts: r.sorts,
+    searches: r.searches,
+    currentFilters: r.currentFilters,
+    currentSort: r.currentSort,
+    currentSearches: r.currentSearches,
+    isSortable: r.isSortable,
+    isSearchable: r.isSearchable,
+    isMatchable: r.isMatchable,
+    isFiltering: r.isFiltering,
+    isSorting: r.isSorting,
+    isSearching: r.isSearching,
+    getFilter: r.getFilter,
+    getSort: r.getSort,
+    getSearch: r.getSearch,
+    apply: r.apply,
+    applyFilter: r.applyFilter,
+    applySort: r.applySort,
+    applySearch: r.applySearch,
+    applyMatch: r.applyMatch,
+    clearFilter: r.clearFilter,
+    clearSort: r.clearSort,
+    clearSearch: r.clearSearch,
+    clearMatch: r.clearMatch,
+    reset: r.reset,
+    bindFilter: r.bindFilter,
+    bindSort: r.bindSort,
+    bindSearch: r.bindSearch,
+    bindMatch: r.bindMatch,
+    stringValue: r.stringValue,
+    omitValue: r.omitValue,
+    toggleValue: r.toggleValue,
+    delimitArray: r.delimitArray
   });
 }
-function se(l, d) {
-  return l ? typeof l == "object" ? l.type === d : l === d : !1;
+function ce(a, m) {
+  return a ? typeof a == "object" ? a.type === m : a === m : !1;
 }
 export {
-  se as is,
-  ce as useTable
+  ce as is,
+  ue as useTable
 };