@polyv/vue-components 1.1.1 → 1.2.0

package/vue3/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/vue3/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/vue3/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/vue3/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/vue3/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/vue3/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/vue3/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;
+    };
+};

package/vue3/src/hooks/animation/types/common.d.ts

@@ -0,0 +1,32 @@
+import { AnimationControllerOptions, PlayAnimationOptions } from './index';
+/**
+ * 动画实现器
+ */
+export interface AnimationImplement {
+    /**
+     * 自动播放前钩子
+     */
+    beforeAutoPlay?: () => Promise<void>;
+    /**
+     * 清空动画
+     */
+    clearAnimation: () => Promise<void>;
+    /**
+     * 播放一次动画
+     */
+    playSingleAnimation: () => Promise<void>;
+}
+export declare const useCommonAnimation: (hookOptions: AnimationControllerOptions, implement: AnimationImplement) => {
+    wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+    isPlayingAnimation: import('vue').Ref<boolean>;
+    currentUrl: import('vue').Ref<string | undefined>;
+    autoPlay: boolean;
+    loop: import('vue').Ref<boolean>;
+    loopTimeInterval: import('vue').Ref<number>;
+    beforePlayAnimation: (options: PlayAnimationOptions) => void;
+    beforePlayCallback: (options: PlayAnimationOptions) => void;
+    onFinishedCallback: (options: PlayAnimationOptions) => void;
+    onErrorCallback: (options: PlayAnimationOptions, error: Error) => void;
+    playAnimation: (options?: PlayAnimationOptions) => Promise<void>;
+    clearAnimation: () => Promise<void>;
+};

package/vue3/src/hooks/animation/types/index.d.ts

@@ -0,0 +1,71 @@
+import { Ref } from 'vue';
+export interface AnimationCallback {
+    /**
+     * 播放前回调
+     */
+    onBeforePlay?: () => void;
+    /**
+     * 播放完成回调
+     */
+    onFinished?: () => void;
+    /**
+     * 播放异常回调
+     */
+    onError?: (error: Error) => void;
+}
+export interface PlayAnimationOptions extends AnimationCallback {
+    /**
+     * 动画文件地址
+     */
+    url?: string;
+    /**
+     * 是否循环播放
+     */
+    loop?: boolean;
+    /**
+     * 循环间隔时间
+     */
+    loopTimeInterval?: number;
+}
+export interface AnimationControllerOptions extends AnimationCallback {
+    /**
+     * 容器节点
+     */
+    wrapRef?: Ref<HTMLDivElement | undefined>;
+    /**
+     * 动画文件地址
+     */
+    url?: string;
+    /**
+     * 是否循环播放
+     * @default false
+     */
+    loop?: boolean;
+    /**
+     * 循环间隔时间
+     */
+    loopTimeInterval?: number;
+    /**
+     * 自动播放
+     * @default true
+     */
+    autoPlay?: boolean;
+    /**
+     * 是否播放动画中
+     */
+    isPlayingAnimation?: Ref<boolean>;
+}
+export interface AnimationController {
+    /**
+     * 容器节点
+     */
+    wrapRef: Ref<HTMLDivElement | undefined>;
+    /**
+     * 播放动画
+     */
+    playAnimation: (options?: PlayAnimationOptions) => Promise<void>;
+    /**
+     * 清空动画
+     */
+    clearAnimation: () => Promise<void>;
+}

package/vue3/src/hooks/animation/use-image-animation/index.d.ts

@@ -0,0 +1,4 @@
+import { AnimationController, AnimationControllerOptions } from '../types';
+export interface UseImageAnimationOptions extends AnimationControllerOptions {
+}
+export declare const useImageAnimation: (hookOptions?: UseImageAnimationOptions) => AnimationController;

package/vue3/src/hooks/animation/use-special-effect/index.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+import { PlayAnimationOptions } from '../types';
+export interface UseSpecialEffectOptions {
+    /**
+     * 容器节点
+     */
+    wrapRef?: Ref<HTMLDivElement | undefined>;
+}
+export interface AnimationQueueItem {
+    url: string;
+}
+export interface PushAnimationQueueOptions {
+    /**
+     * 动画文件地址
+     */
+    url: string;
+    /**
+     * 是否从头部插入
+     * @default false
+     */
+    inHeader?: boolean;
+    /**
+     * 是否过滤重复的动画
+     * @default false
+     */
+    filterRepeat?: boolean;
+}
+export declare const useSpecialEffect: (options?: UseSpecialEffectOptions) => {
+    wrapRef: Ref<HTMLDivElement | undefined>;
+    animationQueue: Ref<{
+        url: string;
+    }[]>;
+    currentAnimationItem: Ref<AnimationQueueItem | undefined>;
+    pushAnimationQueue: (options: PushAnimationQueueOptions) => void;
+    pauseAnimationQueue: () => void;
+    startAnimationQueue: () => void;
+    clearAnimationQueue: () => void;
+    playAnimation: (options?: PlayAnimationOptions) => Promise<void>;
+    clearAnimation: () => Promise<void>;
+};

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

