@echolab-auto/echo-prodoc 0.1.0

package/vendor/@echolab/ui-frame/dist/composables/usePagination.d.ts

@@ -0,0 +1,37 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface UsePaginationOptions {
+    /** v-model current page */
+    modelValue: Ref<number>;
+    /** Total number of items */
+    total: Ref<number> | ComputedRef<number>;
+    /** Items per page */
+    pageSize?: Ref<number> | ComputedRef<number>;
+    /** Maximum visible page buttons */
+    maxVisiblePages?: Ref<number> | ComputedRef<number>;
+    /** Whether pagination is disabled */
+    disabled?: Ref<boolean>;
+}
+export interface UsePaginationReturn {
+    /** Total number of pages */
+    totalPages: ComputedRef<number>;
+    /** Current page (clamped) */
+    currentPage: ComputedRef<number>;
+    /** Array of visible page numbers and ellipsis markers */
+    visiblePages: ComputedRef<(number | 'prev-ellipsis' | 'next-ellipsis')[]>;
+    /** Change to a specific page */
+    changePage: (page: number) => void;
+    /** Go to previous page */
+    prevPage: () => void;
+    /** Go to next page */
+    nextPage: () => void;
+    /** Whether previous button should be disabled */
+    isPrevDisabled: ComputedRef<boolean>;
+    /** Whether next button should be disabled */
+    isNextDisabled: ComputedRef<boolean>;
+}
+/**
+ * Headless pagination — encapsulates page calculation, ellipsis logic,
+ * and page navigation. Use with your own UI rendering.
+ */
+export declare function usePagination(opts: UsePaginationOptions): UsePaginationReturn;

package/vendor/@echolab/ui-frame/dist/composables/usePagination.js

@@ -0,0 +1,40 @@
+import { computed as i } from "vue";
+function D(o) {
+  const { modelValue: f, total: g } = o, p = o.pageSize ?? i(() => 10), d = o.maxVisiblePages ?? i(() => 7), c = o.disabled ?? i(() => !1), u = i(() => Math.max(1, Math.ceil(g.value / p.value))), l = i(() => Math.min(Math.max(1, f.value), u.value));
+  function v(n) {
+    if (isNaN(n) || !isFinite(n)) return;
+    const e = Math.round(n);
+    c.value || e < 1 || e > u.value || e === l.value || (f.value = e);
+  }
+  function x() {
+    v(l.value - 1);
+  }
+  function P() {
+    v(l.value + 1);
+  }
+  const M = i(() => l.value <= 1 || c.value), b = i(() => l.value >= u.value || c.value), N = i(() => {
+    const n = d.value, e = u.value, h = l.value;
+    if (e <= n)
+      return Array.from({ length: e }, (r, V) => V + 1);
+    const m = Math.floor(n / 2);
+    let a = h - m, t = h + m;
+    a < 1 && (t += 1 - a, a = 1), t > e && (a -= t - e, t = e), a = Math.max(1, a), t = Math.min(e, t);
+    const s = [];
+    a > 1 && s.push(1), a > 2 && s.push("prev-ellipsis");
+    for (let r = a; r <= t; r++) s.push(r);
+    return t < e - 1 && s.push("next-ellipsis"), t < e && s.push(e), s;
+  });
+  return {
+    totalPages: u,
+    currentPage: l,
+    visiblePages: N,
+    changePage: v,
+    prevPage: x,
+    nextPage: P,
+    isPrevDisabled: M,
+    isNextDisabled: b
+  };
+}
+export {
+  D as usePagination
+};

package/vendor/@echolab/ui-frame/dist/composables/usePopover.d.ts

