@vtj/ui 0.8.135 → 0.8.137

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

@@ -1,17 +1,371 @@
-import { DefineComponent, PropType, VNode, ComputedRef, Ref, ComponentOptionsMixin, ComponentInternalInstance, PublicProps, ExtractPropTypes } from 'vue';
-import { IconParam } from '../';
+import { nextTick, ComponentInternalInstance, ExtractPropTypes, PropType, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, Ref, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, DefineComponent, VNode, ComputedRef, PublicProps } from 'vue';
 import { BaseSize } from '../shared';
-import { DraggableOptions, ResizableOptions } from '../../directives';
+import { ContainerDirection, ContainerWrap, ContainerJustifyContent, ContainerAlignItems, ContainerAlignContent, ContainerProps } from '../container';
+import { IconParam } from '../icon';
+import { HeaderProps } from '../header';
+import { OnCleanup } from '@vue/reactivity';
+import { DraggableOptions, ResizableOptions } from '../..';
 import { DialogMode } from './types';
 import { UseMouseSourceType, Position } from '@vueuse/core';
 declare function __VLS_template(): {
-    actions?(_: {}): any;
-    default?(_: {}): any;
-    footer?(_: {}): any;
-    extra?(_: {}): any;
-    handle?(_: {}): any;
+    slots: {
+        actions?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+        extra?(_: {}): any;
+        handle?(_: {}): any;
+    };
+    refs: {
+        wrapper: HTMLDivElement;
+        panelRef: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                radius: boolean;
+                fit: boolean;
+                border: boolean;
+                card: boolean;
+            }> & Omit<{
+                readonly radius: boolean;
+                readonly fit: boolean;
+                readonly border: boolean;
+                readonly card: boolean;
+                readonly size?: BaseSize | undefined;
+                readonly body?: Readonly<Partial< ExtractPropTypes<{
+                    tag: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    fit: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    width: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    height: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    flex: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                    };
+                    direction: {
+                        type: PropType<ContainerDirection>;
+                        default: string;
+                    };
+                    wrap: {
+                        type: PropType<ContainerWrap>;
+                        default: string;
+                    };
+                    justify: {
+                        type: PropType<ContainerJustifyContent>;
+                        default: string;
+                    };
+                    align: {
+                        type: PropType<ContainerAlignItems>;
+                        default: string;
+                    };
+                    alignContent: {
+                        type: PropType<ContainerAlignContent>;
+                        default: string;
+                    };
+                    grow: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    shrink: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    alignSelf: {
+                        type: PropType<"auto" | ContainerAlignItems>;
+                        default: string;
+                    };
+                    overflow: {
+                        type: PropType<"auto" | "hidden" | "visible">;
+                    };
+                    padding: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    gap: {
+                        type: BooleanConstructor;
+                    };
+                    autoPointer: {
+                        type: BooleanConstructor;
+                    };
+                }>>> | undefined;
+                readonly footer?: Readonly<Partial< ExtractPropTypes<{
+                    tag: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    fit: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    width: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    height: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    flex: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    inline: {
+                        type: BooleanConstructor;
+                    };
+                    direction: {
+                        type: PropType<ContainerDirection>;
+                        default: string;
+                    };
+                    wrap: {
+                        type: PropType<ContainerWrap>;
+                        default: string;
+                    };
+                    justify: {
+                        type: PropType<ContainerJustifyContent>;
+                        default: string;
+                    };
+                    align: {
+                        type: PropType<ContainerAlignItems>;
+                        default: string;
+                    };
+                    alignContent: {
+                        type: PropType<ContainerAlignContent>;
+                        default: string;
+                    };
+                    grow: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    shrink: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    alignSelf: {
+                        type: PropType<"auto" | ContainerAlignItems>;
+                        default: string;
+                    };
+                    overflow: {
+                        type: PropType<"auto" | "hidden" | "visible">;
+                    };
+                    padding: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    gap: {
+                        type: BooleanConstructor;
+                    };
+                    autoPointer: {
+                        type: BooleanConstructor;
+                    };
+                }>>> | undefined;
+                readonly header?: string | Readonly<Partial< ExtractPropTypes<{
+                    size: {
+                        type: PropType<BaseSize>;
+                        default: string;
+                    };
+                    content: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    subtitle: {
+                        type: StringConstructor;
+                    };
+                    icon: {
+                        type: PropType<IconParam>;
+                    };
+                    border: {
+                        type: BooleanConstructor;
+                    };
+                    more: {
+                        type: BooleanConstructor;
+                    };
+                }>>> | null | undefined;
+                readonly width?: string | number | undefined;
+                readonly height?: string | number | undefined;
+                readonly shadow?: "hover" | "always" | "none" | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly< ExtractPropTypes<{
+                fit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                width: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                height: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                border: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                radius: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                card: {
+                    type: BooleanConstructor;
+                };
+                size: {
+                    type: PropType<BaseSize>;
+                };
+                shadow: {
+                    type: PropType<"none" | "always" | "hover">;
+                };
+                header: {
+                    type: PropType<string | HeaderProps | null>;
+                };
+                body: {
+                    type: PropType<ContainerProps>;
+                };
+                footer: {
+                    type: PropType<ContainerProps>;
+                };
+            }>> & Readonly<{}>, "radius" | "fit" | "border" | "card">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+                fit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                width: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                height: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                border: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                radius: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                card: {
+                    type: BooleanConstructor;
+                };
+                size: {
+                    type: PropType<BaseSize>;
+                };
+                shadow: {
+                    type: PropType<"none" | "always" | "hover">;
+                };
+                header: {
+                    type: PropType<string | HeaderProps | null>;
+                };
+                body: {
+                    type: PropType<ContainerProps>;
+                };
+                footer: {
+                    type: PropType<ContainerProps>;
+                };
+            }>> & Readonly<{}>, {
+                bodyRef: Ref<any, any>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                radius: boolean;
+                fit: boolean;
+                border: boolean;
+                card: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            radius: boolean;
+            fit: boolean;
+            border: boolean;
+            card: boolean;
+        }> & Omit<Readonly< ExtractPropTypes<{
+            fit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            width: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            height: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            border: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            radius: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            card: {
+                type: BooleanConstructor;
+            };
+            size: {
+                type: PropType<BaseSize>;
+            };
+            shadow: {
+                type: PropType<"none" | "always" | "hover">;
+            };
+            header: {
+                type: PropType<string | HeaderProps | null>;
+            };
+            body: {
+                type: PropType<ContainerProps>;
+            };
+            footer: {
+                type: PropType<ContainerProps>;
+            };
+        }>> & Readonly<{}>, "bodyRef" | ("radius" | "fit" | "border" | "card")> & ShallowUnwrapRef<{
+            bodyRef: Ref<any, any>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                header?(_: {}): any;
+                title?(_: {}): any;
+                actions?(_: {}): any;
+                default?(_: {}): any;
+                footer?(_: {}): any;
+            };
+        }) | null;
+    };
+    attrs: Partial<{}>;
 };
