@indielayer/ui 1.0.10 → 1.2.0

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

@@ -1,42 +1,8 @@
-import type { PropType } from 'vue';
-import { type Align } from './TableHeader.vue';
-export type Header = {
-    sortable?: boolean;
-    sort?: string[];
-    align?: Align;
-    value?: string;
-    text?: string;
-    width?: string | number;
-};
-declare const _default: __VLS_WithTemplateSlots<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,26 +26,271 @@ declare const _default: __VLS_WithTemplateSlots<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;
-}, {
-    sort: string[];
-    items: unknown[];
-    loading: boolean;
-    fixed: boolean;
-    pointer: boolean;
-    dense: boolean;
-    stickyHeader: boolean;
-    headers: Header[];
-    striped: boolean;
-    scrollable: boolean;
-}, {}>, Partial<Record<string, (_: {
-    item: unknown;
-}) => any>>>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
+} & 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.js

@@ -0,0 +1,15 @@
+import { defineComponent as d, createVNode as n } from "vue";
+const p = /* @__PURE__ */ d({
+  name: "XTableBody",
+  setup(o, {
+    slots: e
+  }) {
+    return () => {
+      var a;
+      return n("tbody", null, [(a = e.default) == null ? void 0 : a.call(e)]);
+    };
+  }
+});
+export {
+  p as default
+};

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

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

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

@@ -0,0 +1,11 @@
+const i = {
+  classes: {
+    wrapper: ({ props: t }) => {
+      const e = ["last:pr-0 px-3"];
+      return e.push(t.dense ? "py-2" : "py-4"), t.textAlign === "left" ? e.push("text-left") : t.textAlign === "center" ? e.push("text-center") : t.textAlign === "right" ? e.push("text-right") : t.textAlign === "justify" && e.push("text-justify"), t.verticalAlign === "baseline" ? e.push("align-baseline") : t.verticalAlign === "bottom" ? e.push("align-bottom") : t.verticalAlign === "middle" ? e.push("align-middle") : t.verticalAlign === "text-bottom" ? e.push("align-text-bottom") : t.verticalAlign === "text-top" ? e.push("align-text-top") : t.verticalAlign === "top" && e.push("align-top"), t.truncate && t.fixed && e.push("truncate"), e;
+    }
+  }
+}, l = i;
+export {
+  l as default
+};

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

@@ -1,33 +1,55 @@
+import type { ExtractPublicPropTypes, PropType } from 'vue';
+declare const validators: {
+    textAlign: readonly [null, "left", "center", "right", "justify"];
+    verticalAlign: readonly [null, "baseline", "bottom", "middle", "text-bottom", "text-top", "top"];
+};
+declare const tableCellProps: {
+    textAlign: {
+        type: PropType<"left" | "right" | "center" | "justify" | null>;
+        validator: (value: string) => boolean;
+    };
+    truncate: BooleanConstructor;
+    dense: BooleanConstructor;
+    fixed: BooleanConstructor;
+    verticalAlign: {
+        type: PropType<"top" | "bottom" | "baseline" | "middle" | "text-bottom" | "text-top" | null>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+};
+export type TableCellTextAlign = typeof validators.textAlign[number];
+export type TableCellVerticalAlign = typeof validators.verticalAlign[number];
+export type TableCellProps = ExtractPublicPropTypes<typeof tableCellProps>;
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     textAlign: {
-        type: StringConstructor;
+        type: PropType<"left" | "right" | "center" | "justify" | null>;
         validator: (value: string) => boolean;
     };
     truncate: BooleanConstructor;
     dense: BooleanConstructor;
     fixed: BooleanConstructor;
     verticalAlign: {
-        type: StringConstructor;
+        type: PropType<"top" | "bottom" | "baseline" | "middle" | "text-bottom" | "text-top" | null>;
         default: string;
         validator: (value: string) => boolean;
     };
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     textAlign: {
-        type: StringConstructor;
+        type: PropType<"left" | "right" | "center" | "justify" | null>;
         validator: (value: string) => boolean;
     };
     truncate: BooleanConstructor;
     dense: BooleanConstructor;
     fixed: BooleanConstructor;
     verticalAlign: {
-        type: StringConstructor;
+        type: PropType<"top" | "bottom" | "baseline" | "middle" | "text-bottom" | "text-top" | null>;
         default: string;
         validator: (value: string) => boolean;
     };
 }>>, {
     fixed: boolean;
     dense: boolean;
-    verticalAlign: string;
+    verticalAlign: "top" | "bottom" | "baseline" | "middle" | "text-bottom" | "text-top" | null;
     truncate: boolean;
 }, {}>, {
     default?(_: {}): any;

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

@@ -0,0 +1,43 @@
+import { defineComponent as i, openBlock as c, createElementBlock as p, normalizeStyle as d, unref as l, normalizeClass as m, renderSlot as u } from "vue";
+import { useTheme as f } from "../../composables/theme.js";
+import g from "./TableCell.theme.js";
+const o = {
+  textAlign: [null, "left", "center", "right", "justify"],
+  verticalAlign: [null, "baseline", "bottom", "middle", "text-bottom", "text-top", "top"]
+}, x = {
+  textAlign: {
+    type: String,
+    validator: (e) => o.textAlign.includes(e)
+  },
+  truncate: Boolean,
+  dense: Boolean,
+  fixed: Boolean,
+  verticalAlign: {
+    type: String,
+    default: "middle",
+    validator: (e) => o.verticalAlign.includes(e)
+  }
+}, b = {
+  name: "XTableCell",
+  validators: o
+}, A = /* @__PURE__ */ i({
+  ...b,
+  props: x,
+  setup(e) {
+    const t = e;
+    t.truncate && !t.fixed && console.warn('Table must have "fixed" property set to true when using TableCell "truncate" property');
+    const { styles: n, classes: r, className: a } = f("table-cell", g, t);
+    return (s, y) => (c(), p("td", {
+      style: d(l(n)),
+      class: m([
+        l(a),
+        l(r).wrapper
+      ])
+    }, [
+      u(s.$slots, "default")
+    ], 6));
+  }
+});
+export {
+  A as default
+};

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

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

package/lib/components/table/TableHead.js

@@ -0,0 +1,19 @@
+import { defineComponent as r, createVNode as t } from "vue";
+const o = /* @__PURE__ */ r({
+  name: "XTableHead",
+  setup(d, {
+    slots: e
+  }) {
+    return () => {
+      var a;
+      return t("thead", {
+        class: "align-bottom"
+      }, [t("tr", {
+        class: "text-sm text-gray-600 dark:text-gray-400 border-b"
+      }, [(a = e.default) == null ? void 0 : a.call(e)])]);
+    };
+  }
+});
+export {
+  o as default
+};