@polyv/vue-components 1.1.1 → 1.2.0

package/vue2/src/components/swiper/hooks/use-swiper-slide.d.ts

@@ -0,0 +1 @@
+export declare const useSwiperSlide: () => void;

package/vue2/src/components/swiper/hooks/use-swiper-wrapper.d.ts

@@ -0,0 +1,22 @@
+import { VueEmit, VueProps } from '../../../vue-utils';
+import { ComputedRef } from 'vue';
+import { swiperEmits, swiperProps } from './swiper-props';
+export interface SwiperInjectData {
+    /** 是否初始化 swiper 成功 */
+    swiperInited: ComputedRef<boolean>;
+    /** 当前激活的幻灯片索引 */
+    activeIndex: ComputedRef<number>;
+    /** 总幻灯片数量 */
+    total: ComputedRef<number>;
+    /** 更新 swiper */
+    updateSwiper: () => void;
+}
+export declare const useSwiperWrapper: (options: {
+    props: VueProps<typeof swiperProps>;
+    emit: VueEmit<typeof swiperEmits>;
+}) => {
+    wrapperRef: import('vue').Ref<HTMLDivElement | undefined>;
+    navigationOptions: ComputedRef<false | import('swiper/types').NavigationOptions>;
+    paginationOptions: ComputedRef<false | import('swiper/types').PaginationOptions>;
+};
+export declare const useSwiperInject: () => SwiperInjectData;

package/vue2/src/components/swiper/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PwcSwiper } from './swiper.vue';
+export { default as PwcSwiperSlide } from './swiper-slide.vue';
+export * from './hooks/swiper-props';
+export type { SwiperOptions } from 'swiper/types/swiper-options';

package/vue2/src/components/swiper/modules/use-navigation-module.d.ts

