numeric-input-react 1.0.22 → 1.0.23

package/dist/numeric-input.types.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentProps } from 'react';
+export type NumericInputValue = {
+    value: number;
+    formattedValue: string;
+};
+export type NumericInputProps = ComponentProps<'input'> & {
+    onValueChange: (valueObject: NumericInputValue) => void;
+    separator?: string;
+    allowDecimal?: boolean;
+    allowNegative?: boolean;
+    minValue?: number;
+    maxValue?: number;
+    maxDecimalPlaces?: number;
+};
+//# sourceMappingURL=numeric-input.types.d.ts.map

package/dist/numeric-input.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-input.types.d.ts","sourceRoot":"","sources":["../src/numeric-input.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG;IACxD,aAAa,EAAE,CAAC,WAAW,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACvD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA"}

package/dist/numeric-input.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=numeric-input.types.js.map

package/dist/numeric-input.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-input.types.js","sourceRoot":"","sources":["../src/numeric-input.types.ts"],"names":[],"mappings":""}

package/dist/numeric-input.utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts full-width Japanese characters to half-width equivalents
+ * Supports: numbers (０-９), period (．), comma (，), minus (－)
+ */
+export declare const convertFullWidthToHalfWidth: (str: string) => string;
+/**
+ * Escapes special regex characters in a string
+ */
+export declare const escapeRegex: (str: string) => string;
+/**
+ * Checks if a string is a minus sign (half-width, full-width, katakana, or mathematical)
+ */
+export declare const isMinusSign: (str: string) => boolean;
+/**
+ * Converts any minus sign variant to half-width minus
+ */
+export declare const normalizeMinusSign: (str: string) => string;
+/**
+ * Parses a value prop (string or number) to a number, removing separator if present
+ */
+export declare const parseValueProp: (value: string | number | readonly string[] | null | undefined, separator?: string) => number;
+/**
+ * Normalizes the input string by removing invalid characters
+ * and ensuring proper decimal point handling
+ */
+export declare const normalizeNumericInput: (input: string, allowDecimal: boolean, allowNegative: boolean, maxLength?: number) => string;
+//# sourceMappingURL=numeric-input.utils.d.ts.map

package/dist/numeric-input.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-input.utils.d.ts","sourceRoot":"","sources":["../src/numeric-input.utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GAAI,KAAK,MAAM,KAAG,MAWzD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,MAEzC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,OAEzC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,KAAG,MAEhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAC7D,YAAY,MAAM,KACjB,MA2BF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,MAAM,EACb,cAAc,OAAO,EACrB,eAAe,OAAO,EACtB,YAAY,MAAM,KACjB,MAiFF,CAAA"}

package/dist/numeric-input.utils.js

