@indielayer/ui 1.0.9 → 1.1.0

package/lib/components/tab/TabGroup.vue.js

@@ -0,0 +1,133 @@
+import { defineComponent as B, ref as l, watchEffect as x, reactive as E, computed as a, provide as V, watch as z, onMounted as N, openBlock as $, createElementBlock as q, createElementVNode as c, normalizeClass as f, unref as n, normalizeStyle as F, createVNode as G, withCtx as L, renderSlot as M, withDirectives as X, vShow as j, nextTick as D } from "vue";
+import { useMutationObserver as K } from "../../node_modules/.pnpm/@vueuse_core@10.2.0_vue@3.3.4/node_modules/@vueuse/core/index.js";
+import { injectTabKey as O } from "../../composables/keys.js";
+import { useCommon as g } from "../../composables/common.js";
+import { useColors as P } from "../../composables/colors.js";
+import { useTheme as W } from "../../composables/theme.js";
+import A from "../scroll/Scroll.vue.js";
+import H from "./TabGroup.theme.js";
+import { useThrottleFn as I } from "../../node_modules/.pnpm/@vueuse_shared@10.2.0_vue@3.3.4/node_modules/@vueuse/shared/index.js";
+const J = {
+  ...g.validators(),
+  variant: ["line", "block"],
+  align: ["left", "center", "right"]
+}, Q = {
+  ...g.props(),
+  ...P.props("primary"),
+  modelValue: [String, Number],
+  variant: {
+    type: String,
+    default: "line"
+  },
+  align: {
+    type: String,
+    default: "left"
+  },
+  ghost: Boolean,
+  grow: Boolean,
+  exact: Boolean
+}, U = {
+  name: "XTabGroup",
+  validators: J
+}, ne = /* @__PURE__ */ B({
+  ...U,
+  props: Q,
+  emits: ["update:modelValue"],
+  setup(k, { emit: y }) {
+    const t = k, i = l(null), w = l(null), u = l(null), r = l(null), m = l(null), s = l();
+    x(() => {
+      s.value = t.modelValue;
+    });
+    const R = E({
+      active: a(() => s.value),
+      variant: a(() => t.variant),
+      ghost: a(() => t.ghost),
+      grow: a(() => t.grow),
+      exact: a(() => t.exact),
+      size: a(() => t.size),
+      color: a(() => t.color)
+    });
+    function d(e) {
+      s.value = e, y("update:modelValue", e);
+    }
+    V(O, {
+      tabsContentRef: m,
+      activateTab: d,
+      state: R
+    });
+    const h = I(async (e) => {
+      var b;
+      if (typeof e > "u")
+        return;
+      await D();
+      const o = (b = r.value) == null ? void 0 : b.querySelector(`[data-value="${e}"]`);
+      if (!o || !u.value || (u.value.style.left = `${o.offsetLeft}px`, u.value.style.width = `${o.offsetWidth}px`, !r.value || !i.value))
+        return;
+      const T = o.offsetLeft - (r.value.getBoundingClientRect().width - o.getBoundingClientRect().width) / 2;
+      i.value.scrollEl && i.value.scrollEl.scrollTo({ left: T, behavior: "smooth" });
+    }, 100), v = l(!0);
+    function S() {
+      var e;
+      (e = r.value) != null && e.querySelector(".router-link-active") ? v.value = !0 : (d(null), v.value = !1);
+    }
+    z(() => s.value, (e) => {
+      h(e);
+    }), N(() => {
+      var e;
+      (e = r.value) != null && e.querySelector(".x-link") && K(r.value, S, {
+        attributes: !0,
+        subtree: !0,
+        attributeFilter: ["class"]
+      }), h(s.value);
+    });
+    const { styles: _, classes: p, className: C } = W("tabs", H, t);
+    return (e, o) => ($(), q("div", null, [
+      c("div", {
+        ref_key: "wrapperRef",
+        ref: w,
+        class: f(["relative", [
+          n(C),
+          n(p).wrapper
+        ]]),
+        style: F(n(_))
+      }, [
+        G(A, {
+          ref_key: "scrollRef",
+          ref: i,
+          scrollbar: !1,
+          horizontal: "",
+          mousewheel: "",
+          class: f({
+            "rounded-md": e.variant === "block",
+            "bg-slate-100 dark:bg-gray-800 p-1": e.variant === "block" && !e.ghost
+          })
+        }, {
+          default: L(() => [
+            c("div", {
+              ref_key: "tabsRef",
+              ref: r,
+              class: f(["relative", n(p).list])
+            }, [
+              M(e.$slots, "default")
+            ], 2),
+            X(c("div", {
+              ref_key: "trackerRef",
+              ref: u,
+              class: f(n(p).tracker)
+            }, null, 2), [
+              [j, v.value]
+            ])
+          ]),
+          _: 3
+        }, 8, ["class"])
+      ], 6),
+      c("div", {
+        ref_key: "tabsContentRef",
+        ref: m
+      }, null, 512)
+    ]));
+  }
+});
+export {
+  ne as default
+};

