@infomaximum/ui-kit 0.9.1

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

@@ -0,0 +1,51 @@
+import { InputNumberTokens } from 'components/InputNumber/InputNumber.tokens';
+import { Theme } from 'themes';
+export declare const stepControllerWidth = 24;
+export declare const getStepControllerStyle: (inputNumberTokens: InputNumberTokens) => (theme: Theme) => {
+    readonly position: "absolute";
+    readonly insetBlockStart: 0;
+    readonly insetInlineEnd: 0;
+    readonly display: "flex";
+    readonly flexDirection: "column";
+    readonly height: "100%";
+    readonly width: 0;
+    readonly opacity: 0;
+    readonly background: "#FFFFFF";
+    readonly borderStartEndRadius: 4;
+    readonly borderEndEndRadius: 4;
+    readonly ".input-number:hover &": {
+        readonly width: number;
+        readonly opacity: 1;
+    };
+};
+export declare const getStepUpWrapperStyle: (inputNumberTokens: InputNumberTokens, upDisabled: boolean | undefined) => (theme: Theme) => {
+    boxSizing: "border-box";
+    cursor: "pointer" | "not-allowed";
+    display: "flex";
+    justifyContent: "center";
+    flex: "auto";
+    height: `${number}%`;
+    fontSize: 8;
+    color: `rgba(${number}, ${number}, ${number}, 0.3)`;
+    borderInlineStart: "1px solid #D9D9D9";
+    ":hover": {
+        readonly height: string | undefined;
+        readonly color: `rgba(${number}, ${number}, ${number}, 0.7)` | undefined;
+    };
+};
+export declare const getStepDownWrapperStyle: (inputNumberTokens: InputNumberTokens, downDisabled: boolean | undefined) => (theme: Theme) => {
+    borderBlockStart: string;
+    boxSizing: "border-box";
+    cursor: "pointer" | "not-allowed";
+    display: "flex";
+    justifyContent: "center";
+    flex: "auto";
+    height: `${number}%`;
+    fontSize: 8;
+    color: `rgba(${number}, ${number}, ${number}, 0.3)`;
+    borderInlineStart: "1px solid #D9D9D9";
+    ":hover": {
+        readonly height: string | undefined;
+        readonly color: `rgba(${number}, ${number}, ${number}, 0.7)` | undefined;
+    };
+};

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

@@ -0,0 +1,51 @@
+import { inputNumberClassName } from "../../InputNumber.styles.js";
+const stepControllerWidth = 24;
+const getStepControllerStyle = (inputNumberTokens) => (theme) => ({
+  position: "absolute",
+  insetBlockStart: 0,
+  insetInlineEnd: 0,
+  display: "flex",
+  flexDirection: "column",
+  height: "100%",
+  width: 0,
+  opacity: 0,
+  background: inputNumberTokens.inputNumberBg,
+  borderStartEndRadius: theme.borderRadiusM,
+  borderEndEndRadius: theme.borderRadiusM,
+  [`.${inputNumberClassName}:hover &`]: {
+    width: stepControllerWidth - 1,
+    opacity: 1
+  }
+});
+const getStepWrapperStyle = (inputNumberTokens, disable, theme) => {
+  const stepControllerHeight = theme.controlHeightM - 1 - 1;
+  const hoveredStepWrapperHeight = 15;
+  return {
+    boxSizing: "border-box",
+    cursor: disable ? "not-allowed" : "pointer",
+    display: "flex",
+    justifyContent: "center",
+    flex: "auto",
+    height: `${(stepControllerHeight - hoveredStepWrapperHeight) / stepControllerHeight * 100}%`,
+    fontSize: theme.iconXS,
+    color: theme.textIcon,
+    borderInlineStart: `1px solid ${inputNumberTokens.inputNumberBorder}`,
+    ":hover": {
+      height: disable ? void 0 : `${hoveredStepWrapperHeight / stepControllerHeight * 100}%`,
+      color: disable ? void 0 : theme.textIconHover
+    }
+  };
+};
+const getStepUpWrapperStyle = (inputNumberTokens, upDisabled) => (theme) => ({
+  ...getStepWrapperStyle(inputNumberTokens, upDisabled, theme)
+});
+const getStepDownWrapperStyle = (inputNumberTokens, downDisabled) => (theme) => ({
+  ...getStepWrapperStyle(inputNumberTokens, downDisabled, theme),
+  borderBlockStart: `1px solid ${inputNumberTokens.inputNumberBorder}`
+});
+export {
+  getStepControllerStyle,
+  getStepDownWrapperStyle,
+  getStepUpWrapperStyle,
+  stepControllerWidth
+};

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

