yc-design-vue 1.0.1

package/es/InputNumber/InputNumber.vue2.js

@@ -0,0 +1,271 @@
+import { defineComponent, toRefs, ref, computed, createBlock, openBlock, unref, createSlots, withCtx, renderSlot, createElementVNode, createVNode } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { sleep } from "../_shared/utils/fn.js";
+import { isString, isFunction, isNumber } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useControlValue from "../_shared/utils/control.js";
+import OperaBtn from "./InputOperaBtn.vue.js";
+import Input from "../Input/index.js";
+const _hoisted_1 = { class: "yc-input-number-step" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "InputNumber"
+  },
+  __name: "InputNumber",
+  props: {
+    modelValue: { default: void 0 },
+    defaultValue: { default: "" },
+    mode: { default: "embed" },
+    precision: { default: 0 },
+    step: { default: 1 },
+    disabled: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    max: { default: Infinity },
+    min: { default: -Infinity },
+    placeholder: { default: "" },
+    hideButton: { type: Boolean, default: false },
+    size: { default: void 0 },
+    allowClear: { type: Boolean, default: false },
+    modelEvent: { default: "change" },
+    formatter: {},
+    parser: {},
+    readonly: { type: Boolean, default: false },
+    inputAttrs: { default: () => {
+      return {};
+    } }
+  },
+  emits: ["update:modelValue", "input", "change", "focus", "blur", "clear", "keydown", "pressEnter"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultValue,
+      step,
+      min,
+      max,
+      disabled,
+      hideButton,
+      mode,
+      modelEvent,
+      precision: _precision
+    } = toRefs(props);
+    const { formatter, parser } = props;
+    const inputRef = ref();
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits(
+          "update:modelValue",
+          modelEvent.value == "change" ? val : handlePrecision(val, "number")
+        );
+      },
+      (val) => {
+        const value = isString(val) ? val : handlePrecision(val, "string");
+        return formatter && isFunction(formatter) ? formatter(value) : value;
+      }
+    );
+    const precision = computed(() => {
+      var _a, _b;
+      const stepPrecision = ((_b = (_a = String(step.value).match(/\.(\d+)/)) == null ? void 0 : _a[1]) == null ? void 0 : _b.length) ?? 0;
+      return Math.max(...[stepPrecision, _precision.value]);
+    });
+    const parserValue = (v) => {
+      return parser && isFunction(parser) ? parser(v) : v;
+    };
+    function handlePrecision(value, type) {
+      const handleValue = isNumber(value) ? value : +value;
+      const numberValue = precision.value ? handleValue.toFixed(precision.value) : handleValue.toFixed(0);
+      return type == "number" ? +numberValue : numberValue;
+    }
+    const handleStep = (type) => {
+      var _a;
+      const handleValue = +parserValue(computedValue.value);
+      let value = type == "minus" ? handleValue - step.value : handleValue + step.value;
+      value = value < min.value ? min.value : value;
+      value = value > max.value ? max.value : value;
+      computedValue.value = handlePrecision(value, "number");
+      (_a = inputRef.value) == null ? void 0 : _a.focus();
+    };
+    const handleUpdateValue = (type, e) => {
+      if (type == "blur") {
+        emits("blur", e);
+      } else {
+        emits("pressEnter", e);
+      }
+      if (!computedValue.value) return;
+      let value = +parserValue(computedValue.value);
+      value = value < min.value ? min.value : value;
+      value = value > max.value ? max.value : value;
+      computedValue.value = handlePrecision(value, "number");
+    };
+    const handleInput = (v, e) => {
+      var _a;
+      if (!v) {
+        computedValue.value = v;
+        return;
+      }
+      const handleValue = parserValue(v);
+      const isInValidNumber = !/^-?\d*\.?\d*$/.test(handleValue);
+      const isInValidPoint = (((_a = handleValue.match(/\./g)) == null ? void 0 : _a.length) ?? 0) > 1;
+      const isInValidNegative = handleValue.includes("-") && handleValue[0] != "-";
+      if (isInValidNumber || isInValidPoint || isInValidNegative) {
+        return;
+      }
+      computedValue.value = handleValue;
+      emits("input", handleValue, e);
+    };
+    const handleClear = (ev) => {
+      computedValue.value = "";
+      emits("clear", ev);
+    };
+    __expose({
+      focus() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      },
+      blur() {
+        var _a;
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Input), {
+        "model-value": unref(computedValue),
+        "allow-clear": _ctx.allowClear,
+        disabled: unref(disabled),
+        readonly: _ctx.readonly,
+        error: _ctx.error,
+        size: _ctx.size,
+        placeholder: _ctx.placeholder,
+        "input-attrs": _ctx.inputAttrs,
+        class: "yc-input-number",
+        ref_key: "inputRef",
+        ref: inputRef,
+        onInput: handleInput,
+        onChange: _cache[0] || (_cache[0] = async (v, ev) => {
+          await unref(sleep)(0);
+          _ctx.$emit("change", +v, ev);
+        }),
+        onClear: handleClear,
+        onFocus: _cache[1] || (_cache[1] = (ev) => _ctx.$emit("focus", ev)),
+        onBlur: _cache[2] || (_cache[2] = (ev) => handleUpdateValue("blur", ev)),
+        onKeydown: _cache[3] || (_cache[3] = (ev) => _ctx.$emit("keydown", ev)),
+        onPressEnter: _cache[4] || (_cache[4] = (ev) => handleUpdateValue("pressEnter", ev))
+      }, createSlots({ _: 2 }, [
+        _ctx.$slots.prefix ? {
+          name: "prefix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
+          ]),
+          key: "0"
+        } : void 0,
+        _ctx.$slots.suffix || !unref(hideButton) && unref(mode) == "embed" ? {
+          name: "suffix",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "suffix", {}, () => [
+              createElementVNode("div", _hoisted_1, [
+                createVNode(OperaBtn, {
+                  type: "plus",
+                  mode: unref(mode),
+                  "computed-value": unref(computedValue),
+                  disabled: unref(disabled),
+                  min: unref(min),
+                  max: unref(max),
+                  size: _ctx.size,
+                  onClick: handleStep
+                }, createSlots({ _: 2 }, [
+                  _ctx.$slots.minus ? {
+                    name: "icon",
+                    fn: withCtx(() => [
+                      renderSlot(_ctx.$slots, "plus", {}, void 0, true)
+                    ]),
+                    key: "0"
+                  } : void 0
+                ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"]),
+                createVNode(OperaBtn, {
+                  type: "minus",
+                  mode: unref(mode),
+                  "computed-value": unref(computedValue),
+                  disabled: unref(disabled),
+                  min: unref(min),
+                  max: unref(max),
+                  size: _ctx.size,
+                  onClick: handleStep
+                }, createSlots({ _: 2 }, [
+                  _ctx.$slots.plus ? {
+                    name: "icon",
+                    fn: withCtx(() => [
+                      renderSlot(_ctx.$slots, "minus", {}, void 0, true)
+                    ]),
+                    key: "0"
+                  } : void 0
+                ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"])
+              ])
+            ], true)
+          ]),
+          key: "1"
+        } : void 0,
+        _ctx.$slots.prepend || !unref(hideButton) && unref(mode) == "button" ? {
+          name: "prepend",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "prepend", {}, () => [
+              createVNode(OperaBtn, {
+                type: "minus",
+                mode: unref(mode),
+                "computed-value": unref(computedValue),
+                disabled: unref(disabled),
+                min: unref(min),
+                max: unref(max),
+                size: _ctx.size,
+                onClick: handleStep
+              }, createSlots({ _: 2 }, [
+                _ctx.$slots.minus ? {
+                  name: "icon",
+                  fn: withCtx(() => [
+                    renderSlot(_ctx.$slots, "minus", {}, void 0, true)
+                  ]),
+                  key: "0"
+                } : void 0
+              ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"])
+            ], true)
+          ]),
+          key: "2"
+        } : void 0,
+        _ctx.$slots.append || !unref(hideButton) && unref(mode) == "button" ? {
+          name: "append",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "append", {}, () => [
+              createVNode(OperaBtn, {
+                type: "plus",
+                mode: unref(mode),
+                "computed-value": unref(computedValue),
+                disabled: unref(disabled),
+                max: unref(max),
+                min: unref(min),
+                size: _ctx.size,
+                onClick: handleStep
+              }, createSlots({ _: 2 }, [
+                _ctx.$slots.plus ? {
+                  name: "icon",
+                  fn: withCtx(() => [
+                    renderSlot(_ctx.$slots, "plus", {}, void 0, true)
+                  ]),
+                  key: "0"
+                } : void 0
+              ]), 1032, ["mode", "computed-value", "disabled", "max", "min", "size"])
+            ], true)
+          ]),
+          key: "3"
+        } : void 0
+      ]), 1032, ["model-value", "allow-clear", "disabled", "readonly", "error", "size", "placeholder", "input-attrs"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/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/es/InputNumber/InputOperaBtn.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./InputOperaBtn.vue2.js";
+/* empty css                   */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const OperaBtn = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-07ea2c8a"]]);
+export {
+  OperaBtn as default
+};

package/es/InputNumber/InputOperaBtn.vue2.js

@@ -0,0 +1,58 @@
+import { defineComponent, toRefs, computed, createBlock, openBlock, unref, normalizeClass, withCtx, renderSlot, createElementBlock, Fragment } from "vue";
+import _sfc_main$1 from "../_shared/icons/IconArrowDown.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import _sfc_main$2 from "../_shared/icons/IconMinus.vue2.js";
+import _sfc_main$3 from "../_shared/icons/IconPlus.vue.js";
+import Button from "../Button/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InputOperaBtn",
+  props: {
+    mode: {},
+    type: {},
+    disabled: { type: Boolean },
+    computedValue: {},
+    min: {},
+    max: {},
+    size: {}
+  },
+  emits: ["click"],
+  setup(__props) {
+    const props = __props;
+    const { disabled: _disabled, computedValue, min, max, type } = toRefs(props);
+    const disabled = computed(() => {
+      if (_disabled.value) return _disabled.value;
+      return type.value == "minus" ? +computedValue.value <= min.value : +computedValue.value >= max.value;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Button), {
+        size: _ctx.size,
+        disabled: disabled.value,
+        class: normalizeClass([
+          {
+            "yc-input-number-plus-embed": _ctx.mode == "embed"
+          }
+        ]),
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", unref(type)))
+      }, {
+        icon: withCtx(() => [
+          renderSlot(_ctx.$slots, "icon", {}, () => [
+            _ctx.mode == "embed" ? (openBlock(), createBlock(unref(_sfc_main$1), {
+              key: 0,
+              rotate: unref(type) == "plus" ? 180 : 0
+            }, null, 8, ["rotate"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+              unref(type) == "minus" ? (openBlock(), createBlock(unref(_sfc_main$2), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$3), { key: 1 }))
+            ], 64))
+          ], true)
+        ]),
+        _: 3
+      }, 8, ["size", "disabled", "class"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/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/es/InputNumber/index.js

@@ -0,0 +1,9 @@
+import _InputNumber from "./InputNumber.vue.js";
+const InputNumber = Object.assign(_InputNumber, {
+  install: (app) => {
+    app.component("Yc" + _InputNumber.name, _InputNumber);
+  }
+});
+export {
+  InputNumber as default
+};