@vunk/plus 1.13.1 → 1.15.0

package/ant/vc-trigger/Popup/interface.d.ts

@@ -0,0 +1,151 @@
+import type { Point, AlignType, StretchType, MobileConfig } from '../interface';
+import type { ExtractPropTypes, PropType } from 'vue';
+export declare const innerProps: {
+    visible: BooleanConstructor;
+    prefixCls: StringConstructor;
+    zIndex: NumberConstructor;
+    destroyPopupOnHide: BooleanConstructor;
+    forceRender: BooleanConstructor;
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animation: (ObjectConstructor | StringConstructor)[];
+    transitionName: StringConstructor;
+    stretch: {
+        type: PropType<StretchType>;
+    };
+    align: {
+        type: PropType<AlignType>;
+    };
+    point: {
+        type: PropType<Point>;
+    };
+    getRootDomNode: {
+        type: PropType<() => HTMLElement>;
+    };
+    getClassNameFromAlign: {
+        type: PropType<(align: AlignType) => string>;
+    };
+    onAlign: {
+        type: PropType<(popupDomNode: HTMLElement, align: AlignType) => void>;
+    };
+    onMouseenter: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMouseleave: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMousedown: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onTouchstart: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+};
+export type PopupInnerProps = Partial<ExtractPropTypes<typeof innerProps>> & {
+    align?: AlignType;
+};
+export declare const mobileProps: {
+    mobile: {
+        type: PropType<MobileConfig>;
+    };
+    visible: BooleanConstructor;
+    prefixCls: StringConstructor;
+    zIndex: NumberConstructor;
+    destroyPopupOnHide: BooleanConstructor;
+    forceRender: BooleanConstructor;
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animation: (ObjectConstructor | StringConstructor)[];
+    transitionName: StringConstructor;
+    stretch: {
+        type: PropType<StretchType>;
+    };
+    align: {
+        type: PropType<AlignType>;
+    };
+    point: {
+        type: PropType<Point>;
+    };
+    getRootDomNode: {
+        type: PropType<() => HTMLElement>;
+    };
+    getClassNameFromAlign: {
+        type: PropType<(align: AlignType) => string>;
+    };
+    onAlign: {
+        type: PropType<(popupDomNode: HTMLElement, align: AlignType) => void>;
+    };
+    onMouseenter: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMouseleave: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMousedown: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onTouchstart: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+};
+export type MobilePopupProps = Partial<ExtractPropTypes<typeof mobileProps>> & {
+    align?: AlignType;
+    mobile: MobileConfig;
+};
+export declare const popupProps: {
+    mask: BooleanConstructor;
+    mobile: {
+        type: PropType<MobileConfig>;
+    };
+    maskAnimation: StringConstructor;
+    maskTransitionName: StringConstructor;
+    visible: BooleanConstructor;
+    prefixCls: StringConstructor;
+    zIndex: NumberConstructor;
+    destroyPopupOnHide: BooleanConstructor;
+    forceRender: BooleanConstructor;
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    animation: (ObjectConstructor | StringConstructor)[];
+    transitionName: StringConstructor;
+    stretch: {
+        type: PropType<StretchType>;
+    };
+    align: {
+        type: PropType<AlignType>;
+    };
+    point: {
+        type: PropType<Point>;
+    };
+    getRootDomNode: {
+        type: PropType<() => HTMLElement>;
+    };
+    getClassNameFromAlign: {
+        type: PropType<(align: AlignType) => string>;
+    };
+    onAlign: {
+        type: PropType<(popupDomNode: HTMLElement, align: AlignType) => void>;
+    };
+    onMouseenter: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMouseleave: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onMousedown: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+    onTouchstart: {
+        type: PropType<(align: MouseEvent) => void>;
+    };
+};
+export type PopupProps = Partial<ExtractPropTypes<typeof popupProps>> & {
+    align?: AlignType;
+    mobile: MobileConfig;
+};

