vant 4.0.0-rc.2 → 4.0.0-rc.4

package/es/tabbar-item/types.d.ts

@@ -0,0 +1,9 @@
+export declare type TabbarItemThemeVars = {
+    tabbarItemFontSize?: string;
+    tabbarItemTextColor?: string;
+    tabbarItemActiveColor?: string;
+    tabbarItemActiveBackground?: string;
+    tabbarItemLineHeight?: number | string;
+    tabbarItemIconSize?: string;
+    tabbarItemIconMarginBottom?: string;
+};

package/es/tabs/Tabs.mjs

@@ -133,7 +133,7 @@ var stdin_default = defineComponent({
         index += diff;
       }
     };
-    const setCurrentIndex = (currentIndex) => {
+    const setCurrentIndex = (currentIndex, skipScrollIntoView) => {
       const newIndex = findAvailableTab(currentIndex);
       if (!isDef(newIndex)) {
         return;
@@ -148,11 +148,18 @@ var stdin_default = defineComponent({
           emit("change", newName, newTab.title);
         }
       }
+      if (!skipScrollIntoView) {
+        scrollIntoView();
+      }
+      setLine();
+      if (stickyFixed && !props.scrollspy) {
+        setRootScrollTop(Math.ceil(getElementTop(root.value) - offsetTopPx.value));
+      }
     };
-    const setCurrentIndexByName = (name2) => {
+    const setCurrentIndexByName = (name2, skipScrollIntoView) => {
       const matched = children.find((tab, index2) => getTabName(tab, index2) === name2);
       const index = matched ? children.indexOf(matched) : 0;
-      setCurrentIndex(index);
+      setCurrentIndex(index, skipScrollIntoView);
     };
     const scrollToCurrentContent = (immediate = false) => {
       if (props.scrollspy) {
@@ -279,15 +286,8 @@ var stdin_default = defineComponent({
         });
       }
     });
-    watch(() => state.currentIndex, () => {
-      scrollIntoView();
-      setLine();
-      if (stickyFixed && !props.scrollspy) {
-        setRootScrollTop(Math.ceil(getElementTop(root.value) - offsetTopPx.value));
-      }
-    });
     const init = () => {
-      setCurrentIndexByName(props.active);
+      setCurrentIndexByName(props.active, true);
       nextTick(() => {
         state.inited = true;
         if (wrapRef.value) {

package/es/tabs/index.d.ts

@@ -107,7 +107,7 @@ export declare const Tabs: import("../utils").WithInstall<import("vue").DefineCo
 export default Tabs;
 export { tabsProps } from './Tabs';
 export type { TabsProps };
-export type { TabsType, TabsInstance } from './types';
+export type { TabsType, TabsInstance, TabsThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanTabs: typeof Tabs;

package/es/tabs/types.d.ts

@@ -21,3 +21,17 @@ export declare type TabsExpose = {
     scrollTo: (name: Numeric) => void;
 };
 export declare type TabsInstance = ComponentPublicInstance<TabsProps, TabsExpose>;
+export declare type TabsThemeVars = {
+    tabTextColor?: string;
+    tabActiveTextColor?: string;
+    tabDisabledTextColor?: string;
+    tabFontSize?: string;
+    tabLineHeight?: number | string;
+    tabsDefaultColor?: string;
+    tabsLineHeight?: number | string;
+    tabsCardHeight?: string;
+    tabsNavBackground?: string;
+    tabsBottomBarWidth?: string;
+    tabsBottomBarHeight?: string;
+    tabsBottomBarColor?: string;
+};

package/es/tag/Tag.d.ts

@@ -1,6 +1,5 @@
 import { type PropType, type ExtractPropTypes } from 'vue';
-export declare type TagSize = 'large' | 'medium';
-export declare type TagType = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+import type { TagType, TagSize } from './types';
 export declare const tagProps: {
     size: PropType<TagSize>;
     mark: BooleanConstructor;

package/es/tag/index.d.ts

@@ -1,13 +1,13 @@
 export declare const Tag: import("../utils").WithInstall<import("vue").DefineComponent<{
-    size: import("vue").PropType<import("./Tag").TagSize>;
+    size: import("vue").PropType<import("./types").TagSize>;
     mark: BooleanConstructor;
     show: {
         type: BooleanConstructor;
         default: true;
     };
     type: {
-        type: import("vue").PropType<import("./Tag").TagType>;
-        default: import("./Tag").TagType;
+        type: import("vue").PropType<import("./types").TagType>;
+        default: import("./types").TagType;
     };
     color: StringConstructor;
     plain: BooleanConstructor;
@@ -15,15 +15,15 @@ export declare const Tag: import("../utils").WithInstall<import("vue").DefineCom
     textColor: StringConstructor;
     closeable: BooleanConstructor;
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    size: import("vue").PropType<import("./Tag").TagSize>;
+    size: import("vue").PropType<import("./types").TagSize>;
     mark: BooleanConstructor;
     show: {
         type: BooleanConstructor;
         default: true;
     };
     type: {
-        type: import("vue").PropType<import("./Tag").TagType>;
-        default: import("./Tag").TagType;
+        type: import("vue").PropType<import("./types").TagType>;
+        default: import("./types").TagType;
     };
     color: StringConstructor;
     plain: BooleanConstructor;
@@ -33,7 +33,7 @@ export declare const Tag: import("../utils").WithInstall<import("vue").DefineCom
 }>> & {
     onClose?: ((...args: any[]) => any) | undefined;
 }, {
-    type: import("./Tag").TagType;
+    type: import("./types").TagType;
     mark: boolean;
     round: boolean;
     show: boolean;
@@ -42,7 +42,8 @@ export declare const Tag: import("../utils").WithInstall<import("vue").DefineCom
 }>>;
 export default Tag;
 export { tagProps } from './Tag';
-export type { TagSize, TagType, TagProps } from './Tag';
+export type { TagProps } from './Tag';
+export type { TagSize, TagType, TagThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanTag: typeof Tag;

package/es/tag/types.d.ts

@@ -0,0 +1,20 @@
+export declare type TagSize = 'large' | 'medium';
+export declare type TagType = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+export declare type TagThemeVars = {
+    tagPadding?: string;
+    tagTextColor?: string;
+    tagFontSize?: string;
+    tagRadius?: string;
+    tagLineHeight?: number | string;
+    tagMediumPadding?: string;
+    tagLargePadding?: string;
+    tagLargeRadius?: string;
+    tagLargeFontSize?: string;
+    tagRoundRadius?: string;
+    tagDangerColor?: string;
+    tagPrimaryColor?: string;
+    tagSuccessColor?: string;
+    tagWarningColor?: string;
+    tagDefaultColor?: string;
+    tagPlainBackground?: string;
+};

package/es/toast/index.d.ts

@@ -77,4 +77,9 @@ export default Toast;
 export { toastProps } from './Toast';
 export { showToast, closeToast, showFailToast, showLoadingToast, showSuccessToast, allowMultipleToast, setToastDefaultOptions, resetToastDefaultOptions, } from './function-call';
 export type { ToastProps } from './Toast';
-export type { ToastType, ToastOptions, ToastPosition } from './types';
+export type { ToastType, ToastOptions, ToastPosition, ToastThemeVars, } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanToast: typeof Toast;
+    }
+}

package/es/toast/types.d.ts

@@ -34,3 +34,20 @@ export declare type ToastWrapperInstance = ComponentPublicInstance<{
      */
     open: (props: Record<string, any>) => void;
 }>;
+export declare type ToastThemeVars = {
+    toastMaxWidth?: string;
+    toastFontSize?: string;
+    toastTextColor?: string;
+    toastLoadingIconColor?: string;
+    toastLineHeight?: number | string;
+    toastRadius?: string;
+    toastBackground?: string;
+    toastIconSize?: string;
+    toastTextMinWidth?: string;
+    toastTextPadding?: string;
+    toastDefaultPadding?: string;
+    toastDefaultWidth?: string;
+    toastDefaultMinHeight?: string;
+    toastPositionTopDistance?: string;
+    toastPositionBottomDistance?: string;
+};

package/es/tree-select/index.d.ts

@@ -64,6 +64,7 @@ export declare const TreeSelect: import("../utils").WithInstall<import("vue").De
 export default TreeSelect;
 export { treeSelectProps } from './TreeSelect';
 export type { TreeSelectItem, TreeSelectChild, TreeSelectProps, } from './TreeSelect';
+export type { TreeSelectThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanTreeSelect: typeof TreeSelect;

package/es/tree-select/types.d.ts

@@ -0,0 +1,10 @@
+export declare type TreeSelectThemeVars = {
+    treeSelectFontSize?: string;
+    treeSelectNavBackground?: string;
+    treeSelectContentBackground?: string;
+    treeSelectNavItemPadding?: string;
+    treeSelectItemHeight?: string;
+    treeSelectItemActiveColor?: string;
+    treeSelectItemDisabledColor?: string;
+    treeSelectItemSelectedSize?: string;
+};

package/es/uploader/index.d.ts

@@ -147,7 +147,7 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
 export default Uploader;
 export { uploaderProps } from './Uploader';
 export type { UploaderProps };
-export type { UploaderInstance, UploaderResultType, UploaderFileListItem, } from './types';
+export type { UploaderInstance, UploaderThemeVars, UploaderResultType, UploaderFileListItem, } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanUploader: typeof Uploader;

package/es/uploader/types.d.ts

@@ -29,3 +29,30 @@ export declare type UploaderExpose = {
     closeImagePreview: () => void;
 };
 export declare type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;
+export declare type UploaderThemeVars = {
+    uploaderSize?: string;
+    uploaderIconSize?: string;
+    uploaderIconColor?: string;
+    uploaderTextColor?: string;
+    uploaderTextFontSize?: string;
+    uploaderUploadBackground?: string;
+    uploaderUploadActiveColor?: string;
+    uploaderDeleteColor?: string;
+    uploaderDeleteIconSize?: string;
+    uploaderDeleteBackground?: string;
+    uploaderFileBackground?: string;
+    uploaderFileIconSize?: string;
+    uploaderFileIconColor?: string;
+    uploaderFileNamePadding?: string;
+    uploaderFileNameMarginTop?: string;
+    uploaderFileNameFontSize?: string;
+    uploaderFileNameTextColor?: string;
+    uploaderMaskTextColor?: string;
+    uploaderMaskBackground?: string;
+    uploaderMaskIconSize?: string;
+    uploaderMaskMessageFontSize?: string;
+    uploaderMaskMessageLineHeight?: number | string;
+    uploaderLoadingIconSize?: string;
+    uploaderLoadingIconColor?: string;
+    uploaderDisabledOpacity?: number | string;
+};

package/lib/action-bar/index.d.ts

@@ -17,6 +17,7 @@ export declare const ActionBar: import("../utils").WithInstall<import("vue").Def
 export default ActionBar;
 export { actionBarProps } from './ActionBar';
 export type { ActionBarProps } from './ActionBar';
+export type { ActionBarThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanActionBar: typeof ActionBar;

package/lib/action-bar/types.d.ts

@@ -0,0 +1,4 @@
+export declare type ActionBarThemeVars = {
+    actionBarBackground?: string;
+    actionBarHeight?: string;
+};

package/lib/action-bar/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/action-bar-button/index.d.ts

@@ -28,6 +28,7 @@ export declare const ActionBarButton: import("../utils").WithInstall<import("vue
 export default ActionBarButton;
 export { actionBarButtonProps } from './ActionBarButton';
 export type { ActionBarButtonProps } from './ActionBarButton';
+export type { ActionBarButtonThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanActionBarButton: typeof ActionBarButton;

package/lib/action-bar-button/types.d.ts

@@ -0,0 +1,5 @@
+export declare type ActionBarButtonThemeVars = {
+    actionBarButtonHeight?: string;
+    actionBarButtonWarningColor?: string;
+    actionBarButtonDangerColor?: string;
+};

package/lib/action-bar-button/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/action-bar-icon/index.d.ts

@@ -31,6 +31,7 @@ export declare const ActionBarIcon: import("../utils").WithInstall<import("vue")
 export default ActionBarIcon;
 export { actionBarIconProps } from './ActionBarIcon';
 export type { ActionBarIconProps } from './ActionBarIcon';
+export type { ActionBarIconThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanActionBarIcon: typeof ActionBarIcon;

package/lib/action-bar-icon/types.d.ts

@@ -0,0 +1,10 @@
+export declare type ActionBarIconThemeVars = {
+    actionBarIconWidth?: string;
+    actionBarIconHeight?: string;
+    actionBarIconColor?: string;
+    actionBarIconSize?: string;
+    actionBarIconFontSize?: string;
+    actionBarIconActiveColor?: string;
+    actionBarIconTextColor?: string;
+    actionBarIconBackground?: string;
+};

package/lib/action-bar-icon/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/action-sheet/index.d.ts

@@ -128,6 +128,7 @@ export declare const ActionSheet: import("../utils").WithInstall<import("vue").D
 export default ActionSheet;
 export { actionSheetProps } from './ActionSheet';
 export type { ActionSheetProps, ActionSheetAction } from './ActionSheet';
+export type { ActionSheetThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanActionSheet: typeof ActionSheet;

package/lib/action-sheet/types.d.ts

@@ -0,0 +1,23 @@
+export declare type ActionSheetThemeVars = {
+    actionSheetMaxHeight?: string;
+    actionSheetHeaderHeight?: string;
+    actionSheetHeaderFontSize?: string;
+    actionSheetDescriptionColor?: string;
+    actionSheetDescriptionFontSize?: string;
+    actionSheetDescriptionLineHeight?: number | string;
+    actionSheetItemBackground?: string;
+    actionSheetItemFontSize?: string;
+    actionSheetItemLineHeight?: number | string;
+    actionSheetItemTextColor?: string;
+    actionSheetItemDisabledTextColor?: string;
+    actionSheetSubnameColor?: string;
+    actionSheetSubnameFontSize?: string;
+    actionSheetSubnameLineHeight?: number | string;
+    actionSheetCloseIconSize?: string;
+    actionSheetCloseIconColor?: string;
+    actionSheetCloseIconPadding?: string;
+    actionSheetCancelTextColor?: string;
+    actionSheetCancelPaddingTop?: string;
+    actionSheetCancelPaddingColor?: string;
+    actionSheetLoadingIconSize?: string;
+};

package/lib/action-sheet/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/address-edit/index.d.ts

@@ -110,7 +110,7 @@ export declare const AddressEdit: import("../utils").WithInstall<import("vue").D
 export default AddressEdit;
 export { addressEditProps } from './AddressEdit';
 export type { AddressEditProps };
-export type { AddressEditInfo, AddressEditInstance, AddressEditSearchItem, } from './types';
+export type { AddressEditInfo, AddressEditInstance, AddressEditThemeVars, AddressEditSearchItem, } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanAddressEdit: typeof AddressEdit;

package/lib/address-edit/types.d.ts

@@ -20,3 +20,9 @@ export declare type AddressEditExpose = {
     setAddressDetail: (value: string) => void;
 };
 export declare type AddressEditInstance = ComponentPublicInstance<AddressEditProps, AddressEditExpose>;
+export declare type AddressEditThemeVars = {
+    addressEditPadding?: string;
+    addressEditButtonsPadding?: string;
+    addressEditButtonMarginBottom?: string;
+    addressEditButtonFontSize?: string;
+};

package/lib/address-list/index.d.ts

@@ -49,6 +49,7 @@ export default AddressList;
 export { addressListProps } from './AddressList';
 export type { AddressListProps } from './AddressList';
 export type { AddressListAddress } from './AddressListItem';
+export type { AddressListThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanAddressList: typeof AddressList;

package/lib/address-list/types.d.ts

@@ -0,0 +1,15 @@
+export declare type AddressListThemeVars = {
+    addressListPadding?: string;
+    addressListDisabledTextColor?: string;
+    addressListDisabledTextPadding?: string;
+    addressListDisabledTextFontSize?: string;
+    addressListDisabledTextLineHeight?: number | string;
+    addressListAddButtonZIndex?: number | string;
+    addressListItemPadding?: string;
+    addressListItemTextColor?: string;
+    addressListItemDisabledTextColor?: string;
+    addressListItemFontSize?: string;
+    addressListItemLineHeight?: number | string;
+    addressListRadioColor?: string;
+    addressListEditIconSize?: string;
+};

package/lib/address-list/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/badge/index.d.ts

@@ -43,6 +43,7 @@ export declare const Badge: import("../utils").WithInstall<import("vue").DefineC
 export default Badge;
 export { badgeProps } from './Badge';
 export type { BadgeProps, BadgePosition } from './Badge';
+export type { BadgeThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanBadge: typeof Badge;

package/lib/badge/types.d.ts

@@ -0,0 +1,12 @@
+export declare type BadgeThemeVars = {
+    badgeSize?: string;
+    badgeColor?: string;
+    badgePadding?: string;
+    badgeFontSize?: string;
+    badgeFontWeight?: string;
+    badgeBorderWidth?: string;
+    badgeBackground?: string;
+    badgeDotColor?: string;
+    badgeDotSize?: string;
+    badgeFont?: string;
+};

package/lib/badge/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/button/index.d.ts

@@ -96,7 +96,7 @@ export declare const Button: import("../utils").WithInstall<import("vue").Define
 export default Button;
 export { buttonProps } from './Button';
 export type { ButtonProps } from './Button';
-export type { ButtonType, ButtonSize, ButtonNativeType, ButtonIconPosition, } from './types';
+export type { ButtonType, ButtonSize, ButtonThemeVars, ButtonNativeType, ButtonIconPosition, } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanButton: typeof Button;

package/lib/button/types.d.ts

@@ -3,3 +3,39 @@ export declare type ButtonType = 'default' | 'primary' | 'success' | 'warning' |
 export declare type ButtonSize = 'large' | 'normal' | 'small' | 'mini';
 export declare type ButtonNativeType = NonNullable<ButtonHTMLAttributes['type']>;
 export declare type ButtonIconPosition = 'left' | 'right';
+export declare type ButtonThemeVars = {
+    buttonMiniHeight?: string;
+    buttonMiniPadding?: string;
+    buttonMiniFontSize?: string;
+    buttonSmallHeight?: string;
+    buttonSmallPadding?: string;
+    buttonSmallFontSize?: string;
+    buttonNormalPadding?: string;
+    buttonNormalFontSize?: string;
+    buttonLargeHeight?: string;
+    buttonDefaultHeight?: string;
+    buttonDefaultLineHeight?: number | string;
+    buttonDefaultFontSize?: string;
+    buttonDefaultColor?: string;
+    buttonDefaultBackground?: string;
+    buttonDefaultBorderColor?: string;
+    buttonPrimaryColor?: string;
+    buttonPrimaryBackground?: string;
+    buttonPrimaryBorderColor?: string;
+    buttonSuccessColor?: string;
+    buttonSuccessBackground?: string;
+    buttonSuccessBorderColor?: string;
+    buttonDangerColor?: string;
+    buttonDangerBackground?: string;
+    buttonDangerBorderColor?: string;
+    buttonWarningColor?: string;
+    buttonWarningBackground?: string;
+    buttonWarningBorderColor?: string;
+    buttonBorderWidth?: string;
+    buttonRadius?: string;
+    buttonRoundRadius?: string;
+    buttonPlainBackground?: string;
+    buttonDisabledOpacity?: number | string;
+    buttonIconSize?: string;
+    buttonLoadingIconSize?: string;
+};

package/lib/calendar/index.d.ts

@@ -202,7 +202,7 @@ export declare const Calendar: import("../utils").WithInstall<import("vue").Defi
 export default Calendar;
 export { calendarProps } from './Calendar';
 export type { CalendarProps } from './Calendar';
-export type { CalendarType, CalendarDayItem, CalendarDayType, CalendarInstance, } from './types';
+export type { CalendarType, CalendarDayItem, CalendarDayType, CalendarInstance, CalendarThemeVars, } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanCalendar: typeof Calendar;

package/lib/calendar/types.d.ts

@@ -26,3 +26,31 @@ export declare type CalendarMonthInstance = ComponentPublicInstance<CalendarMont
     scrollToDate: (body: Element, targetDate: Date) => void;
     disabledDays: Ref<ComputedRef<CalendarDayItem[]>>;
 }>;
+export declare type CalendarThemeVars = {
+    calendarBackground?: string;
+    calendarPopupHeight?: string;
+    calendarHeaderShadow?: string;
+    calendarHeaderTitleHeight?: string;
+    calendarHeaderTitleFontSize?: string;
+    calendarHeaderSubtitleFontSize?: string;
+    calendarWeekdaysHeight?: string;
+    calendarWeekdaysFontSize?: string;
+    calendarMonthTitleFontSize?: string;
+    calendarMonthMarkColor?: string;
+    calendarMonthMarkFontSize?: string;
+    calendarDayHeight?: string;
+    calendarDayFontSize?: string;
+    calendarDayMarginBottom?: string;
+    calendarRangeEdgeColor?: string;
+    calendarRangeEdgeBackground?: string;
+    calendarRangeMiddleColor?: string;
+    calendarRangeMiddleBackgroundOpacity?: number | string;
+    calendarSelectedDaySize?: string;
+    calendarSelectedDayColor?: string;
+    calendarInfoFontSize?: string;
+    calendarInfoLineHeight?: number | string;
+    calendarSelectedDayBackground?: string;
+    calendarDayDisabledColor?: string;
+    calendarConfirmButtonHeight?: string;
+    calendarConfirmButtonMargin?: string;
+};

package/lib/card/index.d.ts

@@ -38,6 +38,7 @@ export declare const Card: import("../utils").WithInstall<import("vue").DefineCo
 export default Card;
 export { cardProps } from './Card';
 export type { CardProps } from './Card';
+export type { CardThemeVars } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanCard: typeof Card;