@1money/component-ui 0.0.1

package/es/components/Input/interface.d.ts

@@ -0,0 +1,153 @@
+import type { ChangeEvent, FC, InputHTMLAttributes, ReactNode, RefObject, TextareaHTMLAttributes } from 'react';
+import type { InputSize, InputStatus, SearchTrigger } from './constants';
+export type { InputSize, InputStatus, SearchTrigger };
+export interface InputBaseProps {
+    className?: string;
+    prefixCls?: string;
+    size?: InputSize;
+    status?: InputStatus;
+    label?: ReactNode;
+    info?: ReactNode;
+    errorMsg?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    allowClear?: boolean;
+    loading?: boolean;
+}
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix' | 'size' | 'onChange'>, InputBaseProps {
+    ref?: RefObject<HTMLInputElement | null>;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    /** When provided, Input behaves as a mask input. Pattern: 9 = digit, a = letter, * = alphanumeric */
+    mask?: string;
+    /** Placeholder character for unfilled mask positions */
+    slotChar?: string;
+    /** When true, onChange returns the raw value without mask characters */
+    unmask?: boolean;
+    /** When true, clears incomplete mask input on blur */
+    autoClear?: boolean;
+    /** Callback when all mask positions are filled */
+    onComplete?: (value: string) => void;
+}
+export interface InputPasswordProps extends Omit<InputProps, 'type' | 'allowClear'> {
+    visibilityToggle?: boolean;
+    /** Icon displayed when password is visible (to hide it) */
+    showIcon?: ReactNode;
+    /** Icon displayed when password is hidden (to show it) */
+    hideIcon?: ReactNode;
+}
+export interface InputSearchProps extends InputProps {
+    loading?: boolean;
+    searchButton?: ReactNode | boolean;
+    searchTrigger?: SearchTrigger;
+    onSearch?: (value: string) => void;
+}
+export interface InputTextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange' | 'prefix'>, Omit<InputBaseProps, 'allowClear' | 'prefix' | 'suffix'> {
+    ref?: RefObject<HTMLTextAreaElement | null>;
+    value?: string;
+    defaultValue?: string;
+    rows?: number;
+    showCount?: boolean;
+    maxLength?: number;
+    onChange?: (value: string, event: ChangeEvent<HTMLTextAreaElement>) => void;
+}
+export interface InputOTPProps extends Omit<InputBaseProps, 'allowClear' | 'prefix' | 'suffix'> {
+    ref?: RefObject<HTMLDivElement | null>;
+    value?: string;
+    defaultValue?: string;
+    length?: number;
+    autoFocus?: boolean;
+    mask?: boolean;
+    formatter?: (value: string) => string;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+}
+export interface InputTradeProps {
+    className?: string;
+    prefixCls?: string;
+    status?: InputStatus;
+    disabled?: boolean;
+    readOnly?: boolean;
+    ref?: RefObject<HTMLInputElement | null>;
+    value?: string;
+    defaultValue?: string;
+    /** Currency symbol displayed before the value, e.g. "$" */
+    currencySymbol?: string;
+    /** Currency unit displayed after the value, e.g. "USD" */
+    currencyUnit?: string;
+    /** Exchange info displayed in the subline, e.g. "0 USDT" */
+    exchangeText?: ReactNode;
+    /** Error or helper message displayed below the subline */
+    errorMsg?: ReactNode;
+    /** Whether to show the Max button */
+    showMax?: boolean;
+    /** Callback when Max button is clicked */
+    onMax?: () => void;
+    /** Callback when swap icon is clicked */
+    onSwap?: () => void;
+    /** Callback when value changes */
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    placeholder?: string;
+    /** Minimum numeric value (inclusive) */
+    min?: number | bigint;
+    /** Maximum numeric value (inclusive) */
+    max?: number | bigint;
+    /** Maximum number of fraction digits (decimal places) */
+    maxFractionDigits?: number | bigint;
+    /** Allow negative numbers */
+    negative?: boolean;
+}
+export interface InputAmountProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix' | 'size' | 'onChange' | 'min' | 'max'>, Omit<InputBaseProps, 'allowClear'> {
+    ref?: RefObject<HTMLInputElement | null>;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    allowClear?: boolean;
+    /** Action button label (e.g. "Use Max"), rendered before the divider */
+    actionLabel?: ReactNode;
+    /** Callback when the action button is clicked */
+    onAction?: () => void;
+    /** Currency icon (e.g. <img src="..." />) shown in the currency selector */
+    currencyIcon?: ReactNode;
+    /** Currency label text (e.g. "USDC") */
+    currencyLabel?: string;
+    /** Callback when the currency selector is clicked */
+    onCurrencyClick?: () => void;
+    /** Minimum numeric value (inclusive) */
+    min?: number | bigint;
+    /** Maximum numeric value (inclusive) */
+    max?: number | bigint;
+    /** Maximum number of fraction digits (decimal places) */
+    maxFractionDigits?: number | bigint;
+    /** Allow negative numbers */
+    negative?: boolean;
+}
+export interface InputMaskProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix' | 'size' | 'onChange'>, Omit<InputBaseProps, 'allowClear'> {
+    ref?: RefObject<HTMLInputElement | null>;
+    value?: string;
+    defaultValue?: string;
+    /** Mask pattern: 9 = digit, a = letter, * = alphanumeric */
+    mask: string;
+    /** Placeholder character for unfilled positions */
+    slotChar?: string;
+    /** When true, onChange returns the raw value without mask characters */
+    unmask?: boolean;
+    /** When true, clears incomplete input on blur */
+    autoClear?: boolean;
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    onComplete?: (value: string) => void;
+}
+export interface InputComponent extends FC<InputProps> {
+    Password: FC<InputPasswordProps>;
+    Search: FC<InputSearchProps>;
+    TextArea: FC<InputTextAreaProps>;
+    OTP: FC<InputOTPProps>;
+    Trade: FC<InputTradeProps>;
+    Amount: FC<InputAmountProps>;
+    Mask: FC<InputMaskProps>;
+}

