tuikit-atomicx-vue3 0.1.0

package/dist/components/Avatar/Avatar.js

@@ -0,0 +1,167 @@
+import { defineComponent, useSlots, ref, computed, h, createBlock, openBlock, resolveDynamicComponent } from "vue";
+import { Badge } from "@tencentcloud/uikit-base-component-vue3";
+import { c as cs } from "../../index-BF6QB9jF.js";
+import AvatarOnlineBadge from "./AvatarBadge/AvatarBadge.js";
+import { _ as _export_sfc } from "../../_plugin-vue_export-helper-1tPrXgE0.js";
+const DEFAULT_AVATAR_URL = "https://web.sdk.qcloud.com/component/TUIKit/assets/avatar_21.png";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Avatar"
+  },
+  __name: "Avatar",
+  props: {
+    isShowOnlineStatus: { type: Boolean, default: false },
+    isOnline: { type: Boolean, default: false },
+    unreadCount: { default: 0 },
+    maxUnreadCount: { default: 99 },
+    isDotUnreadCount: { type: Boolean, default: false },
+    src: {},
+    size: { default: "md" },
+    shape: { default: "circular" },
+    alt: {},
+    className: {},
+    style: {},
+    onClick: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const imageError = ref(false);
+    const isLoading = ref(!!props.src);
+    const children = computed(() => slots.default);
+    const setIsLoading = (loading) => {
+      isLoading.value = loading;
+    };
+    const handleImageLoad = () => {
+      isLoading.value = false;
+    };
+    const handleImageError = () => {
+      imageError.value = true;
+      isLoading.value = false;
+    };
+    const handleClick = () => {
+      if (props.onClick) {
+        props.onClick();
+      }
+    };
+    const getAltText = () => {
+      if (!props.alt) {
+        return "";
+      }
+      return props.alt.trim().charAt(0);
+    };
+    const fontSizeStyle = computed(() => {
+      let _size = 40;
+      if (typeof props.size === "number") {
+        const shapeStyle = props.shape === "circular" ? "50%" : props.shape === "square" ? "0%" : `${props.size / 6}px`;
+        return {
+          width: `${props.size}px`,
+          height: `${props.size}px`,
+          fontSize: `${Math.floor(props.size / 2)}px`,
+          borderRadius: shapeStyle
+        };
+      }
+      if (typeof props.size === "string") {
+        switch (props.size) {
+          case "xxl":
+            _size = 96;
+            break;
+          case "xl":
+            _size = 64;
+            break;
+          case "lg":
+            _size = 48;
+            break;
+          case "md":
+            _size = 40;
+            break;
+          case "sm":
+            _size = 32;
+            break;
+          case "xs":
+            _size = 24;
+            break;
+          default:
+            _size = 40;
+            break;
+        }
+      }
+      return {
+        fontSize: `${Math.floor(_size / 2)}px`
+      };
+    });
+    const avatarClasses = computed(() => cs(
+      "avatar",
+      `avatar--shape-${props.shape}`,
+      typeof props.size !== "number" && `size-${props.size}`,
+      props.className
+    ));
+    const baseAvatar = computed(() => h(
+      "div",
+      {
+        "class": avatarClasses.value,
+        "style": [fontSizeStyle.value, props.style, { cursor: props.onClick ? "pointer" : "default" }],
+        "onClick": handleClick,
+        "role": props.onClick ? "button" : void 0,
+        "tabindex": props.onClick ? 0 : void 0,
+        "aria-label": props.alt || "avatar"
+      },
+      [
+        // Render avatar content
+        (() => {
+          if (children.value) {
+            return h("div", { class: "avatar__fallback" }, children.value);
+          }
+          if (props.src && !imageError.value) {
+            return h("img", {
+              class: cs("avatar__image"),
+              src: props.src,
+              alt: props.alt || "avatar",
+              onLoad: handleImageLoad,
+              onError: handleImageError
+            });
+          }
+          if (props.alt) {
+            return h("div", { class: "avatar__fallback" }, getAltText());
+          }
+          return h("img", {
+            class: "avatar__image",
+            src: DEFAULT_AVATAR_URL,
+            alt: "default avatar",
+            onLoad: () => setIsLoading(false),
+            onError: () => setIsLoading(false)
+          });
+        })(),
+        // Loading skeleton
+        isLoading.value && h("div", { class: "avatar__skeleton" })
+      ]
+    ));
+    const avatarWithBadges = computed(() => {
+      let result = baseAvatar.value;
+      if (props.unreadCount !== void 0) {
+        result = h(Badge, {
+          hidden: props.unreadCount === 0,
+          value: typeof props.unreadCount === "number" ? props.unreadCount : "",
+          max: props.maxUnreadCount,
+          isDot: props.isDotUnreadCount,
+          type: "danger"
+        }, [result]);
+      }
+      if (props.isShowOnlineStatus) {
+        result = h(AvatarOnlineBadge, {
+          show: true,
+          onlineStatus: props.isOnline ? "online" : "offline",
+          size: typeof props.size === "number" ? "md" : props.size
+        }, [result]);
+      }
+      return result;
+    });
+    return (_ctx, _cache) => {
+      return !_ctx.isShowOnlineStatus && !_ctx.unreadCount ? (openBlock(), createBlock(resolveDynamicComponent(baseAvatar.value), { key: 0 })) : (openBlock(), createBlock(resolveDynamicComponent(avatarWithBadges.value), { key: 1 }));
+    };
+  }
+});
+const Avatar = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c8ebafa8"]]);
+export {
+  Avatar as default
+};