package/lib/components/tab/TabGroup.vue2.js

@@ -0,0 +1,4 @@
+import f from "./TabGroup.vue.js";
+export {
+  f as default
+};

package/lib/components/tab/index.d.ts

@@ -0,0 +1,4 @@
+export { default as XTab } from './Tab.vue';
+export type { TabProps } from './Tab.vue';
+export { default as XTabGroup } from './TabGroup.vue';
+export type { TabGroupProps, TabGroupAlign, TabGroupInjection, TabGroupVariant } from './TabGroup.vue';

package/lib/components/table/Table.theme.d.ts

@@ -1,8 +1,10 @@
-import type { ThemeParams } from '../../composables/theme';
-declare const _default: {
-    classes: {
-        wrapper: ({ props, data }: ThemeParams) => string[];
-        loadingWrapper: string;
-    };
-};
-export default _default;
+import type { ThemeClasses, ThemeComponent } from '../../composables/theme';
+import type { TableProps } from './Table.vue';
+type InternalClasses = 'wrapper' | 'loadingWrapper';
+interface InternalTheme extends ThemeComponent<TableProps, InternalClasses> {
+}
+export interface TableTheme extends Omit<InternalTheme, 'classes'> {
+    classes?: Partial<ThemeClasses<TableProps, InternalClasses>>;
+}
+declare const theme: InternalTheme;
+export default theme;

package/lib/components/table/Table.theme.js

@@ -0,0 +1,12 @@
+const t = {
+  classes: {
+    wrapper: ({ props: a, data: l }) => {
+      const e = ["w-full relative"];
+      return a.scrollable && e.push("overflow-x-scroll sm:overflow-x-auto whitespace-wrap sm:whitespace-normal block sm:table"), a.stickyHeader && e.push("relative"), a.fixed && e.push("table-fixed"), e;
+    },
+    loadingWrapper: "absolute inset-0 flex items-center justify-center z-40 bg-gray-300 dark:bg-gray-600 rounded opacity-50"
+  }
+}, r = t;
+export {
+  r as default
+};

package/lib/components/table/Table.vue.d.ts