@@ -0,0 +1,5 @@
+export interface StepControllerProps {
+    upDisabled?: boolean;
+    downDisabled?: boolean;
+    onStep: (up: boolean, emitter: "handler" | "keyboard" | "wheel") => void;
+}

package/dist/components/InputNumber/hooks/useChangeValue/index.d.ts

@@ -0,0 +1 @@
+export { useChangeValue } from './useChangeValue';

package/dist/components/InputNumber/hooks/useChangeValue/useChangeValue.d.ts

@@ -0,0 +1,9 @@
+import { UseChangeValueOptions } from './useChangeValue.types';
+import { DecimalClass } from 'components/InputNumber/utils';
+import { ChangeEventHandler } from 'react';
+export declare const useChangeValue: (options: UseChangeValueOptions) => {
+    inputValue: string | number | undefined;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    triggerValueUpdate: (newValue: DecimalClass, userTyping: boolean) => DecimalClass;
+    flushInputValue: (userTyping: boolean) => void;
+};

package/dist/components/InputNumber/hooks/useChangeValue/useChangeValue.js

@@ -0,0 +1,103 @@
+import { isNumber } from "lodash-es";
+import { getDecimalValue } from "../../InputNumber.utils.js";
+import { useState } from "react";
+import { emptyString } from "../../../../utils/const/index.js";
+import { getMiniDecimal, toFixed } from "../../utils/MiniDecimal.js";
+const useChangeValue = (options) => {
+  const {
+    decimalValue,
+    getPrecision,
+    mergedParser,
+    mergedFormatter,
+    setDecimalValue,
+    getRangeValue,
+    isInRange,
+    inputValueRef,
+    defaultValue,
+    value,
+    disabled,
+    readOnly,
+    stringMode,
+    onChange,
+    onInput
+  } = options;
+  const [inputValue, setInternalInputValue] = useState(() => {
+    const initValue = defaultValue ?? value;
+    if (decimalValue.isInvalidate() && ["string", "number"].includes(typeof initValue)) {
+      return Number.isNaN(initValue) ? emptyString : initValue;
+    }
+    return mergedFormatter(decimalValue.toString(), false);
+  });
+  inputValueRef.current = inputValue;
+  const setInputValue = (newValue, userTyping) => {
+    setInternalInputValue(mergedFormatter(newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping));
+  };
+  const setUncontrolledDecimalValue = (newDecimal) => {
+    if (value === void 0) {
+      setDecimalValue(newDecimal);
+    }
+  };
+  const triggerValueUpdate = (newValue, userTyping) => {
+    let updateValue = newValue;
+    let isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
+    if (!updateValue.isEmpty() && !userTyping) {
+      updateValue = getRangeValue(updateValue) || updateValue;
+      isRangeValidate = true;
+    }
+    if (!readOnly && !disabled && isRangeValidate) {
+      const numStr = updateValue.toString();
+      const mergedPrecision = getPrecision(numStr, userTyping);
+      if (isNumber(mergedPrecision) && mergedPrecision >= 0) {
+        updateValue = getMiniDecimal(toFixed(numStr, ".", mergedPrecision));
+        if (!isInRange(updateValue)) {
+          updateValue = getMiniDecimal(toFixed(numStr, ".", mergedPrecision, true));
+        }
+      }
+      if (!updateValue.equals(decimalValue)) {
+        setUncontrolledDecimalValue(updateValue);
+        onChange == null ? void 0 : onChange(updateValue.isEmpty() ? null : getDecimalValue(stringMode, updateValue));
+        if (value === void 0) {
+          setInputValue(updateValue, userTyping);
+        }
+      }
+      return updateValue;
+    }
+    return decimalValue;
+  };
+  const collectInputValue = (inputStr) => {
+    inputValueRef.current = inputStr;
+    setInternalInputValue(inputStr);
+    const finalValue = mergedParser(inputStr);
+    const finalDecimal = getMiniDecimal(finalValue);
+    if (!finalDecimal.isNaN()) {
+      triggerValueUpdate(finalDecimal, true);
+    }
+    onInput == null ? void 0 : onInput(inputStr);
+  };
+  const handleChange = (e) => {
+    collectInputValue(e.target.value);
+  };
+  const flushInputValue = (userTyping) => {
+    const parsedValue = getMiniDecimal(mergedParser(inputValue || ""));
+    let formatValue;
+    if (!parsedValue.isNaN()) {
+      formatValue = triggerValueUpdate(parsedValue, userTyping);
+    } else {
+      formatValue = triggerValueUpdate(decimalValue, userTyping);
+    }
+    if (value !== void 0) {
+      setInputValue(decimalValue, false);
+    } else if (!formatValue.isNaN()) {
+      setInputValue(formatValue, false);
+    }
+  };
+  return {
+    inputValue,
+    onChange: handleChange,
+    triggerValueUpdate,
+    flushInputValue
+  };
+};
+export {
+  useChangeValue
+};

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

