yc-design-vue 1.0.1

package/lib/Tabs/index.d.ts

@@ -0,0 +1,111 @@
+import { App } from 'vue';
+import { default as _Tabs } from './Tabs.vue';
+import { default as _TabPane } from './TabPane.vue';
+export type TabsInstance = InstanceType<typeof _Tabs>;
+export type TabPaneInstance = InstanceType<typeof _TabPane>;
+export * from './type';
+declare const Tabs: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').TabsProps> & Readonly<{
+        onChange?: ((value: import('./type').TabKey) => any) | undefined;
+        onDelete?: ((value: import('./type').TabKey) => any) | undefined;
+        onAdd?: (() => any) | undefined;
+        "onUpdate:activeKey"?: ((value: import('./type').TabKey) => any) | undefined;
+        "onTab-click"?: ((value: import('./type').TabKey) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').TabKey) => any;
+        delete: (value: import('./type').TabKey) => any;
+        add: () => any;
+        "update:activeKey": (value: import('./type').TabKey) => any;
+        "tab-click": (value: import('./type').TabKey) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').Size;
+        trigger: import('./type').TabTrigger;
+        position: import('./type').TabPositon;
+        justify: boolean;
+        type: import('./type').TabType;
+        animation: boolean;
+        direction: import('..').Direction;
+        activeKey: import('./type').TabKey;
+        defaultActiveKey: import('./type').TabKey;
+        editable: boolean;
+        autoSwitch: boolean;
+        headerPadding: boolean;
+        destoryOnHide: boolean;
+        showAddButton: boolean;
+        hideContent: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        listRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').TabsProps> & Readonly<{
+        onChange?: ((value: import('./type').TabKey) => any) | undefined;
+        onDelete?: ((value: import('./type').TabKey) => any) | undefined;
+        onAdd?: (() => any) | undefined;
+        "onUpdate:activeKey"?: ((value: import('./type').TabKey) => any) | undefined;
+        "onTab-click"?: ((value: import('./type').TabKey) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('..').Size;
+        trigger: import('./type').TabTrigger;
+        position: import('./type').TabPositon;
+        justify: boolean;
+        type: import('./type').TabType;
+        animation: boolean;
+        direction: import('..').Direction;
+        activeKey: import('./type').TabKey;
+        defaultActiveKey: import('./type').TabKey;
+        editable: boolean;
+        autoSwitch: boolean;
+        headerPadding: boolean;
+        destoryOnHide: boolean;
+        showAddButton: boolean;
+        hideContent: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').TabsProps> & Readonly<{
+    onChange?: ((value: import('./type').TabKey) => any) | undefined;
+    onDelete?: ((value: import('./type').TabKey) => any) | undefined;
+    onAdd?: (() => any) | undefined;
+    "onUpdate:activeKey"?: ((value: import('./type').TabKey) => any) | undefined;
+    "onTab-click"?: ((value: import('./type').TabKey) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').TabKey) => any;
+    delete: (value: import('./type').TabKey) => any;
+    add: () => any;
+    "update:activeKey": (value: import('./type').TabKey) => any;
+    "tab-click": (value: import('./type').TabKey) => any;
+}, string, {
+    size: import('..').Size;
+    trigger: import('./type').TabTrigger;
+    position: import('./type').TabPositon;
+    justify: boolean;
+    type: import('./type').TabType;
+    animation: boolean;
+    direction: import('..').Direction;
+    activeKey: import('./type').TabKey;
+    defaultActiveKey: import('./type').TabKey;
+    editable: boolean;
+    autoSwitch: boolean;
+    headerPadding: boolean;
+    destoryOnHide: boolean;
+    showAddButton: boolean;
+    hideContent: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').TabsSlots> & import('./type').TabsSlots;
+}) & {
+    install: (app: App) => void;
+};
+export { _TabPane as TabPane };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcTabs: typeof Tabs;
+        YcTabPane: typeof _TabPane;
+    }
+}
+export default Tabs;

package/lib/Tabs/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./Tabs.vue.js"),s=require("./TabPane.vue.js");;/* empty css              */const t=Object.assign(e,{install:t=>{t.component("Yc"+e.name,e),t.component("Yc"+s.name,s)}});exports.TabPane=s,exports.default=t;