package/es/components/Input/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9JbnB1dC9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvSW5wdXQvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiJBQUFBIiwiaWdub3JlTGlzdCI6W119

package/es/components/Input/style/css.js

@@ -0,0 +1,7 @@
+import '../FieldShell/FieldShell.css';
+import '../Input/Input.css';
+import '../TextArea/TextArea.css';
+import '../OTP/OTP.css';
+import '../Trade/Trade.css';
+import '../Amount/style/Amount.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvSW5wdXQvc3JjL2NvbXBvbmVudHMvSW5wdXQvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywrQkFBK0I7QUFDdEMsT0FBTyxxQkFBcUI7QUFDNUIsT0FBTywyQkFBMkI7QUFDbEMsT0FBTyxpQkFBaUI7QUFDeEIsT0FBTyxxQkFBcUI7QUFDNUIsT0FBTyw2QkFBNkIiLCJmaWxlIjoiY29tcG9uZW50cy9JbnB1dC9zdHlsZS9jc3MuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Input/style/index.d.ts

@@ -0,0 +1,6 @@
+import '../FieldShell/FieldShell.scss';
+import '../Input/Input.scss';
+import '../TextArea/TextArea.scss';
+import '../OTP/OTP.scss';
+import '../Trade/Trade.scss';
+import '../Amount/style/Amount.scss';

package/es/components/Input/style/index.js

@@ -0,0 +1,7 @@
+import '../FieldShell/FieldShell.scss';
+import '../Input/Input.scss';
+import '../TextArea/TextArea.scss';
+import '../OTP/OTP.scss';
+import '../Trade/Trade.scss';
+import '../Amount/style/Amount.scss';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvSW5wdXQvc3JjL2NvbXBvbmVudHMvSW5wdXQvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywrQkFBK0I7QUFDdEMsT0FBTyxxQkFBcUI7QUFDNUIsT0FBTywyQkFBMkI7QUFDbEMsT0FBTyxpQkFBaUI7QUFDeEIsT0FBTyxxQkFBcUI7QUFDNUIsT0FBTyw2QkFBNkIiLCJmaWxlIjoiY29tcG9uZW50cy9JbnB1dC9zdHlsZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/components/Input/useAmountInput.d.ts

