@polyv/vue-components 1.0.1

package/src/hooks/components/use-message-box/index.d.ts

@@ -0,0 +1,9 @@
+import { MessageBoxOptions } from './types';
+export * from './types';
+export declare const useMessageBox: () => {
+    messageBox: (options: MessageBoxOptions) => {
+        /** 显示确认框 */
+        $confirm: () => Promise<void>;
+        $alert: () => Promise<void>;
+    };
+};

package/src/hooks/components/use-message-box/types.d.ts

@@ -0,0 +1,24 @@
+export interface MessageBoxOptions {
+    /** 消息 */
+    message?: string;
+    /** 描述 */
+    description?: string;
+    /** 是否显示取消按钮 */
+    showCancelButton?: boolean;
+    /** 是否显示确认按钮 */
+    showConfirmButton?: boolean;
+    /** 取消按钮文本 */
+    cancelButtonText?: string;
+    /** 确认按钮文本 */
+    confirmButtonText?: string;
+    /** 二次确认类型，仅 $confirm 有效 */
+    confirmType?: ConfirmType;
+}
+export declare enum ConfirmType {
+    /** 普通确认 */
+    Normal = "normal",
+    /** 删除确认 */
+    Delete = "delete",
+    /** 提交确认 */
+    Submit = "submit"
+}

package/src/hooks/components/use-popper/_hooks/use-popper-arrow.d.ts

@@ -0,0 +1,2 @@
+import { PopperOptions } from '../_popper-type';
+export declare const usePopperArrow: (popperOptions: PopperOptions) => void;

package/src/hooks/components/use-popper/_hooks/use-popper-core.d.ts

@@ -0,0 +1,15 @@
+import { Instance as PopperInstance, OptionsGeneric, Modifier } from '@popperjs/core';
+import { PopperOptions } from '../_popper-type';
+/**
+ * 构建 popperjs 的配置
+ */
+export declare const usePopperCoreOptions: (popperOptions: PopperOptions, getPopperCtx: () => PopperInstance | undefined) => {
+    /** 弹层选项 */
+    popperCoreOptions: import('vue').ComputedRef<OptionsGeneric<Modifier<unknown, unknown>>>;
+};
+export declare const usePopperCore: (popperOptions: PopperOptions) => {
+    getPopperCtx: () => PopperInstance | undefined;
+    updatePopper: () => Promise<void>;
+    createPopperCore: () => void;
+    destroyPopperCore: () => void;
+};

package/src/hooks/components/use-popper/_hooks/use-popper-interactive.d.ts

@@ -0,0 +1,5 @@
+import { PopperOptions } from '../_popper-type';
+/**
+ * 弹层交互方式 hook
+ */
+export declare const usePopperInteractive: (popperOptions: PopperOptions) => void;

package/src/hooks/components/use-popper/_hooks/use-popper-visible.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { PopperVisibleResult } from '../_popper-type';
+export type UsePopperVisibleOptions = {
+    popperVisible?: boolean | Ref<boolean>;
+};
+export declare const usePopperVisible: (options?: UsePopperVisibleOptions) => PopperVisibleResult;

package/src/hooks/components/use-popper/_popper-type.d.ts