@@ -0,0 +1,143 @@
+/**
+ * Converts full-width Japanese characters to half-width equivalents
+ * Supports: numbers (０-９), period (．), comma (，), minus (－)
+ */
+export const convertFullWidthToHalfWidth = (str) => {
+    return str
+        .replace(/[０-９]/g, (char) => {
+        // Convert full-width numbers (０-９) to half-width (0-9)
+        return String.fromCharCode(char.charCodeAt(0) - 0xfee0);
+    })
+        .replace(/[．]/g, '.') // Convert full-width period (．) to half-width (.)
+        .replace(/[，]/g, ',') // Convert full-width comma (，) to half-width (,)
+        .replace(/[－]/g, '-') // Convert full-width minus (－, U+FF0D) to half-width (-)
+        .replace(/[ー]/g, '-') // Convert katakana long vowel mark (ー, U+30FC) to minus (-) when used as minus
+        .replace(/[−]/g, '-'); // Convert mathematical minus sign (−, U+2212) to half-width (-)
+};
+/**
+ * Escapes special regex characters in a string
+ */
+export const escapeRegex = (str) => {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+/**
+ * Checks if a string is a minus sign (half-width, full-width, katakana, or mathematical)
+ */
+export const isMinusSign = (str) => {
+    return str === '-' || str === '－' || str === 'ー' || str === '−';
+};
+/**
+ * Converts any minus sign variant to half-width minus
+ */
+export const normalizeMinusSign = (str) => {
+    return isMinusSign(str) ? '-' : str;
+};
+/**
+ * Parses a value prop (string or number) to a number, removing separator if present
+ */
+export const parseValueProp = (value, separator) => {
+    if (value === null || value === undefined || value === '') {
+        return NaN;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    // Handle array case (shouldn't happen for numeric input, but handle gracefully)
+    if (Array.isArray(value)) {
+        const firstValue = value[0];
+        if (!firstValue) {
+            return NaN;
+        }
+        const cleanedValue = separator
+            ? firstValue.replace(new RegExp(`[${escapeRegex(separator)}]`, 'g'), '')
+            : firstValue;
+        return Number(cleanedValue);
+    }
+    // At this point, value must be a string
+    const cleanedValue = separator
+        ? value.replace(new RegExp(`[${escapeRegex(separator)}]`, 'g'), '')
+        : value;
+    return Number(cleanedValue);
+};
+/**
+ * Normalizes the input string by removing invalid characters
+ * and ensuring proper decimal point handling
+ */
+export const normalizeNumericInput = (input, allowDecimal, allowNegative, maxLength) => {
+    let normalized = input;
+    // Remove all characters except digits, decimal point, and optionally minus sign
+    const allowedChars = allowDecimal
+        ? allowNegative
+            ? /[^0-9.\-]/g
+            : /[^0-9.]/g
+        : allowNegative
+            ? /[^0-9\-]/g
+            : /[^0-9]/g;
+    normalized = normalized.replace(allowedChars, '');
+    // Handle negative sign: only allow at the start
+    if (allowNegative) {
+        const minusCount = (normalized.match(/-/g) || []).length;
+        if (minusCount > 1) {
+            // Keep only the first minus sign
+            normalized = normalized.replace(/-/g, (match, offset) => {
+                return offset === 0 ? match : '';
+            });
+        }
+        // If minus is not at the start, move it to the start
+        if (normalized.includes('-') && !normalized.startsWith('-')) {
+            normalized = `-${normalized.replace(/-/g, '')}`;
+        }
+    }
+    else {
+        normalized = normalized.replace(/-/g, '');
+    }
+    // Handle decimal point: only allow one, and only if decimals are allowed
+    if (allowDecimal) {
+        const decimalCount = (normalized.match(/\./g) || []).length;
+        if (decimalCount > 1) {
+            // Keep only the first decimal point
+            const firstDecimalIndex = normalized.indexOf('.');
+            normalized =
+                normalized.slice(0, firstDecimalIndex + 1) +
+                    normalized.slice(firstDecimalIndex + 1).replace(/\./g, '');
+        }
+    }
+    else {
+        normalized = normalized.replace(/\./g, '');
+    }
+    // Apply maxLength if specified
+    // maxLength should only apply to digits, not to minus sign or decimal point
+    if (maxLength) {
+        // Count only digits in the normalized string
+        const digitCount = (normalized.match(/\d/g) || []).length;
+        if (digitCount > maxLength) {
+            // Remove excess digits from the end, preserving minus sign and decimal point
+            const hasMinus = normalized.startsWith('-');
+            let result = hasMinus ? '-' : '';
+            let digitsSeen = 0;
+            let decimalAdded = false;
+            // Start from after minus sign if present
+            for (let i = hasMinus ? 1 : 0; i < normalized.length; i++) {
+                const char = normalized[i];
+                if (/\d/.test(char)) {
+                    // Only keep digits up to maxLength
+                    if (digitsSeen < maxLength) {
+                        result += char;
+                        digitsSeen++;
+                    }
+                    // Skip excess digits
+                }
+                else if (char === '.' && !decimalAdded) {
+                    // Only keep decimal point if we have at least one digit and haven't added one yet
+                    if (digitsSeen > 0) {
+                        result += char;
+                        decimalAdded = true;
+                    }
+                }
+            }
+            normalized = result;
+        }
+    }
+    return normalized;
+};
+//# sourceMappingURL=numeric-input.utils.js.map

package/dist/numeric-input.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-input.utils.js","sourceRoot":"","sources":["../src/numeric-input.utils.ts"],"names":[],"mappings":"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"}

package/dist/use-numeric-input.d.ts

@@ -0,0 +1,28 @@
+import { type CompositionEvent, type FocusEvent } from 'react';
+import type { NumericInputValue, NumericInputProps } from './numeric-input.types';
+type UseNumericInputOptions = {
+    value: NumericInputProps['value'];
+    separator?: string;
+    allowDecimal?: boolean;
+    allowNegative?: boolean;
+    minValue?: number;
+    maxValue?: number;
+    maxDecimalPlaces?: number;
+    maxLength?: number;
+    onValueChange: (valueObject: NumericInputValue) => void;
+    onCompositionStart?: NumericInputProps['onCompositionStart'];
+    onCompositionEnd?: NumericInputProps['onCompositionEnd'];
+    onBlur?: NumericInputProps['onBlur'];
+};
+export declare const useNumericInput: (options: UseNumericInputOptions) => {
+    inputRef: import("react").RefObject<HTMLInputElement | null>;
+    inputMode: "decimal" | "numeric";
+    displayValue: string;
+    hasProcessedComposition: import("react").RefObject<boolean>;
+    handleBlur: (e: FocusEvent<HTMLInputElement>) => void;
+    handleValueChange: (inputValue: string, skipCompositionCheck?: boolean) => void;
+    handleCompositionEnd: (e: CompositionEvent<HTMLInputElement>) => void;
+    handleCompositionStart: (e: CompositionEvent<HTMLInputElement>) => void;
+};
+export {};
+//# sourceMappingURL=use-numeric-input.d.ts.map

package/dist/use-numeric-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-numeric-input.d.ts","sourceRoot":"","sources":["../src/use-numeric-input.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAMhB,MAAM,OAAO,CAAA;AAQd,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAEjF,KAAK,sBAAsB,GAAG;IAC5B,KAAK,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAA;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,CAAC,WAAW,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACvD,kBAAkB,CAAC,EAAE,iBAAiB,CAAC,oBAAoB,CAAC,CAAA;IAC5D,gBAAgB,CAAC,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,CAAA;IACxD,MAAM,CAAC,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAA;CACrC,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB;;;;;oBAwTvD,UAAU,CAAC,gBAAgB,CAAC;oCAzPnB,MAAM;8BAqOf,gBAAgB,CAAC,gBAAgB,CAAC;gCA/BlC,gBAAgB,CAAC,gBAAgB,CAAC;CAgQzC,CAAA"}

package/dist/use-numeric-input.js

@@ -0,0 +1,420 @@
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { convertFullWidthToHalfWidth, isMinusSign, normalizeMinusSign, normalizeNumericInput, parseValueProp, } from './numeric-input.utils';
+export const useNumericInput = (options) => {
+    const { value, maxValue, minValue, separator, maxLength, maxDecimalPlaces, allowDecimal = false, allowNegative = false, onBlur, onValueChange, onCompositionEnd, onCompositionStart, } = options;
+    // Validate min/max values
+    if (minValue !== undefined && maxValue !== undefined && minValue > maxValue) {
+        console.warn('NumericInput: minValue should be less than or equal to maxValue');
+    }
+    const isComposing = useRef(false);
+    const inputRef = useRef(null);
+    // Store the raw input value during IME composition
+    const [composingValue, setComposingValue] = useState('');
+    // Track if we've already processed the value from composition end
+    const hasProcessedComposition = useRef(false);
+    // Store the raw input string to preserve leading zeros
+    const [rawInputValue, setRawInputValue] = useState('');
+    const formatValue = useCallback((numValue) => {
+        if (Number.isNaN(numValue) || !Number.isFinite(numValue)) {
+            return '';
+        }
+        const valueStr = numValue.toString();
+        // If no separator, return as is
+        if (!separator) {
+            return valueStr;
+        }
+        // Split into integer and decimal parts
+        const [integerPart, decimalPart] = valueStr.split('.');
+        // Format integer part with separator (thousands separator)
+        const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+        // Combine with decimal part if exists
+        return decimalPart !== undefined
+            ? `${formattedInteger}.${decimalPart}`
+            : formattedInteger;
+    }, [separator]);
+    const handleValueChange = useCallback((inputValue, skipCompositionCheck = false) => {
+        // During IME composition, update the composing value for display
+        // Don't convert full-width to half-width yet - wait for composition end
+        if (!skipCompositionCheck && isComposing.current) {
+            setComposingValue(inputValue);
+            // Store raw input value (could be full-width) for later processing
+            setRawInputValue(inputValue);
+            // Still notify parent but don't process the value
+            onValueChange({
+                value: 0,
+                formattedValue: inputValue,
+            });
+            return;
+        }
+        // Convert full-width Japanese characters to half-width
+        let rawValue = convertFullWidthToHalfWidth(inputValue);
+        // Remove scientific notation (e.g., "1e10", "1E10")
+        // This prevents unexpected number conversions
+        rawValue = rawValue.replace(/[eE]/g, '');
+        // Normalize the input (remove invalid chars, handle decimals, negatives)
+        rawValue = normalizeNumericInput(rawValue, allowDecimal, allowNegative, maxLength);
+        // Limit decimal places if specified
+        if (maxDecimalPlaces !== undefined && allowDecimal) {
+            const decimalIndex = rawValue.indexOf('.');
+            if (decimalIndex !== -1) {
+                const integerPart = rawValue.slice(0, decimalIndex);
+                const decimalPart = rawValue.slice(decimalIndex + 1);
+                if (decimalPart.length > maxDecimalPlaces) {
+                    rawValue = `${integerPart}.${decimalPart.slice(0, maxDecimalPlaces)}`;
+                }
+            }
+        }
+        // Handle empty input first (before processing leading zeros)
+        if (rawValue === '') {
+            setRawInputValue('');
+            onValueChange({
+                value: 0,
+                formattedValue: '',
+            });
+            return;
+        }
+        // Handle only minus sign (half-width or full-width converted): preserve it if allowNegative is true
+        if (rawValue === '-') {
+            if (allowNegative) {
+                setRawInputValue('-');
+                onValueChange({
+                    value: 0,
+                    formattedValue: '-',
+                });
+                return;
+            }
+            else {
+                // If negative is not allowed, treat as empty
+                setRawInputValue('');
+                onValueChange({
+                    value: 0,
+                    formattedValue: '',
+                });
+                return;
+            }
+        }
+        // Remove leading zeros except for single "0" or "0." patterns
+        const shouldKeepSingleZero = rawValue === '0' ||
+            rawValue === '-0' ||
+            rawValue === '0.' ||
+            rawValue === '-0.';
+        if (!shouldKeepSingleZero) {
+            const hasMinus = rawValue.startsWith('-');
+            const withoutMinus = hasMinus ? rawValue.slice(1) : rawValue;
+            const hasDecimal = withoutMinus.includes('.');
+            if (hasDecimal) {
+                const [integerPart, decimalPart] = withoutMinus.split('.');
+                const cleanedInteger = integerPart.replace(/^0+/, '');
+                const prefix = hasMinus ? '-' : '';
+                if (cleanedInteger === '' && decimalPart) {
+                    rawValue = `${prefix}0.${decimalPart}`;
+                }
+                else if (cleanedInteger === '') {
+                    rawValue = `${prefix}0`;
+                }
+                else {
+                    rawValue = `${prefix}${cleanedInteger}.${decimalPart}`;
+                }
+            }
+            else {
+                const cleaned = withoutMinus.replace(/^0+/, '');
+                const prefix = hasMinus ? '-' : '';
+                rawValue = cleaned === '' ? `${prefix}0` : `${prefix}${cleaned}`;
+            }
+        }
+        // Store the raw input value to preserve single "0" only
+        setRawInputValue(rawValue);
+        // Convert to number
+        const valueAsNumber = Number(rawValue);
+        // Handle invalid numbers
+        if (Number.isNaN(valueAsNumber) || !Number.isFinite(valueAsNumber)) {
+            setRawInputValue('');
+            onValueChange({
+                value: 0,
+                formattedValue: '',
+            });
+            return;
+        }
+        // Handle value exceeding MAX_SAFE_INTEGER
+        if (Math.abs(valueAsNumber) > Number.MAX_SAFE_INTEGER) {
+            const clampedValue = valueAsNumber > 0 ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER;
+            const clampedString = clampedValue.toString();
+            setRawInputValue(clampedString);
+            onValueChange({
+                value: clampedValue,
+                formattedValue: formatValue(clampedValue),
+            });
+            return;
+        }
+        // Only preserve single "0" or "0." patterns (not multiple leading zeros like "01", "0123")
+        const isSingleZero = rawValue === '0' ||
+            rawValue === '-0' ||
+            rawValue.startsWith('0.') ||
+            rawValue.startsWith('-0.');
+        // Check if the value ends with a decimal point (e.g., "2.", "-2.", "123.")
+        // This allows users to continue typing decimal digits
+        const endsWithDecimalPoint = allowDecimal && rawValue.endsWith('.') && !rawValue.endsWith('..');
+        // Apply min/max validation only for complete numbers (not intermediate typing states)
+        // Allow intermediate values while typing (e.g., allow "1000" if max is 100, user might be typing "100")
+        let finalValue = valueAsNumber;
+        let finalRawValue = rawValue;
+        let shouldClamp = false;
+        // Only clamp if the value is complete (not ending with decimal point and not a single zero pattern)
+        if (!isSingleZero && !endsWithDecimalPoint) {
+            if (minValue !== undefined && finalValue < minValue) {
+                finalValue = minValue;
+                finalRawValue = minValue.toString();
+                shouldClamp = true;
+            }
+            if (maxValue !== undefined && finalValue > maxValue) {
+                finalValue = maxValue;
+                finalRawValue = maxValue.toString();
+                shouldClamp = true;
+            }
+        }
+        // If clamped, update rawInputValue
+        if (shouldClamp) {
+            setRawInputValue(finalRawValue);
+        }
+        // If it's a single zero pattern or ends with decimal point, use the raw value for display
+        if (isSingleZero || endsWithDecimalPoint) {
+            // Use the raw value as-is to preserve single "0" or trailing decimal point
+            onValueChange({
+                value: finalValue,
+                formattedValue: shouldClamp ? formatValue(finalValue) : rawValue,
+            });
+            return;
+        }
+        // Valid number without leading zeros - format and return
+        onValueChange({
+            value: finalValue,
+            formattedValue: formatValue(finalValue),
+        });
+    }, [
+        allowDecimal,
+        allowNegative,
+        maxLength,
+        onValueChange,
+        formatValue,
+        separator,
+        minValue,
+        maxValue,
+        maxDecimalPlaces,
+    ]);
+    const handleCompositionStart = useCallback((e) => {
+        isComposing.current = true;
+        hasProcessedComposition.current = false;
+        // Store the current input value when composition starts
+        setComposingValue(e.currentTarget.value);
+        // Handle custom onCompositionStart
+        if (onCompositionStart) {
+            onCompositionStart(e);
+        }
+    }, [onCompositionStart]);
+    // Helper to process value after conversion (used in composition end and blur)
+    const processConvertedValue = useCallback((convertedValue) => {
+        if (allowNegative && convertedValue === '-') {
+            setRawInputValue('-');
+            onValueChange({
+                value: 0,
+                formattedValue: '-',
+            });
+        }
+        else {
+            handleValueChange(convertedValue, true);
+        }
+    }, [allowNegative, handleValueChange, onValueChange]);
+    const handleCompositionEnd = useCallback((e) => {
+        isComposing.current = false;
+        const finalValue = e.currentTarget.value;
+        setComposingValue('');
+        hasProcessedComposition.current = true;
+        if (onCompositionEnd) {
+            onCompositionEnd(e);
+        }
+        requestAnimationFrame(() => {
+            const convertedValue = convertFullWidthToHalfWidth(finalValue);
+            processConvertedValue(convertedValue);
+            hasProcessedComposition.current = false;
+        });
+    }, [onCompositionEnd, processConvertedValue]);
+    const handleBlur = useCallback((e) => {
+        const currentValue = e.target.value;
+        const shouldPreserveMinus = allowNegative && (isMinusSign(rawInputValue) || isMinusSign(currentValue));
+        // Handle composition states
+        if (isComposing.current) {
+            isComposing.current = false;
+            const convertedValue = convertFullWidthToHalfWidth(e.target.value);
+            setComposingValue('');
+            hasProcessedComposition.current = true;
+            processConvertedValue(convertedValue);
+        }
+        else if (composingValue !== '') {
+            const convertedValue = convertFullWidthToHalfWidth(composingValue);
+            processConvertedValue(convertedValue);
+            setComposingValue('');
+        }
+        else if (!hasProcessedComposition.current && e.target.value) {
+            const convertedValue = convertFullWidthToHalfWidth(e.target.value);
+            handleValueChange(convertedValue, true);
+        }
+        // Apply min/max validation on blur
+        if (rawInputValue !== '' && !(allowNegative && isMinusSign(rawInputValue))) {
+            const convertedValue = convertFullWidthToHalfWidth(rawInputValue);
+            const numValue = Number(convertedValue);
+            if (!Number.isNaN(numValue) && Number.isFinite(numValue)) {
+                let clampedValue = numValue;
+                let shouldUpdate = false;
+                if (minValue !== undefined && clampedValue < minValue) {
+                    clampedValue = minValue;
+                    shouldUpdate = true;
+                }
+                if (maxValue !== undefined && clampedValue > maxValue) {
+                    clampedValue = maxValue;
+                    shouldUpdate = true;
+                }
+                if (shouldUpdate) {
+                    const clampedString = clampedValue.toString();
+                    setRawInputValue(clampedString);
+                    onValueChange({
+                        value: clampedValue,
+                        formattedValue: formatValue(clampedValue),
+                    });
+                }
+            }
+        }
+        // Normalize minus sign to half-width if needed
+        if (shouldPreserveMinus && isMinusSign(rawInputValue) && rawInputValue !== '-') {
+            setRawInputValue('-');
+            onValueChange({
+                value: 0,
+                formattedValue: '-',
+            });
+        }
+        hasProcessedComposition.current = false;
+        if (onBlur) {
+            onBlur(e);
+        }
+    }, [
+        composingValue,
+        onBlur,
+        handleValueChange,
+        rawInputValue,
+        minValue,
+        maxValue,
+        formatValue,
+        allowNegative,
+        processConvertedValue,
+    ]);
+    // Reset rawInputValue when value prop changes externally (e.g., form reset)
+    useEffect(() => {
+        const numValue = parseValueProp(value, separator);
+        if (Number.isNaN(numValue)) {
+            // Preserve minus sign if allowNegative is true and user is typing
+            if (allowNegative && isMinusSign(rawInputValue)) {
+                return;
+            }
+            setRawInputValue('');
+            return;
+        }
+        // If the value is 0, preserve rawInputValue if it's a special pattern
+        if (numValue === 0) {
+            const isSingleZero = rawInputValue === '0' ||
+                rawInputValue === '-0' ||
+                isMinusSign(rawInputValue) ||
+                rawInputValue.startsWith('0.') ||
+                rawInputValue.startsWith('-0.');
+            // Check if rawInputValue is a negative number (preserve it when allowNegative is true)
+            if (allowNegative && rawInputValue !== '') {
+                const convertedRawValue = convertFullWidthToHalfWidth(rawInputValue);
+                const rawAsNumber = Number(convertedRawValue);
+                if (!Number.isNaN(rawAsNumber) &&
+                    Number.isFinite(rawAsNumber) &&
+                    rawAsNumber < 0) {
+                    return;
+                }
+            }
+            if (!isSingleZero) {
+                setRawInputValue('0');
+            }
+            return;
+        }
+        // For non-zero values, check if the numeric value matches what we'd get from rawInputValue
+        if (rawInputValue !== '') {
+            // Preserve minus sign only if allowNegative is true
+            if (allowNegative && isMinusSign(rawInputValue)) {
+                return;
+            }
+            const convertedRawValue = convertFullWidthToHalfWidth(rawInputValue);
+            const rawAsNumber = Number(convertedRawValue);
+            if (allowNegative && convertedRawValue.startsWith('-')) {
+                if (rawAsNumber === numValue) {
+                    return;
+                }
+                else if (numValue > 0 && Math.abs(rawAsNumber) === numValue) {
+                    setRawInputValue('');
+                }
+                else {
+                    return;
+                }
+            }
+            else if (rawAsNumber !== numValue) {
+                setRawInputValue('');
+            }
+        }
+    }, [value, separator, rawInputValue, allowNegative]);
+    // Format the display value
+    const displayValue = useMemo(() => {
+        if (composingValue !== '') {
+            return composingValue;
+        }
+        if (rawInputValue === '') {
+            const numValue = parseValueProp(value, separator);
+            if (Number.isNaN(numValue)) {
+                return '';
+            }
+            if (numValue === 0) {
+                return '0';
+            }
+            if (Number.isFinite(numValue)) {
+                return formatValue(numValue);
+            }
+            return '';
+        }
+        if (rawInputValue !== '') {
+            const isSingleZero = rawInputValue === '0' ||
+                rawInputValue === '-0' ||
+                rawInputValue.startsWith('0.') ||
+                rawInputValue.startsWith('-0.');
+            const isMinusOnly = allowNegative && isMinusSign(rawInputValue);
+            const endsWithDecimalPoint = allowDecimal &&
+                rawInputValue.endsWith('.') &&
+                !rawInputValue.endsWith('..');
+            if (isSingleZero || isMinusOnly || endsWithDecimalPoint) {
+                return normalizeMinusSign(rawInputValue);
+            }
+            const rawAsNumber = Number(rawInputValue);
+            if (!Number.isNaN(rawAsNumber) && Number.isFinite(rawAsNumber)) {
+                return formatValue(rawAsNumber);
+            }
+        }
+        const numValue = parseValueProp(value, separator);
+        if (Number.isNaN(numValue) || !Number.isFinite(numValue)) {
+            return '';
+        }
+        return formatValue(numValue);
+    }, [value, formatValue, separator, composingValue, rawInputValue, allowNegative, allowDecimal]);
+    // Determine appropriate inputMode for mobile keyboards
+    const inputMode = allowDecimal ? 'decimal' : 'numeric';
+    return {
+        inputRef,
+        inputMode,
+        displayValue,
+        hasProcessedComposition,
+        handleBlur,
+        handleValueChange,
+        handleCompositionEnd,
+        handleCompositionStart,
+    };
+};
+//# sourceMappingURL=use-numeric-input.js.map