@@ -0,0 +1,38 @@
+import { Ref } from 'vue';
+
+export type PopoverPosition = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+export type PopoverTrigger = 'click' | 'hover' | 'focus' | 'manual';
+export interface UsePopoverOptions {
+    /** Preferred position of the popover relative to the trigger */
+    position?: Ref<PopoverPosition>;
+    /** How the popover is triggered */
+    trigger?: Ref<PopoverTrigger>;
+    /** Whether the popover is disabled */
+    disabled?: Ref<boolean>;
+    /** Offset from the trigger element in px */
+    offset?: Ref<number> | number;
+    /** Delay before showing (ms, for hover trigger) */
+    delay?: number;
+}
+export interface UsePopoverReturn {
+    /** Whether the popover is currently open */
+    isOpen: Ref<boolean>;
+    /** Show the popover */
+    show: () => void;
+    /** Hide the popover */
+    hide: () => void;
+    /** Toggle visibility (for click trigger) */
+    toggle: () => void;
+    /** Handle keydown (Escape to close, Tab to dismiss) */
+    handleKeydown: (event: KeyboardEvent) => void;
+    /** Handle click outside detection — call from the popover content wrapper */
+    handleClickOutside: (event: MouseEvent) => void;
+}
+/**
+ * Headless popover — encapsulates open/close, trigger modes (click/hover/focus/manual),
+ * boundary-aware positioning helpers, keyboard dismissal, and click-outside detection.
+ *
+ * Use with your own UI rendering. Position calculation and DOM measurement
+ * are the consumer's responsibility; this composable provides the state machine.
+ */
+export declare function usePopover(opts?: UsePopoverOptions): UsePopoverReturn;

package/vendor/@echolab/ui-frame/dist/composables/usePopover.js

@@ -0,0 +1,54 @@
+import { ref as k, onMounted as y, onBeforeUnmount as h, nextTick as p } from "vue";
+function C(r = {}) {
+  const { trigger: i, disabled: e } = r, v = r.delay ?? 150, n = k(!1);
+  let u = null, t = null;
+  const m = (i == null ? void 0 : i.value) ?? "click";
+  function f() {
+    e != null && e.value || (t && (clearTimeout(t), t = null), m === "hover" ? u = setTimeout(() => {
+      n.value = !0;
+    }, v) : n.value = !0);
+  }
+  function c() {
+    u && (clearTimeout(u), u = null), t = setTimeout(() => {
+      n.value = !1;
+    }, 100);
+  }
+  function s() {
+    e != null && e.value || (n.value ? c() : f());
+  }
+  function d(l) {
+    if (!(e != null && e.value)) {
+      if (l.key === "Escape") {
+        n.value = !1;
+        return;
+      }
+      l.key === "Tab" && n.value && p(() => {
+        typeof document > "u" || (n.value = !1);
+      });
+    }
+  }
+  function a(l) {
+    n.value;
+  }
+  let o = null;
+  function T(l) {
+    !n.value || e != null && e.value || a();
+  }
+  return y(() => {
+    typeof document > "u" || (o = (l) => {
+      T();
+    }, document.addEventListener("click", o, !0));
+  }), h(() => {
+    u && (clearTimeout(u), u = null), t && (clearTimeout(t), t = null), typeof document < "u" && o && document.removeEventListener("click", o, !0);
+  }), {
+    isOpen: n,
+    show: f,
+    hide: c,
+    toggle: s,
+    handleKeydown: d,
+    handleClickOutside: a
+  };
+}
+export {
+  C as usePopover
+};

package/vendor/@echolab/ui-frame/dist/composables/useSelect.d.ts

@@ -0,0 +1,30 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface SelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface UseSelectOptions {
+    /** v-model value */
+    modelValue: Ref<string | number | undefined>;
+    /** Available options */
+    options: Ref<SelectOption[]> | ComputedRef<SelectOption[]>;
+    /** Whether the select is disabled */
+    disabled?: Ref<boolean>;
+}
+export interface UseSelectReturn {
+    isOpen: Ref<boolean>;
+    selectedOption: ComputedRef<SelectOption | undefined>;
+    toggleOpen: () => void;
+    close: () => void;
+    selectOption: (option: SelectOption) => void;
+    clearValue: (value?: string | number) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    handleBlur: (relatedTarget: EventTarget | null, currentTarget: HTMLElement) => void;
+}
+/**
+ * Headless select — encapsulates open/close, keyboard navigation, and
+ * option selection logic without any rendering. Use with your own UI.
+ */
+export declare function useSelect(opts: UseSelectOptions): UseSelectReturn;

package/vendor/@echolab/ui-frame/dist/composables/useSelect.js