@@ -1,42 +1,8 @@
-import type { PropType } from 'vue';
-import { type Align } from './TableHeader.vue';
-export declare type Header = {
-    sortable?: boolean;
-    sort?: string[];
-    align?: Align;
-    value?: string;
-    text?: string;
-    width?: string | number;
-};
-declare const _default: import("vue").DefineComponent<{
-    headers: {
-        type: PropType<Header[]>;
-        default: () => never[];
-    };
-    items: {
-        type: ArrayConstructor;
-        default: () => never[];
-    };
-    sort: {
-        type: PropType<string[]>;
-        default: () => never[];
-    };
-    loading: BooleanConstructor;
-    dense: BooleanConstructor;
-    fixed: BooleanConstructor;
-    striped: BooleanConstructor;
-    pointer: BooleanConstructor;
-    scrollable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    stickyHeader: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:sort" | "click-row")[], "update:sort" | "click-row", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+import type { ExtractPublicPropTypes, PropType } from 'vue';
+import { type TableHeaderAlign } from './TableHeader.vue';
+declare const tableProps: {
     headers: {
-        type: PropType<Header[]>;
+        type: PropType<TableHeader[]>;
         default: () => never[];
     };
     items: {
@@ -60,19 +26,271 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+};
+export type TableHeader = {
+    sortable?: boolean;
+    sort?: string[];
+    align?: TableHeaderAlign;
+    value?: string;
+    text?: string;
+    width?: string | number;
+};
+export type TableProps = ExtractPublicPropTypes<typeof tableProps>;
+declare const _default: <T>(__VLS_props: {
+    sort?: string[] | undefined;
+    loading?: boolean | undefined;
+    items?: T[] | undefined;
+    fixed?: boolean | undefined;
+    pointer?: boolean | undefined;
+    dense?: boolean | undefined;
+    stickyHeader?: boolean | undefined;
+    headers?: TableHeader[] | undefined;
+    striped?: boolean | undefined;
+    scrollable?: boolean | undefined;
+    key?: string | number | symbol | undefined;
+    ref?: import("vue").VNodeRef | undefined;
+    ref_for?: boolean | undefined;
+    ref_key?: string | undefined;
+    onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>) => void)[] | undefined;
+    class?: unknown;
+    style?: unknown;
     "onUpdate:sort"?: ((...args: any[]) => any) | undefined;
     "onClick-row"?: ((...args: any[]) => any) | undefined;
-}, {
-    fixed: boolean;
-    sort: string[];
-    items: unknown[];
-    loading: boolean;
-    pointer: boolean;
-    dense: boolean;
-    stickyHeader: boolean;
-    striped: boolean;
-    headers: Header[];
-    scrollable: boolean;
-}>;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: Pick<{
+    props: {
+        sort?: string[] | undefined;
+        loading?: boolean | undefined;
+        items?: T[] | undefined;
+        fixed?: boolean | undefined;
+        pointer?: boolean | undefined;
+        dense?: boolean | undefined;
+        stickyHeader?: boolean | undefined;
+        headers?: TableHeader[] | undefined;
+        striped?: boolean | undefined;
+        scrollable?: boolean | undefined;
+        key?: string | number | symbol | undefined;
+        ref?: import("vue").VNodeRef | undefined;
+        ref_for?: boolean | undefined;
+        ref_key?: string | undefined;
+        onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        class?: unknown;
+        style?: unknown;
+        "onUpdate:sort"?: ((...args: any[]) => any) | undefined;
+        "onClick-row"?: ((...args: any[]) => any) | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        item: T;
+    }) => any>>;
+    emit: (event: "update:sort" | "click-row", ...args: any[]) => void;
+}, "slots" | "attrs" | "emit"> | undefined, __VLS_setup?: {
+    props: {
+        sort?: string[] | undefined;
+        loading?: boolean | undefined;
+        items?: T[] | undefined;
+        fixed?: boolean | undefined;
+        pointer?: boolean | undefined;
+        dense?: boolean | undefined;
+        stickyHeader?: boolean | undefined;
+        headers?: TableHeader[] | undefined;
+        striped?: boolean | undefined;
+        scrollable?: boolean | undefined;
+        key?: string | number | symbol | undefined;
+        ref?: import("vue").VNodeRef | undefined;
+        ref_for?: boolean | undefined;
+        ref_key?: string | undefined;
+        onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[] | undefined;
+        class?: unknown;
+        style?: unknown;
+        "onUpdate:sort"?: ((...args: any[]) => any) | undefined;
+        "onClick-row"?: ((...args: any[]) => any) | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        item: T;
+    }) => any>>;
+    emit: (event: "update:sort" | "click-row", ...args: any[]) => void;
+}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            sort?: string[] | undefined;
+            loading?: boolean | undefined;
+            items?: T[] | undefined;
+            fixed?: boolean | undefined;
+            pointer?: boolean | undefined;
+            dense?: boolean | undefined;
+            stickyHeader?: boolean | undefined;
+            headers?: TableHeader[] | undefined;
+            striped?: boolean | undefined;
+            scrollable?: boolean | undefined;
+            key?: string | number | symbol | undefined;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+            style?: unknown;
+            "onUpdate:sort"?: ((...args: any[]) => any) | undefined;
+            "onClick-row"?: ((...args: any[]) => any) | undefined;
+        };
+        expose(exposed: {}): void;
+        attrs: any;
+        slots: Partial<Record<string, (_: {
+            item: T;
+        }) => any>>;
+        emit: (event: "update:sort" | "click-row", ...args: any[]) => void;
+    } | undefined;
+};
 export default _default;

package/lib/components/table/Table.vue.js

