tanxin-ui 0.2.0

package/lib/textarea/src/textarea.js

@@ -0,0 +1,310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+require("../../utils/components/icons/Checkmark.js");
+require("../../utils/components/icons/CheckmarkCircle.js");
+require("../../utils/components/icons/CheckmarkSharp.js");
+require("../../utils/components/icons/CheckmarkCircleOutline.js");
+require("../../utils/components/icons/AlertCircle.js");
+require("../../utils/components/icons/AlertCircleOutline.js");
+require("../../utils/components/icons/InformationCircle.js");
+require("../../utils/components/icons/InformationCircleOutline.js");
+require("../../utils/components/icons/CloseCircle.js");
+var CloseCircleOutline = require("../../utils/components/icons/CloseCircleOutline.js");
+require("../../utils/components/icons/HelpCircleSharp.js");
+var EyeOffOutline = require("../../utils/components/icons/EyeOffOutline.js");
+var EyeOutline = require("../../utils/components/icons/EyeOutline.js");
+require("../../utils/components/icons/LoadingOutlined.js");
+require("../../utils/components/icons/Close.js");
+require("../../utils/components/icons/CloseOutline.js");
+require("../../utils/components/icons/ArrowsMaximize.js");
+require("../../utils/components/icons/ArrowsMinimize.js");
+require("../../utils/components/icons/AddOutline.js");
+require("../../utils/components/icons/RemoveOutline.js");
+require("../../utils/components/icons/ChevronUp.js");
+require("../../utils/components/icons/ChevronDown.js");
+require("../../utils/components/icons/ChevronForward.js");
+require("../../utils/components/icons/ChevronLeft24Filled.js");
+require("../../utils/components/icons/ChevronRight24Filled.js");
+require("../../utils/components/icons/ChevronDoubleLeft16Filled.js");
+require("../../utils/components/icons/ChevronDoubleRight16Filled.js");
+require("../../utils/components/icons/CheckmarkOutline.js");
+require("../../utils/components/icons/IosCheckmark.js");
+require("../../utils/components/icons/Empty.js");
+require("../../utils/components/icons/Bars.js");
+require("../../utils/components/icons/ArrowUpCircle.js");
+require("../../utils/components/icons/ArrowUp.js");
+require("../../utils/components/icons/ArrowForward.js");
+require("../../utils/components/icons/TimeOutline.js");
+require("../../utils/components/icons/CalendarClearOutline.js");
+require("../../utils/components/icons/KeyboardArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardArrowRightRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowRightRound.js");
+require("../../utils/components/icons/MenuFoldOutlined.js");
+require("../../utils/components/icons/IosArrowDown.js");
+require("../../utils/components/icons/IosArrowBack.js");
+require("../../utils/components/icons/IosArrowForward.js");
+require("../../utils/components/icons/ImageSharp.js");
+require("../../utils/components/icons/Pause.js");
+require("../../utils/components/icons/Refresh.js");
+require("../../utils/components/icons/QuestionCircle24Regular.js");
+require("../../utils/components/icons/CloudUploadOutline.js");
+require("../../utils/components/icons/UploadFileFilled.js");
+require("../../utils/components/icons/EllipsisHorizontal.js");
+require("../../utils/components/icons/ArrowNext24Filled.js");
+require("../../utils/components/icons/ArrowPrevious24Filled.js");
+require("../../utils/components/icons/ArrowDropDownSharp.js");
+require("../../utils/components/icons/ArrowDropUpSharp.js");
+require("../../utils/components/icons/ArrowForwardIosFilled.js");
+var resizeObserver = require("../../utils/components/resize-observer.js");
+const textareaProps = {
+  placeholder: type.PropTypes.string.def(""),
+  value: type.PropTypes.oneOfType([type.PropTypes.string, type.PropTypes.number]).def(""),
+  resize: type.PropTypes.oneOf(["none", "both", "vertical", "horizontal"]).def("none"),
+  readonly: type.PropTypes.bool.def(false),
+  disabled: type.PropTypes.bool.def(false),
+  showWordLimit: type.PropTypes.bool.def(false),
+  clearable: type.PropTypes.bool.def(false),
+  maxlength: type.PropTypes.number,
+  rows: type.PropTypes.number.def(3),
+  minRows: type.PropTypes.number.def(2),
+  maxRows: type.PropTypes.number.def(10),
+  autoHeight: type.PropTypes.bool.def(false)
+};
+var Textarea = vue.defineComponent({
+  name: "TTextarea",
+  components: {
+    ResizeObserver: resizeObserver["default"],
+    EyeOffOutline: EyeOffOutline["default"],
+    EyeOutline: EyeOutline["default"],
+    CloseCircleOutline: CloseCircleOutline["default"]
+  },
+  props: textareaProps,
+  setup(props, {
+    emit,
+    attrs
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("textarea", props);
+    const showClear = vue.ref(false);
+    const currentValue = vue.ref(props.value);
+    const isComposing = vue.ref(false);
+    const validateEnable = vue.ref(true);
+    const showWordCount = vue.computed(() => {
+      return props.showWordLimit && props.maxlength;
+    });
+    const txForm = vue.inject("txForm", {
+      gutter: false,
+      disabled: false,
+      formMitt: null,
+      rules: []
+    });
+    const refInput = vue.ref(null);
+    const refTextarea = vue.ref(null);
+    const textareaStyles = vue.ref({});
+    const refValue = vue.computed(() => refInput.value);
+    const validateStatus = vue.ref("");
+    const currentLength = vue.computed(() => {
+      if (typeof currentValue.value === "number") {
+        return String(currentValue.value).length;
+      }
+      return (currentValue.value || "").length;
+    });
+    const shouldDisabled = vue.computed(() => {
+      return props.disabled || txForm.disabled;
+    });
+    const isFocus = vue.ref(false);
+    const classes = vue.computed(() => {
+      const values = [[`${prefixCls.value}-wrapper`], {
+        [`${prefixCls.value}-readonly`]: props.readonly,
+        error: validateStatus.value === "error",
+        validating: validateStatus.value === "validating",
+        success: validateStatus.value === "success",
+        "is-focus": isFocus.value,
+        "is-disabled": shouldDisabled.value
+      }];
+      return values;
+    });
+    vue.watch(() => props.value, () => {
+      currentValue.value = props.value;
+    });
+    const focus = () => {
+      vue.nextTick(() => {
+        refValue.value.focus();
+      });
+    };
+    const blur = () => {
+      refValue.value.blur();
+    };
+    const handleClearClick = () => {
+      currentValue.value = "";
+      emit("update:value", currentValue.value);
+    };
+    const handleInput = (event) => {
+      const {
+        value
+      } = event.target;
+      if (isComposing.value)
+        return;
+      currentValue.value = value;
+      emit("update:value", value);
+      emit("input", value);
+    };
+    const handleChange = (event) => {
+      emit("change", event);
+    };
+    const handleFocus = (event) => {
+      isFocus.value = true;
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      isFocus.value = false;
+      emit("blur", event);
+      if (!validateEnable.value)
+        return;
+    };
+    const handleKeydown = (event) => {
+      emit("keydown", event);
+    };
+    const handleCompositionStart = () => {
+      isComposing.value = true;
+    };
+    const handleCompositionUpdate = () => {
+    };
+    const handleCompositionEnd = (event) => {
+      if (isComposing.value) {
+        isComposing.value = false;
+        handleInput(event);
+      }
+    };
+    const processing = vue.ref(false);
+    const handleResize = (data) => {
+      if (processing.value)
+        return;
+      processing.value = true;
+      const lineHeight = getWidthFromCss("line-height");
+      const mirrorHeight = data.height;
+      let textareaHeight = mirrorHeight;
+      if (props.minRows) {
+        const minHeight = additionalHeight.value + props.minRows * lineHeight;
+        if (mirrorHeight < minHeight)
+          textareaHeight = minHeight;
+      }
+      if (props.maxRows) {
+        const maxHeight = additionalHeight.value + props.maxRows * lineHeight;
+        if (mirrorHeight > maxHeight)
+          textareaHeight = maxHeight;
+      }
+      textareaStyles.value["height"] = `${textareaHeight}px`;
+      setTimeout(() => {
+        processing.value = false;
+      }, 300);
+    };
+    vue.onMounted(() => {
+      if (props.autoHeight)
+        copyStylesToMirror();
+      textareaStyles.value["resize"] = props.resize;
+    });
+    const getWidthFromCss = (property) => {
+      return parseFloat(textareaStyles.value[property]);
+    };
+    const additionalHeight = vue.computed(() => {
+      return getWidthFromCss("border-top-width") + getWidthFromCss("border-bottom-width") + getWidthFromCss("padding-top") + getWidthFromCss("padding-top");
+    });
+    const copyStylesToMirror = () => {
+      const cssDeclaration = window.getComputedStyle(refTextarea.value);
+      const styles = {};
+      const SIZING_STYLE = ["border-bottom-width", "border-left-width", "border-right-width", "border-top-width", "box-sizing", "font-family", "font-size", "font-style", "font-weight", "letter-spacing", "line-height", "padding-bottom", "padding-left", "padding-right", "padding-top", "tab-size", "text-indent", "text-rendering", "text-transform", "width", "word-break"];
+      SIZING_STYLE.forEach((item) => {
+        styles[item] = cssDeclaration.getPropertyValue(item);
+      });
+      textareaStyles.value = styles;
+    };
+    const render = () => {
+      const controlProps = {
+        class: prefixCls.value,
+        value: currentValue.value,
+        placeholder: props.placeholder,
+        maxlength: props.maxlength,
+        disabled: shouldDisabled.value,
+        rows: props.rows,
+        readonly: props.readonly,
+        onCompositionstart: handleCompositionStart,
+        onCompositionupdate: handleCompositionUpdate,
+        onCompositionend: handleCompositionEnd,
+        onInput: handleInput,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        onChange: handleChange,
+        onKeydown: handleKeydown
+      };
+      let resizeMirror = null;
+      if (props.autoHeight) {
+        resizeMirror = vue.createVNode(resizeObserver["default"], {
+          "onResize": handleResize
+        }, {
+          default: () => [vue.createVNode("div", {
+            "class": [prefixCls.value, `${prefixCls.value}-mirror`]
+          }, [`${currentValue.value}
+`])]
+        });
+      }
+      const containerProps = __spreadValues({}, attrs);
+      if (!props.disabled && props.clearable) {
+        containerProps["onMouseenter"] = () => {
+          showClear.value = true;
+        };
+        containerProps["onMouseleave"] = () => {
+          showClear.value = false;
+        };
+      }
+      const wordCount = showWordCount.value ? vue.createVNode("span", {
+        "class": `${prefixCls.value}-word-limit`
+      }, [currentLength.value, vue.createTextVNode("/"), props.maxlength]) : null;
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode("div", vue.mergeProps({
+        "class": classes.value
+      }, containerProps), [vue.createVNode("textarea", vue.mergeProps({
+        "ref": refTextarea
+      }, controlProps, {
+        "style": textareaStyles.value
+      }), null), showClear.value && currentValue.value ? vue.createVNode("span", {
+        "class": "btn-clear-wrapper"
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), {
+        "class": "btn-clear",
+        "onClick": handleClearClick
+      }, {
+        default: () => [vue.createVNode(CloseCircleOutline["default"], null, null)]
+      })]) : null, wordCount, resizeMirror])]);
+    };
+    return {
+      refTextarea,
+      render,
+      focus,
+      blur
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = Textarea;

package/lib/time-picker/index.d.ts

@@ -0,0 +1,50 @@
+declare const TTimePicker: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: ((event: string, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {
+            render: () => JSX.Element;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {
+    render: () => JSX.Element;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TTimePicker };

package/lib/time-picker/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var type = require("../utils/type.js");
+var timePicker = require("./src/time-picker.js");
+const TTimePicker = type.withInstall(timePicker["default"]);
+exports.TTimePicker = TTimePicker;

package/lib/time-picker/src/time-picker.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, {
+    render: () => JSX.Element;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/lib/time-picker/src/time-picker.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var index = require("../../date-picker/index.js");
+var TimePicker = vue.defineComponent({
+  name: "TTimePicker",
+  components: {
+    TDatePicker: index.TDatePicker
+  },
+  inheritAttrs: false,
+  setup(props, {
+    slots,
+    attrs
+  }) {
+    const render = () => {
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode(index.TDatePicker, vue.mergeProps({
+        "type": "time"
+      }, props, attrs), slots)]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = TimePicker;

package/lib/tooltip/index.d.ts

@@ -0,0 +1,204 @@
+declare const TTooltip: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            content: string;
+            minWidth: string | number;
+            offset: string | number;
+            visible: boolean;
+            trigger: string;
+            placement: string;
+            theme: string;
+            transitionName: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            trigger: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            placement: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            visible: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            theme: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            content: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            transitionName: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            offset: import("vue-types").VueTypeDef<string | number> & {
+                default: string | number;
+            };
+            minWidth: import("vue-types").VueTypeDef<string | number> & {
+                default: string | number;
+            };
+        }>> & {
+            "onUpdate:visible"?: (...args: any[]) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "content" | "minWidth" | "offset" | "visible" | "trigger" | "placement" | "theme" | "transitionName">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: "update:visible", ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            trigger: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            placement: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            visible: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            theme: import("vue-types").VueTypeDef<string> & {
+                default: string;
+            };
+            content: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            };
+            transitionName: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            offset: import("vue-types").VueTypeDef<string | number> & {
+                default: string | number;
+            };
+            minWidth: import("vue-types").VueTypeDef<string | number> & {
+                default: string | number;
+            };
+        }>> & {
+            "onUpdate:visible"?: (...args: any[]) => any;
+        }, {
+            render: () => JSX.Element;
+            updatePosition: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:visible"[], string, {
+            content: string;
+            minWidth: string | number;
+            offset: string | number;
+            visible: boolean;
+            trigger: string;
+            placement: string;
+            theme: string;
+            transitionName: string;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        trigger: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        placement: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        visible: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        theme: import("vue-types").VueTypeDef<string> & {
+            default: string;
+        };
+        content: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        };
+        transitionName: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        } & {
+            default: string;
+        };
+        offset: import("vue-types").VueTypeDef<string | number> & {
+            default: string | number;
+        };
+        minWidth: import("vue-types").VueTypeDef<string | number> & {
+            default: string | number;
+        };
+    }>> & {
+        "onUpdate:visible"?: (...args: any[]) => any;
+    } & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+        updatePosition: () => void;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    trigger: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    placement: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    visible: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    theme: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    content: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    transitionName: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    offset: import("vue-types").VueTypeDef<string | number> & {
+        default: string | number;
+    };
+    minWidth: import("vue-types").VueTypeDef<string | number> & {
+        default: string | number;
+    };
+}>> & {
+    "onUpdate:visible"?: (...args: any[]) => any;
+}, {
+    render: () => JSX.Element;
+    updatePosition: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:visible"[], "update:visible", {
+    content: string;
+    minWidth: string | number;
+    offset: string | number;
+    visible: boolean;
+    trigger: string;
+    placement: string;
+    theme: string;
+    transitionName: string;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TTooltip };

package/lib/tooltip/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var type = require("../utils/type.js");
+var tooltip = require("./src/tooltip.js");
+const TTooltip = type.withInstall(tooltip["default"]);
+exports.TTooltip = TTooltip;