@polyv/vue-components 1.1.2 → 1.2.0

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

@@ -0,0 +1,91 @@
+import { ResponsiveRef } from '../../../vue-utils';
+import { Ref } from 'vue';
+export type PopperOffset = [number, number];
+/** 弹层位置 */
+export declare const popperPlacements: readonly ["top", "bottom", "left", "right", "top-start", "top-end", "bottom-start", "bottom-end", "left-start", "left-end", "right-start", "right-end"];
+export type PopperPlacement = (typeof popperPlacements)[number];
+/** 弹层触发方式 */
+export declare const popperTriggers: readonly ["click", "hover", "focus", "long-press", "custom"];
+export type PopperTrigger = (typeof popperTriggers)[number];
+export interface PopperArrowOptions {
+    /** 颜色，默认：#fff */
+    color?: string;
+    /** 尺寸，默认：6 */
+    size?: number;
+}
+export type BeforeShowPopper = () => boolean;
+export interface UsePopperOptions {
+    popperVisible?: boolean | Ref<boolean>;
+    /**
+     * 显示弹层前回调
+     * @returns 是否显示弹层
+     */
+    beforeShowPopper?: BeforeShowPopper;
+    /** 触发节点 ref */
+    referenceRef?: HTMLElement | Ref<HTMLElement | undefined>;
+    /** 弹层节点 ref */
+    popperRef?: HTMLElement | Ref<HTMLElement | undefined>;
+    /** 输入框节点 ref，用于聚焦显示的交互 */
+    inputRef?: HTMLInputElement | Ref<HTMLInputElement | undefined>;
+    /** 弹层是否禁用 */
+    popperDisabled?: boolean | ResponsiveRef<boolean>;
+    /** 触发方式 */
+    trigger?: PopperTrigger | Ref<PopperTrigger>;
+    /**
+     * 鼠标移入延迟显示时间
+     * @default 100
+     */
+    mouseEnterDelay?: number | Ref<number>;
+    /**
+     * 鼠标移出延迟隐藏时间
+     * @default 100
+     */
+    mouseLeaveDelay?: number | Ref<number>;
+    /** 弹层位置 */
+    placement?: PopperPlacement | Ref<PopperPlacement>;
+    /** 弹层偏移量 */
+    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: Element | undefined;
+    popperElem: Element | undefined;
+    inputElem: Element | undefined;
+}
+export interface OnPopperEventParams {
+    /** 触发节点是否已隐藏 */
+    isReferenceHidden: boolean;
+}
+export interface PopperOptions extends Required<Omit<UsePopperOptions, 'popperVisible' | 'beforeShowPopper'>>, PopperVisibleResult {
+    /** 获取相关 dom 节点 */
+    getElement: () => PopperElements;
+    /** 处理弹层事件 */
+    onPopperEvent: (params: OnPopperEventParams) => void;
+}

package/vue3/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-utils').ResponsiveRef<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('./_popper-type').PopperPlacement | import('vue').Ref<import('./_popper-type').PopperPlacement>;
+    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/vue3/src/hooks/element/use-document-visible/index.d.ts

@@ -0,0 +1,3 @@
+export declare const useDocumentVisible: (callback?: (documentVisible: boolean) => unknown) => {
+    documentVisible: import('vue').Ref<boolean>;
+};

package/vue3/src/hooks/element/use-element-size/index.d.ts

@@ -0,0 +1,18 @@
+import { ResponsiveElement } from '../../../vue-utils';
+import { ComputedRef, Ref } from 'vue';
+export interface UseElementSizeReturn {
+    /** 宽度 */
+    width: Ref<number>;
+    /** 高度 */
+    height: Ref<number>;
+    /** 尺寸 */
+    size: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+}
+/**
+ * 获取元素尺寸
+ * @param target 响应式元素
+ */
+export declare function useElementSize(target: ResponsiveElement): UseElementSizeReturn;

package/vue3/src/hooks/element/use-text-ellipsis/index.d.ts

@@ -0,0 +1,4 @@
+import { MaybeElement } from '../../../vue-utils';
+export declare function useTextEllipsis(): {
+    isTextEllipsis: (elemRef: MaybeElement) => boolean;
+};

package/vue3/src/hooks/exports.d.ts