package/dist/components/Avatar/Avatar.vue.d.ts

@@ -0,0 +1,95 @@
+import { CSSProperties } from 'vue';
+
+type AvatarSize = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs' | number;
+type AvatarShape = 'circular' | 'square' | 'rounded';
+interface BaseAvatarProps {
+    /** Avatar image URL */
+    src?: string;
+    /**
+     * Avatar size
+     * @default 'md'
+     */
+    size?: AvatarSize;
+    /**
+     * Avatar shape: circular, square, rounded
+     * @default 'circular'
+     */
+    shape?: AvatarShape;
+    /** Alternative text for the image, also used to generate text avatar */
+    alt?: string;
+    /** Custom class name */
+    className?: string;
+    /** Custom style */
+    style?: CSSProperties;
+    /** Click event handler */
+    onClick?: () => void;
+}
+interface AvatarProps extends BaseAvatarProps {
+    /**
+     * Whether to show online status indicator
+     * @default false
+     */
+    isShowOnlineStatus?: boolean;
+    /** Whether the user is online */
+    isOnline?: boolean;
+    /**
+     * Unread message count
+     * If true, displays a small red dot
+     * If number, displays the specific count
+     */
+    unreadCount?: number;
+    /**
+     * Max unread message count
+     * If number, displays the specific count
+     */
+    maxUnreadCount?: number;
+    /**
+     * Whether to display a small red dot
+     * @default false
+     */
+    isDotUnreadCount?: boolean;
+}
+export type { AvatarSize, AvatarShape, BaseAvatarProps, AvatarProps };
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AvatarProps>, {
+    size: string;
+    shape: string;
+    isShowOnlineStatus: boolean;
+    isOnline: boolean;
+    unreadCount: number;
+    maxUnreadCount: number;
+    isDotUnreadCount: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AvatarProps>, {
+    size: string;
+    shape: string;
+    isShowOnlineStatus: boolean;
+    isOnline: boolean;
+    unreadCount: number;
+    maxUnreadCount: number;
+    isDotUnreadCount: boolean;
+}>>> & Readonly<{}>, {
+    size: AvatarSize;
+    shape: AvatarShape;
+    isShowOnlineStatus: boolean;
+    isOnline: boolean;
+    unreadCount: number;
+    maxUnreadCount: number;
+    isDotUnreadCount: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/Avatar/AvatarBadge/AvatarBadge.js

@@ -0,0 +1,40 @@
+import { defineComponent, createElementBlock, openBlock, renderSlot, createElementVNode, normalizeClass, createCommentVNode } from "vue";
+import { _ as _export_sfc } from "../../../_plugin-vue_export-helper-1tPrXgE0.js";
+const _hoisted_1 = { class: "avatar-badge" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "AvatarBadge"
+  },
+  __name: "AvatarBadge",
+  props: {
+    size: { default: "md" },
+    onlineStatus: { default: "online" }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        createElementVNode("div", {
+          class: normalizeClass([
+            "avatar-badge__indicator",
+            "avatar-badge__indicator--bottom-right",
+            `avatar-badge__indicator--${_ctx.size}`
+          ])
+        }, [
+          _ctx.onlineStatus ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: normalizeClass([
+              "avatar-badge__online-status",
+              `avatar-badge__online-status--${_ctx.onlineStatus}`,
+              `avatar-badge__online-status--${_ctx.size}`
+            ])
+          }, null, 2)) : createCommentVNode("", true)
+        ], 2)
+      ]);
+    };
+  }
+});
+const AvatarOnlineBadge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a69536c2"]]);
+export {
+  AvatarOnlineBadge as default
+};

package/dist/components/Avatar/AvatarBadge/AvatarBadge.vue.d.ts