@@ -0,0 +1,76 @@
+import { ref as y, computed as T } from "vue";
+function K(h) {
+  const { modelValue: r, options: p, disabled: u } = h, t = y(!1), s = y("");
+  let f = null;
+  function i() {
+    s.value = "", f && (clearTimeout(f), f = null);
+  }
+  function d(e) {
+    s.value += e.toLowerCase(), f && clearTimeout(f), f = setTimeout(() => {
+      s.value = "";
+    }, 500);
+    const l = p.value.filter((c) => !c.disabled), n = s.value;
+    let a = l.find((c) => c.label.toLowerCase().startsWith(n));
+    a || (a = l.find((c) => c.label.toLowerCase().includes(n))), a && o(a);
+  }
+  const m = T(() => p.value.find((e) => e.value === r.value));
+  function v() {
+    u != null && u.value || (t.value = !t.value);
+  }
+  function k() {
+    t.value = !1, i();
+  }
+  function o(e) {
+    e.disabled || u != null && u.value || (r.value = e.value);
+  }
+  function g(e) {
+    e.disabled || u != null && u.value || (r.value = e.value, t.value = !1, i());
+  }
+  function w(e) {
+    u != null && u.value || (r.value = e, t.value = !1, i());
+  }
+  function D(e) {
+    if (u != null && u.value) return;
+    if (e.key === "Escape") {
+      t.value = !1, i();
+      return;
+    }
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault(), v();
+      return;
+    }
+    if (e.key === "ArrowDown" && !t.value) {
+      e.preventDefault(), t.value = !0;
+      return;
+    }
+    if (!t.value) return;
+    const l = p.value.filter((a) => !a.disabled);
+    if (l.length === 0) return;
+    const n = l.findIndex((a) => a.value === r.value);
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      const a = n + 1 < l.length ? l[n + 1] : l[0];
+      a && o(a);
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      const a = n - 1 >= 0 ? l[n - 1] : l[l.length - 1];
+      a && o(a);
+    } else e.key === "Home" ? (e.preventDefault(), l[0] && o(l[0])) : e.key === "End" ? (e.preventDefault(), l[l.length - 1] && o(l[l.length - 1])) : e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey && (e.preventDefault(), d(e.key));
+  }
+  function O(e, l) {
+    l.contains(e) || (t.value = !1, i());
+  }
+  return {
+    isOpen: t,
+    selectedOption: m,
+    toggleOpen: v,
+    close: k,
+    selectOption: g,
+    clearValue: w,
+    handleKeydown: D,
+    handleBlur: O
+  };
+}
+export {
+  K as useSelect
+};

package/vendor/@echolab/ui-frame/dist/composables/useSlider.d.ts

@@ -0,0 +1,39 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface UseSliderOptions {
+    /** v-model value — a writable Ref<number> */
+    modelValue: Ref<number>;
+    /** Minimum value */
+    min: number;
+    /** Maximum value */
+    max: number;
+    /** Step increment */
+    step: number;
+    /** Whether the slider is disabled */
+    disabled?: Ref<boolean>;
+    /** Whether the slider is vertical (default: false) */
+    vertical?: Ref<boolean>;
+}
+export interface UseSliderReturn {
+    /** Current slider value (computed from modelValue, clamped) */
+    sliderValue: ComputedRef<number>;
+    /** Value expressed as a percentage (0–100) */
+    percentage: ComputedRef<number>;
+    /** Programmatically set the slider value */
+    setValue: (value: number) => void;
+    /** Keyboard event handler */
+    handleKeydown: (event: KeyboardEvent) => void;
+    /** Whether the thumb is currently being dragged */
+    isDragging: Ref<boolean>;
+}
+/**
+ * Calculate a slider value from a coordinate (mouse / touch) relative to a
+ * track element. The caller is responsible for providing the track rect and
+ * the track size dimension.
+ */
+export declare function coordinateToValue(clientCoord: number, trackStart: number, trackSize: number, min: number, max: number, step: number, vertical: boolean): number;
+/**
+ * Headless slider — encapsulates value clamping, keyboard navigation, and
+ * a drag state without any rendering. Use with your own UI.
+ */
+export declare function useSlider(opts: UseSliderOptions): UseSliderReturn;

package/vendor/@echolab/ui-frame/dist/composables/useSlider.js