package/ant/vc-trigger/Popup/useStretchStyle.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef, CSSProperties, Ref } from 'vue';
+import type { StretchType } from '../interface';
+declare const _default: (stretch?: Ref<StretchType>) => [ComputedRef<CSSProperties>, (element: HTMLElement) => void];
+export default _default;

package/ant/vc-trigger/Popup/useVisibleStatus.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+/**
+ * Popup should follow the steps for each component work correctly:
+ * measure - check for the value stretch size
+ * align - let component align the position
+ * aligned - re-align again in case additional className changed the size
+ * afterAlign - choice next step is trigger motion or finished
+ * beforeMotion - should reset motion to invisible so that CSSMotion can do normal motion
+ * motion - play the motion
+ * stable - everything is done
+ */
+type PopupStatus = null | 'measure' | 'align' | 'aligned' | 'motion' | 'stable';
+type Func = () => void;
+declare const _default: (visible: Ref<boolean>, doMeasure: Func) => [Ref<PopupStatus>, (callback?: () => void) => void];
+export default _default;

package/ant/vc-trigger/Trigger.d.ts

@@ -0,0 +1,282 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    action: import("vue-types").VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    hideAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    onPopupVisibleChange: import("vue").PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    popup: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    arrow: import("vue-types").VueTypeValidableDef<boolean, import("vue-types").ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: import("vue").PropType<import("vue").CSSProperties>;
+        default: import("vue").CSSProperties;
+    };
+    prefixCls: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupClassName: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>>;
+    popupTransitionName: StringConstructor;
+    popupAnimation: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    mouseEnterDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    mouseLeaveDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    blurDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>> & {
+        default: () => Record<string, any>;
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: import("vue").PropType<(d?: HTMLElement) => HTMLElement>;
+}>, {
+    vcTriggerContext: {
+        onPopupMouseDown?: (...args: any[]) => void;
+        onPopupMouseenter?: (...args: any[]) => void;
+        onPopupMouseleave?: (...args: any[]) => void;
+    };
+    popupRef: import("vue").ShallowRef<any, any>;
+    setPopupRef: (val: any) => void;
+    triggerRef: import("vue").ShallowRef<any, any>;
+    align: import("vue").ComputedRef<Record<string, any> | import("./interface").AlignType>;
+    focusTime: any;
+    clickOutsideHandler: any;
+    contextmenuOutsideHandler1: any;
+    contextmenuOutsideHandler2: any;
+    touchOutsideHandler: any;
+    attachId: any;
+    delayTimer: any;
+    hasPopupMouseDown: boolean;
+    preClickTime: any;
+    preTouchTime: any;
+    mouseDownTimeout: any;
+    childOriginEvents: {};
+}, {
+    prevPopupVisible: any;
+    sPopupVisible: any;
+    point: any;
+}, {}, {
+    updatedCal(): void;
+    onMouseenter(e: any): void;
+    onMouseMove(e: any): void;
+    onMouseleave(e: any): void;
+    onPopupMouseenter(): void;
+    onPopupMouseleave(e: any): void;
+    onFocus(e: any): void;
+    onMousedown(e: any): void;
+    onTouchstart(e: any): void;
+    onBlur(e: any): void;
+    onContextmenu(e: any): void;
+    onContextmenuClose(): void;
+    onClick(event: any): void;
+    onPopupMouseDown(...args: any[]): void;
+    onDocumentClick(event: any): void;
+    getPopupDomNode(): any;
+    getRootDomNode(): any;
+    handleGetPopupClassFromAlign(align: any): string;
+    getPopupAlign(): Record<string, any> | import("./interface").AlignType;
+    getComponent(): import("vue/jsx-runtime").JSX.Element;
+    attachParent(popupContainer: any): void;
+    getContainer(): any;
+    setPopupVisible(sPopupVisible: boolean, event?: any): void;
+    setPoint(point: any): void;
+    handlePortalUpdate(): void;
+    delaySetPopupVisible(visible: boolean, delayS: number, event?: any): void;
+    clearDelayTimer(): void;
+    clearOutsideHandler(): void;
+    createTwoChains(event: string): any;
+    isClickToShow(): boolean;
+    isContextMenuOnly(): boolean;
+    isContextmenuToShow(): boolean;
+    isClickToHide(): boolean;
+    isMouseEnterToShow(): boolean;
+    isMouseLeaveToHide(): boolean;
+    isFocusToShow(): boolean;
+    isBlurToHide(): boolean;
+    forcePopupAlign(): void;
+    fireEvents(type: string, e: Event): void;
+    close(): void;
+}, {
+    methods: {
+        setState(this: any, state?: {}, callback?: () => any): void;
+        __emit(this: any): void;
+    };
+}, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    action: import("vue-types").VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    hideAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    onPopupVisibleChange: import("vue").PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    popup: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    arrow: import("vue-types").VueTypeValidableDef<boolean, import("vue-types").ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: import("vue").PropType<import("vue").CSSProperties>;
+        default: import("vue").CSSProperties;
+    };
+    prefixCls: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupClassName: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>>;
+    popupTransitionName: StringConstructor;
+    popupAnimation: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    mouseEnterDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    mouseLeaveDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    blurDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>> & {
+        default: () => Record<string, any>;
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: import("vue").PropType<(d?: HTMLElement) => HTMLElement>;
+}>> & Readonly<{}>, {
+    mask: boolean;
+    prefixCls: string;
+    action: string | string[];
+    showAction: any;
+    hideAction: any;
+    getPopupClassNameFromAlign: any;
+    afterPopupVisibleChange: (...args: any[]) => any;
+    arrow: boolean;
+    popupStyle: import("vue").CSSProperties;
+    popupClassName: string;
+    mouseEnterDelay: number;
+    mouseLeaveDelay: number;
+    focusDelay: number;
+    blurDelay: number;
+    getDocument: (...args: any[]) => any;
+    forceRender: boolean;
+    destroyPopupOnHide: boolean;
+    maskClosable: boolean;
+    popupAlign: Record<string, any>;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    alignPoint: boolean;
+    autoDestroy: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/vc-trigger/context.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+export interface PortalContextProps {
+    shouldRender: Ref<boolean>;
+    inTriggerContext: boolean;
+}
+export declare const useProvidePortal: (instance: any, config?: {
+    inTriggerContext: boolean;
+}) => void;
+export declare const useInjectPortal: () => {
+    shouldRender: import("vue").ComputedRef<boolean>;
+};

package/ant/vc-trigger/index.d.ts

@@ -0,0 +1,6 @@
+import Trigger from './Trigger';
+import { triggerProps } from './interface';
+import type { TriggerProps } from './interface';
+export { triggerProps };
+export type { TriggerProps };
+export default Trigger;

package/ant/vc-trigger/interface.d.ts

@@ -0,0 +1,175 @@
+import type { CSSProperties, ExtractPropTypes, TransitionProps, PropType } from 'vue';
+import type { VueNode } from '../_util/type';
+/** Two char of 't' 'b' 'c' 'l' 'r'. Example: 'lt' */
+export type AlignPoint = string;
+export type OffsetType = number | `${number}%`;
+export interface AlignType {
+    /**
+     * move point of source node to align with point of target node.
+     * Such as ['tr','cc'], align top right point of source node with center point of target node.
+     * Point can be 't'(top), 'b'(bottom), 'c'(center), 'l'(left), 'r'(right) */
+    points?: (string | AlignPoint)[];
+    /**
+     * offset source node by offset[0] in x and offset[1] in y.
+     * If offset contains percentage string value, it is relative to sourceNode region.
+     */
+    offset?: OffsetType[];
+    /**
+     * offset target node by offset[0] in x and offset[1] in y.
+     * If targetOffset contains percentage string value, it is relative to targetNode region.
+     */
+    targetOffset?: OffsetType[];
+    /**
+     * If adjustX field is true, will adjust source node in x direction if source node is invisible.
+     * If adjustY field is true, will adjust source node in y direction if source node is invisible.
+     */
+    overflow?: {
+        adjustX?: boolean | number;
+        adjustY?: boolean | number;
+        shiftX?: boolean | number;
+        shiftY?: boolean | number;
+    };
+    /** Auto adjust arrow position */
+    autoArrow?: boolean;
+    /**
+     * Config visible region check of html node. Default `visible`:
+     *  - `visible`:
+     *    The visible region of user browser window.
+     *    Use `clientHeight` for check.
+     *    If `visible` region not satisfy, fallback to `scroll`.
+     *  - `scroll`:
+     *    The whole region of the html scroll area.
+     *    Use `scrollHeight` for check.
+     *  - `visibleFirst`:
+     *    Similar to `visible`, but if `visible` region not satisfy, fallback to `scroll`.
+     */
+    htmlRegion?: 'visible' | 'scroll' | 'visibleFirst';
+    /**
+     * Whether use css right instead of left to position
+     */
+    useCssRight?: boolean;
+    /**
+     * Whether use css bottom instead of top to position
+     */
+    useCssBottom?: boolean;
+    /**
+     * Whether use css transform instead of left/top/right/bottom to position if browser supports.
+     * Defaults to false.
+     */
+    useCssTransform?: boolean;
+    ignoreShake?: boolean;
+}
+export type BuildInPlacements = Record<string, AlignType>;
+export type StretchType = string;
+export type ActionType = string;
+export type AnimationType = string;
+export type TransitionNameType = string;
+export interface Point {
+    pageX: number;
+    pageY: number;
+}
+export interface CommonEventHandler {
+    remove: () => void;
+}
+export interface MobileConfig {
+    /** Set popup motion. You can ref `rc-motion` for more info. */
+    popupMotion?: TransitionProps;
+    popupClassName?: string;
+    popupStyle?: CSSProperties;
+    popupRender?: (originNode: VueNode) => VueNode;
+}
+export declare function noop(): void;
+export declare const triggerProps: () => {
+    action: import("vue-types").VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    hideAction: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>> & {
+        default: any;
+    };
+    onPopupVisibleChange: PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    popup: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    arrow: import("vue-types").VueTypeValidableDef<boolean, import("vue-types").ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    prefixCls: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupClassName: import("vue-types").VueTypeValidableDef<string, import("vue-types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>>;
+    popupTransitionName: StringConstructor;
+    popupAnimation: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    mouseEnterDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    mouseLeaveDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    blurDelay: import("vue-types").VueTypeValidableDef<number, import("vue-types").ValidatorFunction<number>> & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: import("vue-types").VueTypeValidableDef<Record<string, any>, import("vue-types").ValidatorFunction<Record<string, any>>> & {
+        default: () => Record<string, any>;
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: PropType<(d?: HTMLElement) => HTMLElement>;
+};
+export type TriggerProps = Partial<ExtractPropTypes<ReturnType<typeof triggerProps>>>;

package/ant/vc-trigger/utils/alignUtil.d.ts

@@ -0,0 +1,3 @@
+import type { AlignType, BuildInPlacements } from '../interface';
+export declare function getAlignFromPlacement(builtinPlacements: BuildInPlacements, placementStr: string, align: AlignType): AlignType;
+export declare function getAlignPopupClassName(builtinPlacements: BuildInPlacements, prefixCls: string, align: AlignType, isAlignPoint: boolean): string;

package/ant/vc-trigger/utils/motionUtil.d.ts

@@ -0,0 +1,12 @@
+import type { AnimationType, TransitionNameType } from '../interface';
+interface GetMotionProps {
+    animation: AnimationType;
+    transitionName: TransitionNameType;
+    prefixCls: string;
+}
+export declare function getMotion({ prefixCls, animation, transitionName }: GetMotionProps): {
+    name: string;
+} | {
+    name?: undefined;
+};
+export {};