@@ -0,0 +1,46 @@
+export * from './animation/use-image-animation';
+export * from './animation/use-special-effect';
+export * from './animation/use-svga-animation';
+export * from './business/use-app-element';
+export * from './business/use-config-provider';
+export * from './business/use-request';
+export * from './business/use-resize-oss-image';
+export * from './business/use-skin-color';
+export * from './business/use-track-event';
+export * from './components/use-auto-topmost';
+export * from './components/use-popper';
+export * from './element/use-document-visible';
+export * from './element/use-element-size';
+export * from './element/use-text-ellipsis';
+export * from './interactive/use-double-click';
+export * from './interactive/use-fullscreen';
+export * from './interactive/use-hover';
+export * from './interactive/use-outside';
+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 './platform/weixin/use-weixin-mini-program';
+export * from './platform/weixin/use-weixin-sdk';
+export * from './plugin/use-resize-observer';
+export * from './tools/use-append-to';
+export * from './tools/use-auto-listen';
+export * from './tools/use-browser';
+export * from './tools/use-clipboard';
+export * from './tools/use-count-down';
+export * from './tools/use-download';
+export * from './tools/use-event-bus';
+export * from './tools/use-event-listener';
+export * from './tools/use-link-open';
+export * from './tools/use-scroll-lock';
+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 './tools/use-z-index';
+export * from './vue/use-model-value';
+export * from './vue/use-storage-ref';
+export * from './vue/use-vue';

package/vue3/src/hooks/interactive/use-bezier-momentum/index.d.ts

@@ -0,0 +1,17 @@
+import { ResponsiveElement } from '../../../vue-utils';
+export interface UseBezierMomentumOptions {
+    getPosition: () => {
+        x: number;
+        y: number;
+    };
+    updatePosition: (x: number, y: number) => void;
+}
+export declare function useBezierMomentum(transitionElem: ResponsiveElement, options: UseBezierMomentumOptions): {
+    canTransition: import('vue').Ref<boolean>;
+    momentumBezier: import('vue').Ref<string>;
+    momentumTransitionDuration: import('vue').Ref<number>;
+    onMomentumStart: () => void;
+    onMomentumMove: () => void;
+    onMomentumEnd: () => void;
+    stopMomentum: () => void;
+};

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

@@ -0,0 +1,13 @@
+import { ResponsiveElement } from '../../../vue-utils';
+export interface UseDoubleClickOptions {
+    /**
+     * 两次点击时间间隔，单位：毫秒
+     * @default 200
+     */
+    doubleClickTime?: number;
+    /**
+     * 单击回调，该回调有 `doubleClickTime` + 100ms 的延迟
+     */
+    singleClickCallback?: (event: Event) => void;
+}
+export declare function useDoubleClick(target: ResponsiveElement, callback: (event: Event) => void, options?: UseDoubleClickOptions): void;

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

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

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

@@ -0,0 +1,8 @@
+import { ResponsiveElement } from '../../../vue-utils';
+/**
+ * 悬浮事件 hook
+ * @param target 响应式节点
+ */
+export declare const useHover: (target: ResponsiveElement) => {
+    isHover: import('vue').Ref<boolean>;
+};

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

@@ -0,0 +1,27 @@
+import { ResponsiveElement } from '../../../vue-utils';
+export interface UseHoverVisibleOptions {
+    /**
+     * 目标节点
+     */
+    target?: ResponsiveElement;
+    /**
+     * 自动展示
+     * @default true
+     */
+    autoHover?: boolean;
+    /**
+     * 自动关闭时长，单位：ms
+     * @default 3000
+     */
+    timeout?: number;
+}
+/**
+ * 悬浮可见处理
+ */
+export declare const useHoverVisible: (hookOptions?: UseHoverVisibleOptions) => {
+    visible: import('vue').Ref<boolean>;
+    show: () => void;
+    forceShow: () => void;
+    hide: () => void;
+    startAutoHide: () => void;
+};

package/vue3/src/hooks/interactive/use-mouse-wheel/index.d.ts

@@ -0,0 +1,31 @@
+import { ResponsiveElement } from '../../../vue-utils';
+export interface WheelEventData {
+    /** 水平方向的旋转量 */
+    spinX: number;
+    /** 垂直方向的旋转量 */
+    spinY: number;
+    /** 水平方向的像素量 */
+    pixelX: number;
+    /** 垂直方向的像素量 */
+    pixelY: number;
+}
+export interface UseMouseWheelOptions {
+    /**
+     * 鼠标滚轮事件回调
+     */
+    onWheel?: (data: WheelEventData) => void;
+    /**
+     * 向上滚动回调
+     */
+    onUp?: () => void;
+    /**
+     * 向下滚动回调
+     */
+    onDown?: () => void;
+    /**
+     * 是否阻止默认行为
+     * @default true
+     */
+    preventDefault?: boolean;
+}
+export declare function useMouseWheel(target: ResponsiveElement, options?: UseMouseWheelOptions): void;

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

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

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

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

