vxe-pc-ui 0.0.2 → 0.1.0

package/es/switch/src/switch.js

@@ -0,0 +1,151 @@
+import { defineComponent, h, ref, computed, reactive, nextTick, createCommentVNode, inject } from 'vue';
+import XEUtils from 'xe-utils';
+import globalConfigStore from '../../ui/src/globalStore';
+import { useSize } from '../../hooks/size';
+import { getFuncText } from '../../ui/src/utils';
+export default defineComponent({
+    name: 'VxeSwitch',
+    props: {
+        modelValue: [String, Number, Boolean],
+        disabled: Boolean,
+        size: { type: String, default: () => globalConfigStore.switch.size || globalConfigStore.size },
+        openLabel: String,
+        closeLabel: String,
+        openValue: { type: [String, Number, Boolean], default: true },
+        closeValue: { type: [String, Number, Boolean], default: false },
+        openIcon: String,
+        closeIcon: String
+    },
+    emits: [
+        'update:modelValue',
+        'change',
+        'focus',
+        'blur'
+    ],
+    setup(props, context) {
+        const { emit } = context;
+        const $xeform = inject('$xeForm', null);
+        const $xeformiteminfo = inject('$xeFormItemInfo', null);
+        const xID = XEUtils.uniqueId();
+        const computeSize = useSize(props);
+        const reactData = reactive({
+            isActivated: false,
+            hasAnimat: false,
+            offsetLeft: 0
+        });
+        const $xeswitch = {
+            xID,
+            props,
+            context,
+            reactData
+        };
+        const refButton = ref();
+        let switchMethods = {};
+        const computeOnShowLabel = computed(() => {
+            return getFuncText(props.openLabel);
+        });
+        const computeOffShowLabel = computed(() => {
+            return getFuncText(props.closeLabel);
+        });
+        const computeIsChecked = computed(() => {
+            return props.modelValue === props.openValue;
+        });
+        let _atimeout;
+        const clickEvent = (evnt) => {
+            if (!props.disabled) {
+                const isChecked = computeIsChecked.value;
+                clearTimeout(_atimeout);
+                const value = isChecked ? props.closeValue : props.openValue;
+                reactData.hasAnimat = true;
+                emit('update:modelValue', value);
+                switchMethods.dispatchEvent('change', { value }, evnt);
+                // 自动更新校验状态
+                if ($xeform && $xeformiteminfo) {
+                    $xeform.triggerItemEvent(evnt, $xeformiteminfo.itemConfig.field, value);
+                }
+                _atimeout = setTimeout(() => {
+                    reactData.hasAnimat = false;
+                }, 400);
+            }
+        };
+        const focusEvent = (evnt) => {
+            reactData.isActivated = true;
+            switchMethods.dispatchEvent('focus', { value: props.modelValue }, evnt);
+        };
+        const blurEvent = (evnt) => {
+            reactData.isActivated = false;
+            switchMethods.dispatchEvent('blur', { value: props.modelValue }, evnt);
+        };
+        switchMethods = {
+            dispatchEvent(type, params, evnt) {
+                emit(type, Object.assign({ $switch: $xeswitch, $event: evnt }, params));
+            },
+            focus() {
+                const btnElem = refButton.value;
+                reactData.isActivated = true;
+                btnElem.focus();
+                return nextTick();
+            },
+            blur() {
+                const btnElem = refButton.value;
+                btnElem.blur();
+                reactData.isActivated = false;
+                return nextTick();
+            }
+        };
+        Object.assign($xeswitch, switchMethods);
+        const renderVN = () => {
+            const { disabled, openIcon, closeIcon } = props;
+            const isChecked = computeIsChecked.value;
+            const vSize = computeSize.value;
+            const onShowLabel = computeOnShowLabel.value;
+            const offShowLabel = computeOffShowLabel.value;
+            return h('div', {
+                class: ['vxe-switch', isChecked ? 'is--on' : 'is--off', {
+                        [`size--${vSize}`]: vSize,
+                        'is--disabled': disabled,
+                        'is--animat': reactData.hasAnimat
+                    }]
+            }, [
+                h('button', {
+                    ref: refButton,
+                    class: 'vxe-switch--button',
+                    type: 'button',
+                    disabled,
+                    onClick: clickEvent,
+                    onFocus: focusEvent,
+                    onBlur: blurEvent
+                }, [
+                    h('span', {
+                        class: 'vxe-switch--label vxe-switch--label-on'
+                    }, [
+                        openIcon
+                            ? h('i', {
+                                class: ['vxe-switch--label-icon', openIcon]
+                            })
+                            : createCommentVNode(),
+                        onShowLabel
+                    ]),
+                    h('span', {
+                        class: 'vxe-switch--label vxe-switch--label-off'
+                    }, [
+                        closeIcon
+                            ? h('i', {
+                                class: ['vxe-switch--label-icon', closeIcon]
+                            })
+                            : createCommentVNode(),
+                        offShowLabel
+                    ]),
+                    h('span', {
+                        class: 'vxe-switch--icon'
+                    })
+                ])
+            ]);
+        };
+        $xeswitch.renderVN = renderVN;
+        return $xeswitch;
+    },
+    render() {
+        return this.renderVN();
+    }
+});

