@uzum-tech/ui 1.9.1 → 1.10.1

package/lib/modal-fullscreen/src/ModalFull.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modalFullscreenProps = void 0;
+const vdirs_1 = require("vdirs");
+const vue_1 = require("vue");
+const vueuc_1 = require("vueuc");
+const vooks_1 = require("vooks");
+const _utils_1 = require("../../_utils");
+const _mixins_1 = require("../../_mixins");
+const styles_1 = require("../styles");
+const index_cssr_1 = __importDefault(require("./styles/index.cssr"));
+const _internal_1 = require("../../_internal");
+const flex_1 = require("../../flex");
+const typography_1 = require("../../typography");
+exports.modalFullscreenProps = Object.assign(Object.assign({}, _mixins_1.useTheme.props), { to: [String, Object], show: Boolean, zIndex: Number, title: String, subtitle: String, backgroundImage: String, fixed: {
+        type: Boolean,
+        default: false
+    }, displayDirective: {
+        type: String,
+        default: 'if'
+    }, transformOrigin: {
+        type: String,
+        default: 'mouse'
+    }, autoFocus: {
+        type: Boolean,
+        default: true
+    }, trapFocus: {
+        type: Boolean,
+        default: true
+    }, closeOnEsc: {
+        type: Boolean,
+        default: true
+    }, blockScroll: {
+        type: Boolean,
+        default: true
+    }, 
+    // events
+    onEsc: Function, onClose: Function, onAfterEnter: Function, onBeforeLeave: Function, onAfterLeave: Function, onUpdateShow: [Function, Array], 'onUpdate:show': [Function, Array] });
+exports.default = (0, vue_1.defineComponent)({
+    name: 'ModalFullscreen',
+    inheritAttrs: false,
+    props: exports.modalFullscreenProps,
+    setup(props) {
+        const isDisplayed = (0, vue_1.ref)(props.show);
+        const containerRef = (0, vue_1.ref)(null);
+        const scrollbarRef = (0, vue_1.ref)(null);
+        const isClicked = (0, vooks_1.useClicked)(64);
+        const clickPosition = (0, vooks_1.useClickPosition)();
+        const isComposing = (0, _utils_1.useIsComposing)();
+        const isMounted = (0, vooks_1.useIsMounted)();
+        const transformOriginXRef = (0, vue_1.ref)(null);
+        const transformOriginYRef = (0, vue_1.ref)(null);
+        const { mergedClsPrefixRef, namespaceRef, inlineThemeDisabled } = (0, _mixins_1.useConfig)(props);
+        const themeRef = (0, _mixins_1.useTheme)('ModalFullscreen', '-modal-fullscreen', index_cssr_1.default, styles_1.modalFullscreenLight, props, mergedClsPrefixRef);
+        const updateShow = (show) => {
+            const { onUpdateShow, 'onUpdate:show': _onUpdateShow } = props;
+            if (onUpdateShow)
+                (0, _utils_1.call)(onUpdateShow, show);
+            if (_onUpdateShow)
+                (0, _utils_1.call)(_onUpdateShow, show);
+        };
+        const handleCloseClick = () => {
+            const { onClose } = props;
+            if (onClose) {
+                void Promise.resolve(onClose()).then((value) => {
+                    if (value === false)
+                        return;
+                    updateShow(false);
+                });
+            }
+            else {
+                updateShow(false);
+            }
+        };
+        const handleBeforeLeave = (element) => {
+            element.style.transformOrigin = styleTransformOrigin();
+            const { onBeforeLeave } = props;
+            if (onBeforeLeave)
+                (0, _utils_1.call)(onBeforeLeave);
+        };
+        const handleAfterLeave = () => {
+            isDisplayed.value = false;
+            transformOriginXRef.value = null;
+            transformOriginYRef.value = null;
+            const { onAfterLeave } = props;
+            if (onAfterLeave)
+                (0, _utils_1.call)(onAfterLeave);
+        };
+        const handleEsc = (event) => {
+            var _a;
+            (_a = props.onEsc) === null || _a === void 0 ? void 0 : _a.call(props);
+            if (props.show && props.closeOnEsc && (0, _utils_1.eventEffectNotPerformed)(event)) {
+                !isComposing.value && updateShow(false);
+            }
+        };
+        const getMousePosition = () => {
+            if (isClicked.value) {
+                return clickPosition.value;
+            }
+            return null;
+        };
+        const styleTransformOrigin = () => {
+            if (props.transformOrigin === 'center') {
+                return '';
+            }
+            const { value: transformOriginX } = transformOriginXRef;
+            const { value: transformOriginY } = transformOriginYRef;
+            if (transformOriginX === null || transformOriginY === null) {
+                return '';
+            }
+            else if (scrollbarRef.value) {
+                const scrollTop = scrollbarRef.value.containerScrollTop;
+                return `${transformOriginX}px ${transformOriginY + scrollTop}px`;
+            }
+            return '';
+        };
+        const syncTransformOrigin = (element) => {
+            if (props.transformOrigin === 'center') {
+                return;
+            }
+            const mousePosition = getMousePosition();
+            if (!mousePosition) {
+                return;
+            }
+            if (!scrollbarRef.value)
+                return;
+            const scrollTop = scrollbarRef.value.containerScrollTop;
+            const { offsetLeft, offsetTop } = element;
+            if (mousePosition) {
+                const top = mousePosition.y;
+                const left = mousePosition.x;
+                transformOriginXRef.value = -(offsetLeft - left);
+                transformOriginYRef.value = -(offsetTop - top - scrollTop);
+            }
+            element.style.transformOrigin = styleTransformOrigin();
+        };
+        const handleEnter = (element) => {
+            void (0, vue_1.nextTick)(() => {
+                syncTransformOrigin(element);
+            });
+        };
+        const cssVarsRef = (0, vue_1.computed)(() => {
+            const { common: { cubicBezierEaseOut }, self: { modalBg, headerBg, bodyBg, footerBg, textColor, closeMargin, closeSize, closeIconSize, closeBorderRadius, closeColorHover, closeColorPressed, closeIconColor, closeIconColorHover, closeIconColorPressed, subtitleColor, headerPadding, bodyPadding, footerPadding } } = themeRef.value;
+            return {
+                '--u-bezier-ease-out': cubicBezierEaseOut,
+                '--u-text-color': textColor,
+                '--u-close-margin': closeMargin,
+                '--u-close-size': closeSize,
+                '--u-close-icon-size': closeIconSize,
+                '--u-close-border-radius': closeBorderRadius,
+                '--u-close-color-hover': closeColorHover,
+                '--u-close-color-pressed': closeColorPressed,
+                '--u-close-icon-color': closeIconColor,
+                '--u-close-icon-color-hover': closeIconColorHover,
+                '--u-close-icon-color-pressed': closeIconColorPressed,
+                '--u-header-padding': headerPadding,
+                '--u-subtitle-color': subtitleColor,
+                '--u-body-padding': bodyPadding,
+                '--u-footer-padding': footerPadding,
+                '--u-modal-bg': props.backgroundImage
+                    ? `url(${props.backgroundImage})`
+                    : modalBg,
+                '--u-header-bg': headerBg,
+                '--u-body-bg': bodyBg,
+                '--u-footer-bg': footerBg
+            };
+        });
+        const themeClassHandle = inlineThemeDisabled
+            ? (0, _mixins_1.useThemeClass)('theme-class', undefined, cssVarsRef, props)
+            : undefined;
+        (0, vue_1.watch)((0, vue_1.toRef)(props, 'show'), (value) => {
+            if (value)
+                isDisplayed.value = true;
+        });
+        return {
+            containerRef,
+            scrollbarRef,
+            mergedClsPrefix: mergedClsPrefixRef,
+            namespace: namespaceRef,
+            cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
+            themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
+            themeRef,
+            isMounted,
+            isDisplayed,
+            handleEnter,
+            handleBeforeLeave,
+            handleAfterLeave,
+            handleEsc,
+            handleCloseClick,
+            onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
+        };
+    },
+    render() {
+        const { mergedClsPrefix, isDisplayed, handleEnter, handleBeforeLeave, handleAfterLeave, handleEsc, handleCloseClick } = this;
+        const headerLeftSlot = (0, _utils_1.resolveWrappedSlot)(this.$slots.headerLeft, (children) => children);
+        const bodySlot = (0, _utils_1.resolveWrappedSlot)(this.$slots.body || this.$slots.default, (children) => children);
+        const footerSlot = (0, _utils_1.resolveWrappedSlot)(this.$slots.footer, (children) => children);
+        return ((0, vue_1.h)(vueuc_1.VLazyTeleport, { to: this.to, show: this.show }, {
+            default: () => {
+                var _a;
+                (_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
+                return (0, vue_1.withDirectives)((0, vue_1.h)("div", { role: "none", ref: "containerRef", class: [
+                        `${mergedClsPrefix}-modal-container`,
+                        this.themeClass,
+                        this.namespace
+                    ], style: this.cssVars }, this.displayDirective === 'show' || isDisplayed || this.show
+                    ? (0, vue_1.withDirectives)((0, vue_1.h)("div", { role: "none", class: `${mergedClsPrefix}-modal-body-wrapper` },
+                        (0, vue_1.h)(_internal_1.UScrollbar, { ref: "scrollbarRef", theme: this.themeRef.peers.Scrollbar, themeOverrides: this.themeRef.peerOverrides.Scrollbar, contentClass: `${mergedClsPrefix}-modal-scroll-content` }, {
+                            default: () => ((0, vue_1.h)(vueuc_1.VFocusTrap, { disabled: !this.trapFocus, active: this.show, onEsc: handleEsc, autoFocus: this.autoFocus }, {
+                                default: () => ((0, vue_1.h)(vue_1.Transition, { name: "fade-in-scale-up-transition", appear: this.isMounted, onEnter: handleEnter, onAfterEnter: this.onAfterEnter, onAfterLeave: handleAfterLeave, onBeforeLeave: handleBeforeLeave }, {
+                                    default: () => {
+                                        const dirs = [
+                                            [vue_1.vShow, this.show]
+                                        ];
+                                        return (0, vue_1.withDirectives)((0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal` },
+                                            (0, vue_1.h)(flex_1.UFlex, { vertical: true, size: [0, 0], class: [
+                                                    `${mergedClsPrefix}-modal-content`,
+                                                    this.fixed &&
+                                                        `${mergedClsPrefix}-modal-content--fixed`
+                                                ] },
+                                                (0, vue_1.h)(flex_1.UFlex, { align: "center", size: [0, 0], wrap: false, class: `${mergedClsPrefix}-modal-header` },
+                                                    (0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal-header__left` }, headerLeftSlot),
+                                                    (0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal-header__center` },
+                                                        this.title ? ((0, vue_1.h)(typography_1.UText, { variant: "body-l-semi-bold", class: `${mergedClsPrefix}-modal-header__title` }, this.title)) : null,
+                                                        this.subtitle ? ((0, vue_1.h)(typography_1.UText, { variant: "body-m-medium", class: `${mergedClsPrefix}-modal-header__subtitle` }, this.subtitle)) : null),
+                                                    (0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal-header__right` },
+                                                        (0, vue_1.h)(_internal_1.UBaseClose, { clsPrefix: mergedClsPrefix, class: `${mergedClsPrefix}-modal__close`, onClick: handleCloseClick }))),
+                                                (0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal-body` }, bodySlot),
+                                                (0, vue_1.h)("div", { class: `${mergedClsPrefix}-modal-footer` }, footerSlot))), dirs);
+                                    }
+                                }))
+                            }))
+                        })), [
+                        [
+                            vue_1.vShow,
+                            this.displayDirective === 'if' ||
+                                isDisplayed ||
+                                this.show
+                        ]
+                    ])
+                    : null), [
+                    [
+                        vdirs_1.zindexable,
+                        {
+                            zIndex: this.zIndex,
+                            enabled: this.show
+                        }
+                    ]
+                ]);
+            }
+        }));
+    }
+});

package/lib/modal-fullscreen/src/interface.js

@@ -0,0 +1 @@
+"use strict";

package/lib/modal-fullscreen/src/styles/index.cssr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("css-render").CNode;
+export default _default;

package/lib/modal-fullscreen/src/styles/index.cssr.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const cssr_1 = require("../../../_utils/cssr");
+const fade_in_scale_up_cssr_1 = require("../../../_styles/transitions/fade-in-scale-up.cssr");
+// vars:
+// --u-bezier-ease-out
+// --u-text-color
+// --u-close-border-radius
+// --u-close-margin
+// --u-close-size
+// --u-close-color-hover
+// --u-close-color-pressed
+// --u-close-icon-color
+// --u-close-icon-color-hover
+// --u-close-icon-color-pressed
+// --u-header-padding
+// --u-subtitle-color
+// --u-body-padding
+// --u-footer-padding
+// --u-modal-bg
+// --u-header-bg
+// --u-body-bg
+// --u-footer-bg
+exports.default = (0, cssr_1.c)([(0, cssr_1.cB)('modal-container', `
+ position: fixed;
+ left: 0;
+ top: 0;
+ height: 0;
+ width: 0;
+ display: flex;
+ `), (0, cssr_1.cB)('modal-body-wrapper', `
+ position: fixed;
+ left: 0;
+ right: 0;
+ top: 0;
+ bottom: 0;
+ overflow: visible;
+ `, [(0, cssr_1.cB)('modal-scroll-content', `
+ min-height: 100%;
+ position: relative;
+ `)]), (0, cssr_1.cB)('modal', `
+ position: relative;
+ color: var(--u-text-color);
+ margin: auto;
+ width: 100vw;
+ height: 100vh;
+ background: var(--u-modal-bg);
+ background-repeat: no-repeat;
+ background-size: cover;
+ `, [(0, fade_in_scale_up_cssr_1.fadeInScaleUpTransition)({
+  duration: '.25s',
+  enterScale: '.5'
+}), (0, cssr_1.cE)('close', `
+ margin: var(--u-close-margin);
+ transition:
+ background-color .3s var(--u-bezier),
+ color .3s var(--u-bezier);
+ z-index: 1;
+ `)]), (0, cssr_1.cB)('modal-content', `
+ height: 100%;
+ `, [(0, cssr_1.cM)('fixed', '', [(0, cssr_1.cB)('modal-header', `
+ flex: 0 0 auto;
+ `), (0, cssr_1.cB)('modal-body', `
+ flex: 1 1 100%;
+ `), (0, cssr_1.cB)('modal-footer', `
+ flex: 0 0 auto;
+ `)])]), (0, cssr_1.cB)('modal-body', `
+ padding: var(--u-body-padding);
+ background: var(--u-body-bg);
+ overflow-y: auto;
+ `), (0, cssr_1.cB)('modal-footer', `
+ padding: var(--u-footer-padding);
+ background: var(--u-footer-bg);
+ `), (0, cssr_1.cB)('modal-header', `
+ padding: var(--u-header-padding);
+ background: var(--u-header-bg);
+ `, [(0, cssr_1.cE)('left', `
+ flex: 0 1 50%;
+ `), (0, cssr_1.cE)('center', `
+ flex: 0 0 auto;
+ text-align: center;
+ `), (0, cssr_1.cE)('right', `
+ flex: 0 1 50%;
+ `), (0, cssr_1.cE)('title', `
+ `), (0, cssr_1.cE)('subtitle', `
+ color: var(--u-subtitle-color)
+ `)])]);

package/lib/modal-fullscreen/styles/_common.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    headerPadding: string;
+    bodyPadding: string;
+    footerPadding: string;
+    headerBg: string;
+    bodyBg: string;
+    footerBg: string;
+    closeMargin: string;
+    closeMarginIconTop: string;
+    closeBorderRadius: string;
+};
+export default _default;

package/lib/modal-fullscreen/styles/_common.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    headerPadding: '12px 32px',
+    bodyPadding: '24px 40px',
+    footerPadding: '12px 40px',
+    headerBg: 'transparent',
+    bodyBg: 'transparent',
+    footerBg: 'transparent',
+    closeMargin: '0 0 0 auto',
+    closeMarginIconTop: '16px 16px 0',
+    closeBorderRadius: '100px'
+};

package/lib/modal-fullscreen/styles/dark.d.ts

@@ -0,0 +1,3 @@
+import type { ModalFullscreenTheme } from './light';
+declare const modalFullscreenDark: ModalFullscreenTheme;
+export default modalFullscreenDark;

package/lib/modal-fullscreen/styles/dark.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const styles_1 = require("../../_internal/scrollbar/styles");
+const styles_2 = require("../../card/styles");
+const common_1 = require("../../_styles/common");
+const light_1 = require("./light");
+const modalFullscreenDark = {
+    name: 'ModalFullscreen',
+    common: common_1.commonDark,
+    peers: {
+        Scrollbar: styles_1.scrollbarDark,
+        Card: styles_2.cardDark
+    },
+    self: light_1.self
+};
+exports.default = modalFullscreenDark;

package/lib/modal-fullscreen/styles/index.d.ts

@@ -0,0 +1,3 @@
+export { default as modalFullscreenDark } from './dark';
+export { default as modalFullscreenLight } from './light';
+export type { ModalFullscreenTheme, ModalFullscreenThemeVars } from './light';

package/lib/modal-fullscreen/styles/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modalFullscreenLight = exports.modalFullscreenDark = void 0;
+var dark_1 = require("./dark");
+Object.defineProperty(exports, "modalFullscreenDark", { enumerable: true, get: function () { return __importDefault(dark_1).default; } });
+var light_1 = require("./light");
+Object.defineProperty(exports, "modalFullscreenLight", { enumerable: true, get: function () { return __importDefault(light_1).default; } });

package/lib/modal-fullscreen/styles/light.d.ts

@@ -0,0 +1,100 @@
+import type { ThemeCommonVars } from '../../_styles/common';
+export declare const self: (vars: ThemeCommonVars) => {
+    modalBg: string;
+    textColor: string;
+    closeColorHover: string;
+    closeColorPressed: string;
+    closeIconColor: string;
+    closeIconColorHover: string;
+    closeIconColorPressed: string;
+    closeIconSize: string;
+    closeSize: string;
+    subtitleColor: string;
+    headerPadding: string;
+    bodyPadding: string;
+    footerPadding: string;
+    headerBg: string;
+    bodyBg: string;
+    footerBg: string;
+    closeMargin: string;
+    closeMarginIconTop: string;
+    closeBorderRadius: string;
+};
+export type ModalFullscreenThemeVars = ReturnType<typeof self>;
+declare const modalFullscreenLight: import("../../_mixins").Theme<"ModalFullscreen", {
+    modalBg: string;
+    textColor: string;
+    closeColorHover: string;
+    closeColorPressed: string;
+    closeIconColor: string;
+    closeIconColorHover: string;
+    closeIconColorPressed: string;
+    closeIconSize: string;
+    closeSize: string;
+    subtitleColor: string;
+    headerPadding: string;
+    bodyPadding: string;
+    footerPadding: string;
+    headerBg: string;
+    bodyBg: string;
+    footerBg: string;
+    closeMargin: string;
+    closeMarginIconTop: string;
+    closeBorderRadius: string;
+}, {
+    Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
+        height: string;
+        width: string;
+        borderRadius: string;
+        color: string;
+        colorHover: string;
+        railInsetHorizontalBottom: string;
+        railInsetHorizontalTop: string;
+        railInsetVerticalRight: string;
+        railInsetVerticalLeft: string;
+        railColor: string;
+    }, any>;
+    Card: import("../../_mixins").Theme<"Card", {
+        titleFontSizeSmall: string;
+        titleFontSizeMedium: string;
+        titleFontSizeLarge: string;
+        titleFontSizeHuge: string;
+        titleLineHeightSmall: string;
+        titleLineHeightMedium: string;
+        titleLineHeightLarge: string;
+        titleLineHeightHuge: string;
+        titleFontWeight: string;
+        fontSizeSmall: string;
+        fontSizeMedium: string;
+        fontSizeLarge: string;
+        fontSizeHuge: string;
+        lineHeightSmall: string;
+        lineHeightMedium: string;
+        lineHeightLarge: string;
+        lineHeightHuge: string;
+        fontWeight: string;
+        closeIconSize: string;
+        closeSize: string;
+        color: string;
+        colorTarget: string;
+        colorEmbedded: string;
+        textColor: string;
+        titleTextColor: string;
+        borderColor: string;
+        actionColor: string;
+        closeColorHover: string;
+        closeColorPressed: string;
+        closeIconColor: string;
+        closeIconColorHover: string;
+        closeIconColorPressed: string;
+        closeBorderRadius: string;
+        boxShadow: string;
+        borderRadius: string;
+        paddingSmall: string;
+        paddingMedium: string;
+        paddingLarge: string;
+        paddingHuge: string;
+    }, any>;
+}>;
+export default modalFullscreenLight;
+export type ModalFullscreenTheme = typeof modalFullscreenLight;

package/lib/modal-fullscreen/styles/light.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.self = void 0;
+const styles_1 = require("../../_internal/scrollbar/styles");
+const styles_2 = require("../../card/styles");
+const common_1 = require("../../_styles/common");
+const _mixins_1 = require("../../_mixins");
+const _common_1 = __importDefault(require("./_common"));
+const self = (vars) => {
+    const { containerPrimary, textPrimary, transparencySecondary, elementsQuinary, elementsDarkQuinary, elementsSenary, iconMedium, closeMedium, textSecondary } = vars;
+    return Object.assign(Object.assign({}, _common_1.default), { modalBg: containerPrimary, textColor: textPrimary, closeColorHover: transparencySecondary, closeColorPressed: transparencySecondary, closeIconColor: elementsQuinary, closeIconColorHover: elementsDarkQuinary, closeIconColorPressed: elementsSenary, closeIconSize: iconMedium, closeSize: closeMedium, subtitleColor: textSecondary });
+};
+exports.self = self;
+const modalFullscreenLight = (0, _mixins_1.createTheme)({
+    name: 'ModalFullscreen',
+    common: common_1.commonLight,
+    peers: {
+        Scrollbar: styles_1.scrollbarLight,
+        Card: styles_2.cardLight
+    },
+    self: exports.self
+});
+exports.default = modalFullscreenLight;

package/lib/rate/src/Rate.d.ts

@@ -147,8 +147,8 @@ declare const _default: import("vue").DefineComponent<{
     }, any>>>;
 }>>, {
     readonly size: number | "small" | "medium" | "large";
-    readonly clearable: boolean;
     readonly defaultValue: number | null;
+    readonly clearable: boolean;
     readonly readonly: boolean;
     readonly count: number;
     readonly allowHalf: boolean;

package/lib/select/src/Select.d.ts

@@ -2448,6 +2448,7 @@ declare const _default: import("vue").DefineComponent<{
     readonly showArrow: boolean;
     readonly displayDirective: "show" | "if";
     readonly placement: FollowerPlacement;
+    readonly defaultValue: Value | null;
     readonly secondary: boolean;
     readonly filterable: boolean;
     readonly clearable: boolean;
@@ -2455,7 +2456,6 @@ declare const _default: import("vue").DefineComponent<{
     readonly ignoreComposition: boolean;
     readonly counter: boolean;
     readonly keyboard: boolean;
-    readonly defaultValue: Value | null;
     readonly options: SelectMixedOption[];
     readonly clearFilterAfterSelect: boolean;
     readonly remote: boolean;

package/lib/slider/src/Slider.d.ts

@@ -501,9 +501,9 @@ declare const _default: import("vue").DefineComponent<{
     readonly to: string | boolean | HTMLElement;
     readonly range: boolean;
     readonly tooltip: boolean;
+    readonly defaultValue: number | number[];
     readonly max: number;
     readonly keyboard: boolean;
-    readonly defaultValue: number | number[];
     readonly min: number;
     readonly showTooltip: boolean | undefined;
 }, {}>;

package/lib/switch/src/Switch.d.ts

@@ -519,9 +519,9 @@ declare const _default: import("vue").DefineComponent<{
     readonly loading: boolean;
     readonly size: "small" | "medium" | "large";
     readonly round: boolean;
+    readonly defaultValue: string | number | boolean;
     readonly checkedValue: string | number | boolean;
     readonly uncheckedValue: string | number | boolean;
-    readonly defaultValue: string | number | boolean;
     readonly rubberBand: boolean;
 }, {}>;
 export default _default;

package/lib/tag/index.d.ts

@@ -1,2 +1,4 @@
 export { default as UTag, tagProps } from './src/Tag';
 export type { TagProps } from './src/Tag';
+export { default as UTagGroup } from './src/TagGroup';
+export type { TagGroupProps } from './src/TagGroup';

package/lib/tag/index.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tagProps = exports.UTag = void 0;
+exports.UTagGroup = exports.tagProps = exports.UTag = void 0;
 var Tag_1 = require("./src/Tag");
 Object.defineProperty(exports, "UTag", { enumerable: true, get: function () { return __importDefault(Tag_1).default; } });
 Object.defineProperty(exports, "tagProps", { enumerable: true, get: function () { return Tag_1.tagProps; } });
+var TagGroup_1 = require("./src/TagGroup");
+Object.defineProperty(exports, "UTagGroup", { enumerable: true, get: function () { return __importDefault(TagGroup_1).default; } });