@@ -0,0 +1,11 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { useRange } from '../useRange';
+import { useDecimalTools } from '../useDecimalTools';
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { DecimalClass } from 'components/InputNumber/utils';
+export interface UseChangeValueOptions extends Pick<InputNumberProps, "onChange" | "onInput" | "readOnly" | "disabled" | "defaultValue" | "value">, ReturnType<typeof useDecimalTools>, Pick<ReturnType<typeof useRange>, "getRangeValue" | "isInRange"> {
+    decimalValue: DecimalClass;
+    inputValueRef: MutableRefObject<string | number | undefined>;
+    stringMode: Exclude<InputNumberProps["stringMode"], undefined>;
+    setDecimalValue: Dispatch<SetStateAction<DecimalClass>>;
+}

package/dist/components/InputNumber/hooks/useDecimalTools/index.d.ts

@@ -0,0 +1 @@
+export { useDecimalTools } from './useDecimalTools';

package/dist/components/InputNumber/hooks/useDecimalTools/useDecimalTools.d.ts

@@ -0,0 +1,6 @@
+import { UseDecimalToolsOptions } from './useDecimalTools.types';
+export declare const useDecimalTools: (options: UseDecimalToolsOptions) => {
+    getPrecision: (numStr: string, userTyping: boolean) => number | undefined;
+    mergedParser: (num: string | number) => string | number;
+    mergedFormatter: (number: string, userTyping: boolean) => string;
+};

package/dist/components/InputNumber/hooks/useDecimalTools/useDecimalTools.js

@@ -0,0 +1,59 @@
+import { useCallback } from "react";
+import { isNumber } from "lodash-es";
+import { getNumberPrecision, num2str, validateNumber } from "../../utils/numberUtil.js";
+import { toFixed } from "../../utils/MiniDecimal.js";
+const useDecimalTools = (options) => {
+  const {
+    inputValueRef,
+    parser,
+    formatter,
+    precision,
+    decimalSeparator,
+    step
+  } = options;
+  const getPrecision = useCallback((numStr, userTyping) => {
+    if (userTyping) {
+      return;
+    }
+    if (isNumber(precision) && precision >= 0) {
+      return precision;
+    }
+    return Math.max(getNumberPrecision(numStr), getNumberPrecision(step));
+  }, [precision, step]);
+  const mergedParser = useCallback((num) => {
+    const numStr = String(num);
+    if (parser) {
+      return parser(numStr);
+    }
+    let parsedStr = numStr;
+    if (decimalSeparator) {
+      parsedStr = parsedStr.replace(decimalSeparator, ".");
+    }
+    return parsedStr.replace(/[^\w.-]+/g, "");
+  }, [parser, decimalSeparator]);
+  const mergedFormatter = useCallback((number, userTyping) => {
+    if (formatter) {
+      return formatter(number, {
+        userTyping,
+        input: String(inputValueRef.current)
+      });
+    }
+    let str = typeof number === "number" ? num2str(number) : number;
+    if (!userTyping) {
+      const mergedPrecision = getPrecision(str, userTyping);
+      if (validateNumber(str) && (decimalSeparator || isNumber(mergedPrecision) && mergedPrecision >= 0)) {
+        const separatorStr = decimalSeparator || ".";
+        str = toFixed(str, separatorStr, mergedPrecision);
+      }
+    }
+    return str;
+  }, [formatter, inputValueRef, getPrecision, decimalSeparator]);
+  return {
+    getPrecision,
+    mergedParser,
+    mergedFormatter
+  };
+};
+export {
+  useDecimalTools
+};

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