package/es/switch/style.css

@@ -0,0 +1,97 @@
+.vxe-switch {
+  display: inline-block;
+  color: var(--vxe-font-color);
+  vertical-align: middle;
+  padding: 0.4em;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+  text-align: center;
+}
+.vxe-switch.is--animat .vxe-switch--button {
+  transition: border-color 0.3s, background-color 0.3s;
+}
+.vxe-switch.is--animat .vxe-switch--icon {
+  transition: all 0.3s;
+}
+.vxe-switch.is--on .vxe-switch--button {
+  padding-right: 1.7em;
+  background-color: var(--vxe-ui-switch-open-background-color);
+}
+.vxe-switch.is--on .vxe-switch--icon {
+  left: 100%;
+  transform: translateX(-1.4em);
+}
+.vxe-switch.is--off .vxe-switch--button {
+  padding-left: 1.7em;
+  background-color: var(--vxe-ui-switch-close-background-color);
+}
+.vxe-switch.is--off .vxe-switch--icon {
+  left: 0.2em;
+  transform: translateX(0);
+}
+.vxe-switch.is--on .vxe-switch--label-off, .vxe-switch.is--off .vxe-switch--label-on {
+  height: 0;
+  visibility: hidden;
+  overflow: hidden;
+}
+.vxe-switch.is--on .vxe-switch--label, .vxe-switch.is--off .vxe-switch--label {
+  opacity: 1;
+}
+.vxe-switch:not(.is--disabled) .vxe-switch--button {
+  cursor: pointer;
+}
+.vxe-switch:not(.is--disabled) .vxe-switch--button:focus {
+  box-shadow: 0 0 0.4em 0 var(--vxe-primary-color);
+}
+.vxe-switch.is--disabled .vxe-switch--button {
+  cursor: no-drop;
+}
+.vxe-switch.is--disabled.is--on .vxe-switch--button {
+  background-color: var(--vxe-primary-lighten-color);
+}
+.vxe-switch.is--disabled.is--off .vxe-switch--button {
+  background-color: var(--vxe-ui-switch-disabled-background-color);
+}
+.vxe-switch .vxe-switch--button {
+  display: block;
+  position: relative;
+  height: 1.6em;
+  line-height: 1;
+  min-width: 3.2em;
+  padding: 0 0.6em;
+  border-radius: 1em;
+  border: 0;
+  outline: 0;
+}
+.vxe-switch .vxe-switch--label {
+  opacity: 0;
+  display: block;
+  color: var(--vxe-ui-switch-font-color);
+  font-size: 0.8em;
+}
+.vxe-switch .vxe-switch--icon {
+  position: absolute;
+  top: 0.2em;
+  left: 0;
+  width: 1.2em;
+  height: 1.2em;
+  border-radius: 50%;
+  background-color: var(--vxe-ui-switch-icon-background-color);
+}
+.vxe-switch .vxe-switch--label-icon {
+  margin-right: 0.25em;
+}
+
+.vxe-switch {
+  font-size: var(--vxe-font-size);
+}
+.vxe-switch.size--medium {
+  font-size: var(--vxe-font-size-medium);
+}
+.vxe-switch.size--small {
+  font-size: var(--vxe-font-size-small);
+}
+.vxe-switch.size--mini {
+  font-size: var(--vxe-font-size-mini);
+}