@@ -0,0 +1,16 @@
+import { AnimationController, AnimationControllerOptions } from '../types';
+import { SVGAVideoEntity } from './load-svga-player';
+export interface UseSvgaAnimationOptions extends AnimationControllerOptions {
+    /**
+     * 填充模式
+     * @default 'AspectFill'
+     */
+    contentMode?: 'Fill' | 'AspectFill' | 'AspectFit';
+}
+export interface UseSvgaAnimationReturn extends AnimationController {
+    /**
+     * 加载 svga 动画文件地址
+     */
+    loadSvgaFile: (url: string) => Promise<SVGAVideoEntity>;
+}
+export declare const useSvgaAnimation: (hookOptions?: UseSvgaAnimationOptions) => UseSvgaAnimationReturn;

package/vue3/src/hooks/animation/use-svga-animation/load-svga-player.d.ts

@@ -0,0 +1,15 @@
+import { Player as SVGAPlayer, Parser as SVGAParser, VideoEntity as SVGAVideoEntity } from 'svgaplayerweb';
+export type { SVGAPlayer, SVGAParser, SVGAVideoEntity };
+export interface SVGASdk {
+    Player: typeof SVGAPlayer;
+    Parser: typeof SVGAParser;
+}
+declare global {
+    interface Window {
+        SVGA?: SVGASdk;
+    }
+}
+/**
+ * 加载 svga 播放器
+ */
+export declare function loadSvgaPlayer(): Promise<SVGASdk>;

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

@@ -0,0 +1,5 @@
+export declare const useAppElement: () => {
+    getDocument: () => Document;
+    getAppRootElement: () => HTMLElement;
+    getAppBodyElement: () => HTMLElement;
+};

package/vue3/src/hooks/business/use-config-provider/index.d.ts

@@ -0,0 +1,34 @@
+import { PwcEventEmitter } from '../../tools/use-event-bus';
+import { I18nLangs } from '../../../lang/types';
+import { InjectionKey } from 'vue';
+import { SkinColorConfig } from '../use-skin-color';
+import { TrackEventData } from '../use-track-event';
+export interface ConfigProviderInjectData {
+    /** 当前语言 */
+    globalLang?: I18nLangs | (() => I18nLangs);
+    /** 是否网页 css 全屏 */
+    pageFullscreen?: boolean | (() => boolean);
+    /** 全屏元素 */
+    fullscreenElement?: string | Element;
+    /** 获取事件订阅器 */
+    getEmitter?: () => PwcEventEmitter;
+    /** 埋点回调 */
+    trackEventCallback?: (data: TrackEventData) => unknown;
+    /**
+     * 皮肤颜色配置
+     */
+    getSkinColorConfig?: () => SkinColorConfig;
+}
+export interface ConfigProviderOptions {
+    /**
+     * 自动应用根节点皮肤颜色 class
+     * @default true
+     */
+    autoSkinColorRoot?: boolean;
+}
+/** 配置注入 key */
+export declare const ConfigProviderInjectKey: InjectionKey<ConfigProviderInjectData>;
+export declare const useConfigProvider: (config?: ConfigProviderInjectData, options?: ConfigProviderOptions) => void;
+export declare const useConfigProviderInject: (defConfig?: ConfigProviderInjectData) => {
+    configProviderData: ConfigProviderInjectData | undefined;
+};

package/vue3/src/hooks/business/use-request/index.d.ts

@@ -0,0 +1,56 @@
+import { Ref } from 'vue';
+export type UseRequestFunction<R, P extends any[] = any> = (...params: P) => Promise<R>;
+export interface UseRequestOptions<R, P extends any[]> {
+    /**
+     * 请求中响应式对象
+     */
+    loading?: Ref<boolean>;
+    /**
+     * 同步 loading 状态
+     */
+    syncLoadings?: Ref<boolean>[];
+    /**
+     * 请求中禁用请求
+     * @default true
+     */
+    loadingDisabledRequest?: boolean;
+    /**
+     * 提示成功
+     * @default false
+     */
+    toastSuccess?: boolean;
+    /**
+     * 提示错误信息
+     * @default false
+     */
+    toastError?: boolean;
+    /**
+     * 成功文案
+     */
+    successMessage?: string;
+    /**
+     * 请求前
+     */
+    beforeRequest?: (...params: P) => unknown;
+    /**
+     * 成功后回调
+     */
+    onSuccess?: (res: R, ...params: P) => unknown;
+    /**
+     * 失败后回调
+     */
+    onFail?: (error: Error, ...params: P) => unknown;
+    /**
+     * 完成后回调
+     */
+    onFinally?: (...params: P) => unknown;
+}
+/**
+ * 请求 hook
+ * @param fn 请求方法
+ */
+export declare const useRequest: <R, P extends any[] = any>(fn: UseRequestFunction<R, P>, options?: UseRequestOptions<R, P>) => {
+    loading: Ref<boolean>;
+    requestFinished: Ref<boolean>;
+    request: (...params: P) => Promise<R | undefined>;
+};