@@ -0,0 +1,6 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { MutableRefObject } from 'react';
+export interface UseDecimalToolsOptions extends Pick<InputNumberProps, "parser" | "formatter" | "precision" | "decimalSeparator"> {
+    inputValueRef: MutableRefObject<string | number | undefined>;
+    step: Exclude<InputNumberProps["step"], undefined>;
+}

package/dist/components/InputNumber/hooks/useFocusBlurEvents/index.d.ts

@@ -0,0 +1 @@
+export { useFocusBlurEvents } from './useFocusBlurEvents';

package/dist/components/InputNumber/hooks/useFocusBlurEvents/useFocusBlurEvents.d.ts

@@ -0,0 +1,9 @@
+import { MouseEventHandler } from 'react';
+import { UseFocusBlurEventsOptions } from './useFocusBlurEvents.types';
+export declare const useFocusBlurEvents: (options: UseFocusBlurEventsOptions) => {
+    focus: boolean;
+    inputNumberRef: import('react').RefObject<HTMLDivElement>;
+    onFocus: () => void;
+    onBlur: () => void;
+    onInputNumberClick: MouseEventHandler<HTMLDivElement>;
+};

package/dist/components/InputNumber/hooks/useFocusBlurEvents/useFocusBlurEvents.js

@@ -0,0 +1,35 @@
+import { useRef, useState } from "react";
+const useFocusBlurEvents = (options) => {
+  const {
+    changeOnBlur,
+    inputRef,
+    flushInputValue
+  } = options;
+  const inputNumberRef = useRef(null);
+  const [focus, setFocus] = useState(false);
+  const handleFocus = () => {
+    setFocus(true);
+  };
+  const handleBlur = () => {
+    if (changeOnBlur) {
+      flushInputValue(false);
+    }
+    setFocus(false);
+  };
+  const handleInputNumberClick = (e) => {
+    var _a, _b;
+    if (e.target instanceof Node && ((_a = inputNumberRef.current) == null ? void 0 : _a.contains(e.target))) {
+      (_b = inputRef.current) == null ? void 0 : _b.focus();
+    }
+  };
+  return {
+    focus,
+    inputNumberRef,
+    onFocus: handleFocus,
+    onBlur: handleBlur,
+    onInputNumberClick: handleInputNumberClick
+  };
+};
+export {
+  useFocusBlurEvents
+};

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

@@ -0,0 +1,7 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { RefObject } from 'react';
+export interface UseFocusBlurEventsOptions {
+    changeOnBlur: Exclude<InputNumberProps["changeOnBlur"], undefined>;
+    flushInputValue: (userTyping: boolean) => void;
+    inputRef: RefObject<HTMLInputElement>;
+}

package/dist/components/InputNumber/hooks/useKeyboardEvents/index.d.ts

@@ -0,0 +1 @@
+export { useKeyboardEvents } from './useKeyboardEvents';

package/dist/components/InputNumber/hooks/useKeyboardEvents/useKeyboardEvents.d.ts

@@ -0,0 +1,6 @@
+import { KeyboardEventHandler } from 'react';
+import { UseKeyboardEventsOptions } from './useKeyboardEvents.types';
+export declare const useKeyboardEvents: (options: UseKeyboardEventsOptions) => {
+    onKeyDown: KeyboardEventHandler<HTMLInputElement>;
+    onKeyUp: () => void;
+};

package/dist/components/InputNumber/hooks/useKeyboardEvents/useKeyboardEvents.js

@@ -0,0 +1,37 @@
+const useKeyboardEvents = (options) => {
+  const {
+    shiftKeyRef,
+    keyboard,
+    flushInputValue,
+    onStep,
+    onPressEnter
+  } = options;
+  const handleKeyDown = (event) => {
+    const {
+      key,
+      shiftKey
+    } = event;
+    shiftKeyRef.current = shiftKey;
+    if (key === "Enter") {
+      flushInputValue(false);
+      onPressEnter == null ? void 0 : onPressEnter(event);
+    }
+    if (keyboard === false) {
+      return;
+    }
+    if (["Up", "ArrowUp", "Down", "ArrowDown"].includes(key)) {
+      onStep(key === "Up" || key === "ArrowUp", "keyboard");
+      event.preventDefault();
+    }
+  };
+  const handleKeyUp = () => {
+    shiftKeyRef.current = false;
+  };
+  return {
+    onKeyDown: handleKeyDown,
+    onKeyUp: handleKeyUp
+  };
+};
+export {
+  useKeyboardEvents
+};

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