@@ -0,0 +1,75 @@
+import { Ref } from 'vue';
+import { Placement } from '@popperjs/core';
+export type PopperOffset = [number, number];
+/** 弹层触发方式 */
+export type PopperTrigger = 'click' | 'hover' | 'focus' | 'long-press' | 'custom';
+export interface PopperArrowOptions {
+    /** 颜色，默认：#fff */
+    color?: string;
+    /** 尺寸，默认：6 */
+    size?: number;
+}
+export interface UsePopperOptions {
+    popperVisible?: boolean | Ref<boolean>;
+    /** 触发节点 ref */
+    referenceRef?: HTMLElement | Ref<HTMLElement | undefined>;
+    /** 弹层节点 ref */
+    popperRef?: HTMLElement | Ref<HTMLElement | undefined>;
+    /** 输入框节点 ref，用于聚焦显示的交互 */
+    inputRef?: HTMLInputElement | Ref<HTMLInputElement | undefined>;
+    /** 弹层是否禁用 */
+    popperDisabled?: boolean | Ref<boolean>;
+    /** 触发方式 */
+    trigger?: PopperTrigger | Ref<PopperTrigger>;
+    /** 鼠标移入延迟显示时间 */
+    mouseEnterDelay?: number | Ref<number>;
+    /** 鼠标移出延迟隐藏时间 */
+    mouseLeaveDelay?: number | Ref<number>;
+    /** 弹层位置 */
+    placement?: Placement | Ref<Placement>;
+    /** 弹层偏移量 */
+    popperOffset?: PopperOffset | Ref<PopperOffset>;
+    /** 是否显示箭头，默认：false */
+    arrow?: boolean | PopperArrowOptions | Ref<boolean | PopperArrowOptions>;
+    /** 强制 outSideClick 关闭，默认：false */
+    forceOutSideClickHide?: boolean | Ref<boolean>;
+    /** outSideClick 关闭时是否延迟，默认：false */
+    outSideClickDelayHide?: boolean | Ref<boolean>;
+    /** 弹层宽度跟随触发节点，默认：false */
+    followReferenceWidth?: boolean | Ref<boolean>;
+    /** 是否插入到 body 中，默认：true */
+    appendToBody?: boolean;
+    /** 渲染到某个元素中(Dom节点选择器) */
+    mountEl?: string;
+    /** 强制 zIndex，默认 null */
+    forceZIndex?: number | null;
+}
+export interface PopperVisibleResult {
+    /** 弹层显示状态 */
+    popperVisible: Ref<boolean>;
+    /** 显示弹层 */
+    showPopper: () => void;
+    /** 隐藏弹窗 */
+    hidePopper: () => void;
+    /** 切换弹层显示状态 */
+    togglePopper: () => void;
+    /** 延迟显示弹层 */
+    delayShowPopper: (delay?: number) => void;
+    /** 延迟隐藏弹层 */
+    delayHidePopper: (delay?: number) => void;
+}
+export interface PopperElements {
+    referenceElem: HTMLElement | undefined;
+    popperElem: HTMLElement | undefined;
+    inputElem: HTMLElement | undefined;
+}
+export interface OnPopperEventParams {
+    /** 触发节点是否已隐藏 */
+    isReferenceHidden: boolean;
+}
+export interface PopperOptions extends Required<Omit<UsePopperOptions, 'popperVisible'>>, PopperVisibleResult {
+    /** 获取相关 dom 节点 */
+    getElement: () => PopperElements;
+    /** 处理弹层事件 */
+    onPopperEvent: (params: OnPopperEventParams) => void;
+}

package/src/hooks/components/use-popper/index.d.ts

@@ -0,0 +1,32 @@
+import { OnPopperEventParams, PopperOffset, UsePopperOptions } from './_popper-type';
+export * from './_popper-type';
+/**
+ * 弹出层 hook
+ */
+export declare const usePopper: (options?: UsePopperOptions) => {
+    updatePopper: () => Promise<void>;
+    getElement: () => import('./_popper-type').PopperElements;
+    onPopperEvent: (params: OnPopperEventParams) => void;
+    referenceRef: HTMLElement | import('vue').Ref<HTMLElement | undefined>;
+    popperRef: HTMLElement | import('vue').Ref<HTMLElement | undefined>;
+    inputRef: HTMLInputElement | import('vue').Ref<HTMLInputElement | undefined>;
+    popperDisabled: boolean | import('vue').Ref<boolean>;
+    trigger: import('./_popper-type').PopperTrigger | import('vue').Ref<import('./_popper-type').PopperTrigger>;
+    mouseEnterDelay: number | import('vue').Ref<number>;
+    mouseLeaveDelay: number | import('vue').Ref<number>;
+    placement: import('@popperjs/core').Placement | import('vue').Ref<import('@popperjs/core').Placement>;
+    popperOffset: PopperOffset | import('vue').Ref<PopperOffset>;
+    arrow: boolean | import('./_popper-type').PopperArrowOptions | import('vue').Ref<boolean | import('./_popper-type').PopperArrowOptions>;
+    forceOutSideClickHide: boolean | import('vue').Ref<boolean>;
+    outSideClickDelayHide: boolean | import('vue').Ref<boolean>;
+    followReferenceWidth: boolean | import('vue').Ref<boolean>;
+    appendToBody: boolean;
+    mountEl: string;
+    forceZIndex: number | null;
+    popperVisible: import('vue').Ref<boolean>;
+    showPopper: () => void;
+    hidePopper: () => void;
+    togglePopper: () => void;
+    delayShowPopper: (delay?: number) => void;
+    delayHidePopper: (delay?: number) => void;
+};

