@pantograph/vue 0.27.10 → 0.28.0

package/dist/DataTable/components/DataTableHeaderCell.d.ts

@@ -0,0 +1,442 @@
+import { TableCol } from '../types';
+type __VLS_Props = {
+    column: TableCol;
+    cellProps: any;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        headerCell?(_: {
+            column: import('..').TableColExtra & Omit<import('..').TableCustomCellReturn, "rowSpan"> & import('..').TableColumnBase<any> & {
+                customCell?: import('..').TableCustomCell<any>;
+            } & {
+                [key: string]: unknown;
+            };
+        }): any;
+    };
+    refs: {
+        filterRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly text?: string | number | undefined;
+                readonly class?: import('clsx').ClassValue;
+                readonly flipOnDir?: import('../..').FlipOnDir | undefined;
+                readonly target?: string | undefined;
+                readonly size?: import('../..').ButtonSize | undefined;
+                readonly icon?: string | undefined;
+                readonly as?: import('reka-ui').AsTag | import('vue').Component | undefined;
+                readonly active?: boolean | undefined;
+                readonly preIcon?: string | undefined;
+                readonly postIcon?: string | undefined;
+                readonly loading?: boolean | undefined;
+                readonly block?: boolean | undefined;
+                readonly noRing?: boolean | undefined;
+                readonly badgeText?: string | undefined;
+                readonly badgeIcon?: string | undefined;
+                readonly preIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                readonly postIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                readonly badgeIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                readonly htmlType?: "reset" | "submit" | "button" | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly hover?: boolean | undefined;
+                readonly href?: string | undefined;
+                readonly type?: Exclude<import('../..').ButtonType, "fill"> | undefined;
+                readonly variant?: Exclude<import('../..').ButtonVariant, "float"> | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                buttonRef: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly as?: import('reka-ui').AsTag | import('vue').Component | undefined;
+                        readonly class?: import('clsx').ClassValue;
+                        readonly text?: string | number | undefined;
+                        readonly size?: import('../..').ButtonSize | undefined;
+                        readonly color?: import('../..').ButtonColor | undefined;
+                        readonly noRing?: boolean | undefined;
+                        readonly type?: import('../..').ButtonType | undefined;
+                        readonly variant?: import('../..').ButtonVariant | undefined;
+                        readonly loading?: boolean | undefined;
+                        readonly action?: boolean | undefined;
+                        readonly active?: boolean | undefined;
+                        readonly badgeText?: string | undefined;
+                        readonly badgeIcon?: string | undefined;
+                        readonly icon?: string | undefined;
+                        readonly preIcon?: string | undefined;
+                        readonly postIcon?: string | undefined;
+                        readonly flipOnDir?: import('../..').FlipOnDir | undefined;
+                        readonly preIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                        readonly postIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                        readonly badgeIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                        readonly htmlType?: "reset" | "submit" | "button" | undefined;
+                        readonly block?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly hover?: boolean | undefined;
+                        readonly href?: string | undefined;
+                        readonly target?: string | undefined;
+                        readonly onClick?: ((...args: any[]) => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        buttonRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import('vue').PropType<import('reka-ui').AsTag | import('vue').Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                            asChild: boolean;
+                            as: import('reka-ui').AsTag | import('vue').Component;
+                        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('vue').ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import('vue').PropType<import('reka-ui').AsTag | import('vue').Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, {
+                            asChild: boolean;
+                            as: import('reka-ui').AsTag | import('vue').Component;
+                        }> | null;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "click", ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('../..').BaseButtonProps> & Readonly<{
+                        onClick?: ((...args: any[]) => any) | undefined;
+                    }>, {
+                        focus(): void;
+                        blur(): void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        click: (...args: any[]) => void;
+                    }, string, {
+                        color: import('../..').ButtonColor;
+                        type: import('../..').ButtonType;
+                        htmlType: "reset" | "submit" | "button";
+                        disabled: boolean;
+                    }, {}, 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 extends string | ((...args: any) => any)>(source: T, cb: T 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<{
+                    color: import('../..').ButtonColor;
+                    type: import('../..').ButtonType;
+                    htmlType: "reset" | "submit" | "button";
+                    disabled: boolean;
+                }> & Omit<Readonly<import('../..').BaseButtonProps> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, "blur" | "focus" | ("color" | "type" | "htmlType" | "disabled")> & import('vue').ShallowUnwrapRef<{
+                    focus(): void;
+                    blur(): void;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: Readonly<import('../..').BaseButtonSlots> & import('../..').BaseButtonSlots;
+                }) | null;
+            };
+            $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('../..').ActionButtonProps> & Readonly<{}>, {
+                focus(): void;
+                blur(): void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                disabled: boolean;
+            }, {}, 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 extends string | ((...args: any) => any)>(source: T, cb: T 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<{
+            disabled: boolean;
+        }> & Omit<Readonly<import('../..').ActionButtonProps> & Readonly<{}>, "blur" | "focus" | "disabled"> & import('vue').ShallowUnwrapRef<{
+            focus(): void;
+            blur(): void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<import('../..').BaseButtonSlots> & import('../..').BaseButtonSlots;
+        }) | null;
+        actionRef: HTMLDivElement;
+    };
+    rootEl: HTMLTableCellElement;
+};
+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<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    filterRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly text?: string | number | undefined;
+            readonly class?: import('clsx').ClassValue;
+            readonly flipOnDir?: import('../..').FlipOnDir | undefined;
+            readonly target?: string | undefined;
+            readonly size?: import('../..').ButtonSize | undefined;
+            readonly icon?: string | undefined;
+            readonly as?: import('reka-ui').AsTag | import('vue').Component | undefined;
+            readonly active?: boolean | undefined;
+            readonly preIcon?: string | undefined;
+            readonly postIcon?: string | undefined;
+            readonly loading?: boolean | undefined;
+            readonly block?: boolean | undefined;
+            readonly noRing?: boolean | undefined;
+            readonly badgeText?: string | undefined;
+            readonly badgeIcon?: string | undefined;
+            readonly preIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+            readonly postIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+            readonly badgeIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+            readonly htmlType?: "reset" | "submit" | "button" | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly hover?: boolean | undefined;
+            readonly href?: string | undefined;
+            readonly type?: Exclude<import('../..').ButtonType, "fill"> | undefined;
+            readonly variant?: Exclude<import('../..').ButtonVariant, "float"> | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            buttonRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly as?: import('reka-ui').AsTag | import('vue').Component | undefined;
+                    readonly class?: import('clsx').ClassValue;
+                    readonly text?: string | number | undefined;
+                    readonly size?: import('../..').ButtonSize | undefined;
+                    readonly color?: import('../..').ButtonColor | undefined;
+                    readonly noRing?: boolean | undefined;
+                    readonly type?: import('../..').ButtonType | undefined;
+                    readonly variant?: import('../..').ButtonVariant | undefined;
+                    readonly loading?: boolean | undefined;
+                    readonly action?: boolean | undefined;
+                    readonly active?: boolean | undefined;
+                    readonly badgeText?: string | undefined;
+                    readonly badgeIcon?: string | undefined;
+                    readonly icon?: string | undefined;
+                    readonly preIcon?: string | undefined;
+                    readonly postIcon?: string | undefined;
+                    readonly flipOnDir?: import('../..').FlipOnDir | undefined;
+                    readonly preIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                    readonly postIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                    readonly badgeIconFlipOnDir?: import('../..').FlipOnDir | undefined;
+                    readonly htmlType?: "reset" | "submit" | "button" | undefined;
+                    readonly block?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly hover?: boolean | undefined;
+                    readonly href?: string | undefined;
+                    readonly target?: string | undefined;
+                    readonly onClick?: ((...args: any[]) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    buttonRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                        asChild: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('reka-ui').AsTag | import('vue').Component>;
+                            default: string;
+                        };
+                    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                        [key: string]: any;
+                    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        asChild: boolean;
+                        as: import('reka-ui').AsTag | import('vue').Component;
+                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('vue').ExtractPropTypes<{
+                        asChild: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('reka-ui').AsTag | import('vue').Component>;
+                            default: string;
+                        };
+                    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                        [key: string]: any;
+                    }>, {}, {}, {}, {
+                        asChild: boolean;
+                        as: import('reka-ui').AsTag | import('vue').Component;
+                    }> | null;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: "click", ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('../..').BaseButtonProps> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    focus(): void;
+                    blur(): void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (...args: any[]) => void;
+                }, string, {
+                    color: import('../..').ButtonColor;
+                    type: import('../..').ButtonType;
+                    htmlType: "reset" | "submit" | "button";
+                    disabled: boolean;
+                }, {}, 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 extends string | ((...args: any) => any)>(source: T, cb: T 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<{
+                color: import('../..').ButtonColor;
+                type: import('../..').ButtonType;
+                htmlType: "reset" | "submit" | "button";
+                disabled: boolean;
+            }> & Omit<Readonly<import('../..').BaseButtonProps> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, "blur" | "focus" | ("color" | "type" | "htmlType" | "disabled")> & import('vue').ShallowUnwrapRef<{
+                focus(): void;
+                blur(): void;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: Readonly<import('../..').BaseButtonSlots> & import('../..').BaseButtonSlots;
+            }) | null;
+        };
+        $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('../..').ActionButtonProps> & Readonly<{}>, {
+            focus(): void;
+            blur(): void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            disabled: boolean;
+        }, {}, 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 extends string | ((...args: any) => any)>(source: T, cb: T 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<{
+        disabled: boolean;
+    }> & Omit<Readonly<import('../..').ActionButtonProps> & Readonly<{}>, "blur" | "focus" | "disabled"> & import('vue').ShallowUnwrapRef<{
+        focus(): void;
+        blur(): void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<import('../..').BaseButtonSlots> & import('../..').BaseButtonSlots;
+    }) | null;
+    actionRef: HTMLDivElement;
+}, HTMLTableCellElement>;
+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/DataTable/components/DataTableHeaderCellActionsPopover.d.ts