@@ -0,0 +1,10 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { MutableRefObject } from 'react';
+import { useStep } from '../useStep';
+export interface UseKeyboardEventsOptions {
+    shiftKeyRef: MutableRefObject<boolean>;
+    keyboard: InputNumberProps["keyboard"];
+    flushInputValue: (userTyping: boolean) => void;
+    onStep: ReturnType<typeof useStep>["onStep"];
+    onPressEnter: InputNumberProps["onPressEnter"];
+}

package/dist/components/InputNumber/hooks/useRange/index.d.ts

@@ -0,0 +1 @@
+export { useRange } from './useRange';

package/dist/components/InputNumber/hooks/useRange/useRange.d.ts

@@ -0,0 +1,9 @@
+import { UseRangeOptions } from './useRange.types';
+import { DecimalClass } from 'components/InputNumber/utils';
+export declare const useRange: (options: UseRangeOptions) => {
+    outOfRange: boolean;
+    maxDecimal: DecimalClass | null;
+    minDecimal: DecimalClass | null;
+    getRangeValue: (target: DecimalClass) => DecimalClass | null;
+    isInRange: (target: DecimalClass) => boolean;
+};

package/dist/components/InputNumber/hooks/useRange/useRange.js

@@ -0,0 +1,36 @@
+import { useMemo } from "react";
+import { getMiniDecimal } from "../../utils/MiniDecimal.js";
+const getDecimalIfValidate = (value) => {
+  const decimal = getMiniDecimal(value);
+  return decimal.isInvalidate() ? null : decimal;
+};
+const useRange = (options) => {
+  const {
+    max,
+    min,
+    decimalValue
+  } = options;
+  const maxDecimal = useMemo(() => getDecimalIfValidate(max), [max]);
+  const minDecimal = useMemo(() => getDecimalIfValidate(min), [min]);
+  const getRangeValue = (target) => {
+    if (maxDecimal && !target.lessEquals(maxDecimal)) {
+      return maxDecimal;
+    }
+    if (minDecimal && !minDecimal.lessEquals(target)) {
+      return minDecimal;
+    }
+    return null;
+  };
+  const isInRange = (target) => !getRangeValue(target);
+  const outOfRange = !decimalValue.isInvalidate() && !isInRange(decimalValue);
+  return {
+    outOfRange,
+    maxDecimal,
+    minDecimal,
+    getRangeValue,
+    isInRange
+  };
+};
+export {
+  useRange
+};

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

@@ -0,0 +1,7 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { DecimalClass } from 'components/InputNumber/utils';
+export interface UseRangeOptions {
+    decimalValue: DecimalClass;
+    max: InputNumberProps["max"];
+    min: InputNumberProps["min"];
+}

package/dist/components/InputNumber/hooks/useStep/index.d.ts

@@ -0,0 +1 @@
+export { useStep } from './useStep';

package/dist/components/InputNumber/hooks/useStep/useStep.d.ts

@@ -0,0 +1,6 @@
+import { UseStepOptions } from './useStep.types';
+export declare const useStep: (options: UseStepOptions) => {
+    onStep: (up: boolean, emitter: "handler" | "keyboard" | "wheel") => void;
+    upDisabled: boolean;
+    downDisabled: boolean;
+};

package/dist/components/InputNumber/hooks/useStep/useStep.js

@@ -0,0 +1,55 @@
+import { useMemo } from "react";
+import { getDecimalValue } from "../../InputNumber.utils.js";
+import { getMiniDecimal } from "../../utils/MiniDecimal.js";
+import { getDecupleSteps } from "../../utils/numberUtil.js";
+const useStep = (options) => {
+  const {
+    decimalValue,
+    maxDecimal,
+    minDecimal,
+    step,
+    stringMode,
+    inputRef,
+    shiftKeyRef,
+    triggerValueUpdate,
+    onStep
+  } = options;
+  const upDisabled = useMemo(() => {
+    if (!maxDecimal || !decimalValue || decimalValue.isInvalidate()) {
+      return false;
+    }
+    return maxDecimal.lessEquals(decimalValue);
+  }, [maxDecimal, decimalValue]);
+  const downDisabled = useMemo(() => {
+    if (!minDecimal || !decimalValue || decimalValue.isInvalidate()) {
+      return false;
+    }
+    return decimalValue.lessEquals(minDecimal);
+  }, [minDecimal, decimalValue]);
+  const handleStep = (up, emitter) => {
+    var _a;
+    if (up && upDisabled || !up && downDisabled) {
+      return;
+    }
+    let stepDecimal = getMiniDecimal(shiftKeyRef.current ? getDecupleSteps(step) : step);
+    if (!up) {
+      stepDecimal = stepDecimal.negate();
+    }
+    const target = (decimalValue || getMiniDecimal(0)).add(stepDecimal.toString());
+    const updatedValue = triggerValueUpdate(target, false);
+    onStep == null ? void 0 : onStep(getDecimalValue(stringMode, updatedValue), {
+      offset: shiftKeyRef.current ? getDecupleSteps(step) : step,
+      type: up ? "up" : "down",
+      emitter
+    });
+    (_a = inputRef.current) == null ? void 0 : _a.focus();
+  };
+  return {
+    onStep: handleStep,
+    upDisabled,
+    downDisabled
+  };
+};
+export {
+  useStep
+};

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