package/src/hooks/components/use-toast/_component/toast-element.vue.d.ts

@@ -0,0 +1,34 @@
+import { ToastType } from '../types';
+declare const _default: import('vue').DefineComponent<{
+    msg: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    showIcon: 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<{
+    msg: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    showIcon: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}>>, {
+    type: ToastType;
+    duration: number;
+    msg: string;
+    showIcon: boolean;
+}>;
+export default _default;

package/src/hooks/components/use-toast/_component/use-toast-element.d.ts

@@ -0,0 +1,32 @@
+import { FormatProps, VueProps } from '../../../../vue-utils';
+import { ToastType } from '../types';
+export declare const toastProps: () => {
+    /** 提示内容 */
+    msg: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /** 提示类型，默认：info */
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    /** 关闭时间，默认：3000 */
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /** 显示图标 */
+    showIcon: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export type ToastPropsType = FormatProps<typeof toastProps>;
+/**
+ * Toast 组件 hook
+ */
+export declare const useToastElement: (options: {
+    props: VueProps<typeof toastProps>;
+}) => {
+    toastVisible: import('vue').Ref<boolean>;
+    openToast: () => void;
+    closeToast: () => void;
+    onAfterLeave: () => void;
+};

package/src/hooks/components/use-toast/index.d.ts

@@ -0,0 +1,11 @@
+import { ToastOptions } from './types';
+export * from './types';
+export declare const useToast: (options?: ToastOptions) => {
+    toast: {
+        info: (msg: string, opts?: ToastOptions) => void;
+        success: (msg: string, opts?: ToastOptions) => void;
+        warning: (msg: string, opts?: ToastOptions) => void;
+        error: (msg: string, opts?: ToastOptions) => void;
+        loading: (msg: string, opts?: ToastOptions) => void;
+    };
+};

package/src/hooks/components/use-toast/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 提示类型
+ */
+export declare enum ToastType {
+    /** 信息类提示 */
+    Info = "info",
+    /** 成功类提示 */
+    Success = "success",
+    /** 警告类提示 */
+    Warning = "warning",
+    /** 异常类提示 */
+    Error = "error",
+    /** 加载中提示 */
+    Loading = "loading"
+}
+export interface ToastOptions {
+    /** 关闭时间 */
+    duration?: number;
+    /** 显示图标 */
+    showIcon?: boolean;
+}

package/src/hooks/exports.d.ts

@@ -0,0 +1,34 @@
+export * from './business/use-app-element';
+export * from './business/use-config-provider';
+export * from './business/use-track-event';
+export * from './components/use-action-sheet';
+export * from './components/use-auto-topmost';
+export * from './components/use-message-box';
+export * from './components/use-popper';
+export * from './components/use-toast';
+export * from './interactive/use-click-outside';
+export * from './interactive/use-fullscreen';
+export * from './interactive/use-screen-orientation';
+export * from './interactive/use-scroll';
+export * from './interactive/use-sound-effect';
+export * from './pagination/types';
+export * from './pagination/use-scroll-pagintaion';
+export * from './pagination/use-static-pagination';
+export * from './plugin/use-resize-observer';
+export * from './plugin/use-svga-animation';
+export * from './plugin/use-svga-player';
+export * from './tools/use-append-to';
+export * from './tools/use-body-locked';
+export * from './tools/use-browser';
+export * from './tools/use-copy-text';
+export * from './tools/use-count-down';
+export * from './tools/use-event-bus';
+export * from './tools/use-event-listener';
+export * from './tools/use-link-open';
+export * from './tools/use-set-interval';
+export * from './tools/use-set-timeout';
+export * from './tools/use-simple-visible';
+export * from './tools/use-target-event-emitter';
+export * from './tools/use-window-resize-listener';
+export * from './vue/use-model-value';
+export * from './vue/use-vue';

package/src/hooks/interactive/use-click-outside/index.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+export type ClickOutsideTargetType = Ref | HTMLElement | string;
+export type ClickOutsideTargets = ClickOutsideTargetType | ClickOutsideTargetType[];
+export type ClickOutsideTargetsFunction = () => ClickOutsideTargets;
+/**
+ * 点击节点外部事件 hook
+ * @param targets 响应式节点数组或获取方法
+ * @param callback 回调方法
+ * @param autoListen 自动监听，默认：true
+ */
+export declare const useClickOutside: (targets: ClickOutsideTargets | ClickOutsideTargetsFunction, callback: () => unknown, autoListen?: boolean) => {
+    listenClickOutSide: () => void;
+    removeListenClickOutSide: () => void;
+};

package/src/hooks/interactive/use-fullscreen/index.d.ts

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+export interface FullscreenFieldData {
+    /** 浏览器是否支持全屏模式的 api 字段 */
+    enabledField: 'fullscreenEnabled';
+    /** 获取浏览器正在全屏的 dom 节点 api 字段 */
+    elementField: 'fullscreenElement';
+    /** 浏览器全屏的 api 字段 */
+    requestApiField: 'requestFullscreen';
+    /** 浏览器退出全屏的 api 字段 */
+    exitApiField: 'exitFullscreen';
+    /** 浏览器全屏状态改变事件 */
+    fullscreenChangeEvent: 'fullscreenchange';
+}
+export type FullscreenElement = Element | Ref<Element>;
+export type GetFullscreenElement = () => FullscreenElement;
+/**
+ * 系统全屏
+ */
+export declare const useFullscreen: (elementRef?: FullscreenElement | GetFullscreenElement, options?: {
+    /** 强制禁用全屏 */
+    forceDisabled?: boolean;
+    onFullscreenChange?: (isFullscreen: boolean) => void;
+}) => {
+    isFullscreen: Ref<boolean>;
+    supportFullscreen: import('vue').ComputedRef<boolean>;
+    requestFullscreen: () => void;
+    exitFullscreen: () => void;
+    toggleFullscreen: () => void;
+};

package/src/hooks/interactive/use-hover-visible/index.d.ts

@@ -0,0 +1,16 @@
+export interface UseHoverVisibleOptions {
+    /** 自动展示，默认为 true */
+    autoHover?: boolean;
+    /** 自动关闭时长，默认为 3000ms */
+    timeout?: number;
+}
+/**
+ * 悬浮可见处理
+ */
+export declare const useHoverVisible: (hookOptions?: UseHoverVisibleOptions) => {
+    visible: import('vue').Ref<boolean>;
+    show: () => void;
+    forceShow: () => void;
+    hide: () => void;
+    startAutoHide: () => void;
+};

package/src/hooks/interactive/use-page-fullscreen/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 网页 css 全屏
+ */
+export declare const usePageFullscreen: () => {
+    pageFullscreen: import('vue').ComputedRef<boolean>;
+};

package/src/hooks/interactive/use-screen-orientation/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 屏幕旋转模式
+ * @desc 不使用 portrait 和 landscape 是不想和业务名称重合
+ * */
+export declare enum ScreenOrientationMode {
+    /** 屏幕纵向 */
+    Vertical = "Vertical",
+    /** 屏幕横向 */
+    Horizontal = "Horizontal"
+}
+/**
+ * 屏幕旋转
+ */
+export declare const useScreenOrientation: (params?: {
+    /** 自动监听事件，默认：true */
+    autoListen?: boolean;
+    /** 自动监听回调 */
+    autoListenCb?: (screenOrientationMode: ScreenOrientationMode) => void;
+}) => {
+    screenOrientationMode: import('vue').Ref<ScreenOrientationMode>;
+    isVerticalScreenOrientation: import('vue').ComputedRef<boolean>;
+    isHorizontalScreenOrientation: import('vue').ComputedRef<boolean>;
+    listenOrientationEvent: () => void;
+    updateScreenOrientationModeManually: () => void;
+};

package/src/hooks/interactive/use-scroll/index.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+/**
+ * 滚动方向
+ */
+export type ScrollDirection = 'horizontal' | 'vertical';
+/**
+ * 滚动
+ */
+export declare const useScroll: (options?: {
+    scrollRef?: Ref<HTMLDivElement | undefined>;
+    /** 滚动到下一页回调 */
+    nextCallback?: () => unknown;
+    /** 滚动方向，默认：vertical */
+    direction?: ScrollDirection;
+}) => {
+    scrollRef: Ref<HTMLDivElement | undefined>;
+    onScroll: import('lodash-es/debounce').DebouncedFunc<(event: Event) => void>;
+    getScrollElement: () => HTMLDivElement | undefined;
+    hasVerticalScrollbar: () => Promise<boolean | undefined>;
+};

package/src/hooks/interactive/use-sound-effect/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 提示音播放
+ */
+export declare const useSoundEffect: () => {
+    playSoundEffect: () => Promise<void>;
+};

package/src/hooks/pagination/types.d.ts

@@ -0,0 +1,60 @@
+import { Ref } from 'vue';
+/**
+ * 分页模式，scroll-滚动分页，page-分页器
+ */
+export type PaginationMode = 'scroll' | 'page';
+/**
+ * 分页数据
+ */
+export interface PageContent<I = unknown> {
+    /** 当前页数 */
+    pageNumber: number;
+    /** 每页数量 */
+    pageSize: number;
+    /** 总记录数 */
+    totalItems: number;
+    /** 总页数 */
+    totalPages: number;
+    /** 内容列表 */
+    contents: I[];
+}
+/**
+ * 分页请求
+ */
+export type PaginationRequest<I = unknown> = (params: {
+    pageNumber: number;
+    pageSize: number;
+    keyword: string;
+}) => Promise<PageContent<I>>;
+/**
+ * 分页 hook 选项
+ */
+export interface PaginationHookOptions<I = unknown> {
+    /** 关键词 */
+    keyword?: Ref<string>;
+    /** 是否立即执行，默认：true */
+    immediate?: boolean;
+    /** 页数 */
+    pageNumber?: Ref<number>;
+    /** 每页数量，默认：10 */
+    pageSize?: Ref<number>;
+    /** 列表 */
+    contents?: Ref<I[]>;
+    /** 总记录数 */
+    totalItems?: Ref<number>;
+    /** 总页数 */
+    totalPages?: Ref<number>;
+    /** 获取过滤条件 */
+    getFilterParams?: () => Record<string, unknown>;
+}
+/**
+ * 分页 hook 返回值
+ */
+export interface PageinationHookReturn<I = unknown> {
+    pageNumber: Ref<number>;
+    pageSize: Ref<number>;
+    contents: Ref<I[]>;
+    keyword: Ref<string>;
+    /** 刷新当前数据 */
+    refresh: () => Promise<void>;
+}

package/src/hooks/pagination/use-scroll-pagintaion/index.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { PageinationHookReturn, PaginationHookOptions, PaginationRequest } from '../types';
+import { ScrollDirection } from '../../interactive/use-scroll';
+export interface ScrollPaginationHookOptions<I = unknown> extends PaginationHookOptions<I> {
+    scrollRef?: Ref<HTMLDivElement | undefined>;
+    /** 滚动方向 */
+    direction?: ScrollDirection;
+}
+export interface ScrollPaginationHookReturn<I = unknown> extends PageinationHookReturn<I> {
+    scrollRef: Ref<HTMLDivElement | undefined>;
+    isFirstFinish: Ref<boolean>;
+}
+/**
+ * 滚动分页器 hook
+ * @param request 分页请求
+ */
+export declare function useScrollPagination<I = unknown>(request: PaginationRequest<I>, options?: ScrollPaginationHookOptions<I>): ScrollPaginationHookReturn<I>;

package/src/hooks/pagination/use-static-pagination/index.d.ts

@@ -0,0 +1,24 @@
+import { ResponsiveRef } from '../../../vue-utils';
+export interface StaticPaginationHookOptions<RefItem = unknown> {
+    /** 当前页，默认：1 */
+    pageNumber?: number;
+    /** 每页数量，默认：10 */
+    pageSize?: number;
+    /** 响应式列表对象 */
+    listRef: ResponsiveRef<RefItem[]>;
+}
+/**
+ * 将一个总列表进行响应式静态分页
+ */
+export declare const useStaticPagination: <RefItem = unknown>(options: StaticPaginationHookOptions<RefItem>) => {
+    pageNumber: import('vue').Ref<number>;
+    pageSize: import('vue').Ref<number>;
+    totalPages: import('vue').ComputedRef<number>;
+    totalItems: import('vue').ComputedRef<number>;
+    currentPageList: import('vue').ComputedRef<RefItem[]>;
+    nextIsDisabled: import('vue').ComputedRef<boolean>;
+    prevIsDisabled: import('vue').ComputedRef<boolean>;
+    toPage: (pageNum: number) => void;
+    toNextPage: () => void;
+    toPrevPage: () => void;
+};

package/src/hooks/plugin/use-resize-observer/index.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { ResizeObserver } from '@juggle/resize-observer';
+/**
+ * 监听元素 resize
+ * @param refObj 监听元素
+ * @param callback 回调
+ * @param options 选项
+ */
+export declare const useResizeObserver: (refObj: Ref<Element | undefined>, callback: () => unknown, options?: {
+    autoLifeCycle: boolean;
+}) => {
+    observer: ResizeObserver;
+};

package/src/hooks/plugin/use-svga-animation/index.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+export interface UseSvgaAnimationOptions {
+    /** 容器节点 */
+    containerRef: Ref<HTMLDivElement | undefined>;
+    /** svga 动画文件地址 */
+    svgaUrl: string;
+    /** 是否循环播放，默认：true */
+    loop?: boolean;
+    /** 时间间隔，默认：0 */
+    loopTimeInterval?: number;
+    /** 自动播放，默认：true */
+    autoPlay?: boolean;
+    /** 动画完成回调 */
+    onFinished?: () => unknown;
+    /** 填充模式，默认：AspectFit */
+    contentMode?: 'Fill' | 'AspectFill' | 'AspectFit';
+}
+/**
+ * svga 动画
+ */
+export declare const useSvgaAnimation: (options: UseSvgaAnimationOptions) => {
+    setupSvgaUrl: (url: string) => void;
+    startAnimation: () => void;
+    clearAnimation: () => void;
+};

package/src/hooks/plugin/use-svga-player/index.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { SVGAPlayer, SVGAVideoEntity } from '../../../plugins/svgaplayerweb/load-svga-player';
+export interface AnimationQueryItem<T extends object = object> {
+    url: string;
+    ext: T;
+}
+export interface UseSvgaPlayerOptions<T extends object = object> {
+    /** 播放 svga 动画前回调 */
+    beforePlaySvgaAnimation?: (svgaPlayer: SVGAPlayer, ext: T) => void;
+}
+/**
+ * svga 动画播放器
+ */
+export declare const useSvgaPlayer: <T extends object = object>(wrapRef: Ref<HTMLDivElement | undefined>, options?: UseSvgaPlayerOptions<T>) => {
+    animationQueue: Ref<{
+        url: string;
+        ext: T;
+    }[]>;
+    loadSvgaFile: (url: string) => Promise<SVGAVideoEntity>;
+    clearSvgaAnimation: () => void;
+    pushAnimationQueue: (url: string, inHeader?: boolean, extParam?: T, filterRepeat?: boolean) => void;
+    pauseAnimationQueue: () => void;
+    startAnimationQueue: () => void;
+};

package/src/hooks/tools/use-append-to/index.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+/**
+ * 将节点插入到某个容器中
+ * @param elemRef 对应的节点
+ * @param parentRef 父节点，默认：document.body
+ */
+export declare const useAppendTo: (elemRef: Ref | HTMLElement, parentRef?: Ref | HTMLElement) => void;

package/src/hooks/tools/use-body-locked/index.d.ts

@@ -0,0 +1,10 @@
+import { ResponsiveRef } from '../../../vue-utils';
+/**
+ * 锁定 body 滚动
+ * @param lockedRef 是否锁定
+ * @returns 锁定和解锁 body 滚动
+ */
+export declare const useBodyLocked: (lockedRef: ResponsiveRef<boolean>) => {
+    lockBody: () => void;
+    unlockBody: () => void;
+};

package/src/hooks/tools/use-browser/index.d.ts

@@ -0,0 +1,14 @@
+export interface UseBrowserReturn {
+    /** 是否为 MAC */
+    isMac: boolean;
+    /** 是否为移动端 */
+    isMobile: boolean;
+    /** 是否微信（非企业微信） */
+    isWeixin: boolean;
+    /** 是否企业微信 */
+    isWorkWeixin: boolean;
+}
+/**
+ * 浏览器相关 hook
+ */
+export declare const useBrowser: () => UseBrowserReturn;