@@ -0,0 +1,79 @@
+import { ref as A, computed as h } from "vue";
+function f(n, t, e) {
+  return Math.min(Math.max(n, t), e);
+}
+function k(n, t, e) {
+  return e <= 0 ? n : Math.round((n - t) / e) * e + t;
+}
+function V(n, t, e, r, a, o, i) {
+  if (e <= 0) return r;
+  let u = (n - t) / e;
+  i && (u = 1 - u), u = f(u, 0, 1);
+  const p = r + u * (a - r);
+  return k(p, r, o);
+}
+function b(n) {
+  const { modelValue: t, min: e, max: r, step: a, disabled: o, vertical: i } = n, u = A(!1), p = h(() => f(t.value, e, r)), x = h(() => {
+    const c = r - e;
+    return c === 0 ? 0 : (p.value - e) / c * 100;
+  });
+  function s(c) {
+    if (o != null && o.value) return;
+    const d = f(c, e, r), m = k(d, e, a);
+    t.value = m;
+  }
+  function v(c) {
+    if (o != null && o.value) return;
+    const d = (i == null ? void 0 : i.value) ?? !1;
+    let m = !0;
+    const w = p.value;
+    switch (c.key) {
+      case "ArrowRight":
+      case "ArrowUp": {
+        const l = (d && c.key === "ArrowUp", a), g = f(w + l, e, r);
+        s(g);
+        break;
+      }
+      case "ArrowLeft":
+      case "ArrowDown": {
+        const g = f(w - a, e, r);
+        s(g);
+        break;
+      }
+      case "Home": {
+        s(e);
+        break;
+      }
+      case "End": {
+        s(r);
+        break;
+      }
+      case "PageUp": {
+        const l = Math.max(a * 10, (r - e) / 10);
+        s(f(w + l, e, r));
+        break;
+      }
+      case "PageDown": {
+        const l = Math.max(a * 10, (r - e) / 10);
+        s(f(w - l, e, r));
+        break;
+      }
+      default: {
+        m = !1;
+        break;
+      }
+    }
+    m && c.preventDefault();
+  }
+  return {
+    sliderValue: p,
+    percentage: x,
+    setValue: s,
+    handleKeydown: v,
+    isDragging: u
+  };
+}
+export {
+  V as coordinateToValue,
+  b as useSlider
+};

package/vendor/@echolab/ui-frame/dist/composables/useSteps.d.ts

@@ -0,0 +1,54 @@
+import { Ref, ComputedRef } from 'vue';
+
+/**
+ * Status of an individual step in the workflow.
+ * - `wait`: not yet reached
+ * - `process`: the current active step
+ * - `finish`: completed successfully
+ * - `error`: completed with an error
+ */
+export type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+/** Descriptor for a single step in a stepped workflow. */
+export interface StepItem {
+    /** Unique key for the step (used for identity and status mapping). */
+    key: string;
+    /** Display title for the step. */
+    title: string;
+    /** Optional description / subtitle for the step. */
+    description?: string;
+    /** Override the auto-computed status. When omitted the composable auto-assigns it. */
+    status?: StepStatus;
+}
+export interface UseStepsOptions {
+    /** Reactive array of step definitions. */
+    steps: Ref<StepItem[]> | ComputedRef<StepItem[]>;
+    /** Reactive 0-based index of the currently active step. */
+    current: Ref<number>;
+}
+export interface UseStepsReturn {
+    /** The current step item (computed from `current`). */
+    currentStep: ComputedRef<StepItem | undefined>;
+    /** Jump to a specific step by its 0-based index. */
+    setCurrent: (index: number) => void;
+    /** Advance to the next step. Optionally pass a `beforeNext` validator. */
+    next: (beforeNext?: () => boolean | Promise<boolean>) => Promise<void>;
+    /** Go back to the previous step. */
+    prev: () => void;
+    /** Manually override the status of a specific step. */
+    setStepStatus: (key: string, status: StepStatus) => void;
+}
+/**
+ * Headless steps composable — encapsulates step navigation, status auto-
+ * computation, and validation hooks.
+ *
+ * @example
+ * ```ts
+ * const steps = ref<StepItem[]>([
+ *   { key: '1', title: 'Step 1' },
+ *   { key: '2', title: 'Step 2' },
+ * ])
+ * const current = ref(0)
+ * const { currentStep, next, prev, setStepStatus } = useSteps({ steps, current })
+ * ```
+ */
+export declare function useSteps(opts: UseStepsOptions): UseStepsReturn;