package/es/switch/style.min.css

@@ -0,0 +1 @@
+.vxe-switch{display:inline-block;color:var(--vxe-font-color);vertical-align:middle;padding:.4em;-webkit-user-select:none;-moz-user-select:none;user-select:none;text-align:center}.vxe-switch.is--animat .vxe-switch--button{transition:border-color .3s,background-color .3s}.vxe-switch.is--animat .vxe-switch--icon{transition:all .3s}.vxe-switch.is--on .vxe-switch--button{padding-right:1.7em;background-color:var(--vxe-ui-switch-open-background-color)}.vxe-switch.is--on .vxe-switch--icon{left:100%;transform:translateX(-1.4em)}.vxe-switch.is--off .vxe-switch--button{padding-left:1.7em;background-color:var(--vxe-ui-switch-close-background-color)}.vxe-switch.is--off .vxe-switch--icon{left:.2em;transform:translateX(0)}.vxe-switch.is--off .vxe-switch--label-on,.vxe-switch.is--on .vxe-switch--label-off{height:0;visibility:hidden;overflow:hidden}.vxe-switch.is--off .vxe-switch--label,.vxe-switch.is--on .vxe-switch--label{opacity:1}.vxe-switch:not(.is--disabled) .vxe-switch--button{cursor:pointer}.vxe-switch:not(.is--disabled) .vxe-switch--button:focus{box-shadow:0 0 .4em 0 var(--vxe-primary-color)}.vxe-switch.is--disabled .vxe-switch--button{cursor:no-drop}.vxe-switch.is--disabled.is--on .vxe-switch--button{background-color:var(--vxe-primary-lighten-color)}.vxe-switch.is--disabled.is--off .vxe-switch--button{background-color:var(--vxe-ui-switch-disabled-background-color)}.vxe-switch .vxe-switch--button{display:block;position:relative;height:1.6em;line-height:1;min-width:3.2em;padding:0 .6em;border-radius:1em;border:0;outline:0}.vxe-switch .vxe-switch--label{opacity:0;display:block;color:var(--vxe-ui-switch-font-color);font-size:.8em}.vxe-switch .vxe-switch--icon{position:absolute;top:.2em;left:0;width:1.2em;height:1.2em;border-radius:50%;background-color:var(--vxe-ui-switch-icon-background-color)}.vxe-switch .vxe-switch--label-icon{margin-right:.25em}.vxe-switch{font-size:var(--vxe-font-size)}.vxe-switch.size--medium{font-size:var(--vxe-font-size-medium)}.vxe-switch.size--small{font-size:var(--vxe-font-size-small)}.vxe-switch.size--mini{font-size:var(--vxe-font-size-mini)}

package/es/textarea/index.js

@@ -0,0 +1,10 @@
+import VxeTextareaComponent from './src/textarea';
+import { dynamicApp } from '../dynamics';
+export const VxeTextarea = Object.assign(VxeTextareaComponent, {
+    install: function (app) {
+        app.component(VxeTextareaComponent.name, VxeTextareaComponent);
+    }
+});
+export const Textarea = VxeTextarea;
+dynamicApp.component(VxeTextareaComponent.name, VxeTextareaComponent);
+export default VxeTextarea;