package/lib/Tabs/type.d.ts

@@ -0,0 +1,44 @@
+import { Direction, Size } from '../_shared/type';
+export interface TabsProps {
+    activeKey?: TabKey;
+    defaultActiveKey?: TabKey;
+    position?: TabPositon;
+    size?: Size;
+    type?: TabType;
+    direction?: Direction;
+    editable?: boolean;
+    showAddButton?: boolean;
+    destoryOnHide?: boolean;
+    justify?: boolean;
+    animation?: boolean;
+    headerPadding?: boolean;
+    autoSwitch?: boolean;
+    hideContent?: boolean;
+    trigger?: TabTrigger;
+}
+export interface TabsEmits {
+    (e: 'update:activeKey', value: TabKey): void;
+    (e: 'change', value: TabKey): void;
+    (e: 'tab-click', value: TabKey): void;
+    (e: 'add'): void;
+    (e: 'delete', value: TabKey): void;
+}
+export interface TabsSlots {
+    extra(): void;
+    default(): void;
+}
+export interface TabPaneProps {
+    title?: string;
+    path?: TabKey;
+    disabled?: boolean;
+    closable?: boolean;
+    destoryOnHide?: boolean;
+}
+export interface TabPaneSlots {
+    default(): void;
+    title(): void;
+}
+export type TabKey = string | number;
+export type TabType = 'line' | 'card' | 'card-gutter' | 'text' | 'rounded' | 'capsule';
+export type TabPositon = 'left' | 'right' | 'bottom' | 'top';
+export type TabTrigger = 'click' | 'hover';

package/lib/Tag/index.d.ts

