rsuite 6.0.0-canary-20250416 → 6.0.0-canary-20250424

package/cjs/NumberInput/hooks/useNumberInputValue.d.ts

@@ -0,0 +1,7 @@
+export interface UseNumberInputValueParams {
+    value?: number | string | null;
+    isFocused: boolean;
+    formatter?: (value: number | string) => string;
+    decimalSeparator?: string;
+}
+export declare function useNumberInputValue(params: UseNumberInputValueParams): string | number;

package/cjs/NumberInput/hooks/useNumberInputValue.js

@@ -0,0 +1,34 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.useNumberInputValue = useNumberInputValue;
+var _react = require("react");
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+function useNumberInputValue(params) {
+  const {
+    value,
+    isFocused,
+    formatter,
+    decimalSeparator
+  } = params;
+  const replaceDecimalSeparator = (0, _react.useCallback)(val => {
+    if (decimalSeparator && val != null) {
+      return val.toString().replace('.', decimalSeparator);
+    }
+    return val;
+  }, [decimalSeparator]);
+  return (0, _react.useMemo)(() => {
+    if ((0, _isNil.default)(value)) {
+      return '';
+    }
+    if (isFocused) {
+      return replaceDecimalSeparator(value);
+    }
+    if (formatter) {
+      return formatter(value);
+    }
+    return replaceDecimalSeparator(value);
+  }, [formatter, isFocused, replaceDecimalSeparator, value]);
+}

package/cjs/NumberInput/hooks/useWheelHandler.d.ts

@@ -0,0 +1,5 @@
+import { type RefObject } from 'react';
+/**
+ * Attach wheel listener to inputRef.
+ */
+export declare function useWheelHandler(inputRef: RefObject<HTMLInputElement | null>, handleWheel: (event: React.WheelEvent<HTMLInputElement>) => void, scrollable: boolean): void;

package/cjs/NumberInput/hooks/useWheelHandler.js

@@ -0,0 +1,25 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.useWheelHandler = useWheelHandler;
+var _react = require("react");
+var _on = _interopRequireDefault(require("dom-lib/on"));
+/**
+ * Attach wheel listener to inputRef.
+ */
+function useWheelHandler(inputRef, handleWheel, scrollable) {
+  (0, _react.useEffect)(() => {
+    let wheelListener;
+    if (inputRef.current) {
+      wheelListener = (0, _on.default)(inputRef.current, 'wheel', handleWheel, {
+        passive: false
+      });
+    }
+    return () => {
+      var _wheelListener;
+      (_wheelListener = wheelListener) === null || _wheelListener === void 0 || _wheelListener.off();
+    };
+  }, [inputRef, handleWheel, scrollable]);
+}

package/cjs/NumberInput/index.d.ts

@@ -0,0 +1,4 @@
+import NumberInput from './NumberInput';
+export type { NumberInputProps } from './NumberInput';
+export { NumberInput };
+export default NumberInput;

package/cjs/NumberInput/index.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _NumberInput = _interopRequireDefault(require("./NumberInput"));
+exports.NumberInput = _NumberInput.default;
+// export types
+// export components
+var _default = exports.default = _NumberInput.default;

package/cjs/NumberInput/utils/number.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Clamp a value within min/max and handle NaN as empty string.
+ */
+export declare function clampValue(value: number | string, min?: number, max?: number): string;
+export declare function decimals(...values: number[]): number;
+/**
+ * Disable the upper limit of the number.
+ * @param value
+ * @param max
+ */
+export declare function valueReachesMax(value: number | string | null | undefined, max: number): boolean;
+/**
+ * Disable the lower limit of the number.
+ * @param value
+ * @param min
+ */
+export declare function valueReachesMin(value: number | string | null | undefined, min: number): boolean;

package/cjs/NumberInput/utils/number.js

@@ -0,0 +1,67 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.clampValue = clampValue;
+exports.decimals = decimals;
+exports.valueReachesMax = valueReachesMax;
+exports.valueReachesMin = valueReachesMin;
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+/**
+ * Clamp a value within min/max and handle NaN as empty string.
+ */
+function clampValue(value, min, max) {
+  const num = typeof value === 'string' ? parseFloat(value) : value;
+  if (Number.isNaN(num)) {
+    return '';
+  }
+  let result = num;
+  if (typeof max !== 'undefined' && result > max) {
+    result = max;
+  }
+  if (typeof min !== 'undefined' && result < min) {
+    result = min;
+  }
+  return result.toString();
+}
+function isNumber(value) {
+  return /(^-?|^\+?|^\d?)\d*\.\d+$/.test(value + '');
+}
+function getDecimalLength(value) {
+  if (isNumber(value)) {
+    return value.toString().split('.')[1].length;
+  }
+  return 0;
+}
+function decimals() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  const lengths = values.map(getDecimalLength);
+  return Math.max(...lengths);
+}
+
+/**
+ * Disable the upper limit of the number.
+ * @param value
+ * @param max
+ */
+function valueReachesMax(value, max) {
+  if (!(0, _isNil.default)(value)) {
+    return +value >= max;
+  }
+  return false;
+}
+
+/**
+ * Disable the lower limit of the number.
+ * @param value
+ * @param min
+ */
+function valueReachesMin(value, min) {
+  if (!(0, _isNil.default)(value)) {
+    return +value <= min;
+  }
+  return false;
+}

