@antsoo-lib/components 0.1.4 → 0.1.6

package/dist/src/vc-trigger/Trigger.d.ts

@@ -0,0 +1,358 @@
+import { DefineComponent, ExtractPropTypes, PropType, CSSProperties, ShallowRef, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueTypeDef, VueTypeValidableDef } from 'vue-types';
+import { AlignType } from './interface';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    action: VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    hideAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    onPopupVisibleChange: PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    popup: VueTypeValidableDef<any>;
+    arrow: VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    prefixCls: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupClassName: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupTransitionName: StringConstructor;
+    popupAnimation: VueTypeValidableDef<any>;
+    mouseEnterDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    mouseLeaveDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    blurDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: PropType<(d?: HTMLElement) => HTMLElement>;
+}>, {
+    vcTriggerContext: {
+        onPopupMouseDown?: (...args: any[]) => void;
+        onPopupMouseenter?: (...args: any[]) => void;
+        onPopupMouseleave?: (...args: any[]) => void;
+    };
+    popupRef: ShallowRef<null, null>;
+    setPopupRef: (val: any) => void;
+    triggerRef: ShallowRef<null, null>;
+    align: ComputedRef< AlignType | {
+        [key: string]: any;
+    }>;
+    focusTime: null;
+    clickOutsideHandler: null;
+    contextmenuOutsideHandler1: null;
+    contextmenuOutsideHandler2: null;
+    touchOutsideHandler: null;
+    attachId: null;
+    delayTimer: null;
+    hasPopupMouseDown: boolean;
+    preClickTime: null;
+    preTouchTime: null;
+    mouseDownTimeout: null;
+    childOriginEvents: {};
+}, {
+    prevPopupVisible: boolean;
+    sPopupVisible: boolean;
+    point: null;
+}, {}, {
+    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(): AlignType | {
+        [key: string]: any;
+    };
+    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(): any;
+    isContextMenuOnly(): boolean;
+    isContextmenuToShow(): any;
+    isClickToHide(): any;
+    isMouseEnterToShow(): any;
+    isMouseLeaveToHide(): any;
+    isFocusToShow(): any;
+    isBlurToHide(): any;
+    forcePopupAlign(): void;
+    fireEvents(type: string, e: Event): void;
+    close(): void;
+}, {
+    methods: {
+        setState(state: {} | undefined, callback: () => any): void;
+        __emit(): void;
+    };
+}, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    action: VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    hideAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    onPopupVisibleChange: PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    popup: VueTypeValidableDef<any>;
+    arrow: VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    prefixCls: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupClassName: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupTransitionName: StringConstructor;
+    popupAnimation: VueTypeValidableDef<any>;
+    mouseEnterDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    mouseLeaveDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    blurDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: PropType<(d?: HTMLElement) => HTMLElement>;
+}>> & Readonly<{}>, {
+    mask: boolean;
+    prefixCls: string;
+    forceRender: boolean;
+    autoDestroy: boolean;
+    action: string | string[];
+    showAction: any;
+    hideAction: any;
+    getPopupClassNameFromAlign: any;
+    afterPopupVisibleChange: (...args: any[]) => any;
+    arrow: boolean;
+    popupStyle: CSSProperties;
+    popupClassName: string;
+    builtinPlacements: {
+        [key: string]: any;
+    };
+    mouseEnterDelay: number;
+    mouseLeaveDelay: number;
+    focusDelay: number;
+    blurDelay: number;
+    getDocument: (...args: any[]) => any;
+    destroyPopupOnHide: boolean;
+    maskClosable: boolean;
+    popupAlign: {
+        [key: string]: any;
+    };
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    alignPoint: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-trigger/interface.d.ts

@@ -0,0 +1,208 @@
+import { CSSProperties, ExtractPropTypes, PropType, TransitionProps } from 'vue';
+import { VueNode } from '../_util/type';
+import { VueTypeDef, VueTypeValidableDef } from 'vue-types';
+/** 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: VueTypeDef<string | string[]> & {
+        default: string | (() => string[]);
+    };
+    showAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    hideAction: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    getPopupClassNameFromAlign: VueTypeValidableDef<any> & {
+        default: any;
+    };
+    onPopupVisibleChange: PropType<(open: boolean) => void>;
+    afterPopupVisibleChange: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    popup: VueTypeValidableDef<any>;
+    arrow: VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    popupStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    prefixCls: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupClassName: VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    popupPlacement: StringConstructor;
+    builtinPlacements: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupTransitionName: StringConstructor;
+    popupAnimation: VueTypeValidableDef<any>;
+    mouseEnterDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    mouseLeaveDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    zIndex: NumberConstructor;
+    focusDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    blurDelay: VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    getPopupContainer: FunctionConstructor;
+    getDocument: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    } & {
+        default: (...args: any[]) => any;
+    };
+    forceRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    destroyPopupOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popupAlign: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskTransitionName: StringConstructor;
+    maskAnimation: StringConstructor;
+    stretch: StringConstructor;
+    alignPoint: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    autoDestroy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mobile: ObjectConstructor;
+    getTriggerDOMNode: PropType<(d?: HTMLElement) => HTMLElement>;
+};
+export type TriggerProps = Partial<ExtractPropTypes<ReturnType<typeof triggerProps>>>;

package/dist/src/vc-virtual-list/List.d.ts

@@ -0,0 +1,107 @@
+import { CSSProperties, Component, PropType, DefineComponent, ExtractPropTypes, ShallowRef, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { Key } from '../_util/type';
+import { VueTypeValidableDef } from 'vue-types';
+export type ScrollAlign = 'top' | 'bottom' | 'auto';
+export type ScrollConfig = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export type ScrollTo = (arg: number | ScrollConfig) => void;
+export interface ListState {
+    scrollTop: number;
+    scrollMoving: boolean;
+}
+declare const List: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    data: VueTypeValidableDef<unknown[]> & {
+        default: () => unknown[];
+    };
+    height: NumberConstructor;
+    itemHeight: NumberConstructor;
+    /** If not match virtual scroll condition, Set List still use height of container. */
+    fullHeight: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<Key | ((item: Record<string, any>) => Key)>;
+        required: true;
+    };
+    component: {
+        type: PropType<string | Component>;
+    };
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    children: FunctionConstructor;
+    onScroll: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+    onMouseenter: FunctionConstructor;
+    onVisibleChange: PropType<(visibleList: any[], fullList: any[]) => void>;
+}>, {
+    state: {
+        scrollTop: number;
+        scrollMoving: boolean;
+    };
+    mergedData: ShallowRef<never[], never[]>;
+    componentStyle: ComputedRef<CSSProperties | null>;
+    onFallbackScroll: (e: UIEvent) => void;
+    onScrollBar: (newScrollTop: number) => void;
+    componentRef: ShallowRef<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    useVirtual: ComputedRef<boolean>;
+    calRes: {
+        scrollHeight?: number | undefined;
+        start?: number | undefined;
+        end?: number | undefined;
+        offset?: number | undefined;
+    };
+    collectHeight: () => void;
+    setInstance: (item: Record<string, any>, instance: HTMLElement) => void;
+    sharedConfig: {
+        getKey: (item: Record<string, any>) => undefined;
+    };
+    scrollBarRef: ShallowRef<any, any>;
+    fillerInnerRef: ShallowRef<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    delayHideScrollBar: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    data: VueTypeValidableDef<unknown[]> & {
+        default: () => unknown[];
+    };
+    height: NumberConstructor;
+    itemHeight: NumberConstructor;
+    /** If not match virtual scroll condition, Set List still use height of container. */
+    fullHeight: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<Key | ((item: Record<string, any>) => Key)>;
+        required: true;
+    };
+    component: {
+        type: PropType<string | Component>;
+    };
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    children: FunctionConstructor;
+    onScroll: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+    onMouseenter: FunctionConstructor;
+    onVisibleChange: PropType<(visibleList: any[], fullList: any[]) => void>;
+}>> & Readonly<{}>, {
+    data: unknown[];
+    virtual: boolean;
+    fullHeight: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default List;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antsoo-lib/components",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -27,7 +27,10 @@
     "src"
   ],
   "peerDependencies": {
-    "vue": "^3.5.0"
+    "vue": "^3.5.0",
+    "lodash-es": "^4.17.15",
+    "dayjs": "^1.11.15",
+    "@antsoo-lib/utils": "0.1.1"
   },
   "dependencies": {
     "@ant-design/colors": "^7.2.1",
@@ -41,19 +44,16 @@
     "async-validator": "^4.2.5",
     "classnames": "^2.5.1",
     "csstype": "^3.1.1",
-    "dayjs": "^1.11.15",
     "dom-align": "^1.12.4",
     "dom-scroll-into-view": "^2.0.0",
     "lodash": "^4.17.21",
-    "lodash-es": "^4.17.15",
     "resize-observer-polyfill": "^1.5.1",
     "scroll-into-view-if-needed": "^3.1.0",
     "shallow-equal": "^1.0.0",
     "stylis": "^4.3.6",
     "throttle-debounce": "^5.0.2",
-    "vue-types": "^6.0.0",
-    "warning": "^4.0.0",
-    "@antsoo-lib/utils": "0.1.0"
+    "vue-types": "^3.0.0",
+    "warning": "^4.0.0"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",