yc-design-vue 1.0.1

package/lib/InputNumber/InputOperaBtn.vue.d.ts

@@ -0,0 +1,32 @@
+import { InputNumberMode, InputNumberValue } from './type';
+import { Size } from '../_shared/type';
+type __VLS_Props = {
+    mode: InputNumberMode;
+    type: 'minus' | 'plus';
+    disabled: boolean;
+    computedValue: InputNumberValue;
+    min: number;
+    max: number;
+    size?: Size;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        icon?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (type: "minus" | "plus") => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((type: "minus" | "plus") => any) | undefined;
+}>, {}, {}, {}, {}, 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/InputNumber/InputOperaBtn.vue.js

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

package/lib/InputNumber/InputOperaBtn.vue2.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),o=require("../_shared/icons/IconArrowDown.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                           */const r=require("../_shared/icons/IconMinus.vue2.js"),s=require("../_shared/icons/IconPlus.vue.js"),u=require("../Button/index.js"),n=e.defineComponent({__name:"InputOperaBtn",props:{mode:{},type:{},disabled:{type:Boolean},computedValue:{},min:{},max:{},size:{}},emits:["click"],setup(n){const l=n,{disabled:i,computedValue:t,min:c,max:a,type:d}=e.toRefs(l),m=e.computed(()=>i.value?i.value:"minus"==d.value?+t.value<=c.value:+t.value>=a.value);return(n,l)=>(e.openBlock(),e.createBlock(e.unref(u.default),{size:n.size,disabled:m.value,class:e.normalizeClass([{"yc-input-number-plus-embed":"embed"==n.mode}]),onClick:l[0]||(l[0]=o=>n.$emit("click",e.unref(d)))},{icon:e.withCtx(()=>[e.renderSlot(n.$slots,"icon",{},()=>["embed"==n.mode?(e.openBlock(),e.createBlock(e.unref(o),{key:0,rotate:"plus"==e.unref(d)?180:0},null,8,["rotate"])):(e.openBlock(),e.createElementBlock(e.Fragment,{key:1},["minus"==e.unref(d)?(e.openBlock(),e.createBlock(e.unref(r),{key:0})):(e.openBlock(),e.createBlock(e.unref(s),{key:1}))],64))],!0)]),_:3},8,["size","disabled","class"]))}});module.exports=n;

package/lib/InputNumber/index.d.ts

@@ -0,0 +1,284 @@
+import { App } from 'vue';
+import { default as _InputNumber } from './InputNumber.vue';
+export type InputNumberInstance = InstanceType<typeof _InputNumber>;
+export * from './type';
+declare const InputNumber: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').InputNumberProps> & Readonly<{
+        onChange?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+        onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').InputNumberValue) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').InputNumberValue, ev: Event) => any;
+        focus: (ev: FocusEvent) => any;
+        clear: (ev: MouseEvent) => any;
+        blur: (ev: FocusEvent) => any;
+        input: (value: import('./type').InputNumberValue, ev: Event) => any;
+        keydown: (ev: KeyboardEvent) => any;
+        "update:modelValue": (value: import('./type').InputNumberValue) => any;
+        pressEnter: (ev: KeyboardEvent) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').Size;
+        disabled: boolean;
+        error: boolean;
+        placeholder: string;
+        mode: import('./type').InputNumberMode;
+        step: number;
+        modelValue: import('./type').InputNumberValue;
+        defaultValue: import('./type').InputNumberValue;
+        allowClear: boolean;
+        readonly: boolean;
+        inputAttrs: import('../_shared/type').ObjectData;
+        max: number;
+        min: number;
+        precision: number;
+        hideButton: boolean;
+        modelEvent: import('./type').ModelEvent;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | undefined;
+                readonly defaultValue?: string | undefined;
+                readonly size?: import('..').Size | undefined;
+                readonly allowClear?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly maxLength?: import('..').MaxLength | undefined;
+                readonly wordLength?: import('..').WordLength | undefined;
+                readonly wordSlice?: import('..').WordSlice | undefined;
+                readonly showWordLimit?: boolean | undefined;
+                readonly inputAttrs?: import('../_shared/type').ObjectData | undefined;
+                readonly isPassword?: boolean | undefined;
+                readonly visibility?: boolean | undefined;
+                readonly defaultVisibility?: boolean | undefined;
+                readonly invisibleButton?: boolean | undefined;
+                readonly showInput?: boolean | undefined;
+                readonly onChange?: ((value: string, ev: Event) => any) | undefined;
+                readonly onFocus?: ((ev: FocusEvent) => any) | undefined;
+                readonly onClear?: ((ev: MouseEvent) => any) | undefined;
+                readonly onBlur?: ((ev: FocusEvent) => any) | undefined;
+                readonly onInput?: ((value: string, ev: Event) => any) | undefined;
+                readonly onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+                readonly "onVisibility-change"?: ((value: boolean) => any) | undefined;
+                readonly onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "change", value: string, ev: Event) => void) & ((event: "focus", ev: FocusEvent) => void) & ((event: "clear", ev: MouseEvent) => void) & ((event: "blur", ev: FocusEvent) => void) & ((event: "input", value: string, ev: Event) => void) & ((event: "keydown", ev: KeyboardEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "update:visibility", value: boolean) => void) & ((event: "visibility-change", value: boolean) => void) & ((event: "pressEnter", ev: KeyboardEvent) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').InputProps> & 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;
+                "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+                "onVisibility-change"?: ((value: boolean) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                focus(): void;
+                blur(): void;
+                getInputRef(): HTMLInputElement;
+            }, {}, {}, {}, 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;
+                "update:visibility": (value: boolean) => any;
+                "visibility-change": (value: boolean) => any;
+                pressEnter: (ev: KeyboardEvent) => any;
+            }, string, {
+                size: import('..').Size;
+                disabled: boolean;
+                error: boolean;
+                placeholder: string;
+                visibility: boolean;
+                modelValue: string;
+                defaultValue: string;
+                maxLength: import('..').MaxLength;
+                showWordLimit: boolean;
+                allowClear: boolean;
+                readonly: boolean;
+                wordLength: import('..').WordLength;
+                wordSlice: import('..').WordSlice;
+                inputAttrs: import('../_shared/type').ObjectData;
+                isPassword: boolean;
+                defaultVisibility: boolean;
+                invisibleButton: boolean;
+                showInput: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                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 | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: import('..').Size;
+            disabled: boolean;
+            error: boolean;
+            placeholder: string;
+            visibility: boolean;
+            modelValue: string;
+            defaultValue: string;
+            maxLength: import('..').MaxLength;
+            showWordLimit: boolean;
+            allowClear: boolean;
+            readonly: boolean;
+            wordLength: import('..').WordLength;
+            wordSlice: import('..').WordSlice;
+            inputAttrs: import('../_shared/type').ObjectData;
+            isPassword: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+            showInput: boolean;
+        }> & Omit<Readonly<import('..').InputProps> & 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;
+            "onUpdate:visibility"?: ((value: boolean) => any) | undefined;
+            "onVisibility-change"?: ((value: boolean) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "getInputRef" | ("size" | "disabled" | "error" | "placeholder" | "visibility" | "modelValue" | "defaultValue" | "maxLength" | "showWordLimit" | "allowClear" | "readonly" | "wordLength" | "wordSlice" | "inputAttrs" | "isPassword" | "defaultVisibility" | "invisibleButton" | "showInput")> & import('vue').ShallowUnwrapRef<{
+            focus(): void;
+            blur(): void;
+            getInputRef(): HTMLInputElement;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<import('..').InputSlots> & import('..').InputSlots;
+        }) | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').InputNumberProps> & Readonly<{
+        onChange?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+        onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').InputNumberValue) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+    }, {}, {}, {}, {
+        size: import('..').Size;
+        disabled: boolean;
+        error: boolean;
+        placeholder: string;
+        mode: import('./type').InputNumberMode;
+        step: number;
+        modelValue: import('./type').InputNumberValue;
+        defaultValue: import('./type').InputNumberValue;
+        allowClear: boolean;
+        readonly: boolean;
+        inputAttrs: import('../_shared/type').ObjectData;
+        max: number;
+        min: number;
+        precision: number;
+        hideButton: boolean;
+        modelEvent: import('./type').ModelEvent;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').InputNumberProps> & Readonly<{
+    onChange?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onClear?: ((ev: MouseEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onInput?: ((value: import('./type').InputNumberValue, ev: Event) => any) | undefined;
+    onKeydown?: ((ev: KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').InputNumberValue) => any) | undefined;
+    onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+}>, {
+    focus(): void;
+    blur(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').InputNumberValue, ev: Event) => any;
+    focus: (ev: FocusEvent) => any;
+    clear: (ev: MouseEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    input: (value: import('./type').InputNumberValue, ev: Event) => any;
+    keydown: (ev: KeyboardEvent) => any;
+    "update:modelValue": (value: import('./type').InputNumberValue) => any;
+    pressEnter: (ev: KeyboardEvent) => any;
+}, string, {
+    size: import('..').Size;
+    disabled: boolean;
+    error: boolean;
+    placeholder: string;
+    mode: import('./type').InputNumberMode;
+    step: number;
+    modelValue: import('./type').InputNumberValue;
+    defaultValue: import('./type').InputNumberValue;
+    allowClear: boolean;
+    readonly: boolean;
+    inputAttrs: import('../_shared/type').ObjectData;
+    max: number;
+    min: number;
+    precision: number;
+    hideButton: boolean;
+    modelEvent: import('./type').ModelEvent;
+}, {}, 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').InputNumberSlots> & import('./type').InputNumberSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcInputNumber: typeof InputNumber;
+    }
+}
+export default InputNumber;

package/lib/InputNumber/index.js

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

package/lib/InputNumber/type.d.ts

@@ -0,0 +1,50 @@
+import { Size, ObjectData } from '../_shared/type';
+export interface InputNumberProps {
+    modelValue?: InputNumberValue;
+    defaultValue?: InputNumberValue;
+    mode?: InputNumberMode;
+    precision?: number;
+    step?: number;
+    disabled?: boolean;
+    error?: boolean;
+    max?: number;
+    min?: number;
+    placeholder?: string;
+    hideButton?: boolean;
+    size?: Size;
+    allowClear?: boolean;
+    modelEvent?: ModelEvent;
+    formatter?: InputNumberFormatter;
+    parser?: InputNumberParser;
+    readonly?: boolean;
+    inputAttrs?: ObjectData;
+}
+export interface InputNumberEmits {
+    (e: 'update:modelValue', value: InputNumberValue): void;
+    (e: 'input', value: InputNumberValue, ev: Event): void;
+    (e: 'change', value: InputNumberValue, ev: Event): void;
+    (e: 'focus', ev: FocusEvent): void;
+    (e: 'blur', ev: FocusEvent): void;
+    (e: 'clear', ev: MouseEvent): void;
+    (e: 'keydown', ev: KeyboardEvent): void;
+    (e: 'pressEnter', ev: KeyboardEvent): void;
+}
+export interface InputNumberSlots {
+    plus(): void;
+    minus(): void;
+    suffix(): void;
+    prefix(): void;
+    suffix(): void;
+    prepend(): void;
+    append(): void;
+    label(): void;
+}
+export interface InputNumberExpose {
+    focus(): void;
+    blur(): void;
+}
+export type InputNumberValue = number | string;
+export type InputNumberMode = 'embed' | 'button';
+export type ModelEvent = 'change' | 'input';
+export type InputNumberFormatter = (value: string) => string;
+export type InputNumberParser = (value: string) => string;

package/lib/InputTag/index.d.ts

@@ -0,0 +1,140 @@
+import { App } from 'vue';
+import { default as _InputTag } from './index.vue';
+export type InputTagInstance = InstanceType<typeof _InputTag>;
+export * from './type';
+declare const InputTag: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').InputTagProps> & Readonly<{
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onRemove?: ((value: string | number, ev: MouseEvent | KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').InputTagValue) => any) | undefined;
+        "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+        "onInput-value-change"?: ((value: string, ev: Event) => any) | undefined;
+        "onPress-enter"?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        focus: (ev: FocusEvent) => any;
+        clear: (ev: MouseEvent) => any;
+        blur: (ev: FocusEvent) => any;
+        input: (value: string) => any;
+        remove: (value: string | number, ev: MouseEvent | KeyboardEvent) => any;
+        "update:modelValue": (value: import('./type').InputTagValue) => any;
+        "update:inputValue": (value: string) => any;
+        "input-value-change": (value: string, ev: Event) => any;
+        "press-enter": (ev: KeyboardEvent) => any;
+    }, import('vue').PublicProps, {
+        size: import('..').Size;
+        disabled: boolean;
+        error: boolean;
+        placeholder: string;
+        modelValue: import('./type').InputTagValue;
+        defaultValue: import('./type').InputTagValue;
+        allowClear: boolean;
+        readonly: boolean;
+        inputValue: string;
+        defaultInputValue: string;
+        fieldNames: Record<string, string>;
+        allowCreate: boolean;
+        maxTagCount: number;
+        tagNowrap: boolean;
+        retainInputValue: import('./type').InputRetainValue;
+        uniqueValue: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        mirrorRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').InputTagProps> & Readonly<{
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onRemove?: ((value: string | number, ev: MouseEvent | KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').InputTagValue) => any) | undefined;
+        "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+        "onInput-value-change"?: ((value: string, ev: Event) => any) | undefined;
+        "onPress-enter"?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        focus(): void;
+        blur(): void;
+    }, {}, {}, {}, {
+        size: import('..').Size;
+        disabled: boolean;
+        error: boolean;
+        placeholder: string;
+        modelValue: import('./type').InputTagValue;
+        defaultValue: import('./type').InputTagValue;
+        allowClear: boolean;
+        readonly: boolean;
+        inputValue: string;
+        defaultInputValue: string;
+        fieldNames: Record<string, string>;
+        allowCreate: boolean;
+        maxTagCount: number;
+        tagNowrap: boolean;
+        retainInputValue: import('./type').InputRetainValue;
+        uniqueValue: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').InputTagProps> & Readonly<{
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onClear?: ((ev: MouseEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
+    onRemove?: ((value: string | number, ev: MouseEvent | KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').InputTagValue) => any) | undefined;
+    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+    "onInput-value-change"?: ((value: string, ev: Event) => any) | undefined;
+    "onPress-enter"?: ((ev: KeyboardEvent) => any) | undefined;
+}>, {
+    focus(): void;
+    blur(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    focus: (ev: FocusEvent) => any;
+    clear: (ev: MouseEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    input: (value: string) => any;
+    remove: (value: string | number, ev: MouseEvent | KeyboardEvent) => any;
+    "update:modelValue": (value: import('./type').InputTagValue) => any;
+    "update:inputValue": (value: string) => any;
+    "input-value-change": (value: string, ev: Event) => any;
+    "press-enter": (ev: KeyboardEvent) => any;
+}, string, {
+    size: import('..').Size;
+    disabled: boolean;
+    error: boolean;
+    placeholder: string;
+    modelValue: import('./type').InputTagValue;
+    defaultValue: import('./type').InputTagValue;
+    allowClear: boolean;
+    readonly: boolean;
+    inputValue: string;
+    defaultInputValue: string;
+    fieldNames: Record<string, string>;
+    allowCreate: boolean;
+    maxTagCount: number;
+    tagNowrap: boolean;
+    retainInputValue: import('./type').InputRetainValue;
+    uniqueValue: 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').InputTagSlots> & import('./type').InputTagSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcInputTag: typeof InputTag;
+    }
+}
+export default InputTag;

package/lib/InputTag/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/InputTag/index.vue.d.ts

@@ -0,0 +1,62 @@
+import { InputTagProps, InputTagValue, InputTagSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<InputTagSlots> & InputTagSlots;
+    refs: {
+        mirrorRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputTagProps, {
+    focus(): void;
+    blur(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    focus: (ev: FocusEvent) => any;
+    clear: (ev: MouseEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    input: (value: string) => any;
+    remove: (value: string | number, ev: MouseEvent | KeyboardEvent) => any;
+    "update:modelValue": (value: InputTagValue) => any;
+    "update:inputValue": (value: string) => any;
+    "input-value-change": (value: string, ev: Event) => any;
+    "press-enter": (ev: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InputTagProps> & Readonly<{
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onClear?: ((ev: MouseEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
+    onRemove?: ((value: string | number, ev: MouseEvent | KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: InputTagValue) => any) | undefined;
+    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+    "onInput-value-change"?: ((value: string, ev: Event) => any) | undefined;
+    "onPress-enter"?: ((ev: KeyboardEvent) => any) | undefined;
+}>, {
+    size: import('../_shared/type').Size;
+    disabled: boolean;
+    error: boolean;
+    placeholder: string;
+    modelValue: InputTagValue;
+    defaultValue: InputTagValue;
+    allowClear: boolean;
+    readonly: boolean;
+    inputValue: string;
+    defaultInputValue: string;
+    fieldNames: Record<string, string>;
+    allowCreate: boolean;
+    maxTagCount: number;
+    tagNowrap: boolean;
+    retainInputValue: import('./type').InputRetainValue;
+    uniqueValue: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    mirrorRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+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/InputTag/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-353d8392"]]);module.exports=r;

package/lib/InputTag/index.vue2.js

@@ -0,0 +1 @@
+"use strict";const e=require("vue"),l=require("../node_modules/nanoid/index.browser.js"),a=require("../node_modules/@vueuse/core/index.js");require("../node_modules/tinycolor2/esm/tinycolor.js"),require("../_shared/utils/dom.js");const t=require("../_shared/utils/fn.js"),u=require("../_shared/utils/is.js");require("../_shared/utils/time.js");const o=require("../_shared/utils/global-config.js"),r=require("../_shared/utils/control.js"),n=require("../Tag/index.js"),s=require("../_shared/components/IconButton.vue.js"),i=require("../_shared/components/PreventFocus.vue.js");;/* empty css                                          */const d=["disabled","readonly","placeholder"],c=e.defineComponent({name:"InputTag",__name:"index",props:{modelValue:{default:void 0},defaultValue:{default:()=>[]},inputValue:{default:void 0},defaultInputValue:{default:""},placeholder:{default:""},disabled:{type:Boolean,default:!1},error:{type:Boolean,default:!1},readonly:{type:Boolean,default:!1},allowClear:{type:Boolean,default:!1},size:{default:void 0},maxTagCount:{default:0},retainInputValue:{type:[Boolean,Object],default:!1},formatTag:{},uniqueValue:{type:Boolean,default:!1},tagNowrap:{type:Boolean,default:!1},fieldNames:{default:()=>({id:"id",label:"label",value:"value",closeable:"closeable",tagProps:"tagProps"})},allowCreate:{type:Boolean,default:!0}},emits:["update:modelValue","update:inputValue","input","input-value-change","focus","blur","press-enter","remove","clear"],setup(c,{expose:v,emit:p}){const f=c,m=p,{modelValue:g,defaultValue:b,inputValue:y,defaultInputValue:h,allowClear:k,disabled:x,readonly:w,uniqueValue:V,retainInputValue:B,allowCreate:C,maxTagCount:_,fieldNames:j,tagNowrap:q}=e.toRefs(f),{size:N}=o.getGlobalConfig(f),T=e.ref(),E=e.ref(),P=e.computed(()=>Object.fromEntries(["id","label","value","closable","tagProps"].map(e=>[e,j.value[e]??e]))),{width:S}=a.useElementSize(E,void 0,{box:"border-box"}),z=r(g,b.value,e=>m("update:modelValue",e),e=>{const{id:a,label:t,value:o,closable:r,tagProps:n}=P.value;return e.map(e=>{if(u.isObject(e)){const t=e;return t[a]=t[a]??l.nanoid(),t[r]=t[r]??!0,t[n]=t[n]??{bordered:!0,nowrap:q.value},e}const s={};return s[a]=l.nanoid(),s[t]=e,s[o]=e,s[r]=!0,s[n]={bordered:!0,nowrap:q.value},s})}),I=r(y,h.value,e=>{m("update:inputValue",e)}),$=e.computed(()=>({visibleList:_.value>0?z.value.slice(0,_.value):z.value,hideList:z.value.slice(_.value)})),D=e.computed(()=>k.value&&!x.value&&!w.value&&z.value.length),L=()=>{u.isBoolean(B.value)&&B.value||u.isObject(B.value)&&B.value.create||(I.value="")},O=(e,a,t)=>{var u,o;const r=null==(u=I.value)?void 0:u.trim();switch(e){case"input":case"input-value-change":{const{value:l}=a.target;m(e,l,a)}break;case"focus":case"blur":m(e,a),"blur"==e&&L();break;case"pressEnter":{const{label:e,value:t,id:u}=P.value,o=!V.value||V.value&&!z.value.find(e=>((null==e?void 0:e[t])??e)==r);if(!r||!C.value||!o)return;const n={};n[u]=l.nanoid(),n[e]=I.value,n[t]=I.value,z.value=[...z.value,n],m("press-enter",a),L()}break;case"close":{const e=z.value,l=e.find(e=>e.id==t);z.value=e.filter(e=>e.id!=t),m("remove",null==l?void 0:l.value,a)}break;case"remove":{if(r||!(null==(o=z.value)?void 0:o.length))return;const e=z.value[z.value.length-1];z.value=z.value.slice(0,z.value.length-1),m("remove",e.value,a)}break;case"clear":z.value=[],m("clear",a)}};return v({focus(){var e;null==(e=T.value)||e.focus()},blur(){var e;null==(e=T.value)||e.blur()}}),(l,a)=>(e.openBlock(),e.createElementBlock("div",{class:e.normalizeClass(["yc-input-tag",`yc-input-tag-size-${e.unref(N)}`,{"yc-input-tag-no-value":!e.unref(z).length,"yc-input-tag-disabled":e.unref(x),"yc-input-tag-error":l.error,"yc-input-tag-has-suffix":l.$slots.suffix||D.value}]),onMousedown:a[8]||(a[8]=e=>e.preventDefault()),onClick:a[9]||(a[9]=e=>{var l;return null==(l=T.value)?void 0:l.focus()})},[l.$slots.prefix?(e.openBlock(),e.createBlock(e.unref(i),{key:0,class:"yc-input-tag-prefix"},{default:e.withCtx(()=>[e.renderSlot(l.$slots,"prefix",{},void 0,!0)]),_:3})):e.createCommentVNode("",!0),e.createElementVNode("div",{class:"yc-input-tag-mirror",ref_key:"mirrorRef",ref:E},e.toDisplayString(e.unref(I)||(e.unref(z).length?"":l.placeholder)),513),e.createVNode(e.TransitionGroup,{name:"input-tag-zoom",tag:"div",class:"yc-input-tag-inner"},{default:e.withCtx(()=>[(e.openBlock(!0),e.createElementBlock(e.Fragment,null,e.renderList($.value.visibleList,a=>e.renderSlot(l.$slots,"tag",{key:null==a?void 0:a[P.value.id],tag:a},()=>[e.createVNode(e.unref(n),{closable:a[P.value.closable],bordered:a[P.value.tagProps].bordered,nowrap:a[P.value.tagProps].nowrap,checked:!1,onClose:e=>O("close",e,null==a?void 0:a[P.value.id])},{default:e.withCtx(()=>[e.createTextVNode(e.toDisplayString(l.formatTag?l.formatTag(a):a[P.value.label]),1)]),_:2},1032,["closable","bordered","nowrap","onClose"])],!0)),128)),e.unref(_)>0&&e.unref(z).length>e.unref(_)?(e.openBlock(),e.createBlock(e.unref(n),{nowrap:e.unref(q),checked:!1,bordered:"",key:"yc-select-value-tag"},{default:e.withCtx(()=>[e.createTextVNode(" +"+e.toDisplayString($.value.hideList.length)+"... ",1)]),_:1},8,["nowrap"])):e.createCommentVNode("",!0),e.withDirectives(e.createElementVNode("input",{"onUpdate:modelValue":a[0]||(a[0]=l=>e.isRef(I)?I.value=l:null),key:"yc-input-tag-input",disabled:e.unref(x),readonly:e.unref(w),placeholder:e.unref(z).length?"":l.placeholder,style:e.normalizeStyle({width:e.unref(t.valueToPx)(e.unref(S))}),class:"yc-input-tag-input",ref_key:"inputRef",ref:T,onInput:a[1]||(a[1]=e=>O("input",e)),onChange:a[2]||(a[2]=e=>O("input-value-change",e)),onFocus:a[3]||(a[3]=e=>O("focus",e)),onBlur:a[4]||(a[4]=e=>O("blur",e)),onKeydown:[a[5]||(a[5]=e.withKeys(e=>O("pressEnter",e),["enter"])),a[6]||(a[6]=e.withKeys(e=>O("remove",e),["delete"]))]},null,44,d),[[e.vModelText,e.unref(I)]])]),_:3}),l.$slots.suffix||D.value?(e.openBlock(),e.createBlock(e.unref(i),{key:1,class:"yc-input-tag-suffix"},{default:e.withCtx(()=>[D.value?(e.openBlock(),e.createBlock(e.unref(s),{key:0,class:"yc-input-tag-clear-button",onClick:a[7]||(a[7]=e=>O("clear",e))})):e.createCommentVNode("",!0),e.renderSlot(l.$slots,"suffix",{},void 0,!0)]),_:3})):e.createCommentVNode("",!0)],34))}});module.exports=c;