package/vendor/@echolab/ui-frame/dist/composables/useSteps.js

@@ -0,0 +1,26 @@
+import { computed as f } from "vue";
+function p(a) {
+  const { steps: u, current: t } = a, r = /* @__PURE__ */ new Map(), c = f(() => u.value[t.value]);
+  function l(e) {
+    e < 0 || e >= u.value.length || e !== t.value && (t.value = e);
+  }
+  async function o(e) {
+    t.value >= u.value.length - 1 || e && !await e() || (t.value = t.value + 1);
+  }
+  function s() {
+    t.value <= 0 || (t.value = t.value - 1);
+  }
+  function v(e, n) {
+    r.set(e, n);
+  }
+  return {
+    currentStep: c,
+    setCurrent: l,
+    next: o,
+    prev: s,
+    setStepStatus: v
+  };
+}
+export {
+  p as useSteps
+};

package/vendor/@echolab/ui-frame/dist/composables/useTable.d.ts

@@ -0,0 +1,78 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface TableColumn {
+    key: string;
+    label: string;
+    width?: string | number;
+    minWidth?: string | number;
+    align?: 'left' | 'center' | 'right';
+    sortable?: boolean;
+    /** Custom sort function. Return > 0 if a > b. */
+    sorter?: (a: unknown, b: unknown) => number;
+    filterable?: boolean;
+    filters?: {
+        text: string;
+        value: unknown;
+    }[];
+    /** Custom filter function. Return true to keep the row. */
+    filter?: (rowValue: unknown, filterValue: unknown) => boolean;
+}
+export type SortDirection = 'ascend' | 'descend' | null;
+export interface SortState {
+    key: string;
+    direction: SortDirection;
+}
+export type SelectionMode = 'single' | 'multiple';
+export interface UseTableOptions {
+    data: Ref<Record<string, unknown>[]> | ComputedRef<Record<string, unknown>[]>;
+    columns: Ref<TableColumn[]> | ComputedRef<TableColumn[]>;
+    rowKey?: Ref<string> | ComputedRef<string>;
+    selectable?: Ref<boolean | SelectionMode>;
+    selectedKeys?: Ref<string[]>;
+    pagination?: {
+        enabled: Ref<boolean>;
+        pageSize: Ref<number>;
+        currentPage: Ref<number>;
+    };
+}
+export interface UseTableReturn {
+    /** Columns resolved with defaults */
+    resolvedColumns: ComputedRef<TableColumn[]>;
+    /** Display data after sort/filter/page */
+    displayData: ComputedRef<Record<string, unknown>[]>;
+    /** Total count after filter (before pagination) */
+    filteredTotal: ComputedRef<number>;
+    /** Current sort state */
+    sortState: Ref<SortState>;
+    /** Active filter values per column key */
+    filterState: Ref<Record<string, unknown[]>>;
+    /** Toggle sort for a column */
+    toggleSort: (key: string) => void;
+    /** Set sort explicitly */
+    setSort: (key: string, direction: SortDirection) => void;
+    /** Apply filters for a column */
+    setFilter: (key: string, values: unknown[]) => void;
+    /** Clear all filters */
+    clearFilters: () => void;
+    /** Whether row is selected */
+    isSelected: (rowKeyValue: string) => boolean;
+    /** Toggle row selection */
+    toggleSelect: (rowKeyValue: string) => void;
+    /** Select all visible rows */
+    selectAll: () => void;
+    /** Clear selection */
+    clearSelection: () => void;
+    /** Selected row keys */
+    selectedKeys: Ref<string[]>;
+    /** All row keys */
+    allKeys: ComputedRef<string[]>;
+    /** Whether all visible rows are selected */
+    isAllSelected: ComputedRef<boolean>;
+    /** Whether some (but not all) visible rows are selected */
+    isIndeterminate: ComputedRef<boolean>;
+}
+/**
+ * Headless table — encapsulates sort, filter, selection, and pagination logic.
+ * Use with your own UI rendering.
+ */
+export declare function useTable(opts: UseTableOptions): UseTableReturn;