package/es/textarea/src/textarea.js

@@ -0,0 +1,245 @@
+import { defineComponent, h, ref, computed, nextTick, watch, reactive, inject } from 'vue';
+import XEUtils from 'xe-utils';
+import globalConfigStore from '../../ui/src/globalStore';
+import { getFuncText } from '../../ui/src/utils';
+import { getI18n } from '../../ui/src/i18n';
+import { useSize } from '../../hooks/size';
+let autoTxtElem;
+export default defineComponent({
+    name: 'VxeTextarea',
+    props: {
+        modelValue: [String, Number],
+        className: String,
+        immediate: { type: Boolean, default: true },
+        name: String,
+        readonly: Boolean,
+        disabled: Boolean,
+        placeholder: {
+            type: String,
+            default: () => XEUtils.eqNull(globalConfigStore.textarea.placeholder) ? getI18n('vxe.base.pleaseInput') : globalConfigStore.textarea.placeholder
+        },
+        maxlength: [String, Number],
+        rows: { type: [String, Number], default: 2 },
+        cols: { type: [String, Number], default: null },
+        showWordCount: Boolean,
+        countMethod: Function,
+        autosize: [Boolean, Object],
+        form: String,
+        resize: { type: String, default: () => globalConfigStore.textarea.resize },
+        size: { type: String, default: () => globalConfigStore.textarea.size || globalConfigStore.size }
+    },
+    emits: [
+        'update:modelValue',
+        'input',
+        'keydown',
+        'keyup',
+        'click',
+        'change',
+        'focus',
+        'blur'
+    ],
+    setup(props, context) {
+        const { emit } = context;
+        const $xeform = inject('$xeForm', null);
+        const $xeformiteminfo = inject('$xeFormItemInfo', null);
+        const xID = XEUtils.uniqueId();
+        const computeSize = useSize(props);
+        const reactData = reactive({
+            inputValue: props.modelValue
+        });
+        const refElem = ref();
+        const refTextarea = ref();
+        const refMaps = {
+            refElem,
+            refTextarea
+        };
+        const $xetextarea = {
+            xID,
+            props,
+            context,
+            reactData,
+            getRefMaps: () => refMaps
+        };
+        let textareaMethods = {};
+        const computeInputCount = computed(() => {
+            return XEUtils.getSize(reactData.inputValue);
+        });
+        const computeIsCountError = computed(() => {
+            const inputCount = computeInputCount.value;
+            return props.maxlength && inputCount > XEUtils.toNumber(props.maxlength);
+        });
+        const computeSizeOpts = computed(() => {
+            return Object.assign({ minRows: 1, maxRows: 10 }, globalConfigStore.textarea.autosize, props.autosize);
+        });
+        const updateAutoTxt = () => {
+            const { size, autosize } = props;
+            const { inputValue } = reactData;
+            if (autosize) {
+                if (!autoTxtElem) {
+                    autoTxtElem = document.createElement('div');
+                }
+                if (!autoTxtElem.parentNode) {
+                    document.body.appendChild(autoTxtElem);
+                }
+                const textElem = refTextarea.value;
+                const textStyle = getComputedStyle(textElem);
+                autoTxtElem.className = ['vxe-textarea--autosize', size ? `size--${size}` : ''].join(' ');
+                autoTxtElem.style.width = `${textElem.clientWidth}px`;
+                autoTxtElem.style.padding = textStyle.padding;
+                autoTxtElem.innerText = ('' + (inputValue || '　')).replace(/\n$/, '\n　');
+            }
+        };
+        const handleResize = () => {
+            if (props.autosize) {
+                nextTick(() => {
+                    const sizeOpts = computeSizeOpts.value;
+                    const { minRows, maxRows } = sizeOpts;
+                    const textElem = refTextarea.value;
+                    const sizeHeight = autoTxtElem.clientHeight;
+                    const textStyle = getComputedStyle(textElem);
+                    const lineHeight = XEUtils.toNumber(textStyle.lineHeight);
+                    const paddingTop = XEUtils.toNumber(textStyle.paddingTop);
+                    const paddingBottom = XEUtils.toNumber(textStyle.paddingBottom);
+                    const borderTopWidth = XEUtils.toNumber(textStyle.borderTopWidth);
+                    const borderBottomWidth = XEUtils.toNumber(textStyle.borderBottomWidth);
+                    const intervalHeight = paddingTop + paddingBottom + borderTopWidth + borderBottomWidth;
+                    const rowNum = (sizeHeight - intervalHeight) / lineHeight;
+                    const textRows = rowNum && /[0-9]/.test('' + rowNum) ? rowNum : Math.floor(rowNum) + 1;
+                    let vaildRows = textRows;
+                    if (textRows < minRows) {
+                        vaildRows = minRows;
+                    }
+                    else if (textRows > maxRows) {
+                        vaildRows = maxRows;
+                    }
+                    textElem.style.height = `${(vaildRows * lineHeight) + intervalHeight}px`;
+                });
+            }
+        };
+        const triggerEvent = (evnt) => {
+            const value = reactData.inputValue;
+            $xetextarea.dispatchEvent(evnt.type, { value }, evnt);
+        };
+        const emitUpdate = (value, evnt) => {
+            reactData.inputValue = value;
+            emit('update:modelValue', value);
+            if (XEUtils.toValueString(props.modelValue) !== value) {
+                textareaMethods.dispatchEvent('change', { value }, evnt);
+                // 自动更新校验状态
+                if ($xeform && $xeformiteminfo) {
+                    $xeform.triggerItemEvent(evnt, $xeformiteminfo.itemConfig.field, value);
+                }
+            }
+        };
+        const inputEvent = (evnt) => {
+            const { immediate } = props;
+            const textElem = evnt.target;
+            const value = textElem.value;
+            reactData.inputValue = value;
+            if (immediate) {
+                emitUpdate(value, evnt);
+            }
+            $xetextarea.dispatchEvent('input', { value }, evnt);
+            handleResize();
+        };
+        const changeEvent = (evnt) => {
+            const { immediate } = props;
+            if (immediate) {
+                triggerEvent(evnt);
+            }
+            else {
+                emitUpdate(reactData.inputValue, evnt);
+            }
+        };
+        const blurEvent = (evnt) => {
+            const { immediate } = props;
+            const { inputValue } = reactData;
+            if (!immediate) {
+                emitUpdate(inputValue, evnt);
+            }
+            $xetextarea.dispatchEvent('blur', { value: inputValue }, evnt);
+        };
+        textareaMethods = {
+            dispatchEvent(type, params, evnt) {
+                emit(type, Object.assign({ $textarea: $xetextarea, $event: evnt }, params));
+            },
+            focus() {
+                const textElem = refTextarea.value;
+                textElem.focus();
+                return nextTick();
+            },
+            blur() {
+                const textElem = refTextarea.value;
+                textElem.blur();
+                return nextTick();
+            }
+        };
+        Object.assign($xetextarea, textareaMethods);
+        watch(() => props.modelValue, (val) => {
+            reactData.inputValue = val;
+            updateAutoTxt();
+        });
+        nextTick(() => {
+            const { autosize } = props;
+            if (autosize) {
+                updateAutoTxt();
+                handleResize();
+            }
+        });
+        const renderVN = () => {
+            const { className, resize, placeholder, disabled, maxlength, autosize, showWordCount, countMethod, rows, cols } = props;
+            const { inputValue } = reactData;
+            const vSize = computeSize.value;
+            const isCountError = computeIsCountError.value;
+            const inputCount = computeInputCount.value;
+            return h('div', {
+                ref: refElem,
+                class: ['vxe-textarea', className, {
+                        [`size--${vSize}`]: vSize,
+                        'is--autosize': autosize,
+                        'is--count': showWordCount,
+                        'is--disabled': disabled,
+                        'def--rows': !XEUtils.eqNull(rows),
+                        'def--cols': !XEUtils.eqNull(cols)
+                    }]
+            }, [
+                h('textarea', {
+                    ref: refTextarea,
+                    class: 'vxe-textarea--inner',
+                    value: inputValue,
+                    name: props.name,
+                    placeholder: placeholder ? getFuncText(placeholder) : null,
+                    maxlength,
+                    readonly: props.readonly,
+                    disabled,
+                    rows,
+                    cols,
+                    style: resize
+                        ? {
+                            resize
+                        }
+                        : null,
+                    onInput: inputEvent,
+                    onChange: changeEvent,
+                    onKeydown: triggerEvent,
+                    onKeyup: triggerEvent,
+                    onClick: triggerEvent,
+                    onFocus: triggerEvent,
+                    onBlur: blurEvent
+                }),
+                showWordCount
+                    ? h('span', {
+                        class: ['vxe-textarea--count', {
+                                'is--error': isCountError
+                            }]
+                    }, countMethod ? `${countMethod({ value: inputValue })}` : `${inputCount}${maxlength ? `/${maxlength}` : ''}`)
+                    : null
+            ]);
+        };
+        $xetextarea.renderVN = renderVN;
+        return $xetextarea;
+    },
+    render() {
+        return this.renderVN();
+    }
+});

