tanxin-ui 0.2.0

package/lib/input-number/src/input-number.d.ts

@@ -0,0 +1,266 @@
+declare const _default: import("vue").DefineComponent<{
+    placeholder: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    textAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    value: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    shadow: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    maxlength: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    prefix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    suffix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    max: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    min: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    step: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    precision: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    rules: import("vue-types").VueTypeDef<unknown[] | {
+        [key: string]: any;
+    }> & {
+        default: (() => unknown[]) | (() => {
+            [key: string]: any;
+        });
+    };
+    prop: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    autoValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    verify: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    buttonLr: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    onlyButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    autoFocus: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    formatter: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+    parser: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+}, {
+    refInput: import("vue").Ref<HTMLInputElement>;
+    render: () => JSX.Element;
+    blur: () => void;
+    handleAdd: (event: Event) => void;
+    handleReduce: (event: Event) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    placeholder: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    textAlign: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    value: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    readonly: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    disabled: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clearable: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    shadow: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    maxlength: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    prefix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    suffix: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    max: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    min: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    };
+    step: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    precision: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    rules: import("vue-types").VueTypeDef<unknown[] | {
+        [key: string]: any;
+    }> & {
+        default: (() => unknown[]) | (() => {
+            [key: string]: any;
+        });
+    };
+    prop: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    autoValidate: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    verify: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    buttonLr: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    showButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    onlyButton: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    autoFocus: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    formatter: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+    parser: import("vue-types").VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+}>>, {
+    disabled: boolean;
+    size: string;
+    textAlign: string;
+    value: number;
+    max: number;
+    shadow: boolean;
+    readonly: boolean;
+    placeholder: string;
+    clearable: boolean;
+    prefix: string;
+    suffix: string;
+    maxlength: number;
+    min: number;
+    rules: {
+        [key: string]: any;
+    };
+    prop: string;
+    autoValidate: boolean;
+    step: number;
+    precision: number;
+    verify: {
+        [key: string]: any;
+    };
+    buttonLr: boolean;
+    showButton: boolean;
+    onlyButton: boolean;
+    autoFocus: boolean;
+    formatter: (...args: any[]) => any;
+    parser: (...args: any[]) => any;
+}>;
+export default _default;

package/lib/input-number/src/input-number.js

