@opentiny/vue-renderless 3.13.2 → 3.14.1

package/types/cascader.type.d.ts

@@ -1,2 +1,330 @@
+import { ISharedRenderlessParamUtils } from './shared.type.js';
+import { ExtractPropTypes } from 'vue';
+import { N as Node, d as ICascaderPanelNodePropValue, a as ICascaderPanelApi } from './cascader-panel.type-2bd03be3.js';
 
-export { }
+declare const cascaderProps: {
+    _constants: {
+        type: ObjectConstructor;
+        default: () => {
+            placeholder: string;
+            COMPONENT_NAME: {
+                FormItem: string;
+            };
+            EVENT_NAME: {
+                FormBlur: string;
+                FormChange: string;
+            };
+            defaultNodeConfig: {
+                lazy: boolean;
+                load: null;
+                isLeaf: string;
+                afterLoad: null;
+                currentNodeKey: null;
+                checkStrictly: boolean;
+                checkDescendants: null;
+                defaultCheckedKeys: null;
+                defaultExpandedKeys: null;
+                autoExpandParent: null;
+                defaultExpandAll: null;
+                filterNodeMethod: null;
+            };
+        };
+    };
+    autoSize: BooleanConstructor;
+    beforeFilter: {
+        type: FunctionConstructor;
+        default: () => () => void;
+    };
+    clearable: BooleanConstructor;
+    collapseTags: BooleanConstructor;
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disabled: BooleanConstructor;
+    filterMethod: FunctionConstructor;
+    filterable: BooleanConstructor;
+    modelValue: {};
+    options: ArrayConstructor;
+    placeholder: {
+        type: StringConstructor;
+        default: any;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperClass: StringConstructor;
+    props: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+    showAllLevels: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: StringConstructor;
+    shape: StringConstructor;
+    label: StringConstructor;
+    tip: StringConstructor;
+    displayOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hoverExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: StringConstructor;
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    levelTitle: ArrayConstructor;
+    blank: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+
+declare const getConfig: ({ parent, props }: {
+    parent: ICascadeRenderlessParamUtils['parent'];
+    props: ICascaderProps;
+}) => () => Record<string, any>;
+declare const computClearVisible: ({ props, state }: {
+    props: ICascaderProps;
+    state: ICascaderState;
+}) => () => boolean;
+declare const computePresentContent: ({ api, state }: {
+    api: ICascaderApi;
+    state: ICascaderState;
+}) => () => void;
+declare const watchValue: ({ api, state }: {
+    api: ICascaderApi;
+    state: ICascaderState;
+}) => (value: any) => void;
+declare const watchCheckedValue: ({ nextTick, constants, dispatch, api, emit, state }: {
+    api: ICascaderApi;
+    emit: ICascadeRenderlessParamUtils['emit'];
+    state: ICascaderState;
+}) => (value: any) => void;
+declare const selfMounted: ({ api, parent, props, vm, state }: {
+    api: ICascaderApi;
+    parent: ICascadeRenderlessParamUtils['parent'];
+    props: ICascaderProps;
+    vm: ICascadeRenderlessParamUtils['vm'];
+    state: ICascaderState;
+}) => () => void;
+declare const toggleDropDownVisible: ({ emit, vm, state, updatePopper }: {
+    emit: ICascadeRenderlessParamUtils['emit'];
+    vm: ICascadeRenderlessParamUtils['vm'];
+    state: ICascaderState;
+    updatePopper: (popperElm?: HTMLElement | undefined) => void;
+}) => (visible: any) => void;
+declare const handleDropdownLeave: (state: any) => () => void;
+declare const handleKeyDown: ({ api }: {
+    api: any;
+}) => (event: any) => void;
+declare const handleFocus: (emit: any) => (e: any) => void;
+declare const handleBlur: ({ emit, api, props }: {
+    emit: any;
+    api: any;
+    props: any;
+}) => (e: any) => void;
+declare const handleInput: ({ api, state, vm }: {
+    api: any;
+    state: any;
+    vm: any;
+}) => (val: any, event: any) => void;
+declare const handleClear: (state: ICascaderState) => (_event: any) => void;
+declare const handleExpandChange: ({ constants, dispatch, emit, nextTick, state, updatePopper }: {
+    constants: any;
+    dispatch: any;
+    emit: any;
+    nextTick: any;
+    state: any;
+    updatePopper: any;
+}) => (value: any) => void;
+declare const focusFirstNode: ({ vm, state }: {
+    refs: ICascadeRenderlessParamUtils['refs'];
+    state: ICascaderState;
+}) => () => void;
+declare const computePresentText: ({ props, state }: {
+    props: ICascaderProps;
+    state: ICascaderState;
+}) => () => void;
+declare const computePresentTags: ({ api, props, state }: {
+    api: ICascaderApi;
+    props: ICascaderProps;
+    state: ICascaderState;
+}) => () => void;
+declare const calcCollapseTags: ({ state, vm, nextTick }: {
+    state: ICascaderState;
+    vm: ICascadeRenderlessParamUtils['vm'];
+    nextTick: ICascadeRenderlessParamUtils['nextTick'];
+}) => () => void;
+declare const watchInputHover: ({ vm }: {
+    vm: ICascadeRenderlessParamUtils['vm'];
+}) => (newVal: any) => void;
+declare const handleMouseenter: ({ vm, state }: {
+    vm: ICascadeRenderlessParamUtils['vm'];
+    state: ICascaderState;
+}) => ($event: any) => void;
+declare const handleMouseleave: ({ state }: {
+    state: ICascaderState;
+}) => () => boolean;
+declare const getSuggestions: ({ nextTick, props, state, updatePopper }: {
+    nextTick: ICascadeRenderlessParamUtils['nextTick'];
+    props: ICascaderProps;
+    state: ICascaderState;
+    updatePopper: any;
+}) => () => void;
+declare const handleSuggestionKeyDown: ({ api }: {
+    api: ICascaderApi;
+}) => (event: any) => void;
+declare const handleDelete: ({ api, state }: {
+    api: ICascaderApi;
+    state: ICascaderState;
+}) => () => void;
+declare const handleSuggestionClick: ({ api, state }: {
+    api: ICascaderApi;
+    state: ICascaderState;
+}) => (index: number) => void;
+declare const deleteTag: ({ emit, state, api }: {
+    emit: ICascadeRenderlessParamUtils['emit'];
+    state: ICascaderState;
+    api: any;
+}) => (index: any) => void;
+declare const updateStyle: ({ parent, vm, state, updatePopper, nextTick, props }: {
+    parent: any;
+    vm: any;
+    state: any;
+    updatePopper: any;
+    nextTick: any;
+    props: any;
+}) => () => void;
+declare const getCheckedNodes: (state: ICascaderState) => (leafOnly: boolean) => Node[];
+declare const setInputHeightToTag: ({ nextTick, parent, state }: {
+    nextTick: ICascadeRenderlessParamUtils['nextTick'];
+    parent: ICascadeRenderlessParamUtils['parent'];
+    state: ICascaderState;
+}) => () => void;
+declare const handleBeforeUpdate: ({ props, api, state }: {
+    props: ICascaderProps;
+    api: ICascaderApi;
+    state: ICascaderState;
+}) => () => void;
+declare const showPlaceholder: ({ props, state, t, constants }: {
+    props: ICascaderProps;
+    state: ICascaderState;
+    t: ICascadeRenderlessParamUtils['t'];
+    constants: ICascaderConstants;
+}) => () => string;
+
+interface ICascaderState {
+    showAutoWidth: boolean;
+    /** popper 元素是否显示。 它是通过v-show 绑定到页面上，造成隐藏时，popperJs并没有destory,有一定的性能影响 */
+    dropDownVisible: boolean;
+    checkedValue: ICascaderPanelNodePropValue;
+    inputHover: boolean;
+    inputValue: string | null;
+    presentText: string | null;
+    present: string | null;
+    presentTags: Partial<Node & {
+        key: string | number;
+        text: string;
+        closable: boolean;
+        hitState: boolean;
+    }>[];
+    checkedNodes: (Node & {
+        text?: string;
+    })[];
+    filtering: boolean;
+    suggestions: Node[];
+    inputInitialHeight: number;
+    pressDeleteCount: number;
+    realSize: 'medium' | 'small' | 'mini';
+    formDisabled: boolean;
+    displayOnly: boolean;
+    disabled: boolean;
+    tagSize: 'mini' | 'small';
+    isDisabled: boolean;
+    isDisplayOnly: boolean;
+    config: {
+        multiple?: boolean;
+        checkStrictly?: boolean;
+    };
+    multiple: boolean;
+    leafOnly: boolean;
+    readonly: boolean;
+    clearBtnVisible: boolean;
+    panel: Element & ICascaderPanelApi;
+    placeholder: boolean;
+    inputValues: boolean;
+    collapseTagsLength: number;
+    isHidden: boolean;
+    tooltipVisible: boolean;
+    tooltipContent: string;
+}
+type ICascaderProps = ExtractPropTypes<typeof cascaderProps>;
+interface ICascaderApi {
+    state: ICascaderState;
+    handleFocus: ReturnType<typeof handleFocus>;
+    handleClear: ReturnType<typeof handleClear>;
+    getCheckedNodes: ReturnType<typeof getCheckedNodes>;
+    deleteTag: ReturnType<typeof deleteTag>;
+    handleDropdownLeave: ReturnType<typeof handleDropdownLeave>;
+    focusFirstNode: ReturnType<typeof focusFirstNode>;
+    computClearVisible: ReturnType<typeof computClearVisible>;
+    showPlaceholder: ReturnType<typeof showPlaceholder>;
+    updateStyle: ReturnType<typeof updateStyle>;
+    getSuggestions: ReturnType<typeof getSuggestions>;
+    handleExpandChange: ReturnType<typeof handleExpandChange>;
+    getConfig: ReturnType<typeof getConfig>;
+    setInputHeightToTag: ReturnType<typeof setInputHeightToTag>;
+    handleSuggestionClick: ReturnType<typeof handleSuggestionClick>;
+    handleDelete: ReturnType<typeof handleDelete>;
+    computePresentText: ReturnType<typeof computePresentText>;
+    handleSuggestionKeyDown: ReturnType<typeof handleSuggestionKeyDown>;
+    handleInput: ReturnType<typeof handleInput>;
+    handleKeyDown: ReturnType<typeof handleKeyDown>;
+    watchValue: ReturnType<typeof watchValue>;
+    computePresentTags: ReturnType<typeof computePresentTags>;
+    computePresentContent: ReturnType<typeof computePresentContent>;
+    watchCheckedValue: ReturnType<typeof watchCheckedValue>;
+    toggleDropDownVisible: ReturnType<typeof toggleDropDownVisible>;
+    selfMounted: ReturnType<typeof selfMounted>;
+    handleBeforeUpdate: ReturnType<typeof handleBeforeUpdate>;
+    handleBlur: ReturnType<typeof handleBlur>;
+    calcCollapseTags: ReturnType<typeof calcCollapseTags>;
+    watchInputHover: ReturnType<typeof watchInputHover>;
+    handleMouseenter: ReturnType<typeof handleMouseenter>;
+    handleMouseleave: ReturnType<typeof handleMouseleave>;
+    filterHandler: Function;
+}
+type ICascaderConstants = ReturnType<typeof cascaderProps._constants.default>;
+type ICascadeRenderlessParamUtils = ISharedRenderlessParamUtils<ICascaderConstants>;
+
+export { ICascadeRenderlessParamUtils, ICascaderApi, ICascaderConstants, ICascaderProps, ICascaderState };

package/types/checkbox.type.d.ts

@@ -54,6 +54,10 @@ declare const checkboxProps: {
         default: boolean;
     };
     iconPosition: PropType<IconPosition>;
+    shape: {
+        type: StringConstructor;
+        default: string;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -121,6 +125,8 @@ interface ICheckboxState {
     model: ICheckboxModalValue | ICheckboxModalValue[];
     showText: boolean;
     isShowText: boolean;
+    tooltipVisible: boolean;
+    displayedValue: string;
 }
 type ICheckboxProps = ExtractPropTypes<typeof checkboxProps>;
 type ICheckboxConstants = typeof $constants;

package/types/collapse.type.d.ts

@@ -35,6 +35,23 @@ declare const collapseProps: {
     tiny_chart_theme: ObjectConstructor;
 };
 
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+
+declare const setActiveNames: ({ emit, props, state }: Pick<ICollapseRenderlessParams, 'emit' | 'props' | 'state'>) => (activeNames: string | string[]) => void;
+declare const handleItemClick: ({ api, props, state }: Pick<ICollapseRenderlessParams, 'api' | 'props' | 'state'>) => (item?: Object & {
+    name: string;
+}) => void;
+
 type ICollapseProps = ExtractPropTypes<typeof collapseProps>;
 type ICollapseConstants = typeof $constants;
 interface ICollapseState {
@@ -48,8 +65,8 @@ type ICollapseRenderlessParams = ISharedRenderlessFunctionParams<ICollapseConsta
 };
 interface ICollapseApi {
     state: ICollapseState;
-    setActiveNames: (activeName: string[] | string) => void;
-    handleItemClick: (item?: Object) => void;
+    setActiveNames: ReturnType<typeof setActiveNames>;
+    handleItemClick: ReturnType<typeof handleItemClick>;
 }
 type ICollapseRenderlessParamUtils = ISharedRenderlessParamUtils<ICollapseConstants>;
 

package/types/date-picker.type.d.ts

@@ -27,8 +27,41 @@ declare const $constants: {
     Day: string;
 };
 declare const datePickerProps: {
+    tabindex: {
+        type: StringConstructor;
+        default: string;
+    };
+    timeFormat: StringConstructor;
+    suffixIcon: ObjectConstructor;
+    label: StringConstructor;
+    shape: StringConstructor;
+    tip: StringConstructor;
+    changeOnConfirm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isutc8: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dbTimezone: NumberConstructor;
+    timezoneOffset: NumberConstructor;
+    iso8601: BooleanConstructor;
+    autoFormat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: StringConstructor;
+    blank: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     type: {
-        type: PropType<"date" | "dates" | "year" | "years" | "yearrange" | "month" | "week" | "daterange" | "datetimerange" | "monthrange" | "datetime">;
+        type: PropType<"date" | "dates" | "daterange" | "week" | "month" | "monthrange" | "year" | "years" | "yearrange" | "datetime" | "datetimerange">;
         default: string;
     };
     _constants: {
@@ -154,6 +187,10 @@ declare const datePickerProps: {
         default: boolean;
     };
     formatWeeks: FunctionConstructor;
+    changeCompat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];

package/types/dialog-box.type.d.ts

@@ -56,7 +56,7 @@ declare const dialogBoxProps: {
         default: () => boolean;
     };
     destroyOnClose: {
-        Boolean: BooleanConstructor;
+        type: BooleanConstructor;
         default: () => boolean;
     };
     dialogClass: {
@@ -67,6 +67,10 @@ declare const dialogBoxProps: {
         type: BooleanConstructor;
         default: () => boolean;
     };
+    dragOutsideWindow: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
     fullscreen: {
         type: BooleanConstructor;
         default: () => boolean;
@@ -141,14 +145,16 @@ declare const dialogBoxProps: {
  */
 
 declare const computedAnimationName: ({ constants, props }: Pick<IDialogBoxRenderlessParams, 'constants' | 'props'>) => () => string;
-declare const computedStyle: ({ props, state }: Pick<IDialogBoxRenderlessParams, 'props' | 'state'>) => () => IDialogBoxStyle;
+declare const computedStyle: ({ props, state, designConfig }: Pick<IDialogBoxRenderlessParams, 'props' | 'state' | 'designConfig'>) => () => IDialogBoxStyle;
 declare const computedBodyStyle: ({ props }: Pick<IDialogBoxRenderlessParams, 'props'>) => () => {
     maxHeight?: string | undefined;
 };
 declare const watchVisible: ({ api, constants, emit, nextTick, parent, props, vm, state }: Pick<IDialogBoxRenderlessParams, 'api' | 'constants' | 'emit' | 'nextTick' | 'parent' | 'props' | 'vm' | 'state'>) => (val: boolean) => void;
 declare const mounted: ({ api, parent, props }: Pick<IDialogBoxRenderlessParams, 'api' | 'parent' | 'props'>) => () => void;
 declare const unMounted: ({ api, parent, props }: Pick<IDialogBoxRenderlessParams, 'api' | 'parent' | 'props'>) => () => void;
-declare const handleWrapperClick: ({ api, props }: Pick<IDialogBoxRenderlessParams, 'api' | 'props'>) => () => void;
+declare const useMouseEventDown: ({ state }: Pick<IDialogBoxRenderlessParams, 'state'>) => (event: MouseEvent) => void;
+declare const useMouseEventUp: ({ state }: Pick<IDialogBoxRenderlessParams, 'state'>) => (event: MouseEvent) => void;
+declare const handleWrapperClick: ({ api, props, state }: Pick<IDialogBoxRenderlessParams, 'api' | 'props' | 'state'>) => () => void;
 declare const handleClose: ({ api, constants, emit, parent, props }: Pick<IDialogBoxRenderlessParams, 'api' | 'constants' | 'emit' | 'parent' | 'props'>) => (type?: string) => void;
 declare const hide: ({ api, emit, state, props }: Pick<IDialogBoxRenderlessParams, 'api' | 'emit' | 'state' | 'props'>) => (cancel?: boolean) => void;
 declare const handleConfirm: ({ api, emit }: Pick<IDialogBoxRenderlessParams, 'api' | 'emit'>) => () => void;
@@ -195,6 +201,8 @@ interface IDialogBoxState {
     animationName: string;
     opened?: boolean;
     rendered?: boolean;
+    mouseUpWrapperFlag: boolean;
+    mouseDownWrapperFlag: boolean;
 }
 interface IDialogBoxApi {
     state: IDialogBoxState;
@@ -205,6 +213,8 @@ interface IDialogBoxApi {
     handleConfirm: ReturnType<typeof handleConfirm>;
     updatePopper: ReturnType<typeof updatePopper>;
     handleWrapperClick: ReturnType<typeof handleWrapperClick>;
+    useMouseEventDown: ReturnType<typeof useMouseEventDown>;
+    useMouseEventUp: ReturnType<typeof useMouseEventUp>;
     hide: ReturnType<typeof hide>;
     handleClose: ReturnType<typeof handleClose>;
     watchVisible: ReturnType<typeof watchVisible>;

package/types/drawer.type.d.ts

@@ -1,2 +1,134 @@
+import { ComputedRef, ExtractPropTypes } from 'vue';
+import { ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const drawerProps: {
+    _constants: {
+        type: ObjectConstructor;
+        default: () => {
+            SCROLL_LOCK_CLASS(mode: string): string;
+            DEFAULT_WIDTH: string;
+        };
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    customClass: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: StringConstructor;
+    };
+    title: StringConstructor;
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFooter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dragable: BooleanConstructor;
+    lockScroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    flex: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    beforeClose: FunctionConstructor;
+    tipsProps: ObjectConstructor;
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+declare const close: ({ api }: {
+    api: any;
+}) => (force?: boolean) => void;
+declare const watchVisible: ({ state }: {
+    state: IDrawerState;
+}) => (bool: any) => void;
+declare const watchToggle: ({ emit }: {
+    emit: ISharedRenderlessParamUtils['emit'];
+}) => (bool: boolean) => void;
+declare const confirm: ({ api }: {
+    api: any;
+}) => () => void;
+declare const mousedown: ({ state, vm }: {
+    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
+    state: IDrawerState;
+}) => (event: any) => void;
+declare const mousemove: ({ state, props }: {
+    state: IDrawerState;
+    props: IDrawerProps;
+}) => EventListenerOrEventListenerObject;
+declare const mouseup: ({ state }: {
+    state: IDrawerState;
+}) => () => void;
+declare const addDragEvent: ({ api, vm }: {
+    api: IDrawerApi;
+    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
+}) => () => void;
+declare const removeDragEvent: ({ api, vm }: {
+    api: IDrawerApi;
+    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
+}) => () => void;
+declare const showScrollbar: (lockScrollClass: any) => () => void;
+declare const hideScrollbar: (lockScrollClass: any) => () => void;
+declare const watchVisibleNotImmediate: ({ api, props }: {
+    api: IDrawerApi;
+    props: IDrawerProps;
+}) => (visible: boolean) => void;
+
+interface IDrawerState {
+    toggle: boolean;
+    width: number;
+    dragEvent: {
+        x: number;
+        isDrag: boolean;
+        offsetWidth: number;
+    };
+    computedWidth: ComputedRef<string>;
+}
+type IDrawerProps = ExtractPropTypes<typeof drawerProps>;
+interface IDrawerApi {
+    state: IDrawerState;
+    confirm: ReturnType<typeof confirm>;
+    close: ReturnType<typeof close>;
+    mousemove: ReturnType<typeof mousemove>;
+    mouseup: ReturnType<typeof mouseup>;
+    mousedown: ReturnType<typeof mousedown>;
+    addDragEvent: ReturnType<typeof addDragEvent>;
+    removeDragEvent: ReturnType<typeof removeDragEvent>;
+    watchVisible: ReturnType<typeof watchVisible>;
+    watchToggle: ReturnType<typeof watchToggle>;
+    showScrollbar: ReturnType<typeof showScrollbar>;
+    hideScrollbar: ReturnType<typeof hideScrollbar>;
+    watchVisibleNotImmediate: ReturnType<typeof watchVisibleNotImmediate>;
+}
+type IDrawerCT = ReturnType<typeof drawerProps._constants.default>;
+
+export { IDrawerApi, IDrawerCT, IDrawerProps, IDrawerState };

package/types/{dropdown-item.type-8ea6c633.d.ts → dropdown-item.type-8475a549.d.ts}

@@ -35,10 +35,7 @@ declare const dropdownItemProps: {
         default: string;
     };
     title: StringConstructor;
-    label: {
-        type: StringConstructor;
-        default: string;
-    };
+    label: StringConstructor;
     level: StringConstructor;
     titleClass: StringConstructor;
     options: {
@@ -109,18 +106,12 @@ declare const dropdownMenuProps: {
         type: BooleanConstructor;
         default: boolean;
     };
-    visibleArrow: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
+    visibleArrow: BooleanConstructor;
     arrowOffset: {
         type: NumberConstructor;
         default: number;
     };
-    placement: {
-        type: StringConstructor;
-        default: string;
-    };
+    placement: StringConstructor;
     popperClass: StringConstructor;
     popperAppendToBody: {
         type: BooleanConstructor;
@@ -249,7 +240,7 @@ declare const tagClick: ({ emit, props }: Pick<IDropdownItemRenderlessParams, 'e
 declare const confirm: ({ emit, props, state }: Pick<IDropdownItemRenderlessParams, 'emit' | 'props' | 'state'>) => () => void;
 declare const reset: ({ emit, props }: Pick<IDropdownItemRenderlessParams, 'emit' | 'props'>) => () => void;
 declare const clickOutside: (parent: IDropdownItemRenderlessParams['parent']) => () => void;
-declare const handleClick: ({ props, dispatch, vm, emit }: Pick<IDropdownItemRenderlessParams, 'props' | 'dispatch' | 'vm' | 'emit'>) => (event: MouseEvent) => void;
+declare const handleClick: ({ state, props, dispatch, vm, emit }: Pick<IDropdownItemRenderlessParams, 'state' | 'props' | 'dispatch' | 'vm' | 'emit'>) => (event: MouseEvent) => void;
 declare const computedGetIcon: ({ constants, designConfig }: Pick<IDropdownItemRenderlessParams, 'constants' | 'designConfig'>) => (name?: string) => object | string;
 declare const getTip: ({ props, vm }: Pick<IDropdownItemRenderlessParams, 'props' | 'vm'>) => string;
 
@@ -261,6 +252,7 @@ type IDropdownItemVm = ComponentPublicInstance & {
 type IDropdownItemProps = ExtractPropTypes<typeof dropdownItemProps>;
 type IDropdownItemConstants = typeof $constants;
 interface IDropdownItemState {
+    checkedStatus: boolean;
     sort: 'asc' | 'desc';
     transition: boolean;
     getTitle: boolean;
@@ -274,6 +266,8 @@ interface IDropdownItemState {
     itemStyle: ComputedRef<string>;
     activeColor: ComputedRef<string>;
     closeOnClickOverlay: ComputedRef<boolean>;
+    dropdownMenuVm: IDropdownMenuVm;
+    currentIndex: number;
     textField: string;
     popperClass: string;
     getIcon: ComputedRef<object>;