@infomaximum/ui-kit 0.9.1

package/dist/components/InputNumber/InputNumber.js

@@ -0,0 +1,189 @@
+import { jsx, jsxs } from "@emotion/react/jsx-runtime";
+import { forwardRef, useRef, useState, memo, Fragment } from "react";
+import { StepController } from "./components/StepController/StepController.js";
+import { isString } from "lodash-es";
+import { getInputNumberTokens } from "./InputNumber.tokens.js";
+import { prefixStyle, nonStringPrefixSuffixStyle, suffixStyle, getAddonStyle, nonStringAddonStyle, inputNumberWrapperClassName, inputNumberWrapperStyle, inputNumberClassName, getInputWrapperStyle, getInputStyle } from "./InputNumber.styles.js";
+import { useMergeRefs } from "@floating-ui/react";
+import { emptyString } from "../../utils/const/index.js";
+import { useTheme } from "../../hooks/useTheme/useTheme.js";
+import { useDecimalTools } from "./hooks/useDecimalTools/useDecimalTools.js";
+import { getMiniDecimal } from "./utils/MiniDecimal.js";
+import { useRange } from "./hooks/useRange/useRange.js";
+import { useChangeValue } from "./hooks/useChangeValue/useChangeValue.js";
+import { useStep } from "./hooks/useStep/useStep.js";
+import { useFocusBlurEvents } from "./hooks/useFocusBlurEvents/useFocusBlurEvents.js";
+import { useWheelEvents } from "./hooks/useWheelEvents/useWheelEvents.js";
+import { useKeyboardEvents } from "./hooks/useKeyboardEvents/useKeyboardEvents.js";
+const InputNumberComponent = forwardRef((props, ref) => {
+  const {
+    style,
+    prefix: prefixProp,
+    suffix: suffixProp,
+    addonBefore: addonBeforeProp,
+    addonAfter: addonAfterProp,
+    status,
+    min,
+    max,
+    step = 1,
+    controls = true,
+    keyboard = true,
+    changeOnWheel = false,
+    changeOnBlur = true,
+    stringMode = false,
+    parser,
+    formatter,
+    precision,
+    decimalSeparator,
+    defaultValue,
+    value,
+    disabled,
+    readOnly,
+    onChange: onChangeProp,
+    onInput,
+    onPressEnter,
+    onStep: onStepProp,
+    ...restProps
+  } = props;
+  const theme = useTheme();
+  const inputNumberTokens = getInputNumberTokens(theme);
+  const inputRef = useRef(null);
+  const mergedRef = useMergeRefs([inputRef, ref]);
+  const shiftKeyRef = useRef(false);
+  const inputValueRef = useRef(emptyString);
+  const errorStatus = status === "error";
+  const hasSuffix = Boolean(suffixProp);
+  const hasAffix = Boolean(prefixProp) || hasSuffix;
+  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);
+  const AddonWrapper = hasAddon ? "span" : Fragment;
+  const {
+    getPrecision,
+    mergedParser,
+    mergedFormatter
+  } = useDecimalTools({
+    inputValueRef,
+    parser,
+    formatter,
+    precision,
+    decimalSeparator,
+    step
+  });
+  const [decimalValue, setDecimalValue] = useState(() => getMiniDecimal(value ?? defaultValue));
+  const {
+    outOfRange,
+    maxDecimal,
+    minDecimal,
+    getRangeValue,
+    isInRange
+  } = useRange({
+    decimalValue,
+    max,
+    min
+  });
+  const {
+    inputValue,
+    triggerValueUpdate,
+    flushInputValue,
+    onChange
+  } = useChangeValue({
+    decimalValue,
+    getPrecision,
+    mergedParser,
+    mergedFormatter,
+    setDecimalValue,
+    getRangeValue,
+    isInRange,
+    inputValueRef,
+    defaultValue,
+    value,
+    disabled,
+    readOnly,
+    stringMode,
+    onInput,
+    onChange: onChangeProp
+  });
+  const {
+    onStep,
+    upDisabled,
+    downDisabled
+  } = useStep({
+    decimalValue,
+    maxDecimal,
+    minDecimal,
+    step,
+    stringMode,
+    inputRef,
+    shiftKeyRef,
+    triggerValueUpdate,
+    onStep: onStepProp
+  });
+  const {
+    onKeyDown,
+    onKeyUp
+  } = useKeyboardEvents({
+    keyboard,
+    shiftKeyRef,
+    flushInputValue,
+    onStep,
+    onPressEnter
+  });
+  const {
+    focus,
+    inputNumberRef,
+    onFocus,
+    onBlur,
+    onInputNumberClick
+  } = useFocusBlurEvents({
+    changeOnBlur,
+    inputRef,
+    flushInputValue
+  });
+  useWheelEvents({
+    focus,
+    changeOnWheel,
+    inputRef,
+    onStep
+  });
+  const prefix = (() => {
+    if (!prefixProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [prefixStyle(theme), isString(prefixProp) ? {} : nonStringPrefixSuffixStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:prefix;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx"],"names":[],"mappings":"AAyIQ","file":"/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx","sourcesContent":["import { forwardRef, Fragment, memo, useRef, useState } from \"react\";\nimport type { InputNumberProps } from \"./InputNumber.types\";\nimport { StepController } from \"./components/StepController/StepController\";\nimport { isString } from \"lodash-es\";\nimport { getInputNumberTokens } from \"./InputNumber.tokens\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  getAddonStyle,\n  getInputStyle,\n  getInputWrapperStyle,\n  inputNumberClassName,\n  inputNumberWrapperClassName,\n  inputNumberWrapperStyle,\n  nonStringAddonStyle,\n  nonStringPrefixSuffixStyle,\n  prefixStyle,\n  suffixStyle,\n} from \"./InputNumber.styles\";\nimport { getMiniDecimal, type DecimalClass } from \"./utils\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useStep } from \"./hooks/useStep\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useWheelEvents } from \"./hooks/useWheelEvents\";\nimport { useFocusBlurEvents } from \"./hooks/useFocusBlurEvents\";\nimport { useRange } from \"./hooks/useRange\";\nimport { useDecimalTools } from \"./hooks/useDecimalTools\";\nimport { emptyString } from \"utils\";\nimport { useChangeValue } from \"./hooks/useChangeValue\";\n\nconst InputNumberComponent = forwardRef<HTMLInputElement, InputNumberProps>((props, ref) => {\n  const {\n    style,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    min,\n    max,\n    step = 1,\n    controls = true,\n    keyboard = true,\n    changeOnWheel = false,\n    changeOnBlur = true,\n    stringMode = false,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    onChange: onChangeProp,\n    onInput,\n    onPressEnter,\n    onStep: onStepProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputNumberTokens = getInputNumberTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const shiftKeyRef = useRef(false);\n  const inputValueRef = useRef<string | number | undefined>(emptyString);\n  const errorStatus = status === \"error\";\n  const hasSuffix = Boolean(suffixProp);\n  const hasAffix = Boolean(prefixProp) || hasSuffix;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { getPrecision, mergedParser, mergedFormatter } = useDecimalTools({\n    inputValueRef,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    step,\n  });\n\n  const [decimalValue, setDecimalValue] = useState<DecimalClass>(() =>\n    getMiniDecimal(value ?? defaultValue)\n  );\n\n  const { outOfRange, maxDecimal, minDecimal, getRangeValue, isInRange } = useRange({\n    decimalValue,\n    max,\n    min,\n  });\n  const { inputValue, triggerValueUpdate, flushInputValue, onChange } = useChangeValue({\n    decimalValue,\n    getPrecision,\n    mergedParser,\n    mergedFormatter,\n    setDecimalValue,\n    getRangeValue,\n    isInRange,\n    inputValueRef,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    stringMode,\n    onInput,\n    onChange: onChangeProp,\n  });\n  const { onStep, upDisabled, downDisabled } = useStep({\n    decimalValue,\n    maxDecimal,\n    minDecimal,\n    step,\n    stringMode,\n    inputRef,\n    shiftKeyRef,\n    triggerValueUpdate,\n    onStep: onStepProp,\n  });\n  const { onKeyDown, onKeyUp } = useKeyboardEvents({\n    keyboard,\n    shiftKeyRef,\n    flushInputValue,\n    onStep,\n    onPressEnter,\n  });\n  const { focus, inputNumberRef, onFocus, onBlur, onInputNumberClick } = useFocusBlurEvents({\n    changeOnBlur,\n    inputRef,\n    flushInputValue,\n  });\n  useWheelEvents({ focus, changeOnWheel, inputRef, onStep });\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[prefixStyle(theme), isString(prefixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[suffixStyle(theme), isString(suffixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputNumberWrapperClassName,\n            css: inputNumberWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <div\n        ref={inputNumberRef}\n        onClick={onInputNumberClick}\n        className={inputNumberClassName}\n        onFocus={onFocus}\n        onBlur={onBlur}\n        onKeyDown={onKeyDown}\n        onKeyUp={onKeyUp}\n        style={hasAddon ? undefined : style}\n        css={getInputWrapperStyle(\n          inputNumberTokens,\n          disabled,\n          hasAffix,\n          hasSuffix,\n          errorStatus,\n          controls\n        )(theme)}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          aria-valuemin={min ? Number(min) : undefined}\n          aria-valuemax={max ? Number(max) : undefined}\n          step={step}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={inputValue}\n          onChange={onChange}\n          css={getInputStyle(inputNumberTokens, disabled, hasAffix, outOfRange)(theme)}\n        />\n        {suffix}\n        {controls && !disabled && (\n          <StepController upDisabled={upDisabled} downDisabled={downDisabled} onStep={onStep} />\n        )}\n      </div>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const InputNumber = memo(InputNumberComponent);\n"]} */"], children: prefixProp });
+  })();
+  const suffix = (() => {
+    if (!suffixProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [suffixStyle(theme), isString(suffixProp) ? {} : nonStringPrefixSuffixStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:suffix;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx"],"names":[],"mappings":"AAuJQ","file":"/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx","sourcesContent":["import { forwardRef, Fragment, memo, useRef, useState } from \"react\";\nimport type { InputNumberProps } from \"./InputNumber.types\";\nimport { StepController } from \"./components/StepController/StepController\";\nimport { isString } from \"lodash-es\";\nimport { getInputNumberTokens } from \"./InputNumber.tokens\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  getAddonStyle,\n  getInputStyle,\n  getInputWrapperStyle,\n  inputNumberClassName,\n  inputNumberWrapperClassName,\n  inputNumberWrapperStyle,\n  nonStringAddonStyle,\n  nonStringPrefixSuffixStyle,\n  prefixStyle,\n  suffixStyle,\n} from \"./InputNumber.styles\";\nimport { getMiniDecimal, type DecimalClass } from \"./utils\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useStep } from \"./hooks/useStep\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useWheelEvents } from \"./hooks/useWheelEvents\";\nimport { useFocusBlurEvents } from \"./hooks/useFocusBlurEvents\";\nimport { useRange } from \"./hooks/useRange\";\nimport { useDecimalTools } from \"./hooks/useDecimalTools\";\nimport { emptyString } from \"utils\";\nimport { useChangeValue } from \"./hooks/useChangeValue\";\n\nconst InputNumberComponent = forwardRef<HTMLInputElement, InputNumberProps>((props, ref) => {\n  const {\n    style,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    min,\n    max,\n    step = 1,\n    controls = true,\n    keyboard = true,\n    changeOnWheel = false,\n    changeOnBlur = true,\n    stringMode = false,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    onChange: onChangeProp,\n    onInput,\n    onPressEnter,\n    onStep: onStepProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputNumberTokens = getInputNumberTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const shiftKeyRef = useRef(false);\n  const inputValueRef = useRef<string | number | undefined>(emptyString);\n  const errorStatus = status === \"error\";\n  const hasSuffix = Boolean(suffixProp);\n  const hasAffix = Boolean(prefixProp) || hasSuffix;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { getPrecision, mergedParser, mergedFormatter } = useDecimalTools({\n    inputValueRef,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    step,\n  });\n\n  const [decimalValue, setDecimalValue] = useState<DecimalClass>(() =>\n    getMiniDecimal(value ?? defaultValue)\n  );\n\n  const { outOfRange, maxDecimal, minDecimal, getRangeValue, isInRange } = useRange({\n    decimalValue,\n    max,\n    min,\n  });\n  const { inputValue, triggerValueUpdate, flushInputValue, onChange } = useChangeValue({\n    decimalValue,\n    getPrecision,\n    mergedParser,\n    mergedFormatter,\n    setDecimalValue,\n    getRangeValue,\n    isInRange,\n    inputValueRef,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    stringMode,\n    onInput,\n    onChange: onChangeProp,\n  });\n  const { onStep, upDisabled, downDisabled } = useStep({\n    decimalValue,\n    maxDecimal,\n    minDecimal,\n    step,\n    stringMode,\n    inputRef,\n    shiftKeyRef,\n    triggerValueUpdate,\n    onStep: onStepProp,\n  });\n  const { onKeyDown, onKeyUp } = useKeyboardEvents({\n    keyboard,\n    shiftKeyRef,\n    flushInputValue,\n    onStep,\n    onPressEnter,\n  });\n  const { focus, inputNumberRef, onFocus, onBlur, onInputNumberClick } = useFocusBlurEvents({\n    changeOnBlur,\n    inputRef,\n    flushInputValue,\n  });\n  useWheelEvents({ focus, changeOnWheel, inputRef, onStep });\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[prefixStyle(theme), isString(prefixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[suffixStyle(theme), isString(suffixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputNumberWrapperClassName,\n            css: inputNumberWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <div\n        ref={inputNumberRef}\n        onClick={onInputNumberClick}\n        className={inputNumberClassName}\n        onFocus={onFocus}\n        onBlur={onBlur}\n        onKeyDown={onKeyDown}\n        onKeyUp={onKeyUp}\n        style={hasAddon ? undefined : style}\n        css={getInputWrapperStyle(\n          inputNumberTokens,\n          disabled,\n          hasAffix,\n          hasSuffix,\n          errorStatus,\n          controls\n        )(theme)}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          aria-valuemin={min ? Number(min) : undefined}\n          aria-valuemax={max ? Number(max) : undefined}\n          step={step}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={inputValue}\n          onChange={onChange}\n          css={getInputStyle(inputNumberTokens, disabled, hasAffix, outOfRange)(theme)}\n        />\n        {suffix}\n        {controls && !disabled && (\n          <StepController upDisabled={upDisabled} downDisabled={downDisabled} onStep={onStep} />\n        )}\n      </div>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const InputNumber = memo(InputNumberComponent);\n"]} */"], children: suffixProp });
+  })();
+  const addonBefore = (() => {
+    if (!addonBeforeProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [getAddonStyle(inputNumberTokens, disabled)(theme), isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:addonBefore;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx"],"names":[],"mappings":"AAqKQ","file":"/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx","sourcesContent":["import { forwardRef, Fragment, memo, useRef, useState } from \"react\";\nimport type { InputNumberProps } from \"./InputNumber.types\";\nimport { StepController } from \"./components/StepController/StepController\";\nimport { isString } from \"lodash-es\";\nimport { getInputNumberTokens } from \"./InputNumber.tokens\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  getAddonStyle,\n  getInputStyle,\n  getInputWrapperStyle,\n  inputNumberClassName,\n  inputNumberWrapperClassName,\n  inputNumberWrapperStyle,\n  nonStringAddonStyle,\n  nonStringPrefixSuffixStyle,\n  prefixStyle,\n  suffixStyle,\n} from \"./InputNumber.styles\";\nimport { getMiniDecimal, type DecimalClass } from \"./utils\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useStep } from \"./hooks/useStep\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useWheelEvents } from \"./hooks/useWheelEvents\";\nimport { useFocusBlurEvents } from \"./hooks/useFocusBlurEvents\";\nimport { useRange } from \"./hooks/useRange\";\nimport { useDecimalTools } from \"./hooks/useDecimalTools\";\nimport { emptyString } from \"utils\";\nimport { useChangeValue } from \"./hooks/useChangeValue\";\n\nconst InputNumberComponent = forwardRef<HTMLInputElement, InputNumberProps>((props, ref) => {\n  const {\n    style,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    min,\n    max,\n    step = 1,\n    controls = true,\n    keyboard = true,\n    changeOnWheel = false,\n    changeOnBlur = true,\n    stringMode = false,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    onChange: onChangeProp,\n    onInput,\n    onPressEnter,\n    onStep: onStepProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputNumberTokens = getInputNumberTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const shiftKeyRef = useRef(false);\n  const inputValueRef = useRef<string | number | undefined>(emptyString);\n  const errorStatus = status === \"error\";\n  const hasSuffix = Boolean(suffixProp);\n  const hasAffix = Boolean(prefixProp) || hasSuffix;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { getPrecision, mergedParser, mergedFormatter } = useDecimalTools({\n    inputValueRef,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    step,\n  });\n\n  const [decimalValue, setDecimalValue] = useState<DecimalClass>(() =>\n    getMiniDecimal(value ?? defaultValue)\n  );\n\n  const { outOfRange, maxDecimal, minDecimal, getRangeValue, isInRange } = useRange({\n    decimalValue,\n    max,\n    min,\n  });\n  const { inputValue, triggerValueUpdate, flushInputValue, onChange } = useChangeValue({\n    decimalValue,\n    getPrecision,\n    mergedParser,\n    mergedFormatter,\n    setDecimalValue,\n    getRangeValue,\n    isInRange,\n    inputValueRef,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    stringMode,\n    onInput,\n    onChange: onChangeProp,\n  });\n  const { onStep, upDisabled, downDisabled } = useStep({\n    decimalValue,\n    maxDecimal,\n    minDecimal,\n    step,\n    stringMode,\n    inputRef,\n    shiftKeyRef,\n    triggerValueUpdate,\n    onStep: onStepProp,\n  });\n  const { onKeyDown, onKeyUp } = useKeyboardEvents({\n    keyboard,\n    shiftKeyRef,\n    flushInputValue,\n    onStep,\n    onPressEnter,\n  });\n  const { focus, inputNumberRef, onFocus, onBlur, onInputNumberClick } = useFocusBlurEvents({\n    changeOnBlur,\n    inputRef,\n    flushInputValue,\n  });\n  useWheelEvents({ focus, changeOnWheel, inputRef, onStep });\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[prefixStyle(theme), isString(prefixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[suffixStyle(theme), isString(suffixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputNumberWrapperClassName,\n            css: inputNumberWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <div\n        ref={inputNumberRef}\n        onClick={onInputNumberClick}\n        className={inputNumberClassName}\n        onFocus={onFocus}\n        onBlur={onBlur}\n        onKeyDown={onKeyDown}\n        onKeyUp={onKeyUp}\n        style={hasAddon ? undefined : style}\n        css={getInputWrapperStyle(\n          inputNumberTokens,\n          disabled,\n          hasAffix,\n          hasSuffix,\n          errorStatus,\n          controls\n        )(theme)}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          aria-valuemin={min ? Number(min) : undefined}\n          aria-valuemax={max ? Number(max) : undefined}\n          step={step}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={inputValue}\n          onChange={onChange}\n          css={getInputStyle(inputNumberTokens, disabled, hasAffix, outOfRange)(theme)}\n        />\n        {suffix}\n        {controls && !disabled && (\n          <StepController upDisabled={upDisabled} downDisabled={downDisabled} onStep={onStep} />\n        )}\n      </div>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const InputNumber = memo(InputNumberComponent);\n"]} */"], children: addonBeforeProp });
+  })();
+  const addonAfter = (() => {
+    if (!addonAfterProp) {
+      return;
+    }
+    return /* @__PURE__ */ jsx("span", { css: [getAddonStyle(inputNumberTokens, disabled)(theme), isString(addonAfterProp) ? {} : nonStringAddonStyle(theme), process.env.NODE_ENV === "production" ? "" : ";label:addonAfter;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx"],"names":[],"mappings":"AAsLQ","file":"/builds/frontend/libs/ui-kit/src/components/InputNumber/InputNumber.tsx","sourcesContent":["import { forwardRef, Fragment, memo, useRef, useState } from \"react\";\nimport type { InputNumberProps } from \"./InputNumber.types\";\nimport { StepController } from \"./components/StepController/StepController\";\nimport { isString } from \"lodash-es\";\nimport { getInputNumberTokens } from \"./InputNumber.tokens\";\nimport { useTheme } from \"hooks/useTheme\";\nimport {\n  getAddonStyle,\n  getInputStyle,\n  getInputWrapperStyle,\n  inputNumberClassName,\n  inputNumberWrapperClassName,\n  inputNumberWrapperStyle,\n  nonStringAddonStyle,\n  nonStringPrefixSuffixStyle,\n  prefixStyle,\n  suffixStyle,\n} from \"./InputNumber.styles\";\nimport { getMiniDecimal, type DecimalClass } from \"./utils\";\nimport { useMergeRefs } from \"@floating-ui/react\";\nimport { useStep } from \"./hooks/useStep\";\nimport { useKeyboardEvents } from \"./hooks/useKeyboardEvents\";\nimport { useWheelEvents } from \"./hooks/useWheelEvents\";\nimport { useFocusBlurEvents } from \"./hooks/useFocusBlurEvents\";\nimport { useRange } from \"./hooks/useRange\";\nimport { useDecimalTools } from \"./hooks/useDecimalTools\";\nimport { emptyString } from \"utils\";\nimport { useChangeValue } from \"./hooks/useChangeValue\";\n\nconst InputNumberComponent = forwardRef<HTMLInputElement, InputNumberProps>((props, ref) => {\n  const {\n    style,\n    prefix: prefixProp,\n    suffix: suffixProp,\n    addonBefore: addonBeforeProp,\n    addonAfter: addonAfterProp,\n    status,\n    min,\n    max,\n    step = 1,\n    controls = true,\n    keyboard = true,\n    changeOnWheel = false,\n    changeOnBlur = true,\n    stringMode = false,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    onChange: onChangeProp,\n    onInput,\n    onPressEnter,\n    onStep: onStepProp,\n    ...restProps\n  } = props;\n  const theme = useTheme();\n  const inputNumberTokens = getInputNumberTokens(theme);\n  const inputRef = useRef<HTMLInputElement>(null);\n  const mergedRef = useMergeRefs([inputRef, ref]);\n  const shiftKeyRef = useRef(false);\n  const inputValueRef = useRef<string | number | undefined>(emptyString);\n  const errorStatus = status === \"error\";\n  const hasSuffix = Boolean(suffixProp);\n  const hasAffix = Boolean(prefixProp) || hasSuffix;\n  const hasAddon = Boolean(addonBeforeProp) || Boolean(addonAfterProp);\n  const AddonWrapper = hasAddon ? \"span\" : Fragment;\n  const { getPrecision, mergedParser, mergedFormatter } = useDecimalTools({\n    inputValueRef,\n    parser,\n    formatter,\n    precision,\n    decimalSeparator,\n    step,\n  });\n\n  const [decimalValue, setDecimalValue] = useState<DecimalClass>(() =>\n    getMiniDecimal(value ?? defaultValue)\n  );\n\n  const { outOfRange, maxDecimal, minDecimal, getRangeValue, isInRange } = useRange({\n    decimalValue,\n    max,\n    min,\n  });\n  const { inputValue, triggerValueUpdate, flushInputValue, onChange } = useChangeValue({\n    decimalValue,\n    getPrecision,\n    mergedParser,\n    mergedFormatter,\n    setDecimalValue,\n    getRangeValue,\n    isInRange,\n    inputValueRef,\n    defaultValue,\n    value,\n    disabled,\n    readOnly,\n    stringMode,\n    onInput,\n    onChange: onChangeProp,\n  });\n  const { onStep, upDisabled, downDisabled } = useStep({\n    decimalValue,\n    maxDecimal,\n    minDecimal,\n    step,\n    stringMode,\n    inputRef,\n    shiftKeyRef,\n    triggerValueUpdate,\n    onStep: onStepProp,\n  });\n  const { onKeyDown, onKeyUp } = useKeyboardEvents({\n    keyboard,\n    shiftKeyRef,\n    flushInputValue,\n    onStep,\n    onPressEnter,\n  });\n  const { focus, inputNumberRef, onFocus, onBlur, onInputNumberClick } = useFocusBlurEvents({\n    changeOnBlur,\n    inputRef,\n    flushInputValue,\n  });\n  useWheelEvents({ focus, changeOnWheel, inputRef, onStep });\n\n  const prefix = (() => {\n    if (!prefixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[prefixStyle(theme), isString(prefixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {prefixProp}\n      </span>\n    );\n  })();\n\n  const suffix = (() => {\n    if (!suffixProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[suffixStyle(theme), isString(suffixProp) ? {} : nonStringPrefixSuffixStyle(theme)]}\n      >\n        {suffixProp}\n      </span>\n    );\n  })();\n\n  const addonBefore = (() => {\n    if (!addonBeforeProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonBeforeProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonBeforeProp}\n      </span>\n    );\n  })();\n\n  const addonAfter = (() => {\n    if (!addonAfterProp) {\n      return;\n    }\n\n    return (\n      <span\n        css={[\n          getAddonStyle(inputNumberTokens, disabled)(theme),\n          isString(addonAfterProp) ? {} : nonStringAddonStyle(theme),\n        ]}\n      >\n        {addonAfterProp}\n      </span>\n    );\n  })();\n\n  return (\n    <AddonWrapper\n      {...(hasAddon\n        ? {\n            className: inputNumberWrapperClassName,\n            css: inputNumberWrapperStyle,\n            style,\n          }\n        : {})}\n    >\n      {addonBefore}\n      <div\n        ref={inputNumberRef}\n        onClick={onInputNumberClick}\n        className={inputNumberClassName}\n        onFocus={onFocus}\n        onBlur={onBlur}\n        onKeyDown={onKeyDown}\n        onKeyUp={onKeyUp}\n        style={hasAddon ? undefined : style}\n        css={getInputWrapperStyle(\n          inputNumberTokens,\n          disabled,\n          hasAffix,\n          hasSuffix,\n          errorStatus,\n          controls\n        )(theme)}\n      >\n        {prefix}\n        <input\n          {...restProps}\n          ref={mergedRef}\n          aria-valuemin={min ? Number(min) : undefined}\n          aria-valuemax={max ? Number(max) : undefined}\n          step={step}\n          disabled={disabled}\n          readOnly={readOnly}\n          value={inputValue}\n          onChange={onChange}\n          css={getInputStyle(inputNumberTokens, disabled, hasAffix, outOfRange)(theme)}\n        />\n        {suffix}\n        {controls && !disabled && (\n          <StepController upDisabled={upDisabled} downDisabled={downDisabled} onStep={onStep} />\n        )}\n      </div>\n      {addonAfter}\n    </AddonWrapper>\n  );\n});\n\nexport const InputNumber = memo(InputNumberComponent);\n"]} */"], children: addonAfterProp });
+  })();
+  return /* @__PURE__ */ jsxs(AddonWrapper, { ...hasAddon ? {
+    className: inputNumberWrapperClassName,
+    css: inputNumberWrapperStyle,
+    style
+  } : {}, children: [
+    addonBefore,
+    /* @__PURE__ */ jsxs("div", { ref: inputNumberRef, onClick: onInputNumberClick, className: inputNumberClassName, onFocus, onBlur, onKeyDown, onKeyUp, style: hasAddon ? void 0 : style, css: getInputWrapperStyle(inputNumberTokens, disabled, hasAffix, hasSuffix, errorStatus, controls)(theme), children: [
+      prefix,
+      /* @__PURE__ */ jsx("input", { ...restProps, ref: mergedRef, "aria-valuemin": min ? Number(min) : void 0, "aria-valuemax": max ? Number(max) : void 0, step, disabled, readOnly, value: inputValue, onChange, css: getInputStyle(inputNumberTokens, disabled, hasAffix, outOfRange)(theme) }),
+      suffix,
+      controls && !disabled && /* @__PURE__ */ jsx(StepController, { upDisabled, downDisabled, onStep })
+    ] }),
+    addonAfter
+  ] });
+});
+const InputNumber = memo(InputNumberComponent);
+export {
+  InputNumber
+};