package/vue3/src/hooks/business/use-resize-oss-image/index.d.ts

@@ -0,0 +1,5 @@
+export declare const useResizeOssImage: () => {
+    appendToOssProcess: (url: string, additionalParams: string) => string;
+    resizeOSSImg: (url: string, width?: number, height?: number) => string;
+    resizeHtmlContentImg: (htmlContent: string, width?: number) => string;
+};

package/vue3/src/hooks/business/use-server/index.d.ts

@@ -0,0 +1,4 @@
+export declare function useServer<T extends (...args: any[]) => unknown>(fn: T, value: ReturnType<T>): ReturnType<T>;
+export declare function useServer<T extends (...args: any[]) => unknown>(fn: T): ReturnType<T> | undefined;
+export declare function useClient<T extends (...args: any[]) => unknown>(fn: T, value: ReturnType<T>): ReturnType<T>;
+export declare function useClient<T extends (...args: any[]) => unknown>(fn: T): ReturnType<T> | undefined;

package/vue3/src/hooks/business/use-skin-color/index.d.ts

@@ -0,0 +1,44 @@
+import { ConfigProviderInjectData } from '../use-config-provider';
+import { VueProps } from '../../../vue-utils';
+/**
+ * 皮肤颜色模式
+ */
+export type SkinColorMode = 'light' | 'dark';
+export interface SkinColorConfig {
+    /**
+     * 皮肤颜色模式
+     * @default dark
+     */
+    skinColorMode?: SkinColorMode;
+    /**
+     * 特殊颜色
+     * @default #3F76FC
+     */
+    specialColor?: string;
+}
+/**
+ * 生成皮肤颜色 class
+ * @param suffix 后缀
+ */
+export declare function genSkinColorClass<T extends string>(suffix: T): string;
+export declare const useSkinColorConfig: (_configProviderData?: ConfigProviderInjectData) => {
+    skinColorConfig: import('vue').ComputedRef<{
+        skinColorMode: SkinColorMode;
+        specialColor: string;
+    }>;
+    currentSkinColorMode: import('vue').ComputedRef<"light" | "dark">;
+    genSkinColorClass: typeof genSkinColorClass;
+    getSpecialColor: (opacity?: number) => string;
+};
+export declare const useSkinColorRoot: (_configProviderData?: ConfigProviderInjectData) => void;
+export declare const skinColorIgnoreProps: () => {
+    /** 是否忽略皮肤颜色 */
+    ignoreSkinColor: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export declare const useSkinColorIgnore: (options?: {
+    props?: VueProps<typeof skinColorIgnoreProps>;
+}) => {
+    skinColorIgnoreClass: import('vue').ComputedRef<string | undefined>;
+};

package/vue3/src/hooks/business/use-track-event/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 埋点数据
+ */
+export interface TrackEventData {
+    /** 事件名 */
+    event_id: string;
+    /** 事件类型 */
+    event_type: string;
+    /** 事件属性，不能为空对象 */
+    spec_attrs: Record<string, unknown>;
+}
+export interface TrackEventSender {
+    trackEvent?: (data: TrackEventData) => unknown;
+}
+/**
+ * 埋点事件发送
+ * @param sender 事件发送器
+ */
+export declare const useTrackEvent: (sender: TrackEventSender) => {
+    trackEvent: (data: TrackEventData) => void;
+};

package/vue3/src/hooks/components/use-auto-topmost/index.d.ts

@@ -0,0 +1,14 @@
+import { ResponsiveElement } from '../../../vue-utils';
+import { Ref } from 'vue';
+export interface UseAutoTopmostOptions {
+    /** 置顶事件 */
+    topmostEvent?: string;
+}
+/**
+ * 设置根据显隐状态自动将节点层叠数置顶
+ * @param visibleRef 显隐响应式
+ * @param elemRef 弹出层节点响应式
+ */
+export declare const useAutoTopmost: (visibleRef: Ref<boolean>, elemRef: ResponsiveElement, options?: UseAutoTopmostOptions) => {
+    topmostElem: () => Promise<void>;
+};

package/vue3/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/vue3/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/vue3/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/vue3/src/hooks/components/use-popper/_hooks/use-popper-visible.d.ts

@@ -0,0 +1,2 @@
+import { PopperVisibleResult, UsePopperOptions } from '../_popper-type';
+export declare const usePopperVisible: (options?: UsePopperOptions) => PopperVisibleResult;