package/es/textarea/style.css

@@ -0,0 +1,102 @@
+.vxe-textarea {
+  position: relative;
+  display: inline-block;
+}
+.vxe-textarea:not(.def--cols) {
+  width: 100%;
+}
+.vxe-textarea:not(.def--cols) .vxe-textarea--inner {
+  width: 100%;
+}
+
+.vxe-textarea--inner {
+  border-radius: var(--vxe-border-radius);
+  outline: 0;
+  font-size: inherit;
+  padding: 0 0.6em;
+  color: var(--vxe-font-color);
+  line-height: inherit;
+  border: 1px solid var(--vxe-ui-input-border-color);
+  background-color: var(--vxe-ui-textarea-background-color);
+  display: block;
+  padding: 0.3em 0.6em;
+}
+.vxe-textarea--inner::-moz-placeholder {
+  color: var(--vxe-ui-input-placeholder-color);
+}
+.vxe-textarea--inner::placeholder {
+  color: var(--vxe-ui-input-placeholder-color);
+}
+.vxe-textarea--inner:focus {
+  border: 1px solid var(--vxe-primary-color);
+}
+.vxe-textarea--inner[disabled] {
+  cursor: not-allowed;
+  background-color: var(--vxe-ui-input-disabled-background-color);
+}
+
+.vxe-textarea--inner,
+.vxe-textarea--autosize {
+  line-height: var(--vxe-ui-textarea-line-height);
+  color: var(--vxe-font-color);
+  font-family: var(--vxe-font-family);
+}
+
+.vxe-textarea--autosize {
+  display: block;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  margin: 0;
+  padding: 0.3em 0.6em;
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  z-index: -1;
+  visibility: hidden;
+}
+
+.vxe-textarea--count {
+  position: absolute;
+  bottom: 0.2em;
+  right: 1.4em;
+  padding-left: 0.2em;
+  color: var(--vxe-ui-input-count-color);
+  background-color: var(--vxe-ui-input-count-background-color);
+}
+.vxe-textarea--count.is--error {
+  color: var(--vxe-ui-input-count-error-color);
+}
+
+.vxe-textarea,
+.vxe-textarea--autosize {
+  font-size: var(--vxe-font-size);
+}
+.vxe-textarea.size--medium,
+.vxe-textarea--autosize.size--medium {
+  font-size: var(--vxe-font-size-medium);
+}
+.vxe-textarea.size--small,
+.vxe-textarea--autosize.size--small {
+  font-size: var(--vxe-font-size-small);
+}
+.vxe-textarea.size--mini,
+.vxe-textarea--autosize.size--mini {
+  font-size: var(--vxe-font-size-mini);
+}
+
+.vxe-textarea:not(.is--autosize) {
+  min-height: var(--vxe-ui-input-height-default);
+}
+.vxe-textarea.size--medium {
+  font-size: var(--vxe-font-size-medium);
+}
+.vxe-textarea.size--medium:not(.is--autosize) {
+  min-height: var(--vxe-ui-input-height-medium);
+}
+.vxe-textarea.size--small:not(.is--autosize) {
+  min-height: var(--vxe-ui-input-height-small);
+}
+.vxe-textarea.size--mini:not(.is--autosize) {
+  min-height: var(--vxe-ui-input-height-mini);
+}