@@ -0,0 +1,51 @@
+type AvatarBadgeSize = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+type BadgeOnlineStatus = 'online' | 'offline';
+interface AvatarBadgeProps {
+    /**
+     * Badge size - must align with Avatar size
+     * @default 'md'
+     */
+    size?: AvatarBadgeSize;
+    /**
+     * Online status
+     * @default 'online'
+     */
+    onlineStatus?: BadgeOnlineStatus;
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AvatarBadgeProps>, {
+    size: string;
+    onlineStatus: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AvatarBadgeProps>, {
+    size: string;
+    onlineStatus: string;
+}>>> & Readonly<{}>, {
+    size: AvatarBadgeSize;
+    onlineStatus: BadgeOnlineStatus;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Avatar/AvatarBadge/index.d.ts

@@ -0,0 +1,3 @@
+import { default as AvatarBadge } from './AvatarBadge.vue';
+
+export { AvatarBadge };

package/dist/components/Avatar/AvatarBadge/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./AvatarBadge.js";
+export {
+  default2 as AvatarBadge
+};

package/dist/components/Avatar/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Avatar } from './Avatar.vue';
+
+export { Avatar };
+export type { AvatarSize, AvatarShape, AvatarProps } from './Avatar.vue';

package/dist/components/Avatar/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./Avatar.js";
+export {
+  default2 as Avatar
+};

package/dist/components/BarrageInput/BarrageInput.js

@@ -0,0 +1,81 @@
+import { defineComponent, computed, createElementBlock, openBlock, createElementVNode, normalizeStyle, normalizeClass, createVNode, withCtx, unref } from "vue";
+import EmojiPicker from "./EmojiPicker/EmojiPicker.js";
+import { _ as _sfc_main$1 } from "../../TextEditor.vue_vue_type_script_setup_true_lang-w_I4bsmJ.js";
+import { useLoginState } from "../../states/LoginState.js";
+import { useLiveAudienceState } from "../../states/LiveAudienceState.js";
+import { useUIKit } from "@tencentcloud/uikit-base-component-vue3";
+import { _ as _export_sfc } from "../../_plugin-vue_export-helper-1tPrXgE0.js";
+const _hoisted_1 = { class: "live-message-input" };
+const _hoisted_2 = { class: "input-actions" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "BarrageInput",
+  props: {
+    containerClass: { default: "" },
+    containerStyle: { default: () => ({}) },
+    height: { default: "" },
+    minHeight: { default: "40px" },
+    maxHeight: { default: "140px" },
+    placeholder: {},
+    disabled: { type: Boolean, default: false },
+    autoFocus: { type: Boolean, default: true }
+  },
+  emits: ["focus", "blur"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const { t } = useUIKit();
+    const { loginUserInfo } = useLoginState();
+    const { audienceList } = useLiveAudienceState();
+    const props = __props;
+    const containerStyle = computed(() => {
+      const defaultStyle = {
+        minHeight: props.minHeight,
+        maxHeight: props.maxHeight
+      };
+      if (props.height) {
+        defaultStyle.height = props.height;
+      }
+      return { ...defaultStyle, ...props.containerStyle };
+    });
+    const disabledAndPlaceholder = computed(() => {
+      const localUser = audienceList.value.find((item) => {
+        var _a;
+        return item.userId === ((_a = loginUserInfo.value) == null ? void 0 : _a.userId);
+      });
+      return {
+        disabled: props.disabled || (localUser == null ? void 0 : localUser.isMessageDisabled),
+        placeholder: (localUser == null ? void 0 : localUser.isMessageDisabled) ? t("You have been muted") : props.placeholder
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          class: normalizeClass(["message-input-container", _ctx.containerClass, disabledAndPlaceholder.value.disabled && "disabled"]),
+          style: normalizeStyle(containerStyle.value)
+        }, [
+          createVNode(_sfc_main$1, {
+            style: { "width": "100%", "height": "100%" },
+            placeholder: disabledAndPlaceholder.value.placeholder,
+            disabled: disabledAndPlaceholder.value.disabled,
+            autoFocus: _ctx.autoFocus,
+            onFocus: _cache[0] || (_cache[0] = ($event) => emit("focus")),
+            onBlur: _cache[1] || (_cache[1] = ($event) => emit("blur"))
+          }, {
+            prefix: withCtx(() => [
+              createElementVNode("div", _hoisted_2, [
+                createVNode(unref(EmojiPicker), {
+                  disabled: disabledAndPlaceholder.value.disabled,
+                  "trigger-style": { display: "flex" }
+                }, null, 8, ["disabled"])
+              ])
+            ]),
+            _: 1
+          }, 8, ["placeholder", "disabled", "autoFocus"])
+        ], 6)
+      ]);
+    };
+  }
+});
+const BarrageInputPC = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-59fc67a0"]]);
+export {
+  BarrageInputPC as default
+};