@@ -0,0 +1,35 @@
+import type { ChangeEvent, RefObject } from 'react';
+export interface UseAmountInputOptions {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, event: ChangeEvent<HTMLInputElement>) => void;
+    min?: number | bigint;
+    max?: number | bigint;
+    maxFractionDigits?: number | bigint;
+    negative?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    ref?: RefObject<HTMLInputElement | null>;
+}
+export interface UseAmountInputResult {
+    inputRef: RefObject<HTMLInputElement | null>;
+    syncRef: (node: HTMLInputElement | null) => void;
+    /** Display value with thousands separators — bind to `<input value>` */
+    formattedValue: string;
+    /** `true` when the internal value is neither null nor empty */
+    hasValue: boolean;
+    handleChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    handleSelect: () => void;
+    /** Clear the value and notify via onChange (caller should manage focus) */
+    clear: () => void;
+}
+/**
+ * Encapsulates the numeric input pipeline shared by InputAmount and InputTrade.
+ *
+ * Handles:
+ * - Thousands-separator formatting (display only; internal value stays raw)
+ * - parse / normalize / fraction-digit truncation / min-max clamping
+ * - Controlled & uncontrolled modes through the same pipeline
+ * - Caret position preservation across formatted re-renders
+ */
+export declare function useAmountInput(options: UseAmountInputOptions): UseAmountInputResult;

package/es/components/Input/useAmountInput.js