@@ -0,0 +1,88 @@
+import { App } from 'vue';
+import { default as _Tag } from './index.vue';
+export type TagInstance = InstanceType<typeof _Tag>;
+export * from './type';
+declare const Tag: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').TagProps> & Readonly<{
+        onClose?: ((ev: MouseEvent, value?: string | undefined) => any) | undefined;
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+        "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+        onCheck?: ((value: boolean, ev: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: (ev: MouseEvent, value?: string | undefined) => any;
+        "update:visible": (value: boolean) => any;
+        "update:checked": (value: boolean) => any;
+        check: (value: boolean, ev: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        size: import('./type').TagSize;
+        loading: boolean;
+        visible: boolean;
+        color: string;
+        nowrap: boolean;
+        bordered: boolean;
+        defaultVisible: boolean;
+        closable: boolean;
+        checkable: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').TagProps> & Readonly<{
+        onClose?: ((ev: MouseEvent, value?: string | undefined) => any) | undefined;
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+        "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+        onCheck?: ((value: boolean, ev: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('./type').TagSize;
+        loading: boolean;
+        visible: boolean;
+        color: string;
+        nowrap: boolean;
+        bordered: boolean;
+        defaultVisible: boolean;
+        closable: boolean;
+        checkable: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').TagProps> & Readonly<{
+    onClose?: ((ev: MouseEvent, value?: string | undefined) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+    onCheck?: ((value: boolean, ev: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: (ev: MouseEvent, value?: string | undefined) => any;
+    "update:visible": (value: boolean) => any;
+    "update:checked": (value: boolean) => any;
+    check: (value: boolean, ev: MouseEvent) => any;
+}, string, {
+    size: import('./type').TagSize;
+    loading: boolean;
+    visible: boolean;
+    color: string;
+    nowrap: boolean;
+    bordered: boolean;
+    defaultVisible: boolean;
+    closable: boolean;
+    checkable: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').TagSlots> & import('./type').TagSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcTag: typeof Tag;
+    }
+}
+export default Tag;

package/lib/Tag/index.js

@@ -0,0 +1 @@
+"use strict";const e=require("./index.vue.js"),s=Object.assign(e,{install:s=>{s.component("Yc"+e.name,e)}});module.exports=s;

package/lib/Tag/index.vue.d.ts

@@ -0,0 +1,38 @@
+import { TagProps, TagSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TagSlots> & TagSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TagProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: (ev: MouseEvent, value?: string | undefined) => any;
+    "update:visible": (value: boolean) => any;
+    "update:checked": (value: boolean) => any;
+    check: (value: boolean, ev: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<TagProps> & Readonly<{
+    onClose?: ((ev: MouseEvent, value?: string | undefined) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+    onCheck?: ((value: boolean, ev: MouseEvent) => any) | undefined;
+}>, {
+    size: import('./type').TagSize;
+    loading: boolean;
+    visible: boolean;
+    color: string;
+    nowrap: boolean;
+    bordered: boolean;
+    defaultVisible: boolean;
+    closable: boolean;
+    checkable: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/Tag/index.vue.js

@@ -0,0 +1 @@
+"use strict";const e=;/* empty css            */;/* empty css            */const r=require("../_virtual/_plugin-vue_export-helper.js")(e,[["__scopeId","data-v-1f61a919"]]);module.exports=r;

package/lib/Tag/index.vue2.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),o=require("../_shared/constants/index.js");require("../node_modules/tinycolor2/esm/tinycolor.js"),require("../_shared/utils/dom.js"),require("../_shared/utils/time.js");const l=require("../_shared/utils/global-config.js"),a=require("../_shared/utils/control.js"),t=require("../Spin/index.js"),c=require("../_shared/components/IconButton.vue.js");;/* empty css                                          */const n={key:0,class:"yc-tag-icon"},s={class:"yc-tag-label"},r=e.defineComponent({name:"Tag",__name:"index",props:{color:{default:"default"},size:{default:void 0},bordered:{type:Boolean,default:!1},visible:{type:Boolean,default:void 0},defaultVisible:{type:Boolean,default:!0},loading:{type:Boolean,default:!1},closable:{type:Boolean,default:!1},checkable:{type:Boolean,default:!1},checked:{type:Boolean,default:void 0},defaultChecked:{type:Boolean,default:!0},nowrap:{type:Boolean,default:!1}},emits:["update:visible","update:checked","close","check"],setup(r,{emit:d}){const i=r,u=d,{visible:m,defaultVisible:p,checked:y,defaultChecked:f,checkable:k,color:g}=e.toRefs(i),{size:v}=l.getGlobalConfig(i),h=a(m,p.value,e=>u("update:visible",e)),b=a(y,f.value,e=>u("update:checked",e)),B=e.computed(()=>o.TAG_PRESET_COLORS.includes(g.value)?"":g.value),C=(e,o)=>{"close"==e?(h.value=!1,u("close",o)):"check"==e&&k.value&&(b.value=!b.value,u("check",b.value,o))};return(l,a)=>e.unref(h)?(e.openBlock(),e.createElementBlock("label",{key:0,class:e.normalizeClass(["yc-tag",`yc-tag-color-${e.unref(g)}`,`yc-tag-size-${["small","medium","large"].includes(e.unref(v))?e.unref(v):"medium"}`,e.unref(o.TAG_PRESET_COLORS).includes(e.unref(g))?"yc-tag-preset-color":"yc-tag-custom-color",l.nowrap?"yc-tag-no-wrap":"yc-tag-wrap",{"yc-tag-loading":l.loading,"yc-tag-bordered":l.bordered,"yc-tag-checked":e.unref(b),"yc-tag-checkable":e.unref(k)}]),style:e.normalizeStyle({background:B.value}),onClick:a[1]||(a[1]=e=>C("check",e))},[l.$slots.icon?(e.openBlock(),e.createElementBlock("div",n,[e.renderSlot(l.$slots,"icon",{},void 0,!0)])):e.createCommentVNode("",!0),e.createElementVNode("span",s,[e.renderSlot(l.$slots,"default",{},void 0,!0)]),l.closable?(e.openBlock(),e.createBlock(e.unref(c),{key:1,"hover-size":16,"hover-color":"rgba(255, 255, 255, 0.2)",class:"yc-tag-close-button",onClick:a[0]||(a[0]=e=>C("close",e))},{default:e.withCtx(()=>[l.$slots["close-icon"]?e.renderSlot(l.$slots,"close-icon",{key:0},void 0,!0):e.createCommentVNode("",!0)]),_:3})):e.createCommentVNode("",!0),l.loading?(e.openBlock(),e.createBlock(e.unref(t),{key:2,size:12,class:"yc-tag-loading-icon"})):e.createCommentVNode("",!0)],6)):e.createCommentVNode("",!0)}});module.exports=r;

package/lib/Tag/type.d.ts

@@ -0,0 +1,25 @@
+export interface TagProps {
+    color?: string;
+    size?: TagSize;
+    bordered?: boolean;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    loading?: boolean;
+    closable?: boolean;
+    checkable?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    nowrap?: boolean;
+}
+export interface TagEmits {
+    (e: 'update:visible', value: boolean): void;
+    (e: 'update:checked', value: boolean): void;
+    (e: 'close', ev: MouseEvent, value?: string): void;
+    (e: 'check', value: boolean, ev: MouseEvent): void;
+}
+export interface TagSlots {
+    default(): void;
+    icon(): void;
+    ['close-icon'](): void;
+}
+export type TagSize = 'small' | 'medium' | 'large';

package/lib/Textarea/hooks/useTextareaHeight.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { AutoSize } from '../type';
+declare const _default: (mirrorRef: Ref<HTMLDivElement | undefined>, autoSize: AutoSize) => {
+    style?: undefined;
+} | {
+    style: import('vue').ComputedRef<{
+        minHeight: string;
+        height: string;
+    }>;
+};
+export default _default;

package/lib/Textarea/hooks/useTextareaHeight.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),r=require("../../node_modules/@vueuse/core/index.js");require("../../node_modules/tinycolor2/esm/tinycolor.js"),require("../../_shared/utils/dom.js");const s=require("../../_shared/utils/fn.js");require("../../_shared/utils/time.js"),require("../../Empty/index.js");/* empty css                              */module.exports=(o,u)=>{if(!u)return{};const{height:i}=r.useElementSize(o,void 0,{box:"border-box"}),t=e=>14*e*1.5715+8;return{style:e.computed(()=>{const{minRows:e=1,maxRows:r=1e4}=u,o=e<=1?1:e,n=t(e),d=t(r<=o?o:r);let l=i.value;return l=l<n?n:l,l=l>d?d:l,{minHeight:s.valueToPx(n),height:s.valueToPx(l)}})}};

package/lib/Textarea/index.d.ts

@@ -0,0 +1,128 @@
+import { App } from 'vue';
+import { default as _Textarea } from './index.vue';
+export type TextareaInstance = InstanceType<typeof _Textarea>;
+export * from './type';
+declare const Textarea: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').TextareaProps> & Readonly<{
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        getInputRef(): HTMLTextAreaElement;
+        getMirrorRef(): HTMLDivElement;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: string, ev: Event) => any;
+        focus: (ev: FocusEvent) => any;
+        clear: (ev: MouseEvent) => any;
+        blur: (ev: FocusEvent) => any;
+        input: (value: string, ev: Event) => any;
+        keydown: (ev: KeyboardEvent) => any;
+        "update:modelValue": (value: string) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        error: import('./type').AutoSize;
+        placeholder: string;
+        modelValue: string;
+        defaultValue: string;
+        maxLength: import('..').MaxLength;
+        showWordLimit: boolean;
+        allowClear: boolean;
+        readonly: boolean;
+        autoSize: import('./type').AutoSize;
+        wordLength: import('..').WordLength;
+        wordSlice: import('..').WordSlice;
+        enterPrevent: boolean;
+        showMirror: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        mirrorRef: HTMLDivElement;
+        inputRef: HTMLTextAreaElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').TextareaProps> & Readonly<{
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+        getInputRef(): HTMLTextAreaElement;
+        getMirrorRef(): HTMLDivElement;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        error: import('./type').AutoSize;
+        placeholder: string;
+        modelValue: string;
+        defaultValue: string;
+        maxLength: import('..').MaxLength;
+        showWordLimit: boolean;
+        allowClear: boolean;
+        readonly: boolean;
+        autoSize: import('./type').AutoSize;
+        wordLength: import('..').WordLength;
+        wordSlice: import('..').WordSlice;
+        enterPrevent: boolean;
+        showMirror: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').TextareaProps> & Readonly<{
+    onChange?: ((value: string, ev: Event) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onClear?: ((ev: MouseEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onInput?: ((value: string, ev: Event) => any) | undefined;
+    onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    focus(): void;
+    blur(): void;
+    getInputRef(): HTMLTextAreaElement;
+    getMirrorRef(): HTMLDivElement;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: string, ev: Event) => any;
+    focus: (ev: FocusEvent) => any;
+    clear: (ev: MouseEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    input: (value: string, ev: Event) => any;
+    keydown: (ev: KeyboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, {
+    disabled: boolean;
+    error: import('./type').AutoSize;
+    placeholder: string;
+    modelValue: string;
+    defaultValue: string;
+    maxLength: import('..').MaxLength;
+    showWordLimit: boolean;
+    allowClear: boolean;
+    readonly: boolean;
+    autoSize: import('./type').AutoSize;
+    wordLength: import('..').WordLength;
+    wordSlice: import('..').WordSlice;
+    enterPrevent: boolean;
+    showMirror: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcTextarea: typeof Textarea;
+    }
+}
+export default Textarea;

package/lib/Textarea/index.js

@@ -0,0 +1 @@
+"use strict";const e=require("./index.vue.js"),s=Object.assign(e,{install:s=>{s.component("Yc"+e.name,e)}});module.exports=s;

package/lib/Textarea/index.vue.d.ts

@@ -0,0 +1,42 @@
+import { TextareaProps } from './type';
+declare const _default: import('vue').DefineComponent<TextareaProps, {
+    focus(): void;
+    blur(): void;
+    getInputRef(): HTMLTextAreaElement;
+    getMirrorRef(): HTMLDivElement;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: string, ev: Event) => any;
+    focus: (ev: FocusEvent) => any;
+    clear: (ev: MouseEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    input: (value: string, ev: Event) => any;
+    keydown: (ev: KeyboardEvent) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<TextareaProps> & Readonly<{
+    onChange?: ((value: string, ev: Event) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onClear?: ((ev: MouseEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onInput?: ((value: string, ev: Event) => any) | undefined;
+    onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    error: import('./type').AutoSize;
+    placeholder: string;
+    modelValue: string;
+    defaultValue: string;
+    maxLength: import('..').MaxLength;
+    showWordLimit: boolean;
+    allowClear: boolean;
+    readonly: boolean;
+    autoSize: import('./type').AutoSize;
+    wordLength: import('..').WordLength;
+    wordSlice: import('..').WordSlice;
+    enterPrevent: boolean;
+    showMirror: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    mirrorRef: HTMLDivElement;
+    inputRef: HTMLTextAreaElement;
+}, HTMLDivElement>;
+export default _default;

package/lib/Textarea/index.vue.js

@@ -0,0 +1 @@
+"use strict";const e=;/* empty css            */;/* empty css            */const r=require("../_virtual/_plugin-vue_export-helper.js")(e,[["__scopeId","data-v-410cecd1"]]);module.exports=r;

package/lib/Textarea/index.vue2.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),r=require("./hooks/useTextareaHeight.js"),t=require("../Input/hooks/useLimitedInput.js"),o=require("../_shared/components/IconButton.vue.js"),a=require("../_shared/components/PreventFocus.vue.js");require("../node_modules/tinycolor2/esm/tinycolor.js"),require("../_shared/utils/dom.js"),require("../_shared/utils/time.js"),require("../Empty/index.js"),/* empty css                           */;/* empty css                                          */const n=["value","disabled","readonly","placeholder"],l=e.defineComponent({name:"Textarea",__name:"index",props:{modelValue:{default:void 0},defaultValue:{default:""},placeholder:{default:""},disabled:{type:Boolean,default:!1},error:{type:[Boolean,Object],default:void 0},maxLength:{default:void 0},showWordLimit:{type:Boolean,default:!1},allowClear:{type:Boolean,default:!1},readonly:{type:Boolean,default:!1},autoSize:{type:[Boolean,Object],default:!1},wordLength:{type:Function,default:e=>e.length},wordSlice:{type:Function,default:(e,r)=>e.slice(0,r)},enterPrevent:{type:Boolean,default:!1},showMirror:{type:Boolean,default:!1}},emits:["update:modelValue","input","change","clear","focus","blur","keydown"],setup(l,{expose:u,emit:s}){const i=l,c=s,{autoSize:d}=e.toRefs(i),p=e.ref(),f=e.ref(),{error:m,computedValue:y,showWordLimit:h,showClearBtn:v,curLength:k,maxLength:x,handleInput:B,handleComposition:b}=t({props:i,emits:c,inputRef:p}),{style:g}=r(f,d.value),w=async(e,r)=>{switch(e){case"input":B(r);break;case"change":c("change",y.value,r);break;case"focus":case"blur":c(e,r);break;case"clear":y.value="",c("clear",r)}};return u({getInputRef:()=>p.value,getMirrorRef:()=>f.value,focus(){var e;null==(e=p.value)||e.focus()},blur(){var e;null==(e=p.value)||e.blur()}}),(r,t)=>(e.openBlock(),e.createElementBlock("div",{class:e.normalizeClass(["yc-textarea-wrapper",{"yc-textarea-disabled":r.disabled,"yc-textarea-error":e.unref(m),"yc-textarea-auto-size":e.unref(d)}])},[e.unref(d)||r.showMirror?(e.openBlock(),e.createElementBlock("div",{key:0,class:"yc-textarea-mirror",ref_key:"mirrorRef",ref:f},e.toDisplayString(e.unref(y)),513)):e.createCommentVNode("",!0),e.createElementVNode("textarea",{value:e.unref(y),disabled:r.disabled,readonly:r.readonly,placeholder:r.placeholder,style:e.normalizeStyle(e.unref(g)),class:"yc-textarea",ref_key:"inputRef",ref:p,onCompositionstart:t[0]||(t[0]=(...r)=>e.unref(b)&&e.unref(b)(...r)),onCompositionupdate:t[1]||(t[1]=(...r)=>e.unref(b)&&e.unref(b)(...r)),onCompositionend:t[2]||(t[2]=(...r)=>e.unref(b)&&e.unref(b)(...r)),onKeydown:t[3]||(t[3]=e=>{"Enter"==e.key&&r.enterPrevent&&e.preventDefault(),r.$emit("keydown",e)}),onInput:t[4]||(t[4]=e=>w("input",e)),onChange:t[5]||(t[5]=e=>w("change",e)),onFocus:t[6]||(t[6]=e=>w("focus",e)),onBlur:t[7]||(t[7]=e=>w("blur",e))},null,44,n),e.unref(h)?(e.openBlock(),e.createBlock(e.unref(a),{key:1,tag:"span",class:"yc-textarea-word-limit"},{default:e.withCtx(()=>[e.createTextVNode(e.toDisplayString(e.unref(k))+" / "+e.toDisplayString(e.unref(x)),1)]),_:1})):e.createCommentVNode("",!0),e.unref(v)?(e.openBlock(),e.createBlock(e.unref(o),{key:2,class:"yc-textarea-clear-button",onClick:t[8]||(t[8]=e=>w("clear",e))})):e.createCommentVNode("",!0)],2))}});module.exports=l;

package/lib/Textarea/type.d.ts

@@ -0,0 +1,36 @@
+import { MaxLength, WordLength, WordSlice } from '../Input';
+export interface TextareaProps {
+    modelValue?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: AutoSize;
+    maxLength?: MaxLength;
+    showWordLimit?: boolean;
+    allowClear?: boolean;
+    readonly?: boolean;
+    autoSize?: AutoSize;
+    wordLength?: WordLength;
+    wordSlice?: WordSlice;
+    enterPrevent?: boolean;
+    showMirror?: boolean;
+}
+export interface TextareaEmits {
+    (e: 'update:modelValue', value: string): void;
+    (e: 'input', value: string, ev: Event): void;
+    (e: 'change', value: string, ev: Event): void;
+    (e: 'clear', ev: MouseEvent): void;
+    (e: 'focus', ev: FocusEvent): void;
+    (e: 'blur', ev: FocusEvent): void;
+    (e: 'keydown', ev: KeyboardEvent): void;
+}
+export type TextareaExpose = {
+    focus(): void;
+    blur(): void;
+    getInputRef(): HTMLTextAreaElement;
+    getMirrorRef(): HTMLDivElement;
+};
+export type AutoSize = boolean | {
+    minRows?: number;
+    maxRows?: number;
+};