package/es/textarea/style.min.css

@@ -0,0 +1 @@
+.vxe-textarea{position:relative;display:inline-block}.vxe-textarea:not(.def--cols){width:100%}.vxe-textarea:not(.def--cols) .vxe-textarea--inner{width:100%}.vxe-textarea--inner{border-radius:var(--vxe-border-radius);outline:0;font-size:inherit;padding:0 .6em;color:var(--vxe-font-color);line-height:inherit;border:1px solid var(--vxe-ui-input-border-color);background-color:var(--vxe-ui-textarea-background-color);display:block;padding:.3em .6em}.vxe-textarea--inner::-moz-placeholder{color:var(--vxe-ui-input-placeholder-color)}.vxe-textarea--inner::placeholder{color:var(--vxe-ui-input-placeholder-color)}.vxe-textarea--inner:focus{border:1px solid var(--vxe-primary-color)}.vxe-textarea--inner[disabled]{cursor:not-allowed;background-color:var(--vxe-ui-input-disabled-background-color)}.vxe-textarea--autosize,.vxe-textarea--inner{line-height:var(--vxe-ui-textarea-line-height);color:var(--vxe-font-color);font-family:var(--vxe-font-family)}.vxe-textarea--autosize{display:block;position:fixed;top:0;left:0;width:100%;margin:0;padding:.3em .6em;word-wrap:break-word;white-space:pre-wrap;z-index:-1;visibility:hidden}.vxe-textarea--count{position:absolute;bottom:.2em;right:1.4em;padding-left:.2em;color:var(--vxe-ui-input-count-color);background-color:var(--vxe-ui-input-count-background-color)}.vxe-textarea--count.is--error{color:var(--vxe-ui-input-count-error-color)}.vxe-textarea,.vxe-textarea--autosize{font-size:var(--vxe-font-size)}.vxe-textarea--autosize.size--medium,.vxe-textarea.size--medium{font-size:var(--vxe-font-size-medium)}.vxe-textarea--autosize.size--small,.vxe-textarea.size--small{font-size:var(--vxe-font-size-small)}.vxe-textarea--autosize.size--mini,.vxe-textarea.size--mini{font-size:var(--vxe-font-size-mini)}.vxe-textarea:not(.is--autosize){min-height:var(--vxe-ui-input-height-default)}.vxe-textarea.size--medium{font-size:var(--vxe-font-size-medium)}.vxe-textarea.size--medium:not(.is--autosize){min-height:var(--vxe-ui-input-height-medium)}.vxe-textarea.size--small:not(.is--autosize){min-height:var(--vxe-ui-input-height-small)}.vxe-textarea.size--mini:not(.is--autosize){min-height:var(--vxe-ui-input-height-mini)}

package/es/tooltip/index.js

@@ -0,0 +1,8 @@
+import VxeTooltipComponent from './src/tooltip';
+const VxeTooltip = Object.assign({}, VxeTooltipComponent, {
+    install(app) {
+        app.component(VxeTooltipComponent.name, VxeTooltipComponent);
+    }
+});
+export const Tooltip = VxeTooltip;
+export default VxeTooltip;