@nuxt/ui 3.1.3 → 3.3.0

package/dist/runtime/components/SelectMenu.vue

@@ -3,7 +3,7 @@ import theme from "#build/ui/select-menu";
 </script>
 
 <script setup>
-import { computed, toRef, toRaw } from "vue";
+import { ref, computed, onMounted, toRef, toRaw } from "vue";
 import { ComboboxRoot, ComboboxArrow, ComboboxAnchor, ComboboxInput, ComboboxTrigger, ComboboxPortal, ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxLabel, ComboboxSeparator, ComboboxItem, ComboboxItemIndicator, FocusScope, useForwardPropsEmits, useFilter } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick, createReusableTemplate } from "@vueuse/core";
@@ -43,6 +43,8 @@ const props = defineProps({
   createItem: { type: [Boolean, String, Object], required: false },
   filterFields: { type: Array, required: false },
   ignoreFilter: { type: Boolean, required: false },
+  autofocus: { type: Boolean, required: false },
+  autofocusDelay: { type: Number, required: false, default: 0 },
   class: { type: null, required: false },
   ui: { type: null, required: false },
   open: { type: Boolean, required: false },
@@ -88,12 +90,10 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.selectMenu ||
 }));
 function displayValue(value) {
   if (props.multiple && Array.isArray(value)) {
-    return value.map((v) => displayValue(v)).filter(Boolean).join(", ");
+    const values = value.map((v) => displayValue(v)).filter(Boolean);
+    return values?.length ? values.join(", ") : void 0;
   }
-  if (!props.valueKey) {
-    return value && (typeof value === "object" ? get(value, props.labelKey) : value);
-  }
-  const item = items.value.find((item2) => compare(typeof item2 === "object" ? get(item2, props.valueKey) : item2, value));
+  const item = items.value.find((item2) => compare(typeof item2 === "object" && props.valueKey ? get(item2, props.valueKey) : item2, value));
   return item && (typeof item === "object" ? get(item, props.labelKey) : item);
 }
 const groups = computed(
@@ -106,13 +106,19 @@ const filteredGroups = computed(() => {
   }
   const fields = Array.isArray(props.filterFields) ? props.filterFields : [props.labelKey];
   return groups.value.map((items2) => items2.filter((item) => {
-    if (typeof item !== "object" || item === null) {
+    if (item === void 0 || item === null) {
+      return false;
+    }
+    if (typeof item !== "object") {
       return contains(String(item), searchTerm.value);
     }
     if (item.type && ["label", "separator"].includes(item.type)) {
       return true;
     }
-    return fields.some((field) => contains(get(item, field), searchTerm.value));
+    return fields.some((field) => {
+      const value = get(item, field);
+      return value !== void 0 && value !== null && contains(String(value), searchTerm.value);
+    });
   })).filter((group) => group.filter(
     (item) => !isSelectItem(item) || (!item.type || !["label", "separator"].includes(item.type))
   ).length > 0);
@@ -129,6 +135,19 @@ const createItem = computed(() => {
   return !filteredItems.value.length;
 });
 const createItemPosition = computed(() => typeof props.createItem === "object" ? props.createItem.position : "bottom");
+const triggerRef = ref(null);
+function autoFocus() {
+  if (props.autofocus) {
+    triggerRef.value?.$el?.focus({
+      focusVisible: true
+    });
+  }
+}
+onMounted(() => {
+  setTimeout(() => {
+    autoFocus();
+  }, props.autofocusDelay);
+});
 function onUpdate(value) {
   if (toRaw(props.modelValue) === value) {
     return;
@@ -173,6 +192,9 @@ function onSelect(e, item) {
 function isSelectItem(item) {
   return typeof item === "object" && item !== null;
 }
+defineExpose({
+  triggerRef
+});
 </script>
 
 <template>
@@ -204,7 +226,7 @@ function isSelectItem(item) {
     @update:open="onUpdateOpen"
   >
     <ComboboxAnchor as-child>
-      <ComboboxTrigger :class="ui.base({ class: [props.ui?.base, props.class] })" tabindex="0">
+      <ComboboxTrigger ref="triggerRef" :class="ui.base({ class: [props.ui?.base, props.class] })" tabindex="0">
         <span v-if="isLeading || !!avatar || !!slots.leading" :class="ui.leading({ class: props.ui?.leading })">
           <slot name="leading" :model-value="modelValue" :open="open" :ui="ui">
             <UIcon v-if="isLeading && leadingIconName" :name="leadingIconName" :class="ui.leadingIcon({ class: props.ui?.leadingIcon })" />
@@ -214,7 +236,7 @@ function isSelectItem(item) {
 
         <slot :model-value="modelValue" :open="open">
           <template v-for="displayedModelValue in [displayValue(modelValue)]" :key="displayedModelValue">
-            <span v-if="displayedModelValue" :class="ui.value({ class: props.ui?.value })">
+            <span v-if="displayedModelValue !== void 0 && displayedModelValue !== null" :class="ui.value({ class: props.ui?.value })">
               {{ displayedModelValue }}
             </span>
             <span v-else :class="ui.placeholder({ class: props.ui?.placeholder })">
@@ -237,7 +259,7 @@ function isSelectItem(item) {
           <slot name="content-top" />
 
           <ComboboxInput v-if="!!searchInput" v-model="searchTerm" :display-value="() => searchTerm" as-child>
-            <UInput autofocus autocomplete="off" v-bind="searchInputProps" :class="ui.input({ class: props.ui?.input })" />
+            <UInput autofocus autocomplete="off" :size="size" v-bind="searchInputProps" :class="ui.input({ class: props.ui?.input })" />
           </ComboboxInput>
 
           <ComboboxEmpty :class="ui.empty({ class: props.ui?.empty })">

package/dist/runtime/components/SelectMenu.vue.d.ts

@@ -114,6 +114,8 @@ export interface SelectMenuProps<T extends ArrayOrNested<SelectMenuItem> = Array
      * @defaultValue false
      */
     ignoreFilter?: boolean;
+    autofocus?: boolean;
+    autofocusDelay?: number;
     class?: any;
     ui?: SelectMenu['slots'];
 }
@@ -182,7 +184,109 @@ declare const _default: <T extends ArrayOrNested<SelectMenuItem>, VK extends Get
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onUpdate:open" | "onUpdate:modelValue" | "onHighlight" | "onUpdate:searchTerm" | "onCreate"> & (SelectMenuProps<T, VK, M> & {
         searchTerm?: string;
     }) & Partial<{}>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        triggerRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>;
+    }>): void;
     attrs: any;
     slots: SelectMenuSlots<T, VK, M, NestedItem<T>>;
     emit: (((evt: "blur", payload: FocusEvent) => void) & ((evt: "change", payload: Event) => void) & ((evt: "focus", payload: FocusEvent) => void) & ((evt: "create", item: string) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", payload: GetModelValue<T, VK, M>) => void) & ((evt: "highlight", payload: {
@@ -194,5 +298,5 @@ declare const _default: <T extends ArrayOrNested<SelectMenuItem>, VK extends Get
 };
 export default _default;
 type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
+    [K in keyof T as K]: T[K];
 } & {};

package/dist/runtime/components/Separator.vue.d.ts

@@ -43,7 +43,7 @@ export interface SeparatorProps extends Pick<_SeparatorProps, 'decorative'> {
 export interface SeparatorSlots {
     default(props?: {}): any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SeparatorProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
     orientation: "horizontal" | "vertical";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SeparatorSlots>;
 export default _default;

package/dist/runtime/components/Skeleton.vue.d.ts

@@ -6,7 +6,7 @@ export interface SkeletonProps {
     as?: any;
     class?: any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SkeletonProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;
 export default _default;

package/dist/runtime/components/Slideover.vue

@@ -40,14 +40,14 @@ const contentEvents = computed(() => {
     closeAutoFocus: (e) => e.preventDefault()
   };
   if (!props.dismissible) {
-    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown", "closeAutoFocus"];
+    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown"];
     return events.reduce((acc, curr) => {
       acc[curr] = (e) => {
         e.preventDefault();
         emits("close:prevent");
       };
       return acc;
-    }, {});
+    }, defaultEvents);
   }
   return defaultEvents;
 });
@@ -58,7 +58,7 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.slideover ||
 </script>
 
 <template>
-  <DialogRoot v-slot="{ open }" v-bind="rootProps">
+  <DialogRoot v-slot="{ open, close }" v-bind="rootProps">
     <DialogTrigger v-if="!!slots.default" as-child :class="props.class">
       <slot :open="open" />
     </DialogTrigger>
@@ -88,9 +88,9 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.slideover ||
           </DialogDescription>
         </VisuallyHidden>
 
-        <slot name="content">
-          <div v-if="!!slots.header || (title || !!slots.title) || (description || !!slots.description) || (close || !!slots.close)" :class="ui.header({ class: props.ui?.header })">
-            <slot name="header">
+        <slot name="content" :close="close">
+          <div v-if="!!slots.header || (title || !!slots.title) || (description || !!slots.description) || (props.close || !!slots.close)" :class="ui.header({ class: props.ui?.header })">
+            <slot name="header" :close="close">
               <div :class="ui.wrapper({ class: props.ui?.wrapper })">
                 <DialogTitle v-if="title || !!slots.title" :class="ui.title({ class: props.ui?.title })">
                   <slot name="title">
@@ -105,16 +105,17 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.slideover ||
                 </DialogDescription>
               </div>
 
-              <DialogClose v-if="close || !!slots.close" as-child>
-                <slot name="close" :ui="ui">
+              <slot name="actions" />
+
+              <DialogClose v-if="props.close || !!slots.close" as-child>
+                <slot name="close" :close="close" :ui="ui">
                   <UButton
-                    v-if="close"
+                    v-if="props.close"
                     :icon="closeIcon || appConfig.ui.icons.close"
-                    size="md"
                     color="neutral"
                     variant="ghost"
                     :aria-label="t('slideover.close')"
-                    v-bind="typeof close === 'object' ? close : {}"
+                    v-bind="typeof props.close === 'object' ? props.close : {}"
                     :class="ui.close({ class: props.ui?.close })"
                   />
                 </slot>
@@ -123,11 +124,11 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.slideover ||
           </div>
 
           <div :class="ui.body({ class: props.ui?.body })">
-            <slot name="body" />
+            <slot name="body" :close="close" />
           </div>
 
           <div v-if="!!slots.footer" :class="ui.footer({ class: props.ui?.footer })">
-            <slot name="footer" />
+            <slot name="footer" :close="close" />
           </div>
         </slot>
       </DialogContent>

package/dist/runtime/components/Slideover.vue.d.ts

@@ -58,19 +58,29 @@ export interface SlideoverSlots {
     default(props: {
         open: boolean;
     }): any;
-    content(props?: {}): any;
-    header(props?: {}): any;
+    content(props: {
+        close: () => void;
+    }): any;
+    header(props: {
+        close: () => void;
+    }): any;
     title(props?: {}): any;
     description(props?: {}): any;
+    actions(props?: {}): any;
     close(props: {
+        close: () => void;
         ui: {
             [K in keyof Required<Slideover['slots']>]: (props?: Record<string, any>) => string;
         };
     }): any;
-    body(props?: {}): any;
-    footer(props?: {}): any;
+    body(props: {
+        close: () => void;
+    }): any;
+    footer(props: {
+        close: () => void;
+    }): any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SlideoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SlideoverProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
     "after:leave": () => any;
     "after:enter": () => any;
@@ -83,9 +93,9 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SlideoverP
 }>, {
     close: boolean | Partial<ButtonProps>;
     modal: boolean;
+    transition: boolean;
     portal: boolean | string | HTMLElement;
     overlay: boolean;
-    transition: boolean;
     side: Slideover["variants"]["side"];
     dismissible: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SlideoverSlots>;

package/dist/runtime/components/Slider.vue.d.ts

@@ -35,24 +35,24 @@ export interface SliderProps extends Pick<SliderRootProps, 'name' | 'disabled' |
     ui?: Slider['slots'];
 }
 export interface SliderEmits<T extends number | number[] = number | number[]> {
-    (e: 'update:modelValue', payload: T): void;
-    (e: 'change', payload: Event): void;
+    'update:modelValue': [payload: T];
+    'change': [payload: Event];
 }
 declare const _default: <T extends number | number[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onChange?: ((payload: Event) => any) | undefined;
-        readonly "onUpdate:modelValue"?: ((payload: T) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue"> & (SliderProps & {
         modelValue?: T;
     }) & Partial<{}>> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {};
-    emit: SliderEmits<T> & ((evt: "update:modelValue", value: T | undefined) => void);
+    emit: (((evt: "change", payload: Event) => void) & ((evt: "update:modelValue", payload: T) => void)) & ((evt: "update:modelValue", value: T | undefined) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
 type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
+    [K in keyof T as K]: T[K];
 } & {};

package/dist/runtime/components/Stepper.vue.d.ts

@@ -81,5 +81,5 @@ declare const _default: <T extends StepperItem>(__VLS_props: NonNullable<Awaited
 };
 export default _default;
 type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
+    [K in keyof T as K]: T[K];
 } & {};

package/dist/runtime/components/Switch.vue.d.ts

@@ -53,7 +53,7 @@ export interface SwitchSlots {
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SwitchProps & {
     modelValue?: boolean;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (payload: Event) => any;
     "update:modelValue": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<SwitchProps & {

package/dist/runtime/components/Table.vue

@@ -18,7 +18,7 @@ const props = defineProps({
   caption: { type: String, required: false },
   meta: { type: Object, required: false },
   empty: { type: String, required: false },
-  sticky: { type: Boolean, required: false },
+  sticky: { type: [Boolean, String], required: false },
   loading: { type: Boolean, required: false },
   loadingColor: { type: null, required: false },
   loadingAnimation: { type: null, required: false },
@@ -38,6 +38,8 @@ const props = defineProps({
   paginationOptions: { type: Object, required: false },
   facetedOptions: { type: Object, required: false },
   onSelect: { type: Function, required: false },
+  onHover: { type: Function, required: false },
+  onContextmenu: { type: [Function, Array], required: false },
   class: { type: null, required: false },
   ui: { type: null, required: false },
   state: { type: Object, required: false },
@@ -69,6 +71,20 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.table || {} }
   loadingColor: props.loadingColor,
   loadingAnimation: props.loadingAnimation
 }));
+const hasFooter = computed(() => {
+  function hasFooterRecursive(columns2) {
+    for (const column of columns2) {
+      if ("footer" in column) {
+        return true;
+      }
+      if ("columns" in column && hasFooterRecursive(column.columns)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return hasFooterRecursive(columns.value);
+});
 const globalFilterState = defineModel("globalFilter", { type: String, ...{ default: void 0 } });
 const columnFiltersState = defineModel("columnFilters", { type: Array, ...{ default: [] } });
 const columnOrderState = defineModel("columnOrder", { type: Array, ...{ default: [] } });
@@ -82,11 +98,13 @@ const sortingState = defineModel("sorting", { type: Array, ...{ default: [] } })
 const groupingState = defineModel("grouping", { type: Array, ...{ default: [] } });
 const expandedState = defineModel("expanded", { type: [Boolean, Object], ...{ default: {} } });
 const paginationState = defineModel("pagination", { type: Object, ...{ default: {} } });
-const tableRef = ref();
+const tableRef = ref(null);
 const tableApi = useVueTable({
   ...reactiveOmit(props, "as", "data", "columns", "caption", "sticky", "loading", "loadingColor", "loadingAnimation", "class", "ui"),
   data,
-  columns: columns.value,
+  get columns() {
+    return columns.value;
+  },
   meta: meta.value,
   getCoreRowModel: getCoreRowModel(),
   ...props.globalFilterOptions || {},
@@ -162,7 +180,7 @@ const tableApi = useVueTable({
 function valueUpdater(updaterOrValue, ref2) {
   ref2.value = typeof updaterOrValue === "function" ? updaterOrValue(ref2.value) : updaterOrValue;
 }
-function handleRowSelect(row, e) {
+function onRowSelect(e, row) {
   if (!props.onSelect) {
     return;
   }
@@ -175,6 +193,28 @@ function handleRowSelect(row, e) {
   e.stopPropagation();
   props.onSelect(row, e);
 }
+function onRowHover(e, row) {
+  if (!props.onHover) {
+    return;
+  }
+  props.onHover(e, row);
+}
+function onRowContextmenu(e, row) {
+  if (!props.onContextmenu) {
+    return;
+  }
+  if (Array.isArray(props.onContextmenu)) {
+    props.onContextmenu.forEach((fn) => fn(e, row));
+  } else {
+    props.onContextmenu(e, row);
+  }
+}
+function resolveValue(prop, arg) {
+  if (typeof prop === "function") {
+    return prop(arg);
+  }
+  return prop;
+}
 watch(
   () => props.data,
   () => {
@@ -203,11 +243,13 @@ defineExpose({
             v-for="header in headerGroup.headers"
             :key="header.id"
             :data-pinned="header.column.getIsPinned()"
+            :scope="header.colSpan > 1 ? 'colgroup' : 'col'"
             :colspan="header.colSpan > 1 ? header.colSpan : void 0"
+            :rowspan="header.rowSpan > 1 ? header.rowSpan : void 0"
             :class="ui.th({
   class: [
     props.ui?.th,
-    typeof header.column.columnDef.meta?.class?.th === 'function' ? header.column.columnDef.meta.class.th(header) : header.column.columnDef.meta?.class?.th
+    resolveValue(header.column.columnDef.meta?.class?.th, header)
   ],
   pinned: !!header.column.getIsPinned()
 })"
@@ -217,36 +259,47 @@ defineExpose({
             </slot>
           </th>
         </tr>
+
+        <tr :class="ui.separator({ class: [props.ui?.separator] })" />
       </thead>
 
       <tbody :class="ui.tbody({ class: [props.ui?.tbody] })">
+        <slot name="body-top" />
+
         <template v-if="tableApi.getRowModel().rows?.length">
           <template v-for="row in tableApi.getRowModel().rows" :key="row.id">
             <tr
               :data-selected="row.getIsSelected()"
-              :data-selectable="!!props.onSelect"
+              :data-selectable="!!props.onSelect || !!props.onHover || !!props.onContextmenu"
               :data-expanded="row.getIsExpanded()"
               :role="props.onSelect ? 'button' : void 0"
               :tabindex="props.onSelect ? 0 : void 0"
               :class="ui.tr({
   class: [
     props.ui?.tr,
-    typeof tableApi.options.meta?.class?.tr === 'function' ? tableApi.options.meta.class.tr(row) : tableApi.options.meta?.class?.tr
+    resolveValue(tableApi.options.meta?.class?.tr, row)
   ]
 })"
-              @click="handleRowSelect(row, $event)"
+              :style="resolveValue(tableApi.options.meta?.style?.tr, row)"
+              @click="onRowSelect($event, row)"
+              @pointerenter="onRowHover($event, row)"
+              @pointerleave="onRowHover($event, null)"
+              @contextmenu="onRowContextmenu($event, row)"
             >
               <td
                 v-for="cell in row.getVisibleCells()"
                 :key="cell.id"
                 :data-pinned="cell.column.getIsPinned()"
+                :colspan="resolveValue(cell.column.columnDef.meta?.colspan?.td, cell)"
+                :rowspan="resolveValue(cell.column.columnDef.meta?.rowspan?.td, cell)"
                 :class="ui.td({
   class: [
     props.ui?.td,
-    typeof cell.column.columnDef.meta?.class?.td === 'function' ? cell.column.columnDef.meta.class.td(cell) : cell.column.columnDef.meta?.class?.td
+    resolveValue(cell.column.columnDef.meta?.class?.td, cell)
   ],
   pinned: !!cell.column.getIsPinned()
 })"
+                :style="resolveValue(cell.column.columnDef.meta?.style?.td, cell)"
               >
                 <slot :name="`${cell.column.id}-cell`" v-bind="cell.getContext()">
                   <FlexRender :render="cell.column.columnDef.cell" :props="cell.getContext()" />
@@ -274,7 +327,35 @@ defineExpose({
             </slot>
           </td>
         </tr>
+
+        <slot name="body-bottom" />
       </tbody>
+
+      <tfoot v-if="hasFooter" :class="ui.tfoot({ class: [props.ui?.tfoot] })">
+        <tr :class="ui.separator({ class: [props.ui?.separator] })" />
+
+        <tr v-for="footerGroup in tableApi.getFooterGroups()" :key="footerGroup.id" :class="ui.tr({ class: [props.ui?.tr] })">
+          <th
+            v-for="header in footerGroup.headers"
+            :key="header.id"
+            :data-pinned="header.column.getIsPinned()"
+            :colspan="header.colSpan > 1 ? header.colSpan : void 0"
+            :rowspan="header.rowSpan > 1 ? header.rowSpan : void 0"
+            :class="ui.th({
+  class: [
+    props.ui?.th,
+    resolveValue(header.column.columnDef.meta?.class?.th, header)
+  ],
+  pinned: !!header.column.getIsPinned()
+})"
+            :style="resolveValue(header.column.columnDef.meta?.style?.th, header)"
+          >
+            <slot :name="`${header.id}-footer`" v-bind="header.getContext()">
+              <FlexRender v-if="!header.isPlaceholder" :render="header.column.columnDef.footer" :props="header.getContext()" />
+            </slot>
+          </th>
+        </tr>
+      </tfoot>
     </table>
   </Primitive>
 </template>