package/vue3/src/hooks/interactive/use-press-hold/index.d.ts

@@ -0,0 +1,28 @@
+import { ResponsiveElement } from '../../../vue-utils';
+export interface UsePressHoldOptions {
+    /**
+     * 按住间隔时间，单位：毫秒
+     * @default 100
+     */
+    holdTime?: number;
+    /**
+     * 按住开始回调
+     */
+    onHoldStart?: () => void;
+    /**
+     * 按住回调
+     */
+    onHold?: () => void;
+    /**
+     * 按住结束回调
+     */
+    onHoldEnd?: () => void;
+    /**
+     * 点击回调
+     */
+    onClick?: () => void;
+}
+export declare function usePressHold(targetRef: ResponsiveElement, options?: UsePressHoldOptions): {
+    isPressDown: import('vue').Ref<boolean>;
+    isPressHold: import('vue').Ref<boolean>;
+};

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

@@ -0,0 +1,25 @@
+/**
+ * 屏幕旋转模式
+ * @description 不使用 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/vue3/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/vue3/src/hooks/interactive/use-sound-effect/index.d.ts

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

package/vue3/src/hooks/interactive/use-vibrate/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 设备振动
+ */
+export declare function useVibrate(): {
+    vibrate: (pattern?: number | number[]) => void;
+    supportVibrate: boolean;
+};

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

@@ -0,0 +1,89 @@
+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> {
+    /**
+     * 是否立即执行
+     * @default true
+     */
+    immediate?: boolean;
+    /**
+     * 关键词
+     */
+    keyword?: Ref<string>;
+    /**
+     * 当前页数
+     * @default 1
+     */
+    pageNumber?: Ref<number>;
+    /**
+     * 每页数量
+     * @default 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>;
+}

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

@@ -0,0 +1,37 @@
+import { Ref, ComputedRef } 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>;
+    /**
+     * 滚动方向
+     * @default 'vertical'
+     */
+    direction?: ScrollDirection;
+}
+export interface ScrollPaginationHookReturn<I = unknown> extends PageinationHookReturn<I> {
+    /**
+     * 滚动容器
+     */
+    scrollRef: Ref<HTMLDivElement | undefined>;
+    /**
+     * 是否为空
+     */
+    isEmpty: ComputedRef<boolean>;
+    /**
+     * 刷新当前数据，重置到第一页
+     */
+    refresh: () => Promise<void>;
+    /**
+     * 根据当前获取的数据，刷新当前列表
+     */
+    refreshList: () => Promise<void>;
+}
+/**
+ * 滚动分页器 hook
+ * @param request 分页请求
+ */
+export declare function useScrollPagination<I = unknown>(request: PaginationRequest<I>, options?: ScrollPaginationHookOptions<I>): ScrollPaginationHookReturn<I>;

package/vue3/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/vue3/src/hooks/platform/weixin/load-wx-sdk.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 加载微信 js-sdk
+ */
+export declare const loadWxSdk: () => Promise<WechatJsSdk.Wx>;
+/**
+ * 加载企业微信的 js-sdk
+ * https://developer.work.weixin.qq.com/document/path/90514
+ */
+export declare const loadWorkWxSdk: () => Promise<WechatJsSdk.Wx>;

package/vue3/src/hooks/platform/weixin/use-weixin-mini-program.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 微信小程序相关 hook
+ */
+export declare const useWeixinMiniProgram: () => {
+    isMiniProgram: () => Promise<boolean>;
+};

package/vue3/src/hooks/platform/weixin/use-weixin-sdk.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 检查 js api 选项
+ */
+export interface WeixinCheckJsApiOptions {
+    /** 不支持的提示文案 */
+    notSupportMessage?: string;
+}
+/**
+ * 微信 sdk 相关 hook
+ */
+export declare const useWeixinSdk: () => {
+    getWeixinSdk: () => Promise<WechatJsSdk.Wx | undefined>;
+    checkJsApi: (apiName: WechatJsSdk.JsApiNames, options?: WeixinCheckJsApiOptions) => Promise<void>;
+};

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

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