@@ -0,0 +1,14 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { DecimalClass } from 'components/InputNumber/utils';
+import { MutableRefObject, RefObject } from 'react';
+export interface UseStepOptions {
+    decimalValue: DecimalClass;
+    maxDecimal: DecimalClass | null;
+    minDecimal: DecimalClass | null;
+    inputRef: RefObject<HTMLInputElement>;
+    shiftKeyRef: MutableRefObject<boolean>;
+    stringMode: Exclude<InputNumberProps["stringMode"], undefined>;
+    step: Exclude<InputNumberProps["step"], undefined>;
+    triggerValueUpdate: (newValue: DecimalClass, userTyping: boolean) => DecimalClass;
+    onStep: InputNumberProps["onStep"];
+}

package/dist/components/InputNumber/hooks/useWheelEvents/index.d.ts

@@ -0,0 +1 @@
+export { useWheelEvents } from './useWheelEvents';

package/dist/components/InputNumber/hooks/useWheelEvents/useWheelEvents.d.ts

@@ -0,0 +1,2 @@
+import { UseWheelEventsOptions } from './useWheelEvents.types';
+export declare const useWheelEvents: (options: UseWheelEventsOptions) => void;

package/dist/components/InputNumber/hooks/useWheelEvents/useWheelEvents.js

@@ -0,0 +1,27 @@
+import { useEffect } from "react";
+const useWheelEvents = (options) => {
+  const {
+    focus,
+    changeOnWheel,
+    inputRef,
+    onStep
+  } = options;
+  useEffect(() => {
+    if (changeOnWheel && focus) {
+      const onWheel = (event) => {
+        onStep(event.deltaY < 0, "wheel");
+        event.preventDefault();
+      };
+      const input = inputRef.current;
+      if (input) {
+        input.addEventListener("wheel", onWheel, {
+          passive: false
+        });
+        return () => input.removeEventListener("wheel", onWheel);
+      }
+    }
+  });
+};
+export {
+  useWheelEvents
+};

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

@@ -0,0 +1,9 @@
+import { InputNumberProps } from 'components/InputNumber/InputNumber.types';
+import { RefObject } from 'react';
+import { useStep } from '../useStep';
+export interface UseWheelEventsOptions {
+    focus: boolean;
+    changeOnWheel: Exclude<InputNumberProps["changeOnWheel"], undefined>;
+    inputRef: RefObject<HTMLInputElement>;
+    onStep: ReturnType<typeof useStep>["onStep"];
+}

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

@@ -0,0 +1,2 @@
+export { InputNumber } from './InputNumber';
+export type { InputNumberProps } from './InputNumber.types';

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

@@ -0,0 +1,27 @@
+import { DecimalClass, ValueType } from './interface';
+export declare class BigIntDecimal implements DecimalClass {
+    private origin;
+    private negative;
+    private integer;
+    private decimal;
+    /** BigInt will convert `0009` to `9`. We need record the len of decimal */
+    private decimalLen;
+    private empty;
+    private nan;
+    constructor(value: string | number | undefined | null);
+    private getMark;
+    private getIntegerStr;
+    private getDecimalStr;
+    private alignDecimal;
+    negate(): BigIntDecimal;
+    private cal;
+    add(value: ValueType): BigIntDecimal;
+    multi(value: ValueType): BigIntDecimal;
+    isEmpty(): boolean | undefined;
+    isNaN(): boolean | undefined;
+    isInvalidate(): boolean | undefined;
+    equals(target: DecimalClass): boolean;
+    lessEquals(target: DecimalClass): boolean;
+    toNumber(): number;
+    toString(safe?: boolean): string;
+}