@@ -0,0 +1,431 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+require("../../utils/components/icons/Checkmark.js");
+require("../../utils/components/icons/CheckmarkCircle.js");
+require("../../utils/components/icons/CheckmarkSharp.js");
+require("../../utils/components/icons/CheckmarkCircleOutline.js");
+require("../../utils/components/icons/AlertCircle.js");
+require("../../utils/components/icons/AlertCircleOutline.js");
+require("../../utils/components/icons/InformationCircle.js");
+require("../../utils/components/icons/InformationCircleOutline.js");
+require("../../utils/components/icons/CloseCircle.js");
+var CloseCircleOutline = require("../../utils/components/icons/CloseCircleOutline.js");
+require("../../utils/components/icons/HelpCircleSharp.js");
+require("../../utils/components/icons/EyeOffOutline.js");
+require("../../utils/components/icons/EyeOutline.js");
+require("../../utils/components/icons/LoadingOutlined.js");
+require("../../utils/components/icons/Close.js");
+require("../../utils/components/icons/CloseOutline.js");
+require("../../utils/components/icons/ArrowsMaximize.js");
+require("../../utils/components/icons/ArrowsMinimize.js");
+var AddOutline = require("../../utils/components/icons/AddOutline.js");
+var RemoveOutline = require("../../utils/components/icons/RemoveOutline.js");
+var ChevronUp = require("../../utils/components/icons/ChevronUp.js");
+var ChevronDown = require("../../utils/components/icons/ChevronDown.js");
+require("../../utils/components/icons/ChevronForward.js");
+require("../../utils/components/icons/ChevronLeft24Filled.js");
+require("../../utils/components/icons/ChevronRight24Filled.js");
+require("../../utils/components/icons/ChevronDoubleLeft16Filled.js");
+require("../../utils/components/icons/ChevronDoubleRight16Filled.js");
+require("../../utils/components/icons/CheckmarkOutline.js");
+require("../../utils/components/icons/IosCheckmark.js");
+require("../../utils/components/icons/Empty.js");
+require("../../utils/components/icons/Bars.js");
+require("../../utils/components/icons/ArrowUpCircle.js");
+require("../../utils/components/icons/ArrowUp.js");
+require("../../utils/components/icons/ArrowForward.js");
+require("../../utils/components/icons/TimeOutline.js");
+require("../../utils/components/icons/CalendarClearOutline.js");
+require("../../utils/components/icons/KeyboardArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardArrowRightRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowRightRound.js");
+require("../../utils/components/icons/MenuFoldOutlined.js");
+require("../../utils/components/icons/IosArrowDown.js");
+require("../../utils/components/icons/IosArrowBack.js");
+require("../../utils/components/icons/IosArrowForward.js");
+require("../../utils/components/icons/ImageSharp.js");
+require("../../utils/components/icons/Pause.js");
+require("../../utils/components/icons/Refresh.js");
+require("../../utils/components/icons/QuestionCircle24Regular.js");
+require("../../utils/components/icons/CloudUploadOutline.js");
+require("../../utils/components/icons/UploadFileFilled.js");
+require("../../utils/components/icons/EllipsisHorizontal.js");
+require("../../utils/components/icons/ArrowNext24Filled.js");
+require("../../utils/components/icons/ArrowPrevious24Filled.js");
+require("../../utils/components/icons/ArrowDropDownSharp.js");
+require("../../utils/components/icons/ArrowDropUpSharp.js");
+require("../../utils/components/icons/ArrowForwardIosFilled.js");
+var shared = require("@vue/shared");
+const inputNumberProps = {
+  placeholder: type.PropTypes.string.def("\u8BF7\u8F93\u5165"),
+  textAlign: type.PropTypes.oneOf(["left", "right", "center"]).def("left"),
+  value: type.PropTypes.number,
+  size: type.PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  readonly: type.PropTypes.bool.def(false),
+  disabled: type.PropTypes.bool.def(false),
+  clearable: type.PropTypes.bool.def(false),
+  shadow: type.PropTypes.bool.def(true),
+  maxlength: type.PropTypes.number,
+  prefix: type.PropTypes.string,
+  suffix: type.PropTypes.string,
+  max: type.PropTypes.number,
+  min: type.PropTypes.number,
+  step: type.PropTypes.number.def(1),
+  precision: type.PropTypes.number.def(0),
+  rules: type.PropTypes.oneOfType([type.PropTypes.object, type.PropTypes.array]).def([]),
+  prop: type.PropTypes.string.def(""),
+  autoValidate: type.PropTypes.bool.def(true),
+  verify: type.PropTypes.object.def({}),
+  buttonLr: type.PropTypes.bool.def(false),
+  showButton: type.PropTypes.bool.def(true),
+  onlyButton: type.PropTypes.bool.def(false),
+  autoFocus: type.PropTypes.bool.def(false),
+  formatter: type.PropTypes.func,
+  parser: type.PropTypes.func
+};
+var InputNumber = vue.defineComponent({
+  name: "TInputNumber",
+  components: {
+    CloseCircleOutline: CloseCircleOutline["default"],
+    AddOutline: AddOutline["default"],
+    RemoveOutline: RemoveOutline["default"],
+    ChevronUp: ChevronUp["default"],
+    ChevronDown: ChevronDown["default"]
+  },
+  props: inputNumberProps,
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("input-number", props);
+    const showClear = vue.ref(false);
+    const displayValue = vue.ref(props.value);
+    const currentValue = vue.ref();
+    vue.onMounted(() => {
+      currentValue.value = props.value;
+      inputFinished.value = true;
+      checkInvalid();
+      if (props.autoFocus && !props.disabled) {
+        focus();
+      }
+    });
+    const validateEnable = vue.ref(true);
+    const hasSuffix = vue.computed(() => props.suffix || slots.suffix || props.clearable);
+    const refInput = vue.ref();
+    const refValue = vue.computed(() => refInput.value);
+    const validateStatus = vue.ref("");
+    const shouldDisabled = vue.computed(() => {
+      return props.disabled;
+    });
+    const isFocus = vue.ref(false);
+    const classes = vue.computed(() => {
+      const values = [[`${prefixCls.value}-wrapper`], {
+        error: validateStatus.value === "error",
+        validating: validateStatus.value === "validating",
+        success: validateStatus.value === "success",
+        "is-readonly": props.readonly,
+        "is-focus": isFocus.value,
+        "with-shadow": isFocus.value && props.shadow,
+        "is-disabled": shouldDisabled.value,
+        [`size-${props.size}`]: props.size !== "md"
+      }];
+      return values;
+    });
+    const inputClasses = vue.computed(() => {
+      const values = [prefixCls.value, {}];
+      return values;
+    });
+    const focus = () => {
+      vue.nextTick(() => {
+        refValue.value.focus();
+      });
+    };
+    const blur = () => {
+      refValue.value.blur();
+    };
+    const handleClearClick = () => {
+      currentValue.value = void 0;
+    };
+    const isInvalid = vue.ref(false);
+    const inputFinished = vue.ref(false);
+    const handleInput = (event) => {
+      inputFinished.value = false;
+      const {
+        value
+      } = event.target;
+      let inVal = value.trim();
+      if (props.parser)
+        inVal = props.parser(inVal);
+      if (inVal.length === 0) {
+        isInvalid.value = false;
+        currentValue.value = void 0;
+        return;
+      } else if (!type.isNumeric(inVal)) {
+        isInvalid.value = true;
+        currentValue.value = void 0;
+        return;
+      }
+      currentValue.value = Number(inVal);
+      checkInvalid();
+    };
+    const checkInvalid = () => {
+      if (props.min !== void 0 && currentValue.value < props.min)
+        isInvalid.value = true;
+      else if (props.max !== void 0 && currentValue.value > props.max)
+        isInvalid.value = true;
+      else
+        isInvalid.value = false;
+    };
+    const handleChange = (event) => {
+      event.stopPropagation();
+      event.preventDefault();
+      const {
+        value
+      } = event.target;
+      inputFinished.value = true;
+      let inVal = value.trim();
+      if (props.parser)
+        inVal = props.parser(inVal);
+      if (inVal.length === 0 || !type.isNumeric(inVal)) {
+        currentValue.value = void 0;
+      } else {
+        currentValue.value = Number(inVal);
+      }
+      console.log("input-number handleChange b");
+      formatCurrentValue();
+      formatDisplayValue();
+      console.log("input-number handleChange c ", currentValue.value, displayValue.value);
+      emit("input", currentValue.value);
+      emitValue();
+    };
+    const emitValue = () => {
+      emit("update:value", currentValue.value);
+      emit("change", currentValue.value);
+    };
+    const handleFocus = (event) => {
+      isFocus.value = true;
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      isFocus.value = false;
+      inputFinished.value = true;
+      emit("blur", event);
+      if (!validateEnable.value)
+        return;
+    };
+    const precisionLen = vue.computed(() => {
+      let stepDigitLen = 0;
+      if (Math.floor(props.step) === props.step)
+        stepDigitLen = 0;
+      else {
+        stepDigitLen = props.step.toString().split(".")[1].length || 0;
+      }
+      return Math.max(stepDigitLen, props.precision);
+    });
+    const formatDisplayValue = () => {
+      displayValue.value = currentValue.value === void 0 ? "" : currentValue.value;
+      if (displayValue.value === "")
+        return;
+      if (inputFinished.value) {
+        if (type.isNumeric(displayValue.value)) {
+          displayValue.value = Number(displayValue.value).toFixed(precisionLen.value);
+        }
+      }
+      if (props.formatter) {
+        displayValue.value = props.formatter(displayValue.value);
+      }
+    };
+    const handleKeydown = (event) => {
+      if (event.code == "ArrowUp")
+        handleAdd(event);
+      else if (event.code == "ArrowDown")
+        handleReduce(event);
+      emit("keydown", event);
+    };
+    const formatCurrentValue = () => {
+      isInvalid.value = false;
+      if (currentValue.value === void 0)
+        return;
+      if (props.min !== void 0 && currentValue.value < props.min)
+        currentValue.value = props.min;
+      if (props.max !== void 0 && currentValue.value > props.max)
+        currentValue.value = props.max;
+      currentValue.value = Number(Number(currentValue.value).toFixed(precisionLen.value));
+    };
+    const handleAdd = (event) => {
+      event.preventDefault();
+      if (props.readonly)
+        return;
+      inputFinished.value = true;
+      if (currentValue.value === void 0) {
+        if (props.min !== void 0)
+          currentValue.value = props.min;
+        else
+          currentValue.value = props.step;
+      } else {
+        const num = Number(currentValue.value);
+        currentValue.value = num + props.step;
+      }
+      dispatchChange();
+      formatCurrentValue();
+    };
+    const handleReduce = (event) => {
+      event.preventDefault();
+      if (props.readonly)
+        return;
+      inputFinished.value = true;
+      if (currentValue.value === void 0) {
+        if (props.min !== void 0)
+          currentValue.value = props.min;
+        else
+          currentValue.value = props.step;
+      } else {
+        const num = Number(currentValue.value);
+        currentValue.value = num - props.step;
+      }
+      dispatchChange();
+      formatCurrentValue();
+    };
+    const dispatchChange = () => {
+      emitValue();
+      if (attrs.hasOwnProperty("onChange")) {
+        const changeEvent = attrs["onChange"];
+        if (shared.isArray(changeEvent))
+          changeEvent.map((event) => event(currentValue.value));
+        else
+          changeEvent(currentValue.value);
+      }
+    };
+    vue.watch(() => currentValue.value, () => {
+      formatDisplayValue();
+    });
+    vue.watch(() => props.value, () => {
+      console.log("props.value=", props.value);
+      currentValue.value = props.value;
+      checkInvalid();
+    });
+    const render = () => {
+      var _a, _b, _c;
+      const controlProps = __spreadProps(__spreadValues({}, attrs), {
+        class: inputClasses.value,
+        value: displayValue.value,
+        placeholder: props.placeholder,
+        maxlength: props.maxlength,
+        disabled: shouldDisabled.value,
+        readonly: props.readonly || props.onlyButton,
+        autocomplete: "off",
+        style: {
+          textAlign: (_a = props.textAlign) != null ? _a : null
+        },
+        onInput: handleInput,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        onChange: handleChange,
+        onKeydown: handleKeydown
+      });
+      let prefix = null;
+      if (slots.prefix) {
+        prefix = vue.createVNode("span", {
+          "class": `${prefixCls.value}-prefix`
+        }, [(_b = slots.prefix) == null ? void 0 : _b.call(slots)]);
+      } else if (props.prefix) {
+        prefix = vue.createVNode("span", {
+          "class": `${prefixCls.value}-prefix`
+        }, [props.prefix]);
+      }
+      const containerProps = {};
+      if (!props.disabled && props.clearable) {
+        containerProps["onMouseenter"] = () => {
+          showClear.value = true;
+        };
+        containerProps["onMouseleave"] = () => {
+          showClear.value = false;
+        };
+      }
+      return vue.createVNode("div", vue.mergeProps({
+        "class": classes.value
+      }, containerProps), [props.showButton && props.buttonLr ? vue.createVNode("button", {
+        "class": `${prefixCls.value}-operator`,
+        "tabindex": -1,
+        "disabled": props.min !== void 0 && currentValue.value <= props.min || props.disabled,
+        "onClick": handleReduce
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), null, {
+        default: () => [vue.createVNode(RemoveOutline["default"], null, null)]
+      })]) : null, prefix, vue.createVNode("input", vue.mergeProps({
+        "ref": refInput
+      }, controlProps, {
+        "unselectable": "on",
+        "inputmode": "decimal",
+        "class": isInvalid.value ? "is-invalid" : ""
+      }), null), hasSuffix.value ? vue.createVNode("span", {
+        "ref": "refSuffix",
+        "class": `${prefixCls.value}-suffix`
+      }, [showClear.value && currentValue.value !== void 0 ? vue.createVNode(vue.resolveComponent("t-icon"), {
+        "class": "is-action",
+        "onClick": handleClearClick
+      }, {
+        default: () => [vue.createVNode(CloseCircleOutline["default"], null, null)]
+      }) : null, slots.suffix ? (_c = slots.suffix) == null ? void 0 : _c.call(slots) : props.suffix]) : null, props.showButton && props.buttonLr ? vue.createVNode("button", {
+        "class": `${prefixCls.value}-operator`,
+        "tabindex": -1,
+        "disabled": props.max !== void 0 && currentValue.value >= props.max || props.disabled,
+        "onClick": handleAdd
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), null, {
+        default: () => [vue.createVNode(AddOutline["default"], null, null)]
+      })]) : null, props.showButton && !props.buttonLr ? vue.createVNode("div", {
+        "class": `${prefixCls.value}-buttons`
+      }, [vue.createVNode("button", {
+        "class": `${prefixCls.value}-operator`,
+        "onClick": handleAdd,
+        "tabindex": -1,
+        "disabled": props.max !== void 0 && currentValue.value >= props.max || props.disabled
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), null, {
+        default: () => [vue.createVNode(ChevronUp["default"], null, null)]
+      })]), vue.createVNode("button", {
+        "class": `${prefixCls.value}-operator`,
+        "onClick": handleReduce,
+        "tabindex": -1,
+        "disabled": props.min !== void 0 && currentValue.value <= props.min || props.disabled
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), null, {
+        default: () => [vue.createVNode(ChevronDown["default"], null, null)]
+      })])]) : null]);
+    };
+    return {
+      refInput,
+      render,
+      blur,
+      handleAdd,
+      handleReduce
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = InputNumber;