@wisemen/vue-core-components 1.16.0 → 2.0.0-beta.0

package/dist/components/date-picker/single/parts/DatePickerRoot.d.ts

@@ -1,10 +1,11 @@
 import { DateValue } from 'reka-ui';
+import { Temporal } from 'temporal-polyfill';
 import { Grid } from '../../shared/datePicker.type';
 import { DatePickerProps } from '../datePicker.props';
 type __VLS_Props = DatePickerProps;
 type __VLS_PublicProps = {
-    modelValue: Date | null;
-    'placeholderValue'?: Date;
+    modelValue: Temporal.PlainDate | null;
+    'placeholderValue'?: Temporal.PlainDate;
 } & __VLS_Props;
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -19,11 +20,11 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: Date | null) => any;
-    "update:placeholderValue": (value: Date) => any;
+    "update:modelValue": (value: Temporal.PlainDate | null) => any;
+    "update:placeholderValue": (value: Temporal.PlainDate) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
-    "onUpdate:placeholderValue"?: ((value: Date) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Temporal.PlainDate | null) => any) | undefined;
+    "onUpdate:placeholderValue"?: ((value: Temporal.PlainDate) => any) | undefined;
 }>, {
     variant: null;
     testId: string | null;

package/dist/components/date-range-field/DateRangeField.d.ts

@@ -1,25 +1,35 @@
-import { DateRangeFieldEmits } from './dateRangeField.emits';
+import { Temporal } from 'temporal-polyfill';
 import { DateRangeFieldProps } from './dateRangeField.props';
 import { DateRangeFieldSlots } from './dateRangeField.slots';
 import { DateRange } from '../../types/dateRange.type';
-declare const _default: <TValue extends Date>(__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 onFocus?: ((e: FocusEvent) => any) | undefined;
-        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
-        readonly "onUpdate:modelValue"?: ((value: DateRange<TValue>) => any) | undefined;
-        readonly "onUpdate:placeholderValue"?: ((value: Date) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onUpdate:modelValue" | "onUpdate:placeholderValue"> & ({
-        modelValue: DateRange<TValue>;
-        placeholderValue?: Date;
-    } & DateRangeFieldProps) & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
+type __VLS_Props = DateRangeFieldProps;
+type __VLS_PublicProps = {
+    modelValue: DateRange<Temporal.PlainDate>;
+    'placeholderValue'?: Temporal.PlainDate;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: Readonly<DateRangeFieldSlots> & DateRangeFieldSlots;
-    emit: DateRangeFieldEmits & (((evt: "update:modelValue", value: DateRange<TValue>) => void) & ((evt: "update:placeholderValue", value: Date) => void));
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: DateRange<Temporal.PlainDate>) => any;
+    "update:placeholderValue": (value: Temporal.PlainDate) => any;
+} & {
+    focus: (e: FocusEvent) => any;
+    blur: (e: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: DateRange<Temporal.PlainDate>) => any) | undefined;
+    "onUpdate:placeholderValue"?: ((value: Temporal.PlainDate) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/date-range-field/dateRangeField.context.d.ts

@@ -1,3 +1,4 @@
+import { Temporal } from 'temporal-polyfill';
 import { ComputedRef, Ref } from 'vue';
 import { ResolvedClassConfig } from '../../class-variant/classVariant.type';
 import { DateRangeFieldProps } from './dateRangeField.props';
@@ -6,8 +7,8 @@ import { DateRange } from '../../types/dateRange.type';
 import { PropsToComputed } from '../../utils/props.util';
 interface DateRangeFieldContext extends PropsToComputed<DateRangeFieldProps> {
     customClassConfig: ComputedRef<ResolvedClassConfig<'dateRangeField'>>;
-    modelValue: Ref<DateRange>;
-    placeholderValue: Ref<Date>;
+    modelValue: Ref<DateRange<Temporal.PlainDate>>;
+    placeholderValue: Ref<Temporal.PlainDate>;
     style: ComputedRef<CreateDateRangeFieldStyle>;
     onBlur: (event: FocusEvent) => void;
     onFocus: (event: FocusEvent) => void;

package/dist/components/date-range-field/parts/DateRangeFieldRoot.d.ts

@@ -1,18 +1,14 @@
-import { DateRangeFieldEmits } from '../dateRangeField.emits';
+import { Temporal } from 'temporal-polyfill';
+import { ResolvedClassConfig } from '../../../class-variant/classVariant.type';
 import { DateRangeFieldProps } from '../dateRangeField.props';
 import { DateRange } from '../../../types/dateRange.type';
-declare const _default: <TValue extends Date>(__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 onFocus?: ((e: FocusEvent) => any) | undefined;
-        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
-        readonly "onUpdate:modelValue"?: ((value: DateRange<TValue>) => any) | undefined;
-        readonly "onUpdate:placeholderValue"?: ((value: Date) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onUpdate:modelValue" | "onUpdate:placeholderValue"> & ({
-        modelValue: DateRange<TValue>;
-        placeholderValue?: Date;
-    } & DateRangeFieldProps) & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
+type __VLS_Props = DateRangeFieldProps;
+type __VLS_PublicProps = {
+    modelValue: DateRange<Temporal.PlainDate>;
+    'placeholderValue'?: Temporal.PlainDate;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         default?(_: {
             segments: {
@@ -27,11 +23,47 @@ declare const _default: <TValue extends Date>(__VLS_props: NonNullable<Awaited<t
             };
         }): any;
     };
-    emit: DateRangeFieldEmits & (((evt: "update:modelValue", value: DateRange<TValue>) => void) & ((evt: "update:placeholderValue", value: Date) => void));
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    refs: {};
+    rootEl: any;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: DateRange<Temporal.PlainDate>) => any;
+    "update:placeholderValue": (value: Temporal.PlainDate) => any;
+} & {
+    focus: (e: FocusEvent) => any;
+    blur: (e: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: DateRange<Temporal.PlainDate>) => any) | undefined;
+    "onUpdate:placeholderValue"?: ((value: Temporal.PlainDate) => any) | undefined;
+}>, {
+    variant: null;
+    iconLeft: import('../../..').Icon | null;
+    label: string | null;
+    hint: string | null;
+    isLoading: boolean;
+    testId: string | null;
+    isDisabled: boolean;
+    id: string | null;
+    isRequired: boolean;
+    isTouched: boolean;
+    errorMessage: string | null;
+    classConfig: ResolvedClassConfig<"dateRangeField"> | null;
+    autocomplete: "off" | "on";
+    hideDatePicker: boolean;
+    maxDate: Date | null;
+    minDate: Date | null;
+    isDateDisabled: (date: Date) => boolean;
+    isDateUnavailable: (date: Date) => boolean;
+    allowDeselect: boolean;
+    showTwoMonths: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dialog/Dialog.d.ts

@@ -23,9 +23,11 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     close: () => any;
     "update:isOpen": (value: boolean) => any;
+    close_: () => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onClose?: (() => any) | undefined;
     "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
+    onClose_?: (() => any) | undefined;
 }>, {
     testId: string | null;
     classConfig: import('../../class-variant/classVariant.type').ResolvedClassConfig<"dialog"> | null;

package/dist/components/dialog/DialogContainer.d.ts

@@ -1,6 +1,2 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:activeDialogCount": (count: number) => any;
-}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
-    "onUpdate:activeDialogCount"?: ((count: number) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/dialog/dialog.composable.d.ts

@@ -1,5 +1,13 @@
-import { Component, Ref } from 'vue';
-import { Dialog, UseDialogContainerReturnType, UseDialogOptions, UseDialogReturnType } from './dialog.type';
+import { Ref } from 'vue';
+import { Dialog, DialogTriggerProps, GetComponentProps, OpenDialog } from './dialog.type';
 export declare const dialogs: Ref<Dialog[]>;
-export declare function useDialogContainer(): UseDialogContainerReturnType;
-export declare function useDialog<TComponent extends Component>(options: UseDialogOptions<TComponent>): UseDialogReturnType<TComponent>;
+export declare function useDialogContainer(): {
+    dialogs: Ref<Dialog[], Dialog[]>;
+};
+export declare function removeDialogFromContainer(id: string): void;
+export declare function useDialog<TComponent extends abstract new (...args: any) => any>(component: TComponent): {
+    isOpen: import('vue').ComputedRef<boolean>;
+    close: () => void;
+    open: OpenDialog<GetComponentProps<TComponent>>;
+    triggerProps: import('vue').ComputedRef<DialogTriggerProps>;
+};

package/dist/components/dialog/dialog.type.d.ts

@@ -1,64 +1,22 @@
-import { Component, Ref } from 'vue';
+import { Component } from 'vue';
 export interface DialogTriggerProps {
     'id': string;
+    'aria-controls'?: string;
     'aria-expanded': boolean;
     'aria-haspopup': 'dialog';
     'data-state': boolean;
 }
-export type IgnoredKeys = '__v_isVNode' | 'class' | 'key' | 'onVnodeBeforeMount' | 'onVnodeBeforeUnmount' | 'onVnodeBeforeUpdate' | 'onVnodeMounted' | 'onVnodeUnmounted' | 'onVnodeUpdated' | 'ref' | 'ref_for' | 'ref_key' | 'style';
+export type IgnoredProps = '__v_isVNode' | 'class' | 'key' | 'onVnodeBeforeMount' | 'onVnodeBeforeUnmount' | 'onVnodeBeforeUpdate' | 'onVnodeMounted' | 'onVnodeUnmounted' | 'onVnodeUpdated' | 'ref' | 'ref_for' | 'ref_key' | 'style';
 type PickKeys<T extends object, TValue extends null | undefined> = NonNullable<{
     [K in keyof T]: TValue extends T[K] ? K : never;
 }[keyof T]>;
 type OptionalKeys<T extends object> = PickKeys<T, undefined>;
 type RequiredKeys<T extends object> = Exclude<keyof T, OptionalKeys<T>>;
-export interface Constructor<P = never> {
-    __isFragment?: never;
-    __isSuspense?: never;
-    __isTeleport?: never;
-    new (...args: never[]): {
-        $props: P;
-    };
-}
-export type Attrs<TComponent> = Omit<{
-    [K in keyof TComponent]: Ref<TComponent[K]> | TComponent[K];
-}, 'isOpen'>;
-export interface UseDialogOptions<TComponent extends Component> {
-    /**
-     * The component to render. Must be a component of which the root is `AppDialog`
-     */
-    component: () => Promise<{
-        default: Constructor<TComponent>;
-    }>;
-}
-export interface UseDialogReturnType<TComponent extends Component> {
-    isOpen: (id?: string) => boolean;
-    /**
-     * Close the dialog
-     */
-    close: (id?: string) => void;
-    /**
-     * The props to pass to the trigger
-     * @param id The id of the dialog
-     */
-    getTriggerProps: (id?: string) => DialogTriggerProps;
-    /**
-     * Open the dialog
-     * @param attrs The props to pass to the dialog - optional
-     */
-    open: Omit<Attrs<TComponent>, 'Symbol'> extends Record<string, never> ? (attrs?: {
-        id?: string;
-    }) => Promise<void> : RequiredKeys<Omit<Attrs<TComponent>, 'Symbol'>> extends Record<string, never> ? (attrs?: Omit<Attrs<TComponent>, IgnoredKeys> & {
-        id?: string;
-    }) => Promise<void> : (attrs: Omit<Attrs<TComponent>, IgnoredKeys> & {
-        id?: string;
-    }) => Promise<void>;
-}
+export type GetComponentProps<TComponent extends abstract new (...args: any) => any> = Omit<InstanceType<TComponent>['$props'], IgnoredProps>;
+export type OpenDialog<TProps extends Record<string, any>> = TProps extends Record<string, never> ? () => Promise<void> : RequiredKeys<Omit<TProps, IgnoredProps>> extends Record<string, never> ? (attrs?: Omit<TProps, IgnoredProps>) => Promise<void> : (attrs: Omit<TProps, IgnoredProps>) => Promise<void>;
 export interface Dialog {
     id: string;
     isOpen: boolean;
     component: Component;
 }
-export interface UseDialogContainerReturnType {
-    dialogs: Ref<Dialog[]>;
-}
 export {};

package/dist/components/dialog/index.d.ts

@@ -1,4 +1,4 @@
-export { useDialog as useVcDialog } from './dialog.composable';
+export { useDialog } from './dialog.composable';
 export type { DialogProps as VcDialogProps } from './dialog.props';
 export { createDialogStyle } from './dialog.style';
 export type { DialogTriggerProps as VcDialogTriggerProps } from './dialog.type';

package/dist/components/dropdown-menu/DropdownMenu.d.ts

@@ -29,8 +29,12 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    closeAutoFocus: (event: Event) => any;
     "update:isOpen": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
     "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/components/dropdown-menu/dropdownMenu.context.d.ts

@@ -7,6 +7,8 @@ interface DropdownMenuContext extends PropsToComputed<DropdownMenuProps> {
     isOpen: ComputedRef<boolean>;
     customClassConfig: ComputedRef<ResolvedClassConfig<'dropdownMenu'>>;
     style: ComputedRef<CreateDropdownMenuStyle>;
+    onCloseAutoFocus: (event: Event) => void;
+    onEscapeKeyDown: (event: KeyboardEvent) => void;
 }
 export declare const useProvideDropdownMenuContext: (context: DropdownMenuContext) => DropdownMenuContext, useInjectDropdownMenuContext: <TFallback extends DropdownMenuContext | null = DropdownMenuContext>(fallback?: TFallback | undefined) => TFallback extends null ? DropdownMenuContext | null : DropdownMenuContext;
 export {};

package/dist/components/dropdown-menu/parts/DropdownMenuRoot.d.ts

@@ -13,8 +13,12 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    closeAutoFocus: (event: Event) => any;
     "update:isOpen": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
     "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
 }>, {
     variant: null;

package/dist/components/index.d.ts

@@ -28,7 +28,6 @@ export * from './select';
 export * from './spinner';
 export * from './switch';
 export * from './table';
-export * from './table-next';
 export * from './tabs';
 export * from './text-field';
 export * from './textarea';

package/dist/components/table/index.d.ts

@@ -1,15 +1,11 @@
 export { default as VcTableBody } from './parts/TableBody';
 export { default as VcTableCell } from './parts/TableCell';
+export { default as VcTableCellSkeleton } from './parts/TableCellSkeleton';
 export { default as VcTableContent } from './parts/TableContent';
-export { default as VcTableEmptyOrLoadingState } from './parts/TableEmptyOrLoadingState';
 export { default as VcTableHeader } from './parts/TableHeader';
-export { default as VcTableHeadercell } from './parts/TableHeaderCell';
+export { default as VcTableHeaderCell } from './parts/TableHeaderCell';
 export { default as VcTableHiddenResultsHint } from './parts/TableHiddenResultsHint';
-export { default as VcTableInteractiveElement } from './parts/TableInteractiveElement';
 export { default as VcTableRoot } from './parts/TableRoot';
 export { default as VcTableRow } from './parts/TableRow';
 export { default as VcTableScrollContainer } from './parts/TableScrollContainer';
-export type { TableProps as VcTableProps } from './table.props';
-export { createTableStyle } from './table.style';
-export type { TableColumn } from './table.type';
-export { default as VcTable } from './Table';
+export { type TableRowAction } from './table.type';

package/dist/components/table/parts/TableBody.d.ts

@@ -1,2 +1,17 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/table/parts/TableCell.d.ts

@@ -1,8 +1,5 @@
 type __VLS_Props = {
-    /**
-     * When set to true, the cell will have the primary text color to make it stand out
-     * @default false
-     */
+    hasInteractiveContent?: boolean;
     isPrimaryCell?: boolean;
 };
 declare function __VLS_template(): {
@@ -15,6 +12,7 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    hasInteractiveContent: boolean;
     isPrimaryCell: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/components/table/parts/TableHeader.d.ts

@@ -1,2 +1,17 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/table/parts/TableHeaderCell.d.ts

@@ -1,14 +1,25 @@
+type __VLS_Props = {
+    isSortable?: boolean;
+    sortDirection?: 'asc' | 'desc' | null;
+};
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
-        left?(_: {}): any;
-        right?(_: {}): any;
+        default?(_: {}): any;
+        default?(_: {}): any;
     };
     refs: {};
-    rootEl: any;
+    rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSort?: (() => any) | undefined;
+}>, {
+    isSortable: boolean;
+    sortDirection: "asc" | "desc" | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/table/parts/TableHiddenResultsHint.d.ts

@@ -1,2 +1,8 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type __VLS_Props = {
+    isEmpty: boolean;
+    isLoading: boolean;
+    activeFilterCount: number;
+    onClear: () => void;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/table/parts/TableRoot.d.ts

@@ -1,20 +1,27 @@
-import { TableEmits } from '../table.emits';
 import { TableProps } from '../table.props';
-import { BasePagination } from '../../../composables/pagination/pagination.type';
-declare const _default: <TSchema, TPagination extends BasePagination>(__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 onNextPage?: (() => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onNextPage"> & TableProps<TSchema, TPagination> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
-    attrs: any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
-        default?(_: {}): any;
+        default?(_: {
+            hasReachedHorizontalEnd: boolean;
+            hasVerticalOverflow: boolean;
+            isScrolledHorizontally: boolean;
+        }): any;
     };
-    emit: TableEmits;
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    refs: {};
+    rootEl: HTMLDivElement;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableProps> & Readonly<{}>, {
+    variant: null;
+    classConfig: import('../../../class-variant/classVariant.type').ResolvedClassConfig<"table"> | null;
+    isFirstColumnSticky: boolean;
+    isLastColumnSticky: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/table/parts/TableRow.d.ts

@@ -1,5 +1,23 @@
+import { TableRowAction } from '../table.type';
 type __VLS_Props = {
-    data: any;
+    action?: TableRowAction | null;
 };
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    action: TableRowAction | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/table/table.composable.d.ts

@@ -1,16 +1,7 @@
-import { ComputedRef } from 'vue';
-import { TableColumn } from './table.type';
-interface UseTableOptions {
-    columns: ComputedRef<TableColumn<any>[]>;
-    rowCount: ComputedRef<number>;
-    onNextPage: () => void;
-}
-interface UseTable {
-    hasReachedHorizontalEnd: ComputedRef<boolean>;
-    hasVerticalOverflow: ComputedRef<boolean>;
-    isScrolledHorizontally: ComputedRef<boolean>;
-    gridTemplateColumns: ComputedRef<string>;
+export declare function useTable(): {
+    hasReachedHorizontalEnd: import('vue').ComputedRef<boolean>;
+    hasVerticalOverflow: import('vue').ComputedRef<boolean>;
+    isScrolledHorizontally: import('vue').ComputedRef<boolean>;
     setTableScrollContainerRef: (el: HTMLElement) => void;
-}
-export declare function useTable({ columns, rowCount, onNextPage, }: UseTableOptions): UseTable;
-export {};
+    tableScrollContainerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+};

package/dist/components/table/table.context.d.ts

@@ -3,17 +3,13 @@ import { ResolvedClassConfig } from '../../class-variant/classVariant.type';
 import { TableProps } from './table.props';
 import { CreateTableStyle } from './table.style';
 import { PropsToComputed } from '../../utils/props.util';
-interface TableContext extends PropsToComputed<TableProps<any, any>> {
+interface TableContext extends PropsToComputed<TableProps> {
     hasReachedHorizontalEnd: ComputedRef<boolean>;
     hasVerticalOverflow: ComputedRef<boolean>;
-    isEmpty: ComputedRef<boolean>;
     isScrolledHorizontally: ComputedRef<boolean>;
-    activeFilterCount: ComputedRef<number>;
     customClassConfig: ComputedRef<ResolvedClassConfig<'table'>>;
-    gridTemplateColumns: ComputedRef<string>;
     setTableScrollContainerRef: (el: HTMLElement) => void;
     style: ComputedRef<CreateTableStyle>;
-    onClearFiltersAndSearch: () => void;
 }
 export declare const useProvideTableContext: (context: TableContext) => TableContext, useInjectTableContext: <TFallback extends TableContext | null = TableContext>(fallback?: TFallback | undefined) => TFallback extends null ? TableContext | null : TableContext;
 export {};