@honed/table 0.9.1 → 0.9.2

package/dist/index.es.js

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