@polyv/watch-identify-sdk-ui-default 0.1.0-rc.1

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

@@ -0,0 +1,15 @@
+/**
+ * @file popper 箭头 hook
+ */
+import Vue, { ComponentOptions } from 'vue';
+import { ExtendedVue } from 'vue/types/vue';
+import { PopperOptions } from '../_popper-type';
+export interface PopperArrowOptions {
+    /** 颜色，默认：#fff */
+    color?: string;
+    /** 尺寸，默认：6 */
+    size?: number;
+}
+export type PopperArrowComponentOptions = ComponentOptions<Vue>;
+export type PopperArrowCtorType = ExtendedVue<Vue, Record<string, never>, Record<string, never>, Record<string, never>, PopperArrowOptions, Record<string, never>>;
+export declare const usePopperArrow: (popperOptions: PopperOptions) => void;

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

@@ -0,0 +1,241 @@
+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) => {
+    popperCtx: import("vue").Ref<{
+        state: {
+            elements: {
+                reference: Element | {
+                    getBoundingClientRect: () => DOMRect | ClientRect;
+                    contextElement?: Element | undefined;
+                };
+                popper: HTMLElement;
+                arrow?: HTMLElement | undefined;
+            };
+            options: {
+                placement: import("@popperjs/core").Placement;
+                modifiers: any[];
+                strategy: import("@popperjs/core").PositioningStrategy;
+                onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+            };
+            placement: import("@popperjs/core").Placement;
+            strategy: import("@popperjs/core").PositioningStrategy;
+            orderedModifiers: {
+                name: any;
+                enabled: boolean;
+                phase: import("@popperjs/core").ModifierPhases;
+                requires?: string[] | undefined;
+                requiresIfExists?: string[] | undefined;
+                fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => void | import("@popperjs/core").State;
+                effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => void | (() => void)) | undefined;
+                options?: Partial<any> | undefined;
+                data?: import("@popperjs/core").Obj | undefined;
+            }[];
+            rects: {
+                reference: {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+                popper: {
+                    width: number;
+                    height: number;
+                    x: number;
+                    y: number;
+                };
+            };
+            scrollParents: {
+                reference: (Element | {
+                    innerHeight: number;
+                    offsetHeight: number;
+                    innerWidth: number;
+                    offsetWidth: number;
+                    pageXOffset: number;
+                    pageYOffset: number;
+                    getComputedStyle: typeof getComputedStyle;
+                    addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    Element: Element;
+                    HTMLElement: HTMLElement;
+                    Node: Node;
+                    toString: () => "[object Window]";
+                    devicePixelRatio: number;
+                    visualViewport?: {
+                        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                        dispatchEvent: (event: Event) => boolean;
+                        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                        width: number;
+                        height: number;
+                        offsetLeft: number;
+                        offsetTop: number;
+                        scale: number;
+                    } | undefined;
+                    ShadowRoot: ShadowRoot;
+                } | {
+                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                })[];
+                popper: (Element | {
+                    innerHeight: number;
+                    offsetHeight: number;
+                    innerWidth: number;
+                    offsetWidth: number;
+                    pageXOffset: number;
+                    pageYOffset: number;
+                    getComputedStyle: typeof getComputedStyle;
+                    addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                    Element: Element;
+                    HTMLElement: HTMLElement;
+                    Node: Node;
+                    toString: () => "[object Window]";
+                    devicePixelRatio: number;
+                    visualViewport?: {
+                        addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                        dispatchEvent: (event: Event) => boolean;
+                        removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                        width: number;
+                        height: number;
+                        offsetLeft: number;
+                        offsetTop: number;
+                        scale: number;
+                    } | undefined;
+                    ShadowRoot: ShadowRoot;
+                } | {
+                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                })[];
+            };
+            styles: {
+                [key: string]: Partial<CSSStyleDeclaration>;
+            };
+            attributes: {
+                [key: string]: {
+                    [key: string]: string | boolean;
+                };
+            };
+            modifiersData: {
+                [x: string]: any;
+                arrow?: {
+                    x?: number | undefined;
+                    y?: number | undefined;
+                    centerOffset: number;
+                } | undefined;
+                hide?: {
+                    isReferenceHidden: boolean;
+                    hasPopperEscaped: boolean;
+                    referenceClippingOffsets: {
+                        top: number;
+                        left: number;
+                        right: number;
+                        bottom: number;
+                    };
+                    popperEscapeOffsets: {
+                        top: number;
+                        left: number;
+                        right: number;
+                        bottom: number;
+                    };
+                } | undefined;
+                offset?: {
+                    auto?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    left?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    right?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    bottom?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    top?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "auto-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "auto-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "top-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "top-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "bottom-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "bottom-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "right-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "right-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "left-start"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                    "left-end"?: {
+                        y: number;
+                        x: number;
+                    } | undefined;
+                } | undefined;
+                preventOverflow?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                popperOffsets?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+            };
+            reset: boolean;
+        };
+        destroy: () => void;
+        forceUpdate: () => void;
+        update: () => Promise<Partial<import("@popperjs/core").State>>;
+        setOptions: (setOptionsAction: Partial<OptionsGeneric<any>> | ((prev: Partial<OptionsGeneric<any>>) => Partial<OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
+    } | undefined>;
+    getPopperCtx: () => PopperInstance | undefined;
+    updatePopper: () => Promise<void>;
+    createPopperCore: () => void;
+    destroyPopperCore: () => void;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * @file popper 弹层显示状态 hook
+ */
+import { Ref } from 'vue';
+import { PopperVisibleResult } from '../_popper-type';
+export type UsePopperVisibleOptions = {
+    popperVisible?: boolean | Ref<boolean>;
+};
+export declare const usePopperVisible: (options?: UsePopperVisibleOptions) => PopperVisibleResult;

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

@@ -0,0 +1,70 @@
+import { Ref } from 'vue';
+import type { Placement } from '@popperjs/core';
+import { PopperArrowOptions } from './_hooks/use-popper-arrow';
+export type PopperOffset = [number, number];
+/** 弹层触发方式 */
+export type PopperTrigger = 'click' | 'hover' | 'focus' | 'long-press' | 'custom';
+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/types/hooks/components/use-popper/index.d.ts

@@ -0,0 +1,31 @@
+import { OnPopperEventParams, PopperOffset, UsePopperOptions } from './_popper-type';
+/**
+ * @hook 弹出层 hook
+ */
+export declare const usePopper: (options?: UsePopperOptions) => {
+    updatePopper: () => Promise<void>;
+    getElement: () => import("./_popper-type").PopperElements;
+    onPopperEvent: (params: OnPopperEventParams) => void;
+    inputRef: HTMLInputElement | import("vue").Ref<HTMLInputElement | undefined>;
+    appendToBody: boolean;
+    mountEl: string;
+    referenceRef: HTMLElement | import("vue").Ref<HTMLElement | undefined>;
+    popperRef: HTMLElement | import("vue").Ref<HTMLElement | 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("./_hooks/use-popper-arrow").PopperArrowOptions | import("vue").Ref<boolean | import("./_hooks/use-popper-arrow").PopperArrowOptions>;
+    forceOutSideClickHide: boolean | import("vue").Ref<boolean>;
+    outSideClickDelayHide: boolean | import("vue").Ref<boolean>;
+    followReferenceWidth: boolean | import("vue").Ref<boolean>;
+    forceZIndex: number | null;
+    popperVisible: import("vue").Ref<boolean>;
+    showPopper: () => void;
+    hidePopper: () => void;
+    togglePopper: () => void;
+    delayShowPopper: (delay?: number | undefined) => void;
+    delayHidePopper: (delay?: number | undefined) => void;
+};

package/types/hooks/components/use-popper/use-auto-topmost-show.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+/**
+ * 设置根据显隐状态自动将节点层叠数置顶
+ * @param visibleRef 显隐响应式
+ * @param elemRef 弹出层节点响应式
+ */
+export declare const useAutoTopmostToShow: (visibleRef: Ref<boolean>, elemRef: RefOrElement) => void;

package/types/hooks/components/use-toast/_components/mobile-toast.vue.d.ts

@@ -0,0 +1,42 @@
+declare const _default: import("vue").DefineComponent<{
+    msg: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    type: import("vue-types").VueTypeValidableDef<import("../_toast_type").ToastType> & {
+        default: import("../_toast_type").ToastType;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    mountEl: import("vue-types").VueTypeDef<string | HTMLElement> & {
+        default: string | (() => HTMLElement);
+    };
+}, {
+    openToast(): void;
+    closeToast(): void;
+    setToastTop(top: number): void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
+    close: (arg?: void | undefined) => void;
+    "after-enter": (arg?: void | undefined) => void;
+    "after-leave": (arg?: void | undefined) => void;
+    open: (arg?: void | undefined) => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
+    msg: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    type: import("vue-types").VueTypeValidableDef<import("../_toast_type").ToastType> & {
+        default: import("../_toast_type").ToastType;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    mountEl: import("vue-types").VueTypeDef<string | HTMLElement> & {
+        default: string | (() => HTMLElement);
+    };
+}>>, {
+    type: import("../_toast_type").ToastType;
+    msg: string;
+    duration: number;
+    mountEl: string | HTMLElement;
+}>;
+export default _default;

package/types/hooks/components/use-toast/_components/pc-toast.vue.d.ts

@@ -0,0 +1,42 @@
+declare const _default: import("vue").DefineComponent<{
+    msg: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    type: import("vue-types").VueTypeValidableDef<import("../_toast_type").ToastType> & {
+        default: import("../_toast_type").ToastType;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    mountEl: import("vue-types").VueTypeDef<string | HTMLElement> & {
+        default: string | (() => HTMLElement);
+    };
+}, {
+    openToast(): void;
+    closeToast(): void;
+    setToastTop(top: number): void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
+    close: (arg?: void | undefined) => void;
+    "after-enter": (arg?: void | undefined) => void;
+    "after-leave": (arg?: void | undefined) => void;
+    open: (arg?: void | undefined) => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
+    msg: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    type: import("vue-types").VueTypeValidableDef<import("../_toast_type").ToastType> & {
+        default: import("../_toast_type").ToastType;
+    };
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    mountEl: import("vue-types").VueTypeDef<string | HTMLElement> & {
+        default: string | (() => HTMLElement);
+    };
+}>>, {
+    type: import("../_toast_type").ToastType;
+    msg: string;
+    duration: number;
+    mountEl: string | HTMLElement;
+}>;
+export default _default;

package/types/hooks/components/use-toast/_hooks/use-toast-comp.d.ts

@@ -0,0 +1,53 @@
+import { VueEmit } from '../../../../assets/utils/vue-utils/emit-utils';
+import { FormatProps, VueProps } from '../../../../assets/utils/vue-utils/props-utils';
+import { ToastInstance, ToastType } from '../_toast_type';
+export declare const toastProps: () => {
+    /** 提示内容 */
+    msg: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    /** 提示类型，默认：info */
+    type: import("vue-types").VueTypeValidableDef<ToastType> & {
+        default: ToastType;
+    };
+    /** 关闭时间，默认：3000 */
+    duration: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    /** 渲染的父容器节点，默认：document.body */
+    mountEl: import("vue-types").VueTypeDef<string | HTMLElement> & {
+        default: string | (() => HTMLElement);
+    };
+};
+export type ToastPropsType = FormatProps<typeof toastProps>;
+export declare const toastEmits: () => {
+    /** toast 打开 */
+    open: (arg: void) => void;
+    /** toast 关闭 */
+    close: (arg: void) => void;
+    /** 进入之后 */
+    'after-enter': (arg: void) => void;
+    /** 离开之后 */
+    'after-leave': (arg: void) => void;
+};
+/**
+ * @hook Toast 组件 hook
+ */
+export declare const useToastComp: (options: {
+    props: VueProps<typeof toastProps>;
+    emit: VueEmit<typeof toastEmits>;
+    /** class 前缀 */
+    prefixCls: string;
+}) => {
+    toastRef: import("vue").Ref<HTMLDivElement | undefined>;
+    toastVisible: import("vue").Ref<boolean>;
+    toastClasses: import("vue").ComputedRef<string[]>;
+    toastStyle: import("vue").ComputedRef<{
+        top: string;
+    }>;
+    openToast: () => void;
+    closeToast: () => void;
+    onAfterEnter: () => void;
+    onAfterLeave: () => void;
+    toastInstance: ToastInstance;
+};

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

@@ -0,0 +1,28 @@
+/**
+ * 提示类型
+ */
+export declare enum ToastType {
+    /** 信息类提示 */
+    Info = "info",
+    /** 成功类提示 */
+    Success = "success",
+    /** 警告类提示 */
+    Warning = "warning",
+    /** 异常类提示 */
+    Error = "error",
+    /** 帮助类提示 */
+    Help = "help",
+    /** 加载中提示 */
+    Loading = "loading"
+}
+/**
+ * toast 提示实例
+ */
+export interface ToastInstance {
+    /** 打开提示 */
+    openToast(): void;
+    /** 关闭提示 */
+    closeToast(): void;
+    /** 设置提示 top 样式 */
+    setToastTop(top: number): void;
+}

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

@@ -0,0 +1,59 @@
+import Vue from 'vue';
+import { ExtendedVue } from 'vue/types/vue';
+import { ToastPropsType } from './_hooks/use-toast-comp';
+import { ToastInstance } from './_toast_type';
+type ToastPropPickOptions = Pick<ToastPropsType, 'duration'>;
+type ToastConstructorCtorType = ExtendedVue<Vue, Record<string, never>, ToastInstance, Record<string, never>, Record<string, never>, Record<string, never>>;
+type ToastManagerOptions = {
+    /** 提示组件构造器 */
+    ToastConstructor: ToastConstructorCtorType;
+    /** 最大显示数量，默认：5 */
+    maxCount?: number;
+    /** 渲染的父容器 */
+    mountEl?: string;
+};
+/** 提示管理器 */
+declare class ToastManager {
+    /** 用于创建的组件 */
+    private __ToastConstructor;
+    /** 提示队列 */
+    private __toastQueue;
+    /** 当前正在显示的 toast 实例 */
+    private __toasts;
+    /** 第一个 toast 的 top */
+    private __startTop;
+    /** 两个 toast 之间的距离 */
+    private __instanceSpacing;
+    /** 最大显示数量 */
+    private __maxCount;
+    /** 渲染的父容器 */
+    private _mountEl?;
+    constructor(options: ToastManagerOptions);
+    /** 插入一个提示 */
+    private __push;
+    /** 检查队列 */
+    private __checkQueue;
+    /**
+     * 提示列表
+     */
+    private __toastList;
+    /** 移除提示实例 */
+    private __remove;
+    /** 重置提示实例的 top 定位 */
+    private __resetTop;
+    /** 信息类提示 */
+    info(msg: string, opts?: ToastPropPickOptions): void;
+    /** 成功类提示 */
+    success(msg: string, opts?: ToastPropPickOptions): void;
+    /** 警告类提示 */
+    warning(msg: string, opts?: ToastPropPickOptions): void;
+    /** 异常类提示 */
+    error(msg: string, opts?: ToastPropPickOptions): void;
+    /** 帮助类提示 */
+    help(msg: string, opts?: ToastPropPickOptions): void;
+    /** 加载中提示 */
+    loading(msg: string, opts?: ToastPropPickOptions): void;
+}
+/** 主屏消息提示对象 */
+export declare const toast: ToastManager;
+export {};

package/types/hooks/core/use-page-size/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 页面尺寸初始化设置
+ */
+export declare const usePageSizeSetup: () => void;

package/types/hooks/core/use-root-inject/index.d.ts

@@ -0,0 +1,11 @@
+import { translate } from '../../../assets/lang';
+import { RootInjectContext } from '../use-root-provide';
+import { IdentifyLoginMethod } from '@polyv/watch-identify-sdk-core';
+export declare const useRootInject: () => {
+    getRootCtx: () => RootInjectContext;
+    currentLang: import("vue").ComputedRef<import("@polyv/watch-identify-sdk-core").LangType>;
+    $lang: typeof translate;
+    limitedLoginMethods: import("vue").ComputedRef<IdentifyLoginMethod[]>;
+    wxAuthEnabled: import("vue").ComputedRef<boolean>;
+    getIdentifyCore: () => import("@polyv/watch-identify-sdk-core").IdentifyCore;
+};