@progress/kendo-vue-inputs 3.5.0 → 3.5.1-dev.202208150613

package/dist/esm/numerictextbox/NumericTextBox.js

@@ -0,0 +1,684 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+var ref = allVue.ref;
+var inject = allVue.inject;
+import { canUseDOM, getDefaultSlots, getListeners, getRef, getTemplate, kendoThemeMaps, setRef, templateDefinition, templateRendering } from '@progress/kendo-vue-common';
+import { provideIntlService, provideLocalizationService } from '@progress/kendo-vue-intl';
+import { guid, validatePackage } from '@progress/kendo-vue-common';
+import { Button as KButton } from '@progress/kendo-vue-buttons';
+import { messages, numericIncreaseValue, numericDecreaseValue } from './../messages.js';
+import { formatValue, sanitizeNumber, rangeValue, increaseValue, decreaseValue, getStateOrPropsValue } from './utils.js';
+import { packageMetadata } from '../package-metadata.js';
+var VALIDATION_MESSAGE = 'Please enter a valid value!';
+/**
+ * @hidden
+ */
+
+var NumericTextBoxVue2 = {
+  model: {
+    event: 'changemodel'
+  },
+  // @ts-ignore
+  emits: {
+    'change': null,
+    'changemodel': null,
+    'update:modelValue': null,
+    'focus': null,
+    'blur': null
+  },
+  props: {
+    modelValue: Number,
+    value: Number,
+    defaultValue: Number,
+    step: {
+      type: Number,
+      default: 1
+    },
+    format: [String, Object],
+    tabIndex: Number,
+    accessKey: String,
+    title: String,
+    placeholder: String,
+    min: Number,
+    max: Number,
+    spinners: {
+      type: Boolean,
+      default: true
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    dir: String,
+    name: String,
+    label: String,
+    validationMessage: String,
+    validityStyles: {
+      type: Boolean,
+      default: true
+    },
+    valid: {
+      type: Boolean,
+      default: undefined
+    },
+    size: {
+      type: String,
+      default: 'medium',
+      validator: function validator(value) {
+        return [null, 'small', 'medium', 'large'].includes(value);
+      }
+    },
+    rounded: {
+      type: String,
+      default: 'medium',
+      validator: function validator(value) {
+        return [null, 'small', 'medium', 'large', 'full'].includes(value);
+      }
+    },
+    fillMode: {
+      type: String,
+      default: 'solid',
+      validator: function validator(value) {
+        return [null, 'solid', 'flat', 'outline'].includes(value);
+      }
+    },
+    required: {
+      type: Boolean,
+      default: false
+    },
+    id: String,
+    ariaLabel: String,
+    iconName: String,
+    inputPrefix: templateDefinition,
+    inputSuffix: templateDefinition,
+    showValidationIcon: Boolean,
+    showLoadingIcon: Boolean,
+    showClearButton: Boolean,
+    inputClass: String,
+    wrapperClass: String
+  },
+  inject: {
+    kendoIntlService: {
+      default: null
+    },
+    kendoLocalizationService: {
+      default: null
+    }
+  },
+  data: function data() {
+    return {
+      hasMounted: false,
+      isInvalid: false,
+      isEmpty: false,
+      currentValue: 0,
+      valueDuringOnChange: 0,
+      currentLooseValue: '',
+      selectionStart: 0,
+      selectionEnd: 0,
+      decimalSelect: false,
+      focused: false,
+      forceUpdate: false
+    };
+  },
+  created: function created() {
+    validatePackage(packageMetadata);
+    this._textBeforeInput = '';
+    this._inputId = guid();
+    this.$data.currentLooseValue = null;
+    this.$data.valueDuringOnChange = undefined;
+    this._intl = provideIntlService(this);
+    this._symbols = this._intl.numberSymbols();
+
+    if (this.$props.value !== undefined) {
+      this.$data.currentValue = this.$props.value;
+    } else if (this.$props.modelValue !== undefined) {
+      this.$data.currentValue = this.$props.modelValue;
+    } else if (this.$props.defaultValue !== undefined) {
+      this.$data.currentValue = this.$props.defaultValue;
+    } else {
+      this.$data.currentValue = null;
+    }
+  },
+  mounted: function mounted() {
+    this._input = getRef(this, 'input');
+    this._elementWrapper = this.v3 ? this.elementWrapperRef : this.$refs.elementWrapper;
+    this.$data.hasMounted = true;
+
+    if (this._input) {
+      this._textBeforeInput = this._input.value;
+    }
+
+    this.setValidity();
+  },
+  updated: function updated() {
+    if (!(canUseDOM && document.activeElement !== this._input || !this._input) && this.$data.currentLooseValue !== null) {
+      if (this.$data.forceUpdate) {
+        this._input.selectionStart = this.$data.selectionStart;
+        this._input.selectionEnd = this.$data.selectionEnd;
+        this.$data.forceUpdate = false;
+      }
+    }
+
+    if (this._input) {
+      this._textBeforeInput = this._input.value;
+    }
+
+    this.setValidity();
+  },
+  computed: {
+    computedValue: {
+      get: function get() {
+        if (this.$data.valueDuringOnChange !== undefined) {
+          return this.$data.valueDuringOnChange;
+        } else {
+          return this.$data.currentValue;
+        }
+      }
+    },
+    looseValue: {
+      get: function get() {
+        return formatValue(this.$data.focused ? this.$data.currentLooseValue : getStateOrPropsValue(this.$props.value, this.$data.currentValue), this.$props.format, this._intl);
+      }
+    },
+    spanClassNames: {
+      get: function get() {
+        var _a;
+
+        var isValid = !this.$data.hasMounted || !this.$props.validityStyles || this.validity().valid;
+        var compValue = this.computedValue;
+        return _a = {
+          'k-floating-label-container': true,
+          'k-focus': this.$data.focused,
+          'k-empty': !(compValue === 0 ? true : compValue || this.$props.placeholder),
+          'k-invalid': !isValid && isValid !== undefined,
+          'k-rtl': this.$props.dir === 'rtl'
+        }, _a[this.inputClass] = this.inputClass, _a;
+      }
+    },
+    wrapperClassNames: function wrapperClassNames() {
+      var _a;
+
+      var _b = this.$props,
+          size = _b.size,
+          fillMode = _b.fillMode,
+          rounded = _b.rounded,
+          required = _b.required,
+          disabled = _b.disabled;
+      var isValid = !this.$props.validityStyles || this.validity().valid;
+      return _a = {
+        'k-input': true,
+        'k-numerictextbox': true
+      }, _a["k-input-".concat(kendoThemeMaps.sizeMap[size] || size)] = size, _a["k-input-".concat(fillMode)] = fillMode, _a["k-rounded-".concat(kendoThemeMaps.roundedMap[rounded] || rounded)] = rounded, _a['k-invalid'] = !isValid, _a['k-required'] = required, _a['k-disabled'] = disabled, _a['k-loading'] = this.showLoadingIcon, _a[this.wrapperClass] = this.wrapperClass, _a;
+    },
+    inputInnerClass: function inputInnerClass() {
+      var _a;
+
+      return _a = {
+        'k-input-inner': true
+      }, _a[this.inputClass] = this.inputClass, _a;
+    }
+  },
+  methods: {
+    validity: function validity() {
+      // The NumericTextBox currently autocorrect its' value,
+      // so the only invalid state is if it's required and
+      // the value is null!
+      var customError = this.$props.validationMessage !== undefined;
+      var isValid = !this.$data.valueIsOutOfRange && (!this.$props.required || this.computedValue !== null);
+      var valid = this.$props.valid !== undefined ? this.$props.valid : isValid;
+      return {
+        customError: customError,
+        valid: valid,
+        valueMissing: this.computedValue === null
+      };
+    },
+    clearClick: function clearClick(event) {
+      if (this.$props.value !== undefined) {
+        // controlled
+        this.$data.currentValue = this.$props.value;
+      } else if (this.$props.modelValue !== undefined) {
+        this.$data.currentValue = this.$props.modelValue;
+      } else {
+        // uncontrolled
+        this.$data.currentValue = null;
+      }
+
+      this.$emit('changemodel', null);
+      this.$emit('update:modelValue', null);
+      this.$emit('change', {
+        event: event,
+        value: null,
+        component: this,
+        target: {
+          name: this.$props.name,
+          value: null
+        },
+        validity: this.validity()
+      });
+    },
+    focus: function focus() {
+      if (this._input) {
+        this._input.focus();
+      }
+    },
+    emitFocus: function emitFocus(e) {
+      this.$data.currentLooseValue = this._prevLooseValue;
+      this.$data.focused = true;
+      this.$emit('focus', e);
+      this.$data.forceUpdate = true;
+    },
+    emitBlur: function emitBlur(e) {
+      this.$data.eventValue = null;
+      this.$data.prevLooseValue = '';
+      this.$data.currentLooseValue = '';
+      this.$data.focused = false;
+      this.$data.selectionStart = undefined;
+      this.$data.selectionEnd = undefined;
+      this.$data.decimalSelect = false;
+      this.$data.valueIsCorrected = false;
+      this.$data.valueIsOutOfRange = false;
+      this.$emit('blur', e);
+      this.$data.forceUpdate = true;
+    },
+    handleFocus: function handleFocus(_) {
+      this.$data.focused = true;
+    },
+    handleBlur: function handleBlur(_) {
+      this.$data.focused = false;
+    },
+    setValidity: function setValidity() {
+      if (this._input && this._input.setCustomValidity) {
+        this._input.setCustomValidity(this.validity().valid ? '' : this.$props.validationMessage || VALIDATION_MESSAGE);
+      }
+    },
+    getCurrentState: function getCurrentState() {
+      return {
+        eventValue: getStateOrPropsValue(this.$props.value, this.$data.currentValue),
+        prevLooseValue: this._prevLooseValue,
+        currentLooseValue: this._input.value,
+        selectionStart: this._input.selectionStart,
+        selectionEnd: this._input.selectionEnd,
+        decimalSelect: false,
+        valueIsCorrected: false,
+        valueIsOutOfRange: false,
+        isPaste: this._isPaste,
+        focused: this.$data.focused
+      };
+    },
+    parseNumber: function parseNumber(text) {
+      return this._intl.parseNumber(text, this.$props.format);
+    },
+    elementChange: function elementChange(event) {
+      var newState = this.getCurrentState();
+      this._isPaste = false;
+      this.triggerChange(event, sanitizeNumber(newState, this.$props.format, this._intl));
+    },
+    triggerChange: function triggerChange(event, newState) {
+      var _this = this;
+
+      if (this.$props.disabled) {
+        return;
+      }
+
+      this.$data.valueDuringOnChange = newState.eventValue;
+      this.$data.currentValue = newState.eventValue;
+      var formattedValue = formatValue(rangeValue(newState.eventValue, this.$props.min, this.$props.max), this.$props.format, this._intl);
+      var rangedValue = rangeValue(this.parseNumber(formattedValue), this.$props.min, this.$props.max);
+
+      if (rangedValue !== newState.eventValue) {
+        newState.valueIsOutOfRange = true;
+        newState.eventValue = rangedValue;
+        this.$data.valueDuringOnChange = rangedValue;
+        this.$data.currentValue = rangedValue;
+      }
+
+      if (newState.valueIsCorrected) {
+        var wrapper = this._elementWrapper;
+
+        if (wrapper && wrapper.className.indexOf("k-invalid") === -1) {
+          this.$data.isInvalid = true;
+          setTimeout(function () {
+            _this.$data.isInvalid = false;
+          }, 50);
+        }
+      }
+
+      var shouldFireEvent = this.$props.value !== newState.eventValue;
+
+      if (this.$props.value !== undefined) {
+        // controlled
+        this.$data.currentValue = this.$props.value;
+      } else if (this.$props.modelValue !== undefined) {
+        this.$data.currentValue = this.$props.modelValue;
+      } else {
+        // uncontrolled
+        this.$data.currentValue = this.$data.valueDuringOnChange;
+      }
+
+      this.$data.prevLooseValue = newState.prevLooseValue;
+      this.$data.currentLooseValue = newState.currentLooseValue;
+      this.$data.selectionStart = newState.selectionStart;
+      this.$data.selectionEnd = newState.selectionEnd;
+      this.$data.decimalSelect = newState.decimalSelect;
+      this.$data.valueIsCorrected = newState.valueIsCorrected;
+      this.$data.valueIsOutOfRange = newState.valueIsOutOfRange;
+      this.$data.focused = newState.focused;
+      this.$data.isPaste = newState.isPaste;
+      this.$data.forceUpdate = !this.$data.forceUpdate;
+
+      if (shouldFireEvent) {
+        this.$emit('changemodel', this.$data.valueDuringOnChange);
+        this.$emit('update:modelValue', this.$data.valueDuringOnChange);
+        this.$emit('change', {
+          event: event,
+          value: this.$data.valueDuringOnChange,
+          component: this,
+          target: {
+            name: this.$props.name,
+            value: this.$data.valueDuringOnChange
+          },
+          validity: this.validity()
+        });
+      }
+
+      this.$data.valueDuringOnChange = undefined;
+    },
+    onPasteHandler: function onPasteHandler(_event) {
+      this._isPaste = true;
+    },
+    increase: function increase(event) {
+      var newState = this.getCurrentState();
+      increaseValue(this.parseNumber(String(newState.currentLooseValue)), newState, this.$props.step, this.$props.min, this.$props.max, this.$props.format, this._intl);
+      this.triggerChange(event, newState);
+    },
+    decrease: function decrease(event) {
+      var newState = this.getCurrentState();
+      decreaseValue(this.parseNumber(String(newState.currentLooseValue)), newState, this.$props.step, this.$props.min, this.$props.max, this.$props.format, this._intl);
+      this.triggerChange(event, newState);
+    },
+    wheel: function wheel(event) {
+      if (!canUseDOM || document.activeElement !== this._input || !this._input) {
+        return;
+      }
+
+      if (event.deltaY < 0) {
+        event.preventDefault();
+        this.increase(event);
+      }
+
+      if (event.deltaY > 0) {
+        event.preventDefault();
+        this.decrease(event);
+      }
+    },
+    keyDown: function keyDown(event) {
+      var newState = this.getCurrentState();
+      var currentValue = this.parseNumber(String(newState.currentLooseValue)); // Select All
+
+      if (newState.selectionEnd > newState.selectionStart && newState.selectionEnd - newState.selectionStart === String(newState.currentLooseValue).length) {
+        return;
+      }
+
+      switch (event.keyCode) {
+        case 38:
+          // Arrow up
+          increaseValue(currentValue, newState, this.$props.step, this.$props.min, this.$props.max, this.$props.format, this._intl);
+          break;
+
+        case 40:
+          // Arrow down
+          decreaseValue(currentValue, newState, this.$props.step, this.$props.min, this.$props.max, this.$props.format, this._intl);
+          break;
+
+        case 13:
+          // Enter - range values
+          var formattedValue = formatValue(rangeValue(currentValue, this.$props.min, this.$props.max), this.$props.format, this._intl);
+          var rangedValue = rangeValue(this.parseNumber(formattedValue), this.$props.min, this.$props.max);
+          newState.eventValue = rangedValue;
+          newState.currentLooseValue = formatValue(rangedValue, this.$props.format, this._intl);
+          newState.selectionStart = newState.selectionEnd = newState.currentLooseValue.length;
+          break;
+
+        case 110:
+          // Numpad decimal key
+          var element = this._input;
+
+          var symbols = this._intl.numberSymbols();
+
+          if (element) {
+            newState.currentLooseValue = newState.currentLooseValue.slice(0, newState.selectionStart) + symbols.decimal + newState.currentLooseValue.slice(newState.selectionEnd);
+            newState.selectionStart = newState.selectionEnd = newState.selectionStart + 1;
+            newState = sanitizeNumber(newState, this.$props.format, this._intl);
+          }
+
+          break;
+
+        default:
+          return;
+      }
+
+      event.preventDefault();
+      this.triggerChange(event, newState);
+    },
+    spinnersWrapperMouseDown: function spinnersWrapperMouseDown(e) {
+      if (canUseDOM && this._input) {
+        e.preventDefault();
+
+        if (document.activeElement !== this._input) {
+          this._input.focus();
+        }
+      }
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    var inputRef = ref(null);
+    var elementWrapperRef = ref(null);
+    var kendoLocalizationService = inject('kendoLocalizationService', {});
+    var kendoIntlService = inject('kendoIntlService', {});
+    return {
+      v3: v3,
+      inputRef: inputRef,
+      elementWrapperRef: elementWrapperRef,
+      kendoLocalizationService: kendoLocalizationService,
+      kendoIntlService: kendoIntlService
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var _a = this.$props,
+        iconName = _a.iconName,
+        showValidationIcon = _a.showValidationIcon,
+        showLoadingIcon = _a.showLoadingIcon,
+        showClearButton = _a.showClearButton;
+    var inputId = this.$props.id || this._inputId;
+    var defaultSlot = getDefaultSlots(this);
+    var localizationService = provideLocalizationService(this);
+    var isValid = this.validity().valid;
+
+    if (this.$props.value !== undefined && this.$props.value !== this.$data.currentValue) {
+      this.$data.currentValue = this.$props.value;
+    } else if (this.$props.modelValue !== undefined && this.$props.modelValue !== this.$data.currentValue) {
+      this.$data.currentValue = this.$props.modelValue;
+    }
+
+    this._prevLooseValue = this.looseValue;
+    var inputPrefixTemplate = templateRendering.call(this, this.$props.inputPrefix, getListeners.call(this));
+    var inputSuffixTemplate = templateRendering.call(this, this.$props.inputSuffix, getListeners.call(this));
+    var inputPrefix = getTemplate.call(this, {
+      h: h,
+      template: inputPrefixTemplate,
+      additionalProps: {
+        value: this.computedValue,
+        valid: isValid
+      }
+    });
+    var inputSuffix = getTemplate.call(this, {
+      h: h,
+      template: inputSuffixTemplate,
+      additionalProps: {
+        value: this.computedValue,
+        valid: isValid
+      }
+    });
+    var numerictextbox = h("span", {
+      dir: this.$props.dir,
+      attrs: this.v3 ? undefined : {
+        dir: this.$props.dir,
+        "aria-disabled": this.$props.disabled ? 'true' : undefined
+      },
+      "class": this.wrapperClassNames,
+      "aria-disabled": this.$props.disabled ? 'true' : undefined,
+      style: this.$attrs.style
+    }, [iconName && h("span", {
+      "class": "k-input-icon k-icon k-i-".concat(iconName)
+    }), this.$props.inputPrefix && h("span", {
+      "class": "k-input-prefix"
+    }, [inputPrefix]), h("input", {
+      tabindex: this.$props.tabIndex,
+      attrs: this.v3 ? undefined : {
+        tabindex: this.$props.tabIndex,
+        accesskey: this.$props.accessKey,
+        disabled: this.$props.disabled,
+        title: this.$props.title,
+        "aria-label": this.$props.ariaLabel,
+        "aria-valuemin": this.$props.min,
+        "aria-valuemax": this.$props.max,
+        placeholder: this.$props.placeholder,
+        type: this.$props.inputType || 'tel',
+        spellcheck: false,
+        autocomplete: "off",
+        autocorrect: "off",
+        id: inputId,
+        "aria-valuenow": this.$data.currentValue !== null ? this.$data.currentValue : undefined,
+        name: this.$props.name
+      },
+      accesskey: this.$props.accessKey,
+      disabled: this.$props.disabled,
+      title: this.$props.title,
+      "aria-label": this.$props.ariaLabel,
+      "aria-valuemin": this.$props.min,
+      "aria-valuemax": this.$props.max,
+      placeholder: this.$props.placeholder,
+      type: this.$props.inputType || 'tel',
+      spellcheck: false,
+      autocomplete: "off",
+      autocorrect: "off",
+      "class": this.inputInnerClass,
+      id: inputId,
+      value: this.v3 ? this.looseValue : null,
+      domProps: this.v3 ? undefined : {
+        "value": this.looseValue
+      },
+      "aria-valuenow": this.$data.currentValue !== null ? this.$data.currentValue : undefined,
+      name: this.$props.name,
+      onWheel: this.wheel,
+      on: this.v3 ? undefined : {
+        "wheel": this.wheel,
+        "keydown": this.keyDown,
+        "input": this.elementChange,
+        "focus": this.emitFocus,
+        "blur": this.emitBlur,
+        "paste": this.onPasteHandler
+      },
+      onKeydown: this.keyDown,
+      onInput: this.elementChange,
+      onFocus: this.emitFocus,
+      onBlur: this.emitBlur,
+      onPaste: this.onPasteHandler,
+      ref: setRef(this, 'input')
+    }), this.$props.inputSuffix && h("span", {
+      "class": "k-input-suffix"
+    }, [inputSuffix]), showValidationIcon && isValid && h("span", {
+      "class": "k-input-validation-icon k-icon k-i-check"
+    }), showValidationIcon && !isValid && h("span", {
+      "class": "k-input-validation-icon k-icon k-i-warning"
+    }), showLoadingIcon && h("span", {
+      "class": "k-input-loading-icon k-icon k-i-loading"
+    }), showClearButton && this.computedValue !== undefined && this.computedValue !== null && h("span", {
+      onClick: this.clearClick,
+      on: this.v3 ? undefined : {
+        "click": this.clearClick
+      },
+      "class": "k-clear-value"
+    }, [h("span", {
+      "class": "k-icon k-i-x"
+    })]), defaultSlot, this.$props.spinners && h("span", {
+      "class": "k-input-spinner k-spin-button",
+      onMousedown: this.spinnersWrapperMouseDown,
+      on: this.v3 ? undefined : {
+        "mousedown": this.spinnersWrapperMouseDown
+      }
+    }, [// @ts-ignore
+    h(KButton, {
+      type: "button",
+      attrs: this.v3 ? undefined : {
+        type: "button",
+        tabIndex: -1,
+        icon: 'arrow-n',
+        "aria-label": localizationService.toLanguageString(numericIncreaseValue, messages[numericIncreaseValue]),
+        title: localizationService.toLanguageString(numericIncreaseValue, messages[numericIncreaseValue])
+      },
+      tabIndex: -1,
+      icon: 'arrow-n',
+      "class": "k-spinner-increase",
+      "aria-label": localizationService.toLanguageString(numericIncreaseValue, messages[numericIncreaseValue]),
+      title: localizationService.toLanguageString(numericIncreaseValue, messages[numericIncreaseValue]),
+      onClick: this.increase,
+      on: this.v3 ? undefined : {
+        "click": this.increase
+      }
+    }), // @ts-ignore
+    h(KButton, {
+      type: "button",
+      attrs: this.v3 ? undefined : {
+        type: "button",
+        tabIndex: -1,
+        icon: 'arrow-s',
+        "aria-label": localizationService.toLanguageString(numericDecreaseValue, messages[numericDecreaseValue]),
+        title: localizationService.toLanguageString(numericDecreaseValue, messages[numericDecreaseValue])
+      },
+      tabIndex: -1,
+      "class": "k-spinner-decrease",
+      icon: 'arrow-s',
+      "aria-label": localizationService.toLanguageString(numericDecreaseValue, messages[numericDecreaseValue]),
+      title: localizationService.toLanguageString(numericDecreaseValue, messages[numericDecreaseValue]),
+      onClick: this.decrease,
+      on: this.v3 ? undefined : {
+        "click": this.decrease
+      }
+    })])]);
+    return this.$props.label ? h("span", {
+      "class": this.spanClassNames,
+      onFocusin: this.handleFocus,
+      on: this.v3 ? undefined : {
+        "focusin": this.handleFocus,
+        "focusout": this.handleBlur
+      },
+      onFocusout: this.handleBlur,
+      dir: this.$props.dir,
+      attrs: this.v3 ? undefined : {
+        dir: this.$props.dir
+      }
+    }, [numerictextbox, this.$props.label ? inputId ? h("label", {
+      "for": inputId,
+      attrs: this.v3 ? undefined : {
+        "for": inputId
+      },
+      "class": "k-label"
+    }, [this.$props.label]) : h("span", {
+      "class": "k-label"
+    }, [this.$props.label]) : null]) : numerictextbox;
+  }
+};
+/**
+ * @hidden
+ */
+
+var NumericTextBox = NumericTextBoxVue2;
+export { NumericTextBox, NumericTextBoxVue2 };

package/dist/esm/numerictextbox/interfaces/NumericTextBoxData.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @hidden
+ */
+export interface NumericTextBoxData {
+    eventValue: number | null | undefined;
+    prevLooseValue: string | undefined;
+    currentLooseValue: string | undefined;
+    selectionStart: number | undefined;
+    selectionEnd: number | undefined;
+    decimalSelect: boolean;
+    valueIsCorrected: boolean;
+    valueIsOutOfRange: boolean;
+    focused: boolean;
+    isPaste: boolean;
+}

package/dist/esm/numerictextbox/interfaces/NumericTextBoxData.js

@@ -0,0 +1 @@
+export {};