@@ -0,0 +1,21 @@
+import { NavigationOptions } from 'swiper/types/modules/navigation';
+import { UseSwiperOptionsReturn } from '../hooks/use-swiper-options';
+export declare const swiperNavigationProps: () => {
+    /**
+     * 是否显示导航箭头
+     * @default true
+     */
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * swiper 导航配置，详细可见 [官方文档](https://swiperjs.com/swiper-api#navigation)
+     * @default false
+     */
+    navigation: import('vue-types').VueTypeDef<boolean | NavigationOptions> & {
+        default: boolean | (() => NavigationOptions);
+    };
+};
+export declare const useNavigationModule: (swiperOptionsHook: UseSwiperOptionsReturn) => {
+    navigationOptions: import('vue').ComputedRef<false | NavigationOptions>;
+};

package/vue2/src/components/swiper/modules/use-pagination-module.d.ts

@@ -0,0 +1,14 @@
+import { PaginationOptions } from 'swiper/types/modules/pagination';
+import { UseSwiperOptionsReturn } from '../hooks/use-swiper-options';
+export declare const swiperPaginationProps: () => {
+    /**
+     * swiper 指示器配置，详细可见 [官方文档](https://swiperjs.com/swiper-api#pagination)
+     * @default false
+     */
+    pagination: import('vue-types').VueTypeDef<boolean | PaginationOptions> & {
+        default: boolean | (() => PaginationOptions);
+    };
+};
+export declare const usePaginationModule: (swiperOptionsHook: UseSwiperOptionsReturn) => {
+    paginationOptions: import('vue').ComputedRef<false | PaginationOptions>;
+};

package/vue2/src/components/swiper/swiper-slide.vue.d.ts

@@ -0,0 +1,17 @@
+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, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/vue2/src/components/swiper/swiper.vue.d.ts

@@ -0,0 +1,73 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'navigation-prev'?(_: {}): any;
+        'navigation-next'?(_: {}): any;
+        pagination?(_: {}): any;
+        'wrapper-suffix'?(_: {}): any;
+    };
+    refs: {
+        wrapperRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    pagination: import('vue-types').VueTypeDef<boolean | import('swiper/types').PaginationOptions> & {
+        default: boolean | (() => import('swiper/types').PaginationOptions);
+    };
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    navigation: import('vue-types').VueTypeDef<boolean | import('swiper/types').NavigationOptions> & {
+        default: boolean | (() => import('swiper/types').NavigationOptions);
+    };
+    initialSlide: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    direction: import('vue-types').VueTypeDef<"horizontal" | "vertical"> & {
+        default: "horizontal" | "vertical";
+    };
+    swiperOptions: import('vue-types').VueTypeValidableDef<import('swiper/types').SwiperOptions, import('vue-types/dist/types').ValidatorFunction<import('swiper/types').SwiperOptions>> & {
+        default: () => import('swiper/types').SwiperOptions;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    init: (arg: import('swiper').default) => void;
+    "slide-change": (arg: import('swiper').default) => void;
+    "slide-change-transition-start": (arg: import('swiper').default) => void;
+    "slide-change-transition-end": (arg: import('swiper').default) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    pagination: import('vue-types').VueTypeDef<boolean | import('swiper/types').PaginationOptions> & {
+        default: boolean | (() => import('swiper/types').PaginationOptions);
+    };
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    navigation: import('vue-types').VueTypeDef<boolean | import('swiper/types').NavigationOptions> & {
+        default: boolean | (() => import('swiper/types').NavigationOptions);
+    };
+    initialSlide: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    direction: import('vue-types').VueTypeDef<"horizontal" | "vertical"> & {
+        default: "horizontal" | "vertical";
+    };
+    swiperOptions: import('vue-types').VueTypeValidableDef<import('swiper/types').SwiperOptions, import('vue-types/dist/types').ValidatorFunction<import('swiper/types').SwiperOptions>> & {
+        default: () => import('swiper/types').SwiperOptions;
+    };
+}>>, {
+    direction: "horizontal" | "vertical";
+    pagination: boolean | import('swiper/types').PaginationOptions;
+    showNavigationArrow: boolean;
+    navigation: boolean | import('swiper/types').NavigationOptions;
+    initialSlide: number;
+    swiperOptions: import('swiper/types').SwiperOptions;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/{src → vue2/src}/components/switch/switch.vue.d.ts

@@ -1,5 +1,5 @@
 declare const _default: import('vue').DefineComponent<{
-    value: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
+    "v-model-key": import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
     disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
         default: boolean;
     };
@@ -21,7 +21,7 @@ declare const _default: import('vue').DefineComponent<{
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     change: (arg: import('./use-switch').SwitchValue) => void;
 }, string, Readonly<import('vue').ExtractPropTypes<{
-    value: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
+    "v-model-key": import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
     disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
         default: boolean;
     };
@@ -41,8 +41,8 @@ declare const _default: import('vue').DefineComponent<{
         default: "default" | "mini" | "medium";
     };
 }>>, {
-    disabled: boolean;
     size: "default" | "mini" | "medium";
+    disabled: boolean;
     activeValue: import('./use-switch').SwitchValue;
     inactiveValue: import('./use-switch').SwitchValue;
     activeColor: string;

package/{src → vue2/src}/components/switch/use-switch.d.ts

@@ -1,10 +1,12 @@
 import { VueEmit, VueProps } from '../../vue-utils';
 export type SwitchValue = boolean | number | string;
+declare const switchSizes: readonly ["default", "medium", "mini"];
+export type SwitchSize = (typeof switchSizes)[number];
 export declare const switchProps: () => {
     /**
      * 是否选中，支持 v-model
      */
-    value: import('vue-types').VueTypeDef<SwitchValue>;
+    "v-model-key": import('vue-types').VueTypeDef<SwitchValue>;
     /**
      * 是否禁用
      * @default false
@@ -64,3 +66,4 @@ export declare const useSwitch: (options: {
     }>;
     toggleSwitch: () => void;
 };
+export {};

package/{src/hooks/components/use-toast → vue2/src/components/toast}/_component/toast-element.vue.d.ts

@@ -9,7 +9,7 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<{
-    value: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
         default: boolean;
     };
     message: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
@@ -27,10 +27,10 @@ declare const __VLS_component: import('vue').DefineComponent<{
 }, {
     openToast: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "after-leave": (arg?: void | undefined) => void;
     "after-enter": (arg?: void | undefined) => void;
+    "after-leave": (arg?: void | undefined) => void;
 }, string, Readonly<import('vue').ExtractPropTypes<{
-    value: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
         default: boolean;
     };
     message: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
@@ -46,7 +46,7 @@ declare const __VLS_component: import('vue').DefineComponent<{
         default: boolean;
     };
 }>>, {
-    value: boolean;
+    "v-model-key": boolean;
     type: ToastType;
     message: string;
     duration: number;

package/{src/hooks/components/use-toast → vue2/src/components/toast}/_component/use-toast-element.d.ts

@@ -1,10 +1,10 @@
-import { FormatEmit, FormatProps, VueEmit, VueProps } from '../../../../vue-utils';
+import { FormatEmit, FormatProps, VueEmit, VueProps } from '../../../vue-utils';
 import { ToastType } from '../types';
 export declare const toastProps: () => {
     /**
      * 是否显示绑定值
      */
-    value: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
         default: boolean;
     };
     /**
@@ -40,11 +40,11 @@ export declare const toastEmits: () => {
     /**
      * 提示动画进入之后
      */
-    'after-enter': import('../../../../vue-utils').EmitFuncType<void>;
+    'after-enter': import('../../../vue-utils').EmitFuncType<void>;
     /**
      * 提示动画离开之后
      */
-    'after-leave': import('../../../../vue-utils').EmitFuncType<void>;
+    'after-leave': import('../../../vue-utils').EmitFuncType<void>;
 };
 export type ToastPropsType = FormatProps<typeof toastProps>;
 export type ToastEmitsType = FormatEmit<typeof toastEmits>;

package/vue2/src/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PwcTooltip } from './tooltip.vue';
+export * from './use-tooltip';