@@ -0,0 +1,8 @@
+import { TableCol } from '../types';
+import { PopoverProps } from '../../Popover';
+type __VLS_Props = {
+    column: TableCol;
+    parentReference: PopoverProps['reference'];
+};
+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/DataTable/components/DataTableLazyLoading.d.ts

@@ -0,0 +1,53 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    target: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly class?: import('clsx').ClassValue;
+            readonly size?: import('../..').TableSize | undefined;
+            readonly empty?: boolean | undefined;
+            readonly wrap?: boolean | undefined;
+            readonly lazyLoadObserver?: boolean | undefined;
+            readonly fixed?: boolean | undefined;
+            readonly afterShadow?: boolean | undefined;
+            readonly ellipseHFull?: boolean | 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: HTMLTableCellElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../..').TdProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, 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 extends string | ((...args: any) => any)>(source: T, cb: T 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<{}> & Omit<Readonly<import('../..').TdProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<import('../..').TdSlots> & import('../..').TdSlots;
+    }) | null;
+}, any>;
+export default _default;

package/dist/DataTable/components/DataTableLoading.d.ts

@@ -0,0 +1,21 @@
+import { TableColumn } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        skeleton?(_: {
+            index: number;
+            column: TableColumn;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+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 _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DataTable/components/DataTableRow.d.ts

@@ -0,0 +1,7 @@
+import { Row } from '@tanstack/table-core';
+type __VLS_Props = {
+    row: Row<unknown>;
+    hasSubRows: boolean;
+};
+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, {}, HTMLTableRowElement>;
+export default _default;

package/dist/DataTable/index.d.ts

@@ -1,3 +1,2 @@
 export { default as DataTable, default } from './DataTable';
-export { type DataTableProps, type GetRowProps, type DataTableSlots, type DataTableEmits, type SortItem, } from './types';
-export * from './DataTable.model';
+export * from './types';

package/dist/DataTable/index.js

@@ -1,5 +1,6 @@
-import { _ as t, _ as f } from "../DataTable.vue_vue_type_style_index_0_lang-B2ObeeJP.js";
+import { _ as o, _ as r } from "../DataTable.vue_vue_type_style_index_0_lang-D3bUDHDD.js";
+import "../Popover.vue_vue_type_style_index_0_lang-CpPisJIC.js";
 export {
-  t as DataTable,
-  f as default
+  o as DataTable,
+  r as default
 };

package/dist/DataTable/index.umd.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("../DataTable.vue_vue_type_style_index_0_lang-BUZ8G07U.js");exports.DataTable=e._sfc_main;exports.default=e._sfc_main;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("../DataTable.vue_vue_type_style_index_0_lang-Ix_14tDu.js");require("../Popover.vue_vue_type_style_index_0_lang-DQJCWgtP.js");exports.DataTable=e._sfc_main;exports.default=e._sfc_main;

package/dist/DataTable/types/cell.d.ts

@@ -0,0 +1,11 @@
+import { ClassValue } from 'class-variance-authority/types';
+import { TableGetFunctionsProps } from './index';
+export type TableCustomCellReturn = {
+    colSpan?: number;
+    rowSpan?: number;
+    class?: ClassValue;
+    wrap?: boolean;
+    editing?: boolean;
+    ellipseHFull?: boolean;
+};
+export type TableCustomCell<T = any> = TableCustomCellReturn | ((props?: Partial<TableGetFunctionsProps<T>>) => TableCustomCellReturn | undefined) | undefined;

package/dist/DataTable/types/column.d.ts

@@ -0,0 +1,58 @@
+import { VNode } from 'vue';
+import { TableCustomCell, TableCustomCellReturn } from './cell';
+import { SkeletonProps } from '../../Skeleton';
+import { TableTitle } from './common';
+import { PopoverProps } from '../../Popover';
+import { Column } from '@tanstack/vue-table';
+export interface TableGetFunctionsProps<T = any> {
+    index: number;
+    record: T;
+    parentId?: string;
+    depth: number;
+    id: {
+        cell: string;
+        column: string;
+    };
+    column: TableColumnBase<T> & TableColExtra;
+}
+export type TableCustomRender<T = any> = (data?: Partial<TableGetFunctionsProps<T>>) => VNode | undefined;
+export interface TableColExtra {
+    id: string;
+    bind: {
+        style: Record<string, any>;
+        fixed: boolean;
+        afterShadow: boolean;
+    };
+}
+export interface DataTableSlotProps {
+    visibleColumns: (TableColumn & TableColExtra)[];
+    visibleRows: object[];
+}
+export interface TableColumnBase<T = any> extends Omit<TableCustomCellReturn, 'rowSpan'> {
+    dataIndex?: string;
+    render?: TableCustomRender<T>;
+    id: string;
+    responsive?: ('desktop' | 'tablet' | 'mobile')[];
+    sorter?: ((a: T, b: T) => number) | 'basic' | 'datetime' | 'textCaseSensitive' | 'text' | 'alphanumericCaseSensitive' | 'alphanumeric' | 'server';
+    hideColumnWrap?: boolean;
+    sortOrder?: 'asc' | 'desc';
+    multiSort?: number;
+    defaultSortOrder?: 'asc' | 'desc';
+    title?: TableTitle;
+    width?: number | string;
+    maxWidth?: number;
+    minWidth?: number;
+    skeletonProps?: SkeletonProps & Record<string, any>;
+    fixed?: boolean;
+    hasFilter?: boolean;
+    onFilter?: (reference: PopoverProps['reference'], placement: PopoverProps['placement']) => void;
+    onDeleteFilter?: (reference: PopoverProps['reference'], placement: PopoverProps['placement']) => void;
+}
+export type TableColumn<T = any> = Omit<TableCustomCellReturn, 'rowSpan'> & TableColumnBase & {
+    customCell?: TableCustomCell<T>;
+} & {
+    [key: string]: unknown;
+};
+export type TableCol = Column<unknown> & {
+    columnDef: TableColumn;
+};

package/dist/DataTable/types/common.d.ts

@@ -0,0 +1,12 @@
+import { VNode } from 'vue';
+export type TableTitle = string | (() => VNode);
+export interface GetTableRowProps {
+    index?: number;
+    row?: object;
+    loading?: boolean;
+    header?: boolean;
+    empty?: boolean;
+    lazyLoadObserver?: boolean;
+    zebra?: boolean;
+    checked?: boolean;
+}