@@ -0,0 +1,147 @@
+import { defineComponent as N, openBlock as s, createElementBlock as a, createElementVNode as T, normalizeStyle as x, unref as i, normalizeClass as g, createVNode as f, withCtx as u, Fragment as d, renderList as c, createBlock as m, createTextVNode as v, toDisplayString as b, renderSlot as H, createCommentVNode as S } from "vue";
+import { useTheme as V } from "../../composables/theme.js";
+import z from "./TableHead.js";
+import X from "./TableHeader.vue.js";
+import h from "./TableBody.js";
+import E from "./TableRow.vue.js";
+import D from "./TableCell.vue.js";
+import F from "../spinner/Spinner.vue.js";
+import I from "./Table.theme.js";
+const L = { class: "w-full overflow-x-auto" }, P = {
+  headers: {
+    type: Array,
+    default: () => []
+  },
+  items: {
+    type: Array,
+    default: () => []
+  },
+  sort: {
+    type: Array,
+    default: () => []
+  },
+  loading: Boolean,
+  dense: Boolean,
+  fixed: Boolean,
+  striped: Boolean,
+  pointer: Boolean,
+  scrollable: {
+    type: Boolean,
+    default: !0
+  },
+  stickyHeader: {
+    type: Boolean,
+    default: !0
+  }
+}, W = { name: "XTable" }, Z = /* @__PURE__ */ N({
+  ...W,
+  props: {
+    ...P,
+    items: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["update:sort", "click-row"],
+  setup(p, { emit: B }) {
+    const y = p;
+    function $(t, r) {
+      if (t)
+        for (let e = 0; e < r.length; e++) {
+          const { 0: l, 1: o } = r[e].split(",");
+          if (t === l)
+            return parseInt(o) > 0 ? 1 : -1;
+        }
+    }
+    function _(t) {
+      const r = y.sort.slice(0);
+      let e = !1;
+      for (let l = 0; l < r.length; l++) {
+        const { 0: o, 1: n } = r[l].split(",");
+        if (o === t.value) {
+          if (e = !0, n === "-1") {
+            r.splice(l, 1, `${t.value},1`);
+            break;
+          } else if (n === "1") {
+            r.splice(l, 1);
+            break;
+          }
+        }
+      }
+      e || r.push(`${t.value},-1`), B("update:sort", r);
+    }
+    function w(t, r) {
+      if (!r)
+        return "";
+      const e = Array.isArray(r) ? r : r.match(/([^[.\]])+/g);
+      return (e == null ? void 0 : e.reduce((o, n) => o && o[n], t)) ?? "";
+    }
+    const { styles: C, classes: k, className: A } = V("table", I, y);
+    return (t, r) => (s(), a("div", L, [
+      T("table", {
+        style: x(i(C)),
+        class: g([
+          i(A),
+          i(k).wrapper
+        ])
+      }, [
+        f(i(z), null, {
+          default: u(() => [
+            (s(!0), a(d, null, c(t.headers, (e, l) => (s(), m(X, {
+              key: l,
+              "sticky-header": t.stickyHeader,
+              "text-align": e.align,
+              sort: $(e.value, t.sort),
+              sortable: e.sortable,
+              width: e.width,
+              onClick: (o) => e.sortable ? _(e) : null
+            }, {
+              default: u(() => [
+                v(b(e.text), 1)
+              ]),
+              _: 2
+            }, 1032, ["sticky-header", "text-align", "sort", "sortable", "width", "onClick"]))), 128))
+          ]),
+          _: 1
+        }),
+        f(i(h), null, {
+          default: u(() => [
+            (s(!0), a(d, null, c(p.items, (e, l) => (s(), m(E, {
+              key: l,
+              pointer: t.pointer,
+              striped: t.striped,
+              onClick: (o) => t.$emit("click-row", e)
+            }, {
+              default: u(() => [
+                (s(!0), a(d, null, c(t.headers, (o, n) => (s(), m(D, {
+                  key: n,
+                  "text-align": o.align,
+                  dense: t.dense,
+                  fixed: t.fixed
+                }, {
+                  default: u(() => [
+                    H(t.$slots, `item-${o.value}`, { item: e }, () => [
+                      v(b(w(e, o.value)), 1)
+                    ])
+                  ]),
+                  _: 2
+                }, 1032, ["text-align", "dense", "fixed"]))), 128))
+              ]),
+              _: 2
+            }, 1032, ["pointer", "striped", "onClick"]))), 128))
+          ]),
+          _: 3
+        }),
+        t.loading ? (s(), a("div", {
+          key: 0,
+          class: g(i(k).loadingWrapper)
+        }, [
+          f(F, { size: "lg" })
+        ], 2)) : S("", !0)
+      ], 6)
+    ]));
+  }
+});
+export {
+  Z as default
+};

package/lib/components/table/Table.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Table.vue.js";
+export {
+  f as default
+};

package/lib/components/table/TableBody.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;