package/vue2/src/components/tooltip/tooltip.vue.d.ts

@@ -0,0 +1,139 @@
+import { BeforeShowPopper } from '../../hooks/components/use-popper';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {
+        popperRef: (import('vue/types/v3-component-public-instance').Vue3Instance<{}, Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>, Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>, {}, {
+            trigger: "click" | "hover" | "focus" | "long-press" | "custom";
+            placement: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            arrow: boolean;
+            disabled: boolean;
+        }, true, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any>> & Readonly<Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>> & import('vue').ShallowUnwrapRef<{
+            referenceRef: import('vue').Ref<any>;
+            popperRef: import('vue').Ref<any>;
+            popperVisible: import('vue').Ref<boolean>;
+        }> & import('vue/types/v3-component-options').ExtractComputedReturns<{}> & import('vue').ComponentCustomProperties & Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>> & {
+            $scopedSlots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: Element;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    content: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+        default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    };
+    effect: import('vue-types').VueTypeDef<"light" | "dark" | "auto"> & {
+        default: "light" | "dark" | "auto";
+    };
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    tooltipClass: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    onlyTextEllipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+    content: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+        default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    };
+    effect: import('vue-types').VueTypeDef<"light" | "dark" | "auto"> & {
+        default: "light" | "dark" | "auto";
+    };
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    tooltipClass: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    onlyTextEllipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}>>, {
+    placement: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    effect: "light" | "dark" | "auto";
+    content: string;
+    disabled: boolean;
+    tooltipClass: string;
+    onlyTextEllipsis: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/vue2/src/components/tooltip/use-tooltip.d.ts

@@ -0,0 +1,46 @@
+declare const tooltipEffect: readonly ["dark", "light", "auto"];
+export type TooltipEffect = typeof tooltipEffect[number];
+export declare const tooltipProps: () => {
+    /**
+     * 提示内容
+     */
+    content: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 提示位置
+     * @propType PopperPlacement
+     * @default bottom
+     */
+    placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+        default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    };
+    /**
+     * 弹层主题
+     * @default 'auto'
+     */
+    effect: import('vue-types').VueTypeDef<"light" | "dark" | "auto"> & {
+        default: "light" | "dark" | "auto";
+    };
+    /**
+     * 是否禁用
+     * @default false
+     */
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 提示类名
+     */
+    tooltipClass: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 仅在文字截断才显示
+     * @default false
+     */
+    onlyTextEllipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export {};

package/vue2/src/components/zoom-container/hooks/use-zoom-drag.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+export declare const useZoomDrag: (options: {
+    isOverflowWrap: Ref<boolean>;
+    contentRef: Ref<HTMLDivElement | undefined>;
+    onDragStart: () => void;
+    onDragMove: (diffX: number, diffY: number) => void;
+    onDragEnd: () => void;
+    toZoomScale: (scale: number) => void;
+    scale: Ref<number>;
+}) => {
+    isDraging: Ref<boolean>;
+};

package/vue2/src/components/zoom-container/hooks/use-zoom-scale.d.ts

@@ -0,0 +1,32 @@
+import { VueEmit, VueProps } from '../../../vue-utils';
+import { ComputedRef, Ref } from 'vue';
+import { zoomContainerEmits, zoomContainerProps } from '../use-zoom-container';
+import { SizeData } from '../../../interface';
+export declare const useZoomScale: (options: {
+    containerRef: Ref<HTMLDivElement | undefined>;
+    defaultSize: ComputedRef<SizeData>;
+    wrapSize: ComputedRef<SizeData>;
+    edgeBetween: Ref<number>;
+    props: VueProps<typeof zoomContainerProps>;
+    emit: VueEmit<typeof zoomContainerEmits>;
+}) => {
+    scale: Ref<number>;
+    centerDiffX: Ref<number>;
+    centerDiffY: Ref<number>;
+    isOverflowWrap: ComputedRef<boolean>;
+    initCenter: () => void;
+    zoomLarge: () => number;
+    zoomSmall: () => number;
+    zoomScale: (_scale?: number) => number;
+    zoomReset: () => number;
+    moveCenter: (diffX?: number, diffY?: number) => void;
+    setCenter: (diffX: number, diffY: number) => void;
+    correctionCenter: () => void;
+    computedCenter: (center?: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+};

package/vue2/src/components/zoom-container/hooks/use-zoom-size.d.ts

@@ -0,0 +1,15 @@
+import { VueProps } from '../../../vue-utils';
+import { Ref } from 'vue';
+import { zoomContainerProps } from '../use-zoom-container';
+import { SizeData } from '../../../interface';
+export declare const useZoomSize: (options: {
+    containerRef: Ref<HTMLDivElement | undefined>;
+    props: VueProps<typeof zoomContainerProps>;
+}) => {
+    wrapSize: import('vue').ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    defaultSize: import('vue').ComputedRef<SizeData>;
+    edgeBetween: import('vue').ComputedRef<0 | 100>;
+};

package/vue2/src/components/zoom-container/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PwcZoomContainer } from './zoom-container.vue';
+export * from './use-zoom-container';

package/vue2/src/components/zoom-container/use-zoom-container.d.ts

@@ -0,0 +1,39 @@
+export declare const zoomContainerProps: () => {
+    /**
+     * 原始宽度
+     * @default 0
+     */
+    originWidth: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 原始高度
+     * @default 0
+     */
+    originHeight: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 最大缩放比例
+     * @default 4
+     */
+    maxZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 最小缩放比例，默认 PC：0.25，移动端：1
+     */
+    minZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>>;
+};
+export declare const zoomContainerEmits: () => {
+    /**
+     * 缩放比例变化
+     * @cbName 缩放比例
+     */
+    'scale-change': import('../../vue-utils').EmitFuncType<number>;
+    /**
+     * 单击
+     * @cbName 缩放比例
+     */
+    'single-click': import('../../vue-utils').EmitFuncType<number>;
+};

package/vue2/src/components/zoom-container/zoom-container.vue.d.ts

@@ -0,0 +1,55 @@
+declare function showScaleToast(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        contentRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    originWidth: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    originHeight: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    maxZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    minZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>>;
+}, {
+    zoomLarge: () => number;
+    zoomSmall: () => number;
+    zoomReset: () => number;
+    showScaleToast: typeof showScaleToast;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "scale-change": (arg: number) => void;
+    "single-click": (arg: number) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    originWidth: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    originHeight: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    maxZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    minZoom: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>>;
+}>>, {
+    originWidth: number;
+    originHeight: number;
+    maxZoom: number;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};