package/vendor/@echolab/ui-frame/dist/composables/useTable.js

@@ -0,0 +1,103 @@
+import { ref as h, computed as i } from "vue";
+function B(u, s) {
+  return u == null && s == null ? 0 : u == null ? -1 : s == null ? 1 : typeof u == "number" && typeof s == "number" ? u - s : String(u).localeCompare(String(s));
+}
+function I(u, s) {
+  const o = u[s];
+  return o != null ? String(o) : "";
+}
+function q(u) {
+  const { data: s, columns: o } = u, F = u.rowKey ?? { value: "key" }, d = u.selectable ?? { value: !1 }, r = u.selectedKeys ?? h([]), c = h({ key: "", direction: null }), g = h({}), w = i(
+    () => o.value.map((e) => ({
+      align: "left",
+      ...e
+    }))
+  ), k = i(() => {
+    const e = [...s.value], { key: t, direction: l } = c.value;
+    if (!t || !l) return e;
+    const n = o.value.find((a) => a.key === t);
+    return n != null && n.sortable && e.sort((a, S) => {
+      const y = a[t], p = S[t], v = n.sorter ? n.sorter(y, p) : B(y, p);
+      return l === "ascend" ? v : -v;
+    }), e;
+  }), m = i(() => {
+    const e = g.value, t = Object.keys(e).filter((l) => {
+      var n;
+      return ((n = e[l]) == null ? void 0 : n.length) > 0;
+    });
+    return t.length === 0 ? k.value : k.value.filter((l) => {
+      for (const n of t) {
+        const a = o.value.find((v) => v.key === n);
+        if (!(a != null && a.filterable)) continue;
+        const S = l[n], y = e[n];
+        if (!(a.filter ? y.some((v) => a.filter(S, v)) : y.includes(S))) return !1;
+      }
+      return !0;
+    });
+  }), x = i(() => m.value.length), b = i(() => {
+    const e = u.pagination;
+    if (!e || !e.enabled.value) return m.value;
+    const t = (e.currentPage.value - 1) * e.pageSize.value;
+    return m.value.slice(t, t + e.pageSize.value);
+  });
+  function D(e) {
+    const t = c.value;
+    t.key !== e ? c.value = { key: e, direction: "ascend" } : t.direction === "ascend" ? c.value = { key: e, direction: "descend" } : c.value = { key: "", direction: null };
+  }
+  function z(e, t) {
+    c.value = { key: e, direction: t };
+  }
+  function A(e, t) {
+    t.length === 0 ? delete g.value[e] : g.value[e] = t;
+  }
+  function C() {
+    g.value = {};
+  }
+  const f = i(
+    () => b.value.map((e) => I(e, F.value)).filter(Boolean)
+  );
+  function O(e) {
+    return d.value ? r.value.includes(e) : !1;
+  }
+  function R(e) {
+    if (!d.value) return;
+    const t = d.value === !0 ? "multiple" : d.value, l = r.value, n = l.indexOf(e);
+    t === "single" ? r.value = n >= 0 ? [] : [e] : n >= 0 ? l.splice(n, 1) : l.push(e);
+  }
+  function T() {
+    if (!d.value) return;
+    const e = f.value;
+    if (e.every((l) => r.value.includes(l)))
+      r.value = r.value.filter((l) => !e.includes(l));
+    else {
+      const l = /* @__PURE__ */ new Set([...r.value, ...e]);
+      r.value = [...l];
+    }
+  }
+  function V() {
+    r.value = [];
+  }
+  const K = i(() => f.value.length === 0 ? !1 : f.value.every((e) => r.value.includes(e))), j = i(() => f.value.length === 0 ? !1 : f.value.some((t) => r.value.includes(t)) && !K.value);
+  return {
+    resolvedColumns: w,
+    displayData: b,
+    filteredTotal: x,
+    sortState: c,
+    filterState: g,
+    toggleSort: D,
+    setSort: z,
+    setFilter: A,
+    clearFilters: C,
+    isSelected: O,
+    toggleSelect: R,
+    selectAll: T,
+    clearSelection: V,
+    selectedKeys: r,
+    allKeys: f,
+    isAllSelected: K,
+    isIndeterminate: j
+  };
+}
+export {
+  q as useTable
+};