vue-next-yui 1.1.13 → 1.1.14

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

@@ -1,62 +1,7 @@
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import('vue').DefineComponent<{}, {
-    close: () => void;
-    $emit: (event: "close" | "cancel" | "confirm" | "opened" | "closed", ...args: any[]) => void;
-    color: string;
-    title: string;
-    mask: boolean;
-    width: string;
-    content: string;
-    maskClose: boolean;
-    zIndex: number;
-    closable: boolean;
-    lockScroll: boolean;
-    titleStyle: Record<string, any>;
-    contentStyle: Record<string, any>;
-    showCancel: boolean;
-    showConfirm: boolean;
-    cancelText: string;
-    confirmText: string;
-    fullscreen: boolean;
-    half: boolean;
-    confirmClose: boolean;
-    escClose: boolean;
-    attach: string | HTMLElement;
-    $props: {
-        readonly color?: string;
-        readonly title?: string;
-        readonly mask?: boolean;
-        readonly width?: string;
-        readonly content?: string;
-        readonly maskClose?: boolean;
-        readonly zIndex?: number;
-        readonly closable?: boolean;
-        readonly lockScroll?: boolean;
-        readonly titleStyle?: Record<string, any>;
-        readonly contentStyle?: Record<string, any>;
-        readonly showCancel?: boolean;
-        readonly showConfirm?: boolean;
-        readonly cancelText?: string;
-        readonly confirmText?: string;
-        readonly fullscreen?: boolean;
-        readonly half?: boolean;
-        readonly confirmClose?: boolean;
-        readonly escClose?: boolean;
-        readonly attach?: string | HTMLElement;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-type __VLS_TemplateResult = {
-    attrs: Partial<{}>;
-    slots: {
-        header?(_: {}): any;
-        default?(_: {}): any;
-        footer?(_: {}): any;
-    };
-    refs: {};
-    rootEl: any;
-};
-//# sourceMappingURL=index.vue.d.ts.map
+export function useMessage(): (params: any) => Promise<any>;
+export default MessagePlugin;
+export function Message(params: any): Promise<any>;
+export namespace MessagePlugin {
+    function install(app: any): void;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dialog/index.js"],"names":[],"mappings":"AAyFA,4DAEC;;AAXD,mDAAwC;;IAGtC,iCAGC"}e,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2OAUG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dialog/index.js"],"names":[],"mappings":"AAyFA,4DAEC;;AAXD,mDAAwC;;IAGtC,iCAGC"}

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

@@ -4,14 +4,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     color: string;
     text: string;
     bgColor: string;
-    zIndex: number;
     fullscreen: boolean;
+    zIndex: number;
     $props: {
         readonly color?: string;
         readonly text?: string;
         readonly bgColor?: string;
-        readonly zIndex?: number;
         readonly fullscreen?: boolean;
+        readonly zIndex?: number;
     };
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -3,14 +3,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     hide: () => void;
     $emit: (event: "close", ...args: any[]) => void;
     color: string;
-    zIndex: number;
     closable: boolean;
     lockScroll: boolean;
+    zIndex: number;
     $props: {
         readonly color?: string;
-        readonly zIndex?: number;
         readonly closable?: boolean;
         readonly lockScroll?: boolean;
+        readonly zIndex?: number;
     };
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -24,7 +24,7 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         readonly activeColor?: string;
     };
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    segmentedControlWrapperRef: HTMLDivElement;
+    segmentedControlRef: HTMLDivElement;
     sliderItemRef: HTMLDivElement[];
 }, HTMLDivElement>;
 type __VLS_TemplateResult = {
@@ -39,7 +39,7 @@ type __VLS_TemplateResult = {
         }): any;
     };
     refs: {
-        segmentedControlWrapperRef: HTMLDivElement;
+        segmentedControlRef: HTMLDivElement;
         sliderItemRef: HTMLDivElement[];
     };
     rootEl: HTMLDivElement;

package/dist/components/segmented/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.vue.d.ts","sourceRoot":"","sources":["../../../src/components/segmented/index.vue"],"names":[],"mappings":"wBAgTqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;mBAUG"}
+{"version":3,"file":"index.vue.d.ts","sourceRoot":"","sources":["../../../src/components/segmented/index.vue"],"names":[],"mappings":"wBAiTqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;mBAUG"}

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