@@ -0,0 +1,207 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useMemo, useRef, useState } from 'react';
+import { useEventCallback, useLatest, useLayoutEffect } from '@1money/hooks';
+import { useSyncRef } from './useSyncRef';
+import { CHAR_DOT, CHAR_MINUS, DECIMAL_POINT_OFFSET, absValue, calcValueInRange, formatThousands, isNumericType, normalizeValue, parseRawInput, stripCommas, stripMinus, truncateFractionDigits } from './Amount/helper';
+/**
+ * Encapsulates the numeric input pipeline shared by InputAmount and InputTrade.
+ *
+ * Handles:
+ * - Thousands-separator formatting (display only; internal value stays raw)
+ * - parse / normalize / fraction-digit truncation / min-max clamping
+ * - Controlled & uncontrolled modes through the same pipeline
+ * - Caret position preservation across formatted re-renders
+ */
+export function useAmountInput(options) {
+  var value = options.value,
+    defaultValue = options.defaultValue,
+    onChange = options.onChange,
+    min = options.min,
+    max = options.max,
+    maxFractionDigits = options.maxFractionDigits,
+    negative = options.negative,
+    disabled = options.disabled,
+    readOnly = options.readOnly,
+    ref = options.ref;
+  var _useSyncRef = useSyncRef(ref),
+    _useSyncRef2 = _slicedToArray(_useSyncRef, 2),
+    inputRef = _useSyncRef2[0],
+    syncRef = _useSyncRef2[1];
+  var isUncontrolled = typeof value === 'undefined';
+  var _useState = useState(defaultValue != null && defaultValue !== '' ? String(defaultValue) : null),
+    _useState2 = _slicedToArray(_useState, 2),
+    innerValue = _useState2[0],
+    setInnerValue = _useState2[1];
+  var caretPosRef = useRef(0);
+  var ignoreSelectRef = useRef(false);
+  var onChangeRef = useLatest(onChange);
+  var formattedValue = useMemo(function () {
+    return formatThousands(innerValue !== null && innerValue !== void 0 ? innerValue : '', negative);
+  }, [innerValue, negative]);
+  var stateRef = useLatest({
+    innerValue: innerValue,
+    formattedValue: formattedValue,
+    min: min,
+    max: max,
+    negative: negative,
+    maxFractionDigits: maxFractionDigits
+  });
+  var calcCaretPos = useEventCallback(function (val) {
+    var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var currPos = arguments.length > 2 ? arguments[2] : undefined;
+    var _a, _b;
+    var input = inputRef.current;
+    if (!input) return;
+    var _stateRef$current = stateRef.current,
+      prev = _stateRef$current.innerValue,
+      negative = _stateRef$current.negative,
+      formattedValue = _stateRef$current.formattedValue;
+    var formattedNewVal = formatThousands(val, negative);
+    var originOffset = val.length - ((_a = prev === null || prev === void 0 ? void 0 : prev.length) !== null && _a !== void 0 ? _a : 0);
+    var position = (_b = currPos !== null && currPos !== void 0 ? currPos : input.selectionEnd) !== null && _b !== void 0 ? _b : 0;
+    // Map formatted position back to raw position
+    position = stripCommas(formattedValue.slice(0, Math.max(position, 0))).length;
+    // Map raw position forward to formatted position
+    var posVal = val.slice(0, position + originOffset);
+    formattedNewVal.split('').reduce(function (acc, _char, ind) {
+      if (_char === ',') return acc;
+      acc.push(_char);
+      if (acc.join('') === posVal) position = ind + 1;
+      return acc;
+    }, []);
+    caretPosRef.current = position + offset;
+  });
+  var commitValue = useEventCallback(function (val, hasDecimalPoint, event) {
+    var _a;
+    if (isUncontrolled) {
+      setInnerValue(val === '' ? null : val);
+      calcCaretPos(val, hasDecimalPoint ? DECIMAL_POINT_OFFSET : 0, Math.max(caretPosRef.current, 0));
+      ignoreSelectRef.current = true;
+    }
+    (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, val, event);
+  });
+  var handleChange = useEventCallback(function (event) {
+    var _a;
+    if (disabled || readOnly) return;
+    var _stateRef$current2 = stateRef.current,
+      innerValue = _stateRef$current2.innerValue,
+      formattedValue = _stateRef$current2.formattedValue,
+      min = _stateRef$current2.min,
+      max = _stateRef$current2.max,
+      negative = _stateRef$current2.negative,
+      maxFractionDigits = _stateRef$current2.maxFractionDigits;
+    var parsed = parseRawInput((_a = event.target.value) !== null && _a !== void 0 ? _a : '', negative);
+    if (!parsed) return;
+    var val = parsed.val;
+    var hasDecimalPoint = parsed.hasDecimalPoint,
+      isStandaloneMinus = parsed.isStandaloneMinus;
+    if (val === innerValue && !hasDecimalPoint) return;
+    // Enforce fraction digit limit
+    if (isNumericType(maxFractionDigits)) {
+      var _truncateFractionDigi = truncateFractionDigits(val, Number(maxFractionDigits)),
+        _int = _truncateFractionDigi["int"],
+        truncated = _truncateFractionDigi.truncated,
+        overflow = _truncateFractionDigi.overflow;
+      if (overflow) {
+        var _formattedValue$split = formattedValue.split(CHAR_DOT),
+          _formattedValue$split2 = _slicedToArray(_formattedValue$split, 1),
+          oldInt = _formattedValue$split2[0];
+        if (stripCommas(oldInt) === _int) return;
+        val = truncated;
+      }
+    }
+    // Clamp to min/max range
+    if (isNumericType(min) || isNumericType(max)) {
+      val = calcValueInRange(val, min, max);
+    }
+    // Normalize the final value
+    if (val !== '') {
+      val = isStandaloneMinus ? CHAR_MINUS : normalizeValue(val, hasDecimalPoint, negative);
+    }
+    commitValue(val, hasDecimalPoint, event);
+  });
+  var handleSelect = useEventCallback(function () {
+    var _a;
+    if (ignoreSelectRef.current) {
+      ignoreSelectRef.current = false;
+      return;
+    }
+    var currPos = (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.selectionEnd;
+    if (typeof currPos === 'number') caretPosRef.current = currPos;
+  });
+  // Keep caret at the expected position after formatted re-render
+  useLayoutEffect(function () {
+    var input = inputRef.current;
+    if (!input || document.activeElement !== input) return;
+    var pos = caretPosRef.current;
+    input.setSelectionRange(pos, pos);
+  }, [formattedValue]);
+  // Sync external controlled value (or defaultValue) through the same pipeline
+  useLayoutEffect(function () {
+    var _a;
+    var val = isUncontrolled ? innerValue : value !== null && value !== void 0 ? value : null;
+    var hasDecimalPoint = false;
+    var isStandaloneMinus = false;
+    if (typeof val === 'string') {
+      if (val === '') {
+        val = null;
+      } else {
+        var parsed = parseRawInput(val, negative);
+        if (!parsed) return;
+        val = parsed.val;
+        hasDecimalPoint = parsed.hasDecimalPoint;
+        isStandaloneMinus = parsed.isStandaloneMinus;
+        if (!negative) val = stripMinus(val);
+      }
+    } else if (val !== null && !isNumericType(val)) {
+      return;
+    }
+    if (!negative && isNumericType(val)) {
+      val = absValue(val);
+    }
+    if ((typeof val === 'string' || typeof val === 'number') && isNumericType(maxFractionDigits)) {
+      var _truncateFractionDigi2 = truncateFractionDigits("".concat(val), Number(maxFractionDigits)),
+        truncated = _truncateFractionDigi2.truncated,
+        overflow = _truncateFractionDigi2.overflow;
+      if (overflow) {
+        if (isUncontrolled) {
+          setInnerValue(truncated);
+        } else {
+          (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, truncated !== null && truncated !== void 0 ? truncated : '', {
+            target: inputRef.current
+          });
+        }
+        return;
+      }
+    }
+    if (isNumericType(val) || typeof val === 'string') {
+      val = calcValueInRange("".concat(val), min, max);
+    }
+    if (val === '' || val == null) {
+      setInnerValue(null);
+    } else {
+      var normalized = isStandaloneMinus ? CHAR_MINUS : normalizeValue("".concat(val), hasDecimalPoint, negative);
+      setInnerValue(normalized);
+    }
+    calcCaretPos((val !== null && val !== void 0 ? val : '').toString(), hasDecimalPoint ? DECIMAL_POINT_OFFSET : 0, Math.max(caretPosRef.current, 0));
+    ignoreSelectRef.current = true;
+  }, [value, maxFractionDigits, min, max, negative]);
+  var clear = useEventCallback(function () {
+    var _a;
+    if (isUncontrolled) setInnerValue(null);
+    (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, '', {
+      target: inputRef.current
+    });
+  });
+  var hasValue = innerValue != null && innerValue !== '';
+  return {
+    inputRef: inputRef,
+    syncRef: syncRef,
+    formattedValue: formattedValue,
+    hasValue: hasValue,
+    handleChange: handleChange,
+    handleSelect: handleSelect,
+    clear: clear
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/Input/useAmountInput.ts","components/Input/useAmountInput.js"],"names":["useMemo","useRef","useState","useEventCallback","useLatest","useLayoutEffect","useSyncRef","CHAR_DOT","CHAR_MINUS","DECIMAL_POINT_OFFSET","absValue","calcValueInRange","formatThousands","isNumericType","normalizeValue","parseRawInput","stripCommas","stripMinus","truncateFractionDigits","useAmountInput","options","value","defaultValue","onChange","min","max","maxFractionDigits","negative","disabled","readOnly","ref","_useSyncRef","_useSyncRef2","_slicedToArray","inputRef","syncRef","isUncontrolled","_useState","String","_useState2","innerValue","setInnerValue","caretPosRef","ignoreSelectRef","onChangeRef","formattedValue","stateRef","calcCaretPos","val","offset","arguments","length","undefined","currPos","_a","_b","input","current","_stateRef$current","prev","formattedNewVal","originOffset","position","selectionEnd","slice","Math","posVal","split","reduce","acc","char","ind","push","join","commitValue","hasDecimalPoint","event","call","handleChange","_stateRef$current2","parsed","target","isStandaloneMinus","_truncateFractionDigi","Number","int","truncated","overflow","_formattedValue$split","_formattedValue$split2","oldInt","handleSelect","document","activeElement","pos","setSelectionRange","_truncateFractionDigi2","concat","normalized","toString","clear","hasValue"],"mappings":"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","file":"components/Input/useAmountInput.js","sourcesContent":[null,"import { useMemo, useRef, useState } from 'react';\nimport { useEventCallback, useLatest, useLayoutEffect } from '@1money/hooks';\nimport { useSyncRef } from './useSyncRef';\nimport { CHAR_DOT, CHAR_MINUS, DECIMAL_POINT_OFFSET, absValue, calcValueInRange, formatThousands, isNumericType, normalizeValue, parseRawInput, stripCommas, stripMinus, truncateFractionDigits, } from './Amount/helper';\n/**\n * Encapsulates the numeric input pipeline shared by InputAmount and InputTrade.\n *\n * Handles:\n * - Thousands-separator formatting (display only; internal value stays raw)\n * - parse / normalize / fraction-digit truncation / min-max clamping\n * - Controlled & uncontrolled modes through the same pipeline\n * - Caret position preservation across formatted re-renders\n */\nexport function useAmountInput(options) {\n    const { value, defaultValue, onChange, min, max, maxFractionDigits, negative, disabled, readOnly, ref, } = options;\n    const [inputRef, syncRef] = useSyncRef(ref);\n    const isUncontrolled = typeof value === 'undefined';\n    const [innerValue, setInnerValue] = useState(defaultValue != null && defaultValue !== '' ? String(defaultValue) : null);\n    const caretPosRef = useRef(0);\n    const ignoreSelectRef = useRef(false);\n    const onChangeRef = useLatest(onChange);\n    const formattedValue = useMemo(() => formatThousands(innerValue !== null && innerValue !== void 0 ? innerValue : '', negative), [innerValue, negative]);\n    const stateRef = useLatest({\n        innerValue,\n        formattedValue,\n        min,\n        max,\n        negative,\n        maxFractionDigits,\n    });\n    const calcCaretPos = useEventCallback((val, offset = 0, currPos) => {\n        var _a, _b;\n        const input = inputRef.current;\n        if (!input)\n            return;\n        const { innerValue: prev, negative, formattedValue } = stateRef.current;\n        const formattedNewVal = formatThousands(val, negative);\n        const originOffset = val.length - ((_a = prev === null || prev === void 0 ? void 0 : prev.length) !== null && _a !== void 0 ? _a : 0);\n        let position = (_b = currPos !== null && currPos !== void 0 ? currPos : input.selectionEnd) !== null && _b !== void 0 ? _b : 0;\n        // Map formatted position back to raw position\n        position = stripCommas(formattedValue.slice(0, Math.max(position, 0))).length;\n        // Map raw position forward to formatted position\n        const posVal = val.slice(0, position + originOffset);\n        formattedNewVal.split('').reduce((acc, char, ind) => {\n            if (char === ',')\n                return acc;\n            acc.push(char);\n            if (acc.join('') === posVal)\n                position = ind + 1;\n            return acc;\n        }, []);\n        caretPosRef.current = position + offset;\n    });\n    const commitValue = useEventCallback((val, hasDecimalPoint, event) => {\n        var _a;\n        if (isUncontrolled) {\n            setInnerValue(val === '' ? null : val);\n            calcCaretPos(val, hasDecimalPoint ? DECIMAL_POINT_OFFSET : 0, Math.max(caretPosRef.current, 0));\n            ignoreSelectRef.current = true;\n        }\n        (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, val, event);\n    });\n    const handleChange = useEventCallback((event) => {\n        var _a;\n        if (disabled || readOnly)\n            return;\n        const { innerValue, formattedValue, min, max, negative, maxFractionDigits } = stateRef.current;\n        const parsed = parseRawInput((_a = event.target.value) !== null && _a !== void 0 ? _a : '', negative);\n        if (!parsed)\n            return;\n        let { val } = parsed;\n        const { hasDecimalPoint, isStandaloneMinus } = parsed;\n        if (val === innerValue && !hasDecimalPoint)\n            return;\n        // Enforce fraction digit limit\n        if (isNumericType(maxFractionDigits)) {\n            const { int, truncated, overflow } = truncateFractionDigits(val, Number(maxFractionDigits));\n            if (overflow) {\n                const [oldInt] = formattedValue.split(CHAR_DOT);\n                if (stripCommas(oldInt) === int)\n                    return;\n                val = truncated;\n            }\n        }\n        // Clamp to min/max range\n        if (isNumericType(min) || isNumericType(max)) {\n            val = calcValueInRange(val, min, max);\n        }\n        // Normalize the final value\n        if (val !== '') {\n            val = isStandaloneMinus ? CHAR_MINUS : normalizeValue(val, hasDecimalPoint, negative);\n        }\n        commitValue(val, hasDecimalPoint, event);\n    });\n    const handleSelect = useEventCallback(() => {\n        var _a;\n        if (ignoreSelectRef.current) {\n            ignoreSelectRef.current = false;\n            return;\n        }\n        const currPos = (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.selectionEnd;\n        if (typeof currPos === 'number')\n            caretPosRef.current = currPos;\n    });\n    // Keep caret at the expected position after formatted re-render\n    useLayoutEffect(() => {\n        const input = inputRef.current;\n        if (!input || document.activeElement !== input)\n            return;\n        const pos = caretPosRef.current;\n        input.setSelectionRange(pos, pos);\n    }, [formattedValue]);\n    // Sync external controlled value (or defaultValue) through the same pipeline\n    useLayoutEffect(() => {\n        var _a;\n        let val = isUncontrolled ? innerValue : (value !== null && value !== void 0 ? value : null);\n        let hasDecimalPoint = false;\n        let isStandaloneMinus = false;\n        if (typeof val === 'string') {\n            if (val === '') {\n                val = null;\n            }\n            else {\n                const parsed = parseRawInput(val, negative);\n                if (!parsed)\n                    return;\n                val = parsed.val;\n                hasDecimalPoint = parsed.hasDecimalPoint;\n                isStandaloneMinus = parsed.isStandaloneMinus;\n                if (!negative)\n                    val = stripMinus(val);\n            }\n        }\n        else if (val !== null && !isNumericType(val)) {\n            return;\n        }\n        if (!negative && isNumericType(val)) {\n            val = absValue(val);\n        }\n        if ((typeof val === 'string' || typeof val === 'number') &&\n            isNumericType(maxFractionDigits)) {\n            const { truncated, overflow } = truncateFractionDigits(`${val}`, Number(maxFractionDigits));\n            if (overflow) {\n                if (isUncontrolled) {\n                    setInnerValue(truncated);\n                }\n                else {\n                    (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, truncated !== null && truncated !== void 0 ? truncated : '', { target: inputRef.current });\n                }\n                return;\n            }\n        }\n        if (isNumericType(val) || typeof val === 'string') {\n            val = calcValueInRange(`${val}`, min, max);\n        }\n        if (val === '' || val == null) {\n            setInnerValue(null);\n        }\n        else {\n            const normalized = isStandaloneMinus\n                ? CHAR_MINUS\n                : normalizeValue(`${val}`, hasDecimalPoint, negative);\n            setInnerValue(normalized);\n        }\n        calcCaretPos((val !== null && val !== void 0 ? val : '').toString(), hasDecimalPoint ? DECIMAL_POINT_OFFSET : 0, Math.max(caretPosRef.current, 0));\n        ignoreSelectRef.current = true;\n    }, [value, maxFractionDigits, min, max, negative]);\n    const clear = useEventCallback(() => {\n        var _a;\n        if (isUncontrolled)\n            setInnerValue(null);\n        (_a = onChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(onChangeRef, '', { target: inputRef.current });\n    });\n    const hasValue = innerValue != null && innerValue !== '';\n    return {\n        inputRef,\n        syncRef,\n        formattedValue,\n        hasValue,\n        handleChange,\n        handleSelect,\n        clear,\n    };\n}"],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Input/useSyncRef.d.ts

@@ -0,0 +1,2 @@
+import type { RefObject } from 'react';
+export declare function useSyncRef<T extends HTMLElement>(externalRef?: RefObject<T | null>): readonly [RefObject<T | null>, (node: T | null) => void];

package/es/components/Input/useSyncRef.js

@@ -0,0 +1,13 @@
+import { useRef } from 'react';
+import { useEventCallback } from '@1money/hooks';
+export function useSyncRef(externalRef) {
+  var internalRef = useRef(null);
+  var callbackRef = useEventCallback(function (node) {
+    internalRef.current = node;
+    if (externalRef) {
+      externalRef.current = node;
+    }
+  });
+  return [internalRef, callbackRef];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvSW5wdXQvdXNlU3luY1JlZi50cyJdLCJuYW1lcyI6WyJ1c2VSZWYiLCJ1c2VFdmVudENhbGxiYWNrIiwidXNlU3luY1JlZiIsImV4dGVybmFsUmVmIiwiaW50ZXJuYWxSZWYiLCJjYWxsYmFja1JlZiIsIm5vZGUiLCJjdXJyZW50Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxNQUFNLFFBQVEsT0FBTztBQUM5QixTQUFTQyxnQkFBZ0IsUUFBUSxlQUFlO0FBR2hELE9BQU0sU0FBVUMsVUFBVUEsQ0FDeEJDLFdBQWlDLEVBQUE7RUFFakMsSUFBTUMsV0FBVyxHQUFHSixNQUFNLENBQVcsSUFBSSxDQUFDO0VBRTFDLElBQU1LLFdBQVcsR0FBR0osZ0JBQWdCLENBQUMsVUFBQ0ssSUFBYyxFQUFJO0lBQ3RERixXQUFXLENBQUNHLE9BQU8sR0FBR0QsSUFBSTtJQUMxQixJQUFJSCxXQUFXLEVBQUU7TUFDZEEsV0FBcUMsQ0FBQ0ksT0FBTyxHQUFHRCxJQUFJO0lBQ3ZEO0VBQ0YsQ0FBQyxDQUFDO0VBRUYsT0FBTyxDQUFDRixXQUFXLEVBQUVDLFdBQVcsQ0FBVTtBQUM1QyIsImZpbGUiOiJjb21wb25lbnRzL0lucHV0L3VzZVN5bmNSZWYuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Modal/Modal.d.ts

@@ -0,0 +1,4 @@
+import type { ModalProps } from './interface';
+import './style';
+export declare const Modal: import("react").NamedExoticComponent<ModalProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Modal;