-declare const __VLS_component: DefineComponent<{
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ExtractPropTypes<{
     modelValue: {
         type: BooleanConstructor;
         default: boolean;
@@ -95,9 +449,9 @@ declare const __VLS_component: DefineComponent<{
     primary: {
         type: BooleanConstructor;
     };
-}, {
+}>, {
     $vtjEl: ComputedRef<any>;
-    panelRef: Ref<any>;
+    panelRef: Ref<any, any>;
     state: {
         mode: DialogMode;
         wrapperWidth: number;
@@ -121,11 +475,11 @@ declare const __VLS_component: DefineComponent<{
     componentInstance: {
         componentInstance: Record<string, any>;
     } | undefined;
-}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-    close: () => void;
-    cancel: () => void;
-    submit: () => void;
-    open: (instance: ComponentInternalInstance) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    close: () => any;
+    open: (instance: ComponentInternalInstance) => any;
+    submit: () => any;
+    cancel: () => any;
     resizing: (dir: string, mie: {
         x: Ref<number>;
         y: Ref<number>;
@@ -138,16 +492,16 @@ declare const __VLS_component: DefineComponent<{
         elementWidth: Ref<number>;
         isOutside: Ref<boolean>;
         stop: () => void;
-    }) => void;
-    normal: () => void;
-    maximized: () => void;
-    minimized: () => void;
-    dragging: (position: Position) => void;
-    "update:modelValue": (value: boolean) => void;
-    destroy: () => void;
-    modeChange: (mode: DialogMode) => void;
-    dragStart: (position: Position) => void;
-    dragEnd: (position: Position) => void;
+    }) => any;
+    normal: () => any;
+    maximized: () => any;
+    minimized: () => any;
+    dragging: (position: Position) => any;
+    "update:modelValue": (value: boolean) => any;
+    destroy: () => any;
+    modeChange: (mode: DialogMode) => any;
+    dragStart: (position: Position) => any;
+    dragEnd: (position: Position) => any;
     resizeStart: (dir: string, mie: {
         x: Ref<number>;
         y: Ref<number>;
@@ -160,7 +514,7 @@ declare const __VLS_component: DefineComponent<{
         elementWidth: Ref<number>;
         isOutside: Ref<boolean>;
         stop: () => void;
-    }) => void;
+    }) => any;
     resizeEnd: (dir: string, mie: {
         x: Ref<number>;
         y: Ref<number>;
@@ -173,7 +527,7 @@ declare const __VLS_component: DefineComponent<{
         elementWidth: Ref<number>;
         isOutside: Ref<boolean>;
         stop: () => void;
-    }) => void;
+    }) => any;
 }, string, PublicProps, Readonly< ExtractPropTypes<{
     modelValue: {
         type: BooleanConstructor;
@@ -258,8 +612,9 @@ declare const __VLS_component: DefineComponent<{
     primary: {
         type: BooleanConstructor;
     };
-}>> & {
+}>> & Readonly<{
     onClose?: (() => any) | undefined;
+    onOpen?: ((instance: ComponentInternalInstance) => any) | undefined;
     onSubmit?: (() => any) | undefined;
     onCancel?: (() => any) | undefined;
     onResizing?: ((dir: string, mie: {
@@ -275,7 +630,6 @@ declare const __VLS_component: DefineComponent<{
         isOutside: Ref<boolean>;
         stop: () => void;
     }) => any) | undefined;
-    onOpen?: ((instance: ComponentInternalInstance) => any) | undefined;
     onNormal?: (() => any) | undefined;
     onMaximized?: (() => any) | undefined;
     onMinimized?: (() => any) | undefined;
@@ -311,7 +665,7 @@ declare const __VLS_component: DefineComponent<{
         isOutside: Ref<boolean>;
         stop: () => void;
     }) => any) | undefined;
-}, {
+}>, {
     size: BaseSize;
     primary: boolean;
     mode: DialogMode;
@@ -324,8 +678,8 @@ declare const __VLS_component: DefineComponent<{
     maximizable: boolean;
     minimizable: boolean;
     bodyPadding: boolean;
-}, {}>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/types/components/dialog/create.d.ts

@@ -1,6 +1,5 @@
 import { AppContext, VNode, RendererNode, RendererElement } from 'vue';
 import { DialogProps } from './types';
-
 export type CreateDialogProps = DialogProps & {
     [index: string]: any;
 };

package/types/components/dialog/hooks.d.ts

@@ -2,7 +2,6 @@ import { MaybeRef, ComputedRef } from 'vue';
 import { DialogProps, DialogState, DialogMode, DialogEmits } from './types';
 import { Emits } from '../';
 import { DraggableOptions, ResizableOptions } from '../../directives';
-
 export declare function useState(props: DialogProps, wrapper: MaybeRef<HTMLElement>): {
     state: {
         mode: DialogMode;

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

@@ -1,5 +1,4 @@
 import { default as XDialog } from './Dialog';
-
 export { XDialog };
 export * from './types';
 export * from './create';

package/types/components/dialog/types.d.ts

@@ -3,7 +3,6 @@ import { Position } from '@vueuse/core';
 import { ComponentPropsType, BaseSize } from '../shared';
 import { IconParam } from '../';
 import { DraggableOptions, ResizableOptions, UseMouseInElementReturn } from '../../directives';
-
 export type DialogMode = 'normal' | 'maximized' | 'minimized';
 export declare const dialogProps: {
     modelValue: {