@@ -5,8 +5,8 @@ declare const _default: import('vue').DefineComponent<{}, {
     title: string;
     mask: boolean;
     bgColor: string;
-    duration: number;
     closable: boolean;
+    duration: number;
     icon: boolean;
     alignCenter: boolean;
     $props: {
@@ -15,8 +15,8 @@ declare const _default: import('vue').DefineComponent<{}, {
         readonly title?: string;
         readonly mask?: boolean;
         readonly bgColor?: string;
-        readonly duration?: number;
         readonly closable?: boolean;
+        readonly duration?: number;
         readonly icon?: boolean;
         readonly alignCenter?: boolean;
     };

package/dist/components/tooltip/constants.d.ts

@@ -0,0 +1,3 @@
+export const tooltipKey: unique symbol;
+export const nestedTooltipKey: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/dist/components/tooltip/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/constants.js"],"names":[],"mappings":"AAAA,uCAA+C;AAE/C,6CAA2D"}

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

@@ -0,0 +1,3 @@
+export default showTooltip;
+declare function showTooltip(options: any): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/tooltip/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/index.js"],"names":[],"mappings":";AAaA,iDAKC"}

package/dist/components/tooltip/props.d.ts

@@ -0,0 +1,113 @@
+export namespace tooltipTriggerProps {
+    namespace trigger {
+        export let type: StringConstructor;
+        let _default: string;
+        export { _default as default };
+        export function validator(value: any): boolean;
+    }
+    namespace triggerStyle {
+        let type_1: ObjectConstructor;
+        export { type_1 as type };
+        function _default_1(): {};
+        export { _default_1 as default };
+    }
+}
+export namespace tooltipContentProps {
+    export namespace trigger_1 {
+        let type_2: StringConstructor;
+        export { type_2 as type };
+        let _default_2: string;
+        export { _default_2 as default };
+        export function validator_1(value: any): boolean;
+        export { validator_1 as validator };
+    }
+    export { trigger_1 as trigger };
+    export namespace placement {
+        let type_3: StringConstructor;
+        export { type_3 as type };
+        let _default_3: string;
+        export { _default_3 as default };
+        export function validator_2(value: any): boolean;
+        export { validator_2 as validator };
+    }
+    export namespace target {
+        let type_4: (StringConstructor | {
+            new (): HTMLElement;
+            prototype: HTMLElement;
+        })[];
+        export { type_4 as type };
+        function _default_4(): string;
+        export { _default_4 as default };
+    }
+    export namespace width {
+        let type_5: (StringConstructor | NumberConstructor)[];
+        export { type_5 as type };
+        let _default_5: string;
+        export { _default_5 as default };
+    }
+    export namespace content {
+        let type_6: StringConstructor;
+        export { type_6 as type };
+        let _default_6: string;
+        export { _default_6 as default };
+    }
+    export namespace contentClass {
+        let type_7: StringConstructor;
+        export { type_7 as type };
+        let _default_7: string;
+        export { _default_7 as default };
+    }
+    export namespace contentStyle {
+        let type_8: ObjectConstructor;
+        export { type_8 as type };
+        function _default_8(): {};
+        export { _default_8 as default };
+    }
+    export namespace offset {
+        let type_9: NumberConstructor;
+        export { type_9 as type };
+        let _default_9: number;
+        export { _default_9 as default };
+    }
+    export namespace bgColor {
+        let type_10: StringConstructor;
+        export { type_10 as type };
+        let _default_10: string;
+        export { _default_10 as default };
+    }
+    export namespace color {
+        let type_11: StringConstructor;
+        export { type_11 as type };
+        let _default_11: string;
+        export { _default_11 as default };
+    }
+    export namespace disabled {
+        let type_12: BooleanConstructor;
+        export { type_12 as type };
+        let _default_12: boolean;
+        export { _default_12 as default };
+    }
+    export namespace arrow {
+        let type_13: BooleanConstructor;
+        export { type_13 as type };
+        let _default_13: boolean;
+        export { _default_13 as default };
+    }
+    export namespace isStatic {
+        let type_14: BooleanConstructor;
+        export { type_14 as type };
+        let _default_14: boolean;
+        export { _default_14 as default };
+    }
+    export namespace attach {
+        let type_15: (StringConstructor | {
+            new (): HTMLElement;
+            prototype: HTMLElement;
+        })[];
+        export { type_15 as type };
+        function _default_15(): string;
+        export { _default_15 as default };
+    }
+}
+export namespace tooltipProps { }
+//# sourceMappingURL=props.d.ts.map

package/dist/components/tooltip/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/props.js"],"names":[],"mappings":";;;;;QAIe,+CAAsE;;;;;QAE5C,0BAAU;;;;;;;;;;QAOpC,iDAAsE;;;;;;;;;QAKtE,iDAAyK;;;;;;;;;QAEtI,8BAAU;;;;;;;;;;;;;;;;;;;;;;;;QAInB,0BAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOD,+BAAa"}

package/dist/components/tooltip/tooltip.d.ts

@@ -0,0 +1,52 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    show: () => void;
+    hide: () => void;
+    $emit: (event: "show" | "hide", ...args: any[]) => void;
+    color: string;
+    disabled: boolean;
+    offset: number;
+    arrow: boolean;
+    width: string | number;
+    bgColor: string;
+    content: string;
+    contentStyle: Record<string, any>;
+    attach: string | HTMLElement;
+    target: string | HTMLElement;
+    trigger: string;
+    triggerStyle: Record<string, any>;
+    placement: string;
+    contentClass: string;
+    isStatic: boolean;
+    $props: {
+        readonly color?: string;
+        readonly disabled?: boolean;
+        readonly offset?: number;
+        readonly arrow?: boolean;
+        readonly width?: string | number;
+        readonly bgColor?: string;
+        readonly content?: string;
+        readonly contentStyle?: Record<string, any>;
+        readonly attach?: string | HTMLElement;
+        readonly target?: string | HTMLElement;
+        readonly trigger?: string;
+        readonly triggerStyle?: Record<string, any>;
+        readonly placement?: string;
+        readonly contentClass?: string;
+        readonly isStatic?: boolean;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+//# sourceMappingURL=tooltip.vue.d.ts.map

package/dist/components/tooltip/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/tooltip.vue"],"names":[],"mappings":"wBA2aqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2OASG"}

package/dist/components/tooltip/tooltipContent.d.ts

@@ -0,0 +1,51 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "hover", ...args: any[]) => void;
+    color: string;
+    disabled: boolean;
+    offset: number;
+    arrow: boolean;
+    width: string | number;
+    bgColor: string;
+    content: string;
+    contentStyle: Record<string, any>;
+    attach: string | HTMLElement;
+    target: string | HTMLElement;
+    trigger: string;
+    placement: string;
+    contentClass: string;
+    isStatic: boolean;
+    $props: {
+        readonly color?: string;
+        readonly disabled?: boolean;
+        readonly offset?: number;
+        readonly arrow?: boolean;
+        readonly width?: string | number;
+        readonly bgColor?: string;
+        readonly content?: string;
+        readonly contentStyle?: Record<string, any>;
+        readonly attach?: string | HTMLElement;
+        readonly target?: string | HTMLElement;
+        readonly trigger?: string;
+        readonly placement?: string;
+        readonly contentClass?: string;
+        readonly isStatic?: boolean;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    contentRef: HTMLDivElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        contentRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=tooltipContent.vue.d.ts.map

package/dist/components/tooltip/tooltipContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltipContent.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/tooltipContent.vue"],"names":[],"mappings":"wBAmJqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAUG"}

package/dist/components/tooltip/trigger.d.ts

@@ -0,0 +1,27 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "click" | "hover" | "contextmenu", ...args: any[]) => void;
+    trigger: string;
+    triggerStyle: Record<string, any>;
+    $props: {
+        readonly trigger?: string;
+        readonly triggerStyle?: Record<string, any>;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    triggerRef: HTMLDivElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=trigger.vue.d.ts.map

package/dist/components/tooltip/trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/trigger.vue"],"names":[],"mappings":"wBAmMqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;mBAUG"}

package/dist/components/tooltip/useContent.d.ts

@@ -0,0 +1,13 @@
+export function useContent(props: any, callback: any): {
+    init: () => Promise<void>;
+    widthStyle: import('vue').ComputedRef<{
+        width: any;
+    }>;
+    arrowStyle: import('vue').ComputedRef<any>;
+    onClickOutside: (e: any) => void;
+    onScroll: import('@vueuse/core').UseDebounceFnReturn<() => Promise<void>>;
+    onResize: import('@vueuse/core').UseDebounceFnReturn<() => Promise<void>>;
+    onContentMouseEnter: () => void;
+    onContentMouseLeave: () => void;
+};
+//# sourceMappingURL=useContent.d.ts.map

package/dist/components/tooltip/useContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContent.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/useContent.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;EA0QC"}

package/dist/components/tooltip/useTooltip.d.ts

@@ -0,0 +1,7 @@
+export function useTooltip(): {
+    generateTooltipKey: () => string;
+    hasChildren: (arr: any) => boolean;
+    onFilterObj: (obj: object) => any[];
+    onFlattenTree: (root: any[]) => {};
+};
+//# sourceMappingURL=useTooltip.d.ts.map

package/dist/components/tooltip/useTooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTooltip.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/useTooltip.js"],"names":[],"mappings":"AAAA;;;uBAgBa,MAAM;;EAiClB"}

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

@@ -8,9 +8,9 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
     img: string;
     width: number;
     height: number;
+    content: string;
     opacity: number;
     angle: number;
-    content: string;
     fontColor: string;
     imgWidth: number;
     $props: {
@@ -18,9 +18,9 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         readonly img?: string;
         readonly width?: number;
         readonly height?: number;
+        readonly content?: string;
         readonly opacity?: number;
         readonly angle?: number;
-        readonly content?: string;
         readonly fontColor?: string;
         readonly imgWidth?: number;
     };

package/dist/hooks/useResize.d.ts

@@ -0,0 +1,9 @@
+export function useResize(target: any, callback: any): {
+    screenWidth: import('vue').Ref<number, number>;
+    isMobile: import('vue').Ref<boolean, boolean>;
+    getScreenInfo: () => {
+        screenWidth: number;
+        isMobile: boolean;
+    };
+};
+//# sourceMappingURL=useResize.d.ts.map

package/dist/hooks/useResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResize.d.ts","sourceRoot":"","sources":["../../src/hooks/useResize.js"],"names":[],"mappings":"AACA;;;;;;;EAwBC"}