package/dist/components/InputNumber/InputNumber.styles.d.ts

@@ -0,0 +1,107 @@
+import { Theme } from 'themes';
+import { InputNumberTokens } from './InputNumber.tokens';
+export declare const inputNumberWrapperClassName = "input-number-wrapper";
+export declare const inputNumberClassName = "input-number";
+export declare const inputNumberWrapperStyle: {
+    display: string;
+};
+export declare const prefixStyle: (theme: Theme) => {
+    marginRight: 4;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const suffixStyle: (theme: Theme) => {
+    marginLeft: 8;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const nonStringPrefixSuffixStyle: (theme: Theme) => {
+    fontSize: 16;
+};
+export declare const getAddonStyle: (inputNumberTokens: InputNumberTokens, disabled: boolean | undefined) => (theme: Theme) => {
+    color: "#262626" | "#8C8C8C";
+    backgroundColor: "#F0F0F0" | "#FAFAFA";
+    borderWidth: number;
+    borderStyle: string;
+    borderColor: "#D9D9D9";
+    borderRadius: 4;
+    paddingInline: number;
+    ":first-child": {
+        borderInlineEnd: number;
+        borderStartEndRadius: number;
+        borderEndEndRadius: number;
+    };
+    ":last-child": {
+        borderInlineStart: number;
+        borderStartStartRadius: number;
+        borderEndStartRadius: number;
+    };
+    fontFamily: "Roboto";
+    fontSize: 14;
+    lineHeight: "20px";
+    cursor: string | undefined;
+    display: string;
+    alignItems: string;
+    flex: string;
+};
+export declare const nonStringAddonStyle: (theme: Theme) => {
+    fontSize: 16;
+};
+export declare const getInputWrapperStyle: (inputNumberTokens: InputNumberTokens, disabled: boolean | undefined, hasAffix: boolean, hasSuffix: boolean, errorStatus: boolean, controls: boolean) => (theme: Theme) => {
+    readonly color: "#8C8C8C" | "#BFBFBF" | "#FF4D4F";
+    readonly padding: string | undefined;
+    readonly background: "#F0F0F0" | "#FFFFFF";
+    readonly borderWidth: 1;
+    readonly borderStyle: "solid";
+    readonly borderColor: "#D9D9D9" | "#FF4D4F";
+    readonly borderRadius: 4;
+    readonly ":focus, :focus-within": {
+        readonly borderColor: "#FF4D4F" | "#0CB3B3";
+        readonly boxShadow: `0px 0px 4px 0px rgba(${number}, ${number}, ${number}, 0.5)`;
+    };
+    readonly ":hover": {
+        readonly borderColor: "#FF7875" | "#50CCC4" | undefined;
+        readonly paddingRight: number | undefined;
+    };
+    readonly ".input-number-wrapper &:first-child": {
+        readonly borderStartEndRadius: 0;
+        readonly borderEndEndRadius: 0;
+    };
+    readonly ".input-number-wrapper &:last-child": {
+        readonly borderStartStartRadius: 0;
+        readonly borderEndStartRadius: 0;
+    };
+    readonly ".input-number-wrapper &:not(:first-child):not(:last-child)": {
+        readonly borderRadius: 0;
+    };
+    readonly fontFamily: "Roboto";
+    readonly fontSize: 14;
+    readonly lineHeight: "20px";
+    readonly boxSizing: "border-box";
+    readonly cursor: "not-allowed" | undefined;
+    readonly display: "inline-flex";
+    readonly position: "relative";
+};
+export declare const getInputStyle: (inputNumberTokens: InputNumberTokens, disabled: boolean | undefined, hasAffix: boolean, outOfRange: boolean) => (theme: Theme) => {
+    readonly boxSizing: "border-box";
+    readonly minWidth: 0;
+    readonly width: "100%";
+    readonly cursor: "inherit";
+    readonly fontFamily: "inherit";
+    readonly fontSize: "inherit";
+    readonly lineHeight: "inherit";
+    readonly background: "inherit";
+    readonly color: "#262626" | "#8C8C8C" | "#FF4D4F";
+    readonly padding: string | 0;
+    readonly border: "none";
+    readonly borderRadius: 4 | undefined;
+    readonly outline: "none";
+    readonly "::placeholder": {
+        readonly color: "#BFBFBF" | "inherit";
+    };
+    readonly ":placeholder-shown": {
+        readonly textOverflow: "ellipsis";
+    };
+};

package/dist/components/InputNumber/InputNumber.styles.js

@@ -0,0 +1,115 @@
+import { stepControllerWidth } from "./components/StepController/StepController.styles.js";
+const inputNumberWrapperClassName = "input-number-wrapper";
+const inputNumberClassName = "input-number";
+const inputNumberWrapperStyle = {
+  display: "inline-flex"
+};
+const commonAffixStyle = {
+  display: "flex",
+  alignItems: "center",
+  flex: "none"
+};
+const prefixStyle = (theme) => ({
+  ...commonAffixStyle,
+  marginRight: theme.marginXS
+});
+const suffixStyle = (theme) => ({
+  ...commonAffixStyle,
+  marginLeft: theme.marginM
+});
+const nonStringPrefixSuffixStyle = (theme) => ({
+  fontSize: theme.iconM
+});
+const getAddonStyle = (inputNumberTokens, disabled) => (theme) => ({
+  cursor: disabled ? "not-allowed" : void 0,
+  display: "flex",
+  alignItems: "center",
+  flex: "none",
+  ...theme.typography.body2,
+  color: disabled ? inputNumberTokens.inputNumberTextDisabled : inputNumberTokens.inputNumberText,
+  backgroundColor: disabled ? inputNumberTokens.inputNumberBgDisabled : inputNumberTokens.inputNumberAddonBg,
+  borderWidth: 1,
+  borderStyle: "solid",
+  borderColor: inputNumberTokens.inputNumberBorder,
+  borderRadius: theme.borderRadiusM,
+  paddingInline: inputNumberTokens.inputNumberPaddingHorizontal - 1,
+  ":first-child": {
+    borderInlineEnd: 0,
+    borderStartEndRadius: 0,
+    borderEndEndRadius: 0
+  },
+  ":last-child": {
+    borderInlineStart: 0,
+    borderStartStartRadius: 0,
+    borderEndStartRadius: 0
+  }
+});
+const nonStringAddonStyle = (theme) => ({
+  fontSize: theme.iconM
+});
+const getInputWrapperStyle = (inputNumberTokens, disabled, hasAffix, hasSuffix, errorStatus, controls) => (theme) => ({
+  boxSizing: "border-box",
+  cursor: disabled ? "not-allowed" : void 0,
+  display: "inline-flex",
+  position: "relative",
+  ...theme.typography.body2,
+  color: disabled ? inputNumberTokens.inputNumberTextDisabled : errorStatus ? inputNumberTokens.inputNumberTextDanger : inputNumberTokens.inputNumberPlaceholder,
+  padding: hasAffix ? `${inputNumberTokens.inputNumberPaddingVertical - 1}px ${inputNumberTokens.inputNumberPaddingHorizontal - 1}px` : void 0,
+  background: disabled ? inputNumberTokens.inputNumberBgDisabled : inputNumberTokens.inputNumberBg,
+  borderWidth: 1,
+  borderStyle: "solid",
+  borderColor: errorStatus ? inputNumberTokens.inputNumberBorderDanger : inputNumberTokens.inputNumberBorder,
+  borderRadius: theme.borderRadiusM,
+  ":focus, :focus-within": {
+    borderColor: errorStatus ? inputNumberTokens.inputNumberBorderDanger : inputNumberTokens.inputNumberBorderActive,
+    boxShadow: `0px 0px 4px 0px ${errorStatus ? theme.fieldFocusedDanger : theme.fieldFocused}`
+  },
+  ":hover": {
+    borderColor: disabled ? void 0 : errorStatus ? inputNumberTokens.inputNumberBorderDangerHover : inputNumberTokens.inputNumberBorderHover,
+    paddingRight: hasSuffix && !disabled && controls ? inputNumberTokens.inputNumberPaddingHorizontal + stepControllerWidth - 1 : void 0
+  },
+  [`.${inputNumberWrapperClassName} &:first-child`]: {
+    borderStartEndRadius: 0,
+    borderEndEndRadius: 0
+  },
+  [`.${inputNumberWrapperClassName} &:last-child`]: {
+    borderStartStartRadius: 0,
+    borderEndStartRadius: 0
+  },
+  [`.${inputNumberWrapperClassName} &:not(:first-child):not(:last-child)`]: {
+    borderRadius: 0
+  }
+});
+const getInputStyle = (inputNumberTokens, disabled, hasAffix, outOfRange) => (theme) => ({
+  boxSizing: "border-box",
+  minWidth: 0,
+  width: "100%",
+  cursor: "inherit",
+  fontFamily: "inherit",
+  fontSize: "inherit",
+  lineHeight: "inherit",
+  background: "inherit",
+  color: outOfRange ? inputNumberTokens.inputNumberTextDanger : disabled ? inputNumberTokens.inputNumberTextDisabled : inputNumberTokens.inputNumberText,
+  padding: hasAffix ? 0 : `${inputNumberTokens.inputNumberPaddingVertical - 1}px ${inputNumberTokens.inputNumberPaddingHorizontal - 1}px`,
+  border: "none",
+  borderRadius: hasAffix ? void 0 : theme.borderRadiusM,
+  outline: "none",
+  "::placeholder": {
+    color: disabled ? "inherit" : inputNumberTokens.inputNumberPlaceholder
+  },
+  ":placeholder-shown": {
+    textOverflow: "ellipsis"
+  }
+});
+export {
+  getAddonStyle,
+  getInputStyle,
+  getInputWrapperStyle,
+  inputNumberClassName,
+  inputNumberWrapperClassName,
+  inputNumberWrapperStyle,
+  nonStringAddonStyle,
+  nonStringPrefixSuffixStyle,
+  prefixStyle,
+  suffixStyle
+};

package/dist/components/InputNumber/InputNumber.tokens.d.ts

@@ -0,0 +1,18 @@
+import { Theme } from 'themes';
+export declare const getInputNumberTokens: (theme: Theme) => {
+    inputNumberBorder: "#D9D9D9";
+    inputNumberBorderHover: "#50CCC4";
+    inputNumberBorderActive: "#0CB3B3";
+    inputNumberBorderDanger: "#FF4D4F";
+    inputNumberBorderDangerHover: "#FF7875";
+    inputNumberBg: "#FFFFFF";
+    inputNumberBgDisabled: "#F0F0F0";
+    inputNumberPlaceholder: "#BFBFBF";
+    inputNumberText: "#262626";
+    inputNumberTextDisabled: "#8C8C8C";
+    inputNumberTextDanger: "#FF4D4F";
+    inputNumberAddonBg: "#FAFAFA";
+    inputNumberPaddingVertical: 4;
+    inputNumberPaddingHorizontal: 12;
+};
+export type InputNumberTokens = ReturnType<typeof getInputNumberTokens>;

package/dist/components/InputNumber/InputNumber.tokens.js

@@ -0,0 +1,19 @@
+const getInputNumberTokens = (theme) => ({
+  inputNumberBorder: theme.lineBorder,
+  inputNumberBorderHover: theme.primaryHover,
+  inputNumberBorderActive: theme.primaryBase,
+  inputNumberBorderDanger: theme.dangerBase,
+  inputNumberBorderDangerHover: theme.dangerHover,
+  inputNumberBg: theme.bgContainer,
+  inputNumberBgDisabled: theme.bgContainerDisabled,
+  inputNumberPlaceholder: theme.textHint,
+  inputNumberText: theme.textPrimary,
+  inputNumberTextDisabled: theme.textDisabled,
+  inputNumberTextDanger: theme.dangerBase,
+  inputNumberAddonBg: theme.bgContainerComplimentary,
+  inputNumberPaddingVertical: theme.x1,
+  inputNumberPaddingHorizontal: theme.x3
+});
+export {
+  getInputNumberTokens
+};

package/dist/components/InputNumber/InputNumber.types.d.ts

@@ -0,0 +1,41 @@
+import { InputHTMLAttributes, KeyboardEventHandler, ReactNode } from 'react';
+type ValueType = string | number;
+export interface InputNumberProps<T extends ValueType = ValueType> extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onInput" | "onChange" | "prefix" | "suffix"> {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    status?: "error";
+    defaultValue?: T;
+    value?: T;
+    min?: T;
+    max?: T;
+    /** @default 1 */
+    step?: ValueType;
+    /** @default true */
+    controls?: boolean;
+    /** @default true */
+    keyboard?: boolean;
+    /** @default false */
+    stringMode?: boolean;
+    parser?: (displayValue: string | undefined) => T;
+    formatter?: (value: T | undefined, info: {
+        userTyping: boolean;
+        input: string;
+    }) => string;
+    precision?: number;
+    decimalSeparator?: string;
+    /** @default true */
+    changeOnBlur?: boolean;
+    /** @default false */
+    changeOnWheel?: boolean;
+    onChange?: (value: T | null) => void;
+    onInput?: (text: string) => void;
+    onPressEnter?: KeyboardEventHandler<HTMLInputElement>;
+    onStep?: (value: T, info: {
+        offset: ValueType;
+        type: "up" | "down";
+        emitter: "handler" | "keyboard" | "wheel";
+    }) => void;
+}
+export {};

package/dist/components/InputNumber/InputNumber.utils.d.ts

@@ -0,0 +1,2 @@
+import { DecimalClass } from './utils';
+export declare const getDecimalValue: (stringMode: boolean, decimalValue: DecimalClass) => string | number;

package/dist/components/InputNumber/InputNumber.utils.js

@@ -0,0 +1,9 @@
+const getDecimalValue = (stringMode, decimalValue) => {
+  if (stringMode || decimalValue.isEmpty()) {
+    return decimalValue.toString();
+  }
+  return decimalValue.toNumber();
+};
+export {
+  getDecimalValue
+};

package/dist/components/InputNumber/components/StepController/StepController.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { StepControllerProps } from './StepController.types';
+export declare const StepController: FC<StepControllerProps>;

package/dist/components/InputNumber/components/StepController/StepController.js

@@ -0,0 +1,26 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { UpOutlined, DownOutlined } from "@infomaximum/icons";
+import { getInputNumberTokens } from "../../InputNumber.tokens.js";
+import { getStepControllerStyle, getStepUpWrapperStyle, getStepDownWrapperStyle } from "./StepController.styles.js";
+import { useTheme } from "../../../../hooks/useTheme/useTheme.js";
+const StepControllerComponent = (props) => {
+  const {
+    upDisabled,
+    downDisabled,
+    onStep
+  } = props;
+  const theme = useTheme();
+  const inputNumberTokens = getInputNumberTokens(theme);
+  return /* @__PURE__ */ jsxs("span", { css: getStepControllerStyle(inputNumberTokens)(theme), children: [
+    /* @__PURE__ */ jsx("span", { unselectable: "on", role: "button", "aria-label": "Increase Value", "aria-disabled": upDisabled, onMouseDown: (e) => e.preventDefault(), onClick: () => {
+      onStep(true, "handler");
+    }, css: getStepUpWrapperStyle(inputNumberTokens, upDisabled)(theme), children: /* @__PURE__ */ jsx(UpOutlined, {}) }),
+    /* @__PURE__ */ jsx("span", { unselectable: "on", role: "button", "aria-label": "Decrease Value", "aria-disabled": downDisabled, onMouseDown: (e) => e.preventDefault(), onClick: () => {
+      onStep(false, "handler");
+    }, css: getStepDownWrapperStyle(inputNumberTokens, downDisabled)(theme), children: /* @__PURE__ */ jsx(DownOutlined, {}) })
+  ] });
+};
+const StepController = StepControllerComponent;
+export {
+  StepController
+};