package/cjs/Pagination/LimitPicker.d.ts

@@ -1,12 +1,12 @@
 import { type SelectPickerProps } from '../SelectPicker';
 import { PaginationLocale } from '../locales';
-import type { OnChangeCallback, Size } from '../internals/types';
+import type { OnChangeCallback, BasicSize } from '../internals/types';
 interface LimitPickerProps extends Omit<SelectPickerProps<any>, 'locale' | 'disabled' | 'data'> {
     disabled?: boolean | ((eventKey: number | string) => boolean);
     limitOptions: number[];
     locale: PaginationLocale;
     limit: number;
-    size?: Size;
+    size?: BasicSize;
     prefix: (input: string) => string;
     onChangeLimit: OnChangeCallback<any>;
 }

package/cjs/Pagination/Pagination.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { BoxProps } from '../internals/Box';
-import type { Size } from '../internals/types';
+import type { BasicSize } from '../internals/types';
 import type { PaginationLocale } from '../locales';
 export interface PaginationProps extends BoxProps {
     /** Current page number */
@@ -30,7 +30,7 @@ export interface PaginationProps extends BoxProps {
     /** Custom locale */
     locale?: PaginationLocale;
     /** A pagination can have different sizes */
-    size?: Size;
+    size?: BasicSize;
     /** callback function for pagination clicked */
     onSelect?: (eventKey: string | number, event: React.MouseEvent) => void;
 }

package/cjs/Pagination/Pagination.js

@@ -15,7 +15,6 @@ var _PaginationButton = _interopRequireDefault(require("./PaginationButton"));
 var _Box = _interopRequireDefault(require("../internals/Box"));
 var _utils = require("../internals/utils");
 var _hooks = require("../internals/hooks");
-var _CustomProvider = require("../CustomProvider");
 const icons = {
   more: /*#__PURE__*/_react.default.createElement(_More.default, null),
   first: /*#__PURE__*/_react.default.createElement(_PageTop.default, null),
@@ -31,7 +30,7 @@ const icons = {
 const Pagination = (0, _utils.forwardRef)((props, ref) => {
   const {
     propsWithDefaults
-  } = (0, _CustomProvider.useCustom)('Pagination', props);
+  } = (0, _hooks.useCustom)('Pagination', props);
   const {
     as,
     className,

package/cjs/Pagination/PaginationGroup.js

@@ -14,7 +14,6 @@ var _LimitPicker = _interopRequireDefault(require("./LimitPicker"));
 var _Box = _interopRequireDefault(require("../internals/Box"));
 var _hooks = require("../internals/hooks");
 var _utils = require("../internals/utils");
-var _CustomProvider = require("../CustomProvider");
 /**
  * The layout of the paging component.
  */
@@ -61,7 +60,7 @@ const PaginationGroup = (0, _utils.forwardRef)((props, ref) => {
   const classes = merge(className, withPrefix(size));
   const {
     getLocale
-  } = (0, _CustomProvider.useCustom)();
+  } = (0, _hooks.useCustom)();
   const locale = getLocale('Pagination', localeProp);
   const handleInputBlur = (0, _hooks.useEventCallback)(event => {
     const value = parseInt(event.target.value);

package/cjs/Panel/Panel.js

@@ -12,7 +12,6 @@ var _useExpanded = _interopRequireDefault(require("./hooks/useExpanded"));
 var _Box = _interopRequireDefault(require("../internals/Box"));
 var _utils = require("../internals/utils");
 var _hooks = require("../internals/hooks");
-var _CustomProvider = require("../CustomProvider");
 var _PanelGroup = require("../PanelGroup");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -23,7 +22,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 const Panel = (0, _utils.forwardRef)((props, ref) => {
   const {
     propsWithDefaults
-  } = (0, _CustomProvider.useCustom)('Panel', props);
+  } = (0, _hooks.useCustom)('Panel', props);
   const {
     as,
     bodyFill,

package/cjs/PanelGroup/PanelGroup.js

@@ -9,7 +9,6 @@ var _react = _interopRequireWildcard(require("react"));
 var _Box = _interopRequireDefault(require("../internals/Box"));
 var _utils = require("../internals/utils");
 var _hooks = require("../internals/hooks");
-var _CustomProvider = require("../CustomProvider");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const PanelGroupContext = exports.PanelGroupContext = /*#__PURE__*/_react.default.createContext({});
@@ -21,7 +20,7 @@ const PanelGroupContext = exports.PanelGroupContext = /*#__PURE__*/_react.defaul
 const PanelGroup = (0, _utils.forwardRef)((props, ref) => {
   const {
     propsWithDefaults
-  } = (0, _CustomProvider.useCustom)('PanelGroup', props);
+  } = (0, _hooks.useCustom)('PanelGroup', props);
   const {
     as,
     accordion,

package/cjs/PasswordInput/PasswordInput.d.ts

@@ -5,6 +5,10 @@ export interface PasswordInputProps extends Omit<InputProps, 'type' | 'plaintext
     visible?: boolean;
     /** Default visibility state of the password */
     defaultVisible?: boolean;
+    /** The icon element to display before the input field */
+    startIcon?: React.ReactNode;
+    /**  The icon element to display after the input field */
+    endIcon?: React.ReactNode;
     /** Custom icon for visibility toggle */
     renderVisibilityIcon?: (visible: boolean) => React.ReactNode;
     /** Callback function triggered when the password visibility changes */

package/cjs/PasswordInput/PasswordInput.js

@@ -12,11 +12,10 @@ var _EyeClose = _interopRequireDefault(require("@rsuite/icons/EyeClose"));
 var _Visible = _interopRequireDefault(require("@rsuite/icons/Visible"));
 var _utils = require("../internals/utils");
 var _hooks = require("../internals/hooks");
-var _CustomProvider = require("../CustomProvider");
 const PasswordInput = (0, _utils.forwardRef)((props, ref) => {
   const {
     propsWithDefaults
-  } = (0, _CustomProvider.useCustom)('PasswordInput', props);
+  } = (0, _hooks.useCustom)('PasswordInput', props);
   const {
     classPrefix = 'password-input',
     className,
@@ -30,6 +29,8 @@ const PasswordInput = (0, _utils.forwardRef)((props, ref) => {
     name,
     readOnly,
     inputRef,
+    startIcon,
+    endIcon,
     onChange,
     onVisibleChange,
     renderVisibilityIcon,
@@ -50,7 +51,7 @@ const PasswordInput = (0, _utils.forwardRef)((props, ref) => {
     ref: ref,
     size: size,
     className: classes
-  }, rest), /*#__PURE__*/_react.default.createElement(_Input.default, {
+  }, rest), startIcon && /*#__PURE__*/_react.default.createElement(_InputGroup.default.Addon, null, startIcon), /*#__PURE__*/_react.default.createElement(_Input.default, {
     type: visible ? 'text' : 'password',
     value: value,
     defaultValue: defaultValue,
@@ -61,7 +62,7 @@ const PasswordInput = (0, _utils.forwardRef)((props, ref) => {
     name: name,
     id: id,
     inputRef: inputRef
-  }), /*#__PURE__*/_react.default.createElement(_InputGroup.default.Button, {
+  }), endIcon ? /*#__PURE__*/_react.default.createElement(_InputGroup.default.Addon, null, endIcon) : /*#__PURE__*/_react.default.createElement(_InputGroup.default.Button, {
     tabIndex: -1,
     onClick: handleToggleVisibility,
     "aria-label": "Toggle password visibility"

package/cjs/PasswordStrengthMeter/PasswordStrengthMeter.js

@@ -10,11 +10,10 @@ var _Box = _interopRequireDefault(require("../internals/Box"));
 var _Text = _interopRequireDefault(require("../Text"));
 var _utils = require("../internals/utils");
 var _hooks = require("../internals/hooks");
-var _CustomProvider = require("../CustomProvider");
 const PasswordStrengthMeter = (0, _utils.forwardRef)((props, ref) => {
   const {
     propsWithDefaults
-  } = (0, _CustomProvider.useCustom)('PasswordStrengthMeter', props);
+  } = (0, _hooks.useCustom)('PasswordStrengthMeter', props);
   const {
     classPrefix = 'password-strength-meter',
     className,

package/cjs/PinInput/PinInput.d.ts

@@ -0,0 +1,36 @@
+import { BoxProps } from '../internals/Box';
+import type { BasicSize } from '../internals/types';
+export interface PinInputProps extends BoxProps {
+    /** Whether input fields are attached (no gap between) */
+    attached?: boolean;
+    /** Whether to auto-focus the first input on mount */
+    autoFocus?: boolean;
+    /** Type of allowed input: number, alphabetic, alphanumeric, or custom regex */
+    type?: 'number' | 'alphabetic' | 'alphanumeric' | RegExp;
+    /** Default PIN value */
+    defaultValue?: string;
+    /** Whether to disable PIN input */
+    disabled?: boolean;
+    /** Number of PIN digits */
+    length?: number;
+    /** Whether to mask PIN input (like password) */
+    mask?: boolean;
+    /** Name for form submission */
+    name?: string;
+    /** Whether to optimize for one-time password (OTP) input */
+    otp?: boolean;
+    /** Placeholder for input fields */
+    placeholder?: string;
+    /** Whether the input is read-only */
+    readOnly?: boolean;
+    /** Input size */
+    size?: BasicSize;
+    /** PIN value */
+    value?: string;
+    /** Callback function when PIN input is completed */
+    onComplete?: (value: string) => void;
+    /** Callback function when PIN value changes */
+    onChange?: (value: string) => void;
+}
+declare const PinInput: import("../internals/types").InternalRefForwardingComponent<"div", PinInputProps, never> & Record<string, never>;
+export default PinInput;

package/cjs/PinInput/PinInput.js

@@ -0,0 +1,224 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireDefault(require("react"));
+var _Input = _interopRequireDefault(require("../Input"));
+var _usePinInputRefs = _interopRequireDefault(require("./hooks/usePinInputRefs"));
+var _usePinValue = _interopRequireDefault(require("./hooks/usePinValue"));
+var _Box = require("../internals/Box");
+var _Stack = require("../Stack");
+var _utils = require("../internals/utils");
+var _hooks = require("../internals/hooks");
+/**
+ * Map `type` prop to regex for allowed keys
+ */
+function getAllowedKeys(type) {
+  if (type instanceof RegExp) {
+    return type;
+  }
+  switch (type) {
+    case 'alphabetic':
+      return /[A-Za-z]/;
+    case 'alphanumeric':
+      return /[A-Za-z0-9]/;
+    default:
+      // number and any other fallback
+      return /\d/;
+  }
+}
+const PinInput = (0, _utils.forwardRef)((props, ref) => {
+  const {
+    propsWithDefaults
+  } = (0, _hooks.useCustom)('PinInput', props);
+  const {
+    type = 'number',
+    as,
+    autoFocus,
+    attached,
+    className,
+    classPrefix = 'pin-input',
+    defaultValue = '',
+    disabled,
+    length = 4,
+    mask,
+    name,
+    otp,
+    placeholder,
+    readOnly,
+    size = 'md',
+    value: controlValue,
+    onChange,
+    onComplete,
+    ...rest
+  } = propsWithDefaults;
+
+  // Regex for filtering input chars based on type prop
+  const allowedKeys = getAllowedKeys(type);
+
+  // Determine inputMode based on type prop
+  const inputModeValue = type === 'number' ? 'numeric' : 'text';
+
+  // Determine input type attribute based on type prop and mask
+  const inputTypeValue = mask ? 'password' : type === 'number' ? 'tel' : 'text';
+  const {
+    withPrefix,
+    prefix,
+    merge
+  } = (0, _hooks.useStyles)(classPrefix);
+
+  // Use our custom hook for handling input refs and focus behavior
+  const {
+    focusInput,
+    focusNextInput,
+    focusPrevInput,
+    getRefSetter
+  } = (0, _usePinInputRefs.default)(length, autoFocus);
+
+  // Use our custom hook for managing PIN values
+  const {
+    valueArray,
+    setDigit,
+    clearDigit,
+    updateValue
+  } = (0, _usePinValue.default)(controlValue, defaultValue, length, onChange, onComplete);
+
+  // Handle input change
+  const handleInputChange = (0, _hooks.useEventCallback)((inputValue, e, index) => {
+    // Safety check for event object
+    if (!e || !e.target) return;
+
+    // For single character input, use it directly
+    // For longer input (like paste or browser autofill), take the last character
+    const char = inputValue.length > 0 ? inputValue.charAt(inputValue.length - 1) : '';
+
+    // Filter by allowedKeys if provided
+    if (!allowedKeys.test(char)) {
+      return;
+    }
+
+    // Always allow overwriting the current value
+    // Update the value using our hook
+    setDigit(index, char);
+
+    // Focus the next input if we have a character and there's a next input
+    if (char && index < length - 1) {
+      // Use setTimeout to ensure the focus happens after the current event cycle
+      focusNextInput(index);
+    }
+
+    // If this is the last input and a character was entered, keep focus on it
+    if (char && index === length - 1) {
+      focusInput(index);
+    }
+  });
+
+  // Handle key down
+  const handleKeyDown = (0, _hooks.useEventCallback)((e, index) => {
+    // Safety check for event object
+    if (!e) return;
+    const target = e.target;
+    const inputValue = (target === null || target === void 0 ? void 0 : target.value) || '';
+
+    // Handle backspace
+    if (e.key === 'Backspace') {
+      if (inputValue === '') {
+        // Focus the previous input if the current one is empty
+        if (index > 0) {
+          clearDigit(index - 1);
+          focusPrevInput(index);
+        }
+      } else {
+        // Clear the current input but keep focus on it
+        clearDigit(index);
+      }
+    }
+    // Handle arrow keys
+    else if (e.key === 'ArrowLeft') {
+      focusPrevInput(index);
+    } else if (e.key === 'ArrowRight') {
+      focusNextInput(index);
+    }
+    // Allow only keys matching allowedKeys
+    else if (allowedKeys.test(e.key)) {
+      setDigit(index, e.key);
+
+      // Move focus to the next input if there is one
+      if (index < length - 1) {
+        setTimeout(() => {
+          focusNextInput(index);
+        }, 10);
+      }
+    }
+  });
+
+  // Handle paste
+  const handlePaste = (0, _hooks.useEventCallback)((e, index) => {
+    if (disabled || readOnly) return;
+
+    // Safety check for event object
+    if (!e || !e.clipboardData) return;
+    e.preventDefault();
+    const pastedData = e.clipboardData.getData('text') || '';
+
+    // Filter pasted data by allowedKeys
+    const filteredData = pastedData.split('').filter(ch => allowedKeys.test(ch)).join('');
+    if (filteredData) {
+      // Create a new value with pasted characters
+      const newValueArray = [...valueArray];
+      for (let i = 0; i < filteredData.length && index + i < length; i++) {
+        newValueArray[index + i] = filteredData[i];
+      }
+
+      // Update value with our hook
+      updateValue(newValueArray.join(''));
+
+      // Focus the input after the last pasted character or the last input
+      // Use setTimeout to ensure focus happens after DOM updates
+      const nextIndex = Math.min(index + filteredData.length, length - 1);
+      setTimeout(() => {
+        focusInput(nextIndex);
+      }, 10);
+    }
+  });
+  const classes = merge(className, withPrefix({
+    attached
+  }));
+  return /*#__PURE__*/_react.default.createElement(_Box.Box, (0, _extends2.default)({
+    as: as,
+    ref: ref,
+    className: classes
+  }, rest), /*#__PURE__*/_react.default.createElement("input", {
+    type: "hidden",
+    value: valueArray.join(''),
+    name: name,
+    "aria-label": "Pin input"
+  }), /*#__PURE__*/_react.default.createElement(_Stack.HStack, {
+    spacing: attached ? 0 : 8
+  }, Array.from({
+    length
+  }).map((_, index) => /*#__PURE__*/_react.default.createElement(_Input.default, {
+    key: index,
+    className: prefix('segment', {
+      masked: mask
+    }),
+    size: size,
+    value: valueArray[index] || '',
+    onChange: (v, e) => handleInputChange(v, e, index),
+    onKeyDown: e => handleKeyDown(e, index),
+    onPaste: e => handlePaste(e, index),
+    disabled: disabled,
+    readOnly: readOnly,
+    maxLength: 1,
+    autoComplete: otp ? 'one-time-code' : 'off',
+    inputMode: inputModeValue,
+    placeholder: placeholder,
+    type: inputTypeValue,
+    ref: getRefSetter(index)
+  }))));
+});
+PinInput.displayName = 'PinInput';
+var _default = exports.default = PinInput;

package/cjs/PinInput/hooks/usePinInputRefs.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+/**
+ * A hook that manages the refs and focus behavior for a PIN input component
+ */
+export declare const usePinInputRefs: (length: number, autoFocus?: boolean) => {
+    inputRefs: import("react").RefObject<(HTMLInputElement | null)[]>;
+    focusInput: (index: number) => boolean;
+    focusNextInput: (currentIndex: number) => boolean;
+    focusPrevInput: (currentIndex: number) => boolean;
+    getRefSetter: (index: number) => (el: HTMLInputElement | null) => void;
+};
+export default usePinInputRefs;