package/dist/components/BarrageInput/BarrageInput.vue.d.ts

@@ -0,0 +1,59 @@
+interface Props {
+    containerClass?: string;
+    containerStyle?: Record<string, any>;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    autoFocus?: boolean;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    containerClass: string;
+    containerStyle: () => {};
+    height: string;
+    minHeight: string;
+    maxHeight: string;
+    disabled: boolean;
+    autoFocus: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: () => void;
+    blur: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    containerClass: string;
+    containerStyle: () => {};
+    height: string;
+    minHeight: string;
+    maxHeight: string;
+    disabled: boolean;
+    autoFocus: boolean;
+}>>> & Readonly<{
+    onBlur?: (() => any) | undefined;
+    onFocus?: (() => any) | undefined;
+}>, {
+    height: string;
+    disabled: boolean;
+    autoFocus: boolean;
+    containerClass: string;
+    containerStyle: Record<string, any>;
+    minHeight: string;
+    maxHeight: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/BarrageInput/BarrageInputH5.js

@@ -0,0 +1,80 @@
+import { defineComponent, ref, createElementBlock, openBlock, createVNode, createBlock, createCommentVNode, unref, withCtx, createTextVNode, toDisplayString } from "vue";
+import { useUIKit, TUIButton } from "@tencentcloud/uikit-base-component-vue3";
+import { useMessageInputState } from "../../states/MessageInputState/MessageInputState.js";
+import BarrageInputPC from "./BarrageInput.js";
+import { _ as _export_sfc } from "../../_plugin-vue_export-helper-1tPrXgE0.js";
+const _hoisted_1 = { class: "live-message-input-h5" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "BarrageInputH5",
+  props: {
+    containerClass: { default: "" },
+    containerStyle: { default: () => ({}) },
+    height: { default: "" },
+    minHeight: { default: "40px" },
+    maxHeight: { default: "140px" },
+    placeholder: {},
+    disabled: { type: Boolean, default: false },
+    autoFocus: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const { t } = useUIKit();
+    const { inputRawValue, setContent, sendMessage, blurEditor } = useMessageInputState();
+    const isFocus = ref(false);
+    const isTouching = ref(false);
+    const handleTouchStart = () => {
+      isTouching.value = true;
+    };
+    const handleSend = () => {
+      if (inputRawValue.value) {
+        sendMessage();
+        setContent("");
+        blurEditor();
+      }
+    };
+    const handleTouchEnd = () => {
+      if (!isTouching.value) {
+        return;
+      }
+      isTouching.value = false;
+      handleSend();
+    };
+    const handleFocus = async () => {
+      isFocus.value = true;
+    };
+    const handleBlur = () => {
+      isFocus.value = false;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(BarrageInputPC, {
+          autoFocus: props.autoFocus,
+          containerClass: props.containerClass,
+          containerStyle: props.containerStyle,
+          height: props.height,
+          minHeight: props.minHeight,
+          maxHeight: props.maxHeight,
+          placeholder: props.placeholder,
+          disabled: props.disabled,
+          onFocus: handleFocus,
+          onBlur: handleBlur
+        }, null, 8, ["autoFocus", "containerClass", "containerStyle", "height", "minHeight", "maxHeight", "placeholder", "disabled"]),
+        isFocus.value ? (openBlock(), createBlock(unref(TUIButton), {
+          key: 0,
+          type: "primary",
+          onTouchstart: handleTouchStart,
+          onTouchend: handleTouchEnd
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(unref(t)("Send")), 1)
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const BarrageInputH5 = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2ea9f5b3"]]);
+export {
+  BarrageInputH5 as default
+};

package/dist/components/BarrageInput/BarrageInputH5.vue.d.ts

@@ -0,0 +1,53 @@
+interface Props {
+    containerClass?: string;
+    containerStyle?: Record<string, any>;
+    height?: string;
+    minHeight?: string;
+    maxHeight?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    autoFocus?: boolean;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    containerClass: string;
+    containerStyle: () => {};
+    height: string;
+    minHeight: string;
+    maxHeight: string;
+    disabled: boolean;
+    autoFocus: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    containerClass: string;
+    containerStyle: () => {};
+    height: string;
+    minHeight: string;
+    maxHeight: string;
+    disabled: boolean;
+    autoFocus: boolean;
+}>>> & Readonly<{}>, {
+    height: string;
+    disabled: boolean;
+    autoFocus: boolean;
+    containerClass: string;
+    containerStyle: Record<string, any>;
+    minHeight: string;
+    maxHeight: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};