@1money/component-ui 0.0.1

package/es/components/Input/Input/Input.scss

@@ -0,0 +1,131 @@
+@use '@/styles/api' as theme;
+
+$component: 'input';
+
+.#{theme.$prefix}-#{$component} {
+  &-control {
+    display: flex;
+    gap: theme.spacing(gap, 200);
+    align-items: center;
+    box-sizing: border-box;
+    width: 100%;
+    height: theme.sizing(component-height, '3xl');
+    padding: 0 theme.spacing(component-padding, 400);
+    background-color: theme.palette(bg, 'default-secondary');
+    border: 1px solid theme.palette(border, 'default');
+    border-radius: theme.shape(300);
+    transition:
+      border-color 0.2s ease,
+      box-shadow 0.2s ease,
+      background-color 0.2s ease;
+  }
+
+  &-control:hover {
+    border-color: theme.palette(border, 'default-tertiary');
+  }
+
+  &-control:focus-within {
+    border-color: theme.palette(border, 'brand');
+    box-shadow: 0 0 0 1px theme.palette(border, 'brand');
+  }
+
+  &-control-disabled {
+    cursor: not-allowed;
+  }
+
+  &-field {
+    @include theme.typography(body, lg);
+
+    flex: 1 1 auto;
+    width: 100%;
+    color: theme.palette(text, 'default');
+    background: transparent;
+    border: none;
+    outline: none;
+
+    &::placeholder {
+      color: theme.palette(text, 'neutral-secondary');
+    }
+
+    &:not(:placeholder-shown) {
+      font-weight: 500;
+    }
+  }
+
+  &-prefix,
+  &-suffix {
+    display: inline-flex;
+    gap: theme.spacing(gap, 200);
+    align-items: center;
+    color: theme.palette(text, 'default-tertiary');
+  }
+
+  &-action {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0;
+    color: theme.palette(icon, 'default-tertiary');
+    background: transparent;
+    border: none;
+    cursor: pointer;
+  }
+
+  &-action:disabled {
+    color: theme.palette(icon, 'disabled');
+    cursor: not-allowed;
+  }
+
+  // ── Size ──
+  &-small &-control {
+    height: theme.sizing(component-height, 'lg');
+    padding: 0 theme.spacing(component-padding, 400);
+    border-radius: theme.shape(200);
+  }
+
+  &-small &-field {
+    @include theme.typography(body, md);
+  }
+
+  // ── Status ──
+  &-error &-control,
+  &-error &-control:hover,
+  &-error &-control:focus-within {
+    border-color: theme.palette(border, 'danger');
+    box-shadow: 0 0 0 1px theme.palette(border, 'danger');
+  }
+
+  &-warning &-control,
+  &-warning &-control:hover,
+  &-warning &-control:focus-within {
+    border-color: theme.palette(border, 'warning');
+    box-shadow: none;
+  }
+
+  &-success &-control,
+  &-success &-control:hover,
+  &-success &-control:focus-within {
+    border-color: theme.palette(border, 'positive');
+    box-shadow: none;
+  }
+
+  // ── Read-only ──
+  &-readonly &-control,
+  &-readonly &-control:hover,
+  &-readonly &-control:focus-within {
+    background-color: theme.palette(bg, 'neutral-tertiary');
+    border-color: transparent;
+    box-shadow: none;
+  }
+
+  // ── Disabled ──
+  &-disabled &-control {
+    background-color: theme.palette(bg, 'disabled');
+    border-color: theme.palette(border, 'default');
+    cursor: not-allowed;
+  }
+
+  &-disabled &-field {
+    color: theme.palette(text, 'disabled');
+  }
+}

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

@@ -0,0 +1,2 @@
+export { Input } from './Input';
+export { default } from './Input';

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

@@ -0,0 +1,3 @@
+export { Input } from './Input';
+export { default } from './Input';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvSW5wdXQvc3JjL2NvbXBvbmVudHMvSW5wdXQvSW5wdXQvaW5kZXgudHMiXSwibmFtZXMiOlsiSW5wdXQiLCJkZWZhdWx0Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxLQUFLLFFBQVEsU0FBUztBQUMvQixTQUFTQyxPQUFPLFFBQVEsU0FBUyIsImZpbGUiOiJjb21wb25lbnRzL0lucHV0L0lucHV0L2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

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

@@ -0,0 +1,5 @@
+import type { FC } from 'react';
+import type { InputMaskProps } from '../interface';
+export declare const InputMask: FC<InputMaskProps>;
+declare const _default: import("react").NamedExoticComponent<InputMaskProps>;
+export default _default;

package/es/components/Input/Mask/Mask.js

@@ -0,0 +1,337 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useId, useRef } from 'react';
+import { useControlledState, useEventCallback } from '@1money/hooks';
+import { default as classnames, joinCls } from '../../../utils/classnames';
+import { FieldShell } from '../FieldShell';
+import { useSyncRef } from '../useSyncRef';
+/** Mask token matchers: 9 = digit, a = letter, * = alphanumeric */
+var MASK_TOKEN = {
+  '9': /\d/,
+  'a': /[a-zA-Z]/,
+  '*': /[a-zA-Z0-9]/
+};
+var isMaskToken = function isMaskToken(_char) {
+  return _char in MASK_TOKEN;
+};
+/** Apply mask to raw value, returning the formatted string */
+var applyMask = function applyMask(raw, mask, slotChar) {
+  var result = '';
+  var rawIndex = 0;
+  for (var i = 0; i < mask.length; i++) {
+    var maskChar = mask[i];
+    if (isMaskToken(maskChar)) {
+      if (rawIndex < raw.length) {
+        var re = MASK_TOKEN[maskChar];
+        // Skip invalid characters in raw
+        while (rawIndex < raw.length && !re.test(raw[rawIndex])) {
+          rawIndex++;
+        }
+        if (rawIndex < raw.length) {
+          result += raw[rawIndex];
+          rawIndex++;
+        } else {
+          result += slotChar;
+        }
+      } else {
+        result += slotChar;
+      }
+    } else {
+      result += maskChar;
+    }
+  }
+  return result;
+};
+/** Extract raw value (only user-typed characters, no literals or slot chars) */
+var extractRaw = function extractRaw(formatted, mask, slotChar) {
+  var raw = '';
+  for (var i = 0; i < mask.length && i < formatted.length; i++) {
+    if (isMaskToken(mask[i]) && formatted[i] !== slotChar) {
+      raw += formatted[i];
+    }
+  }
+  return raw;
+};
+/** Count how many mask tokens exist in the mask pattern */
+var countTokenSlots = function countTokenSlots(mask) {
+  var count = 0;
+  for (var i = 0; i < mask.length; i++) {
+    if (isMaskToken(mask[i])) count++;
+  }
+  return count;
+};
+/** Find the cursor position for the next available mask token slot */
+var findNextSlot = function findNextSlot(mask, formatted, slotChar, fromIndex) {
+  for (var i = fromIndex; i < mask.length; i++) {
+    if (isMaskToken(mask[i]) && (i >= formatted.length || formatted[i] === slotChar)) {
+      return i;
+    }
+  }
+  return fromIndex;
+};
+/** Find the position of the first slot char in formatted value */
+var findFirstSlot = function findFirstSlot(formatted, slotChar) {
+  var idx = formatted.indexOf(slotChar);
+  return idx === -1 ? formatted.length : idx;
+};
+export var InputMask = function InputMask(props) {
+  var _a;
+  var _props$className = props.className,
+    className = _props$className === void 0 ? '' : _props$className,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'input' : _props$prefixCls,
+    _props$size = props.size,
+    size = _props$size === void 0 ? 'large' : _props$size,
+    _props$status = props.status,
+    status = _props$status === void 0 ? 'default' : _props$status,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    _props$loading = props.loading,
+    loading = _props$loading === void 0 ? false : _props$loading,
+    mask = props.mask,
+    _props$slotChar = props.slotChar,
+    slotChar = _props$slotChar === void 0 ? '_' : _props$slotChar,
+    _props$unmask = props.unmask,
+    unmask = _props$unmask === void 0 ? false : _props$unmask,
+    _props$autoClear = props.autoClear,
+    autoClear = _props$autoClear === void 0 ? false : _props$autoClear,
+    label = props.label,
+    info = props.info,
+    errorMsg = props.errorMsg,
+    required = props.required,
+    prefix = props.prefix,
+    suffix = props.suffix,
+    value = props.value,
+    _props$defaultValue = props.defaultValue,
+    defaultValue = _props$defaultValue === void 0 ? '' : _props$defaultValue,
+    onChange = props.onChange,
+    onComplete = props.onComplete,
+    onFocus = props.onFocus,
+    onBlur = props.onBlur,
+    onKeyDown = props.onKeyDown,
+    ref = props.ref,
+    externalId = props.id,
+    rest = __rest(props, ["className", "prefixCls", "size", "status", "disabled", "loading", "mask", "slotChar", "unmask", "autoClear", "label", "info", "errorMsg", "required", "prefix", "suffix", "value", "defaultValue", "onChange", "onComplete", "onFocus", "onBlur", "onKeyDown", "ref", "id"]);
+  var autoId = useId();
+  var inputId = externalId !== null && externalId !== void 0 ? externalId : autoId;
+  var classes = classnames(prefixCls);
+  var _useSyncRef = useSyncRef(ref),
+    _useSyncRef2 = _slicedToArray(_useSyncRef, 2),
+    inputRef = _useSyncRef2[0],
+    syncRef = _useSyncRef2[1];
+  var isComposing = useRef(false);
+  var totalSlots = countTokenSlots(mask);
+  // Internal state always stores the formatted value
+  var formatValue = function formatValue(val) {
+    return applyMask(val, mask, slotChar);
+  };
+  var initialFormatted = defaultValue ? formatValue(defaultValue) : '';
+  var controlledFormatted = value !== undefined ? formatValue(value) : undefined;
+  var _useControlledState = useControlledState(initialFormatted, controlledFormatted),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    innerValue = _useControlledState2[0],
+    setInnerValue = _useControlledState2[1];
+  var isDisabled = disabled || loading;
+  var ariaRequired = required ? 'true' : 'false';
+  var ariaInvalid = status === 'error' ? 'true' : 'false';
+  var emitChange = useEventCallback(function (formatted, event) {
+    var raw = extractRaw(formatted, mask, slotChar);
+    onChange === null || onChange === void 0 ? void 0 : onChange(unmask ? raw : formatted, event);
+    if (raw.length === totalSlots) {
+      onComplete === null || onComplete === void 0 ? void 0 : onComplete(unmask ? raw : formatted);
+    }
+  });
+  var handleChange = useEventCallback(function (event) {
+    var _a;
+    if (isComposing.current) return;
+    var input = event.target;
+    var cursorPos = (_a = input.selectionStart) !== null && _a !== void 0 ? _a : 0;
+    var inputValue = input.value;
+    // Extract only valid characters from the raw input
+    var raw = extractRaw(inputValue, mask, slotChar) + inputValue.slice(cursorPos > 0 ? cursorPos - 1 : 0, cursorPos).replace(/[^\da-zA-Z]/g, '');
+    // Re-extract from the full input to get clean raw
+    var cleanRaw = '';
+    for (var i = 0; i < inputValue.length; i++) {
+      var ch = inputValue[i];
+      if (/[\da-zA-Z]/.test(ch)) cleanRaw += ch;
+    }
+    var formatted = applyMask(cleanRaw, mask, slotChar);
+    setInnerValue(formatted);
+    emitChange(formatted, event);
+    // Position cursor after the last filled slot
+    requestAnimationFrame(function () {
+      var nextPos = findFirstSlot(formatted, slotChar);
+      input.setSelectionRange(nextPos, nextPos);
+    });
+  });
+  var handleKeyDown = useEventCallback(function (event) {
+    var _a, _b, _c;
+    var input = inputRef.current;
+    if (!input) return;
+    if (event.key === 'Backspace') {
+      event.preventDefault();
+      var pos = (_a = input.selectionStart) !== null && _a !== void 0 ? _a : 0;
+      var selEnd = (_b = input.selectionEnd) !== null && _b !== void 0 ? _b : 0;
+      if (pos === 0 && selEnd === 0) return;
+      var currentRaw = extractRaw(innerValue, mask, slotChar);
+      if (pos !== selEnd) {
+        // Selection: remove all raw chars in the selected range
+        var newRaw = '';
+        var rawIdx = 0;
+        for (var i = 0; i < mask.length && rawIdx < currentRaw.length; i++) {
+          if (isMaskToken(mask[i])) {
+            if (i < pos || i >= selEnd) {
+              newRaw += currentRaw[rawIdx];
+            }
+            rawIdx++;
+          }
+        }
+        var formatted = applyMask(newRaw, mask, slotChar);
+        setInnerValue(formatted);
+        emitChange(formatted, {
+          target: input
+        });
+        requestAnimationFrame(function () {
+          var nextPos = findNextSlot(mask, formatted, slotChar, pos);
+          input.setSelectionRange(nextPos, nextPos);
+        });
+      } else {
+        // Single backspace: find prev token position and remove it
+        var targetPos = pos - 1;
+        while (targetPos >= 0 && !isMaskToken(mask[targetPos])) {
+          targetPos--;
+        }
+        if (targetPos < 0) return;
+        var _newRaw = '';
+        var _rawIdx = 0;
+        for (var _i = 0; _i < mask.length; _i++) {
+          if (isMaskToken(mask[_i])) {
+            if (_i !== targetPos && _rawIdx < currentRaw.length) {
+              _newRaw += currentRaw[_rawIdx];
+            }
+            _rawIdx++;
+          }
+        }
+        var _formatted = applyMask(_newRaw, mask, slotChar);
+        setInnerValue(_formatted);
+        emitChange(_formatted, {
+          target: input
+        });
+        requestAnimationFrame(function () {
+          input.setSelectionRange(targetPos, targetPos);
+        });
+      }
+    }
+    if (event.key === 'Delete') {
+      event.preventDefault();
+      var _pos = (_c = input.selectionStart) !== null && _c !== void 0 ? _c : 0;
+      var _targetPos = _pos;
+      while (_targetPos < mask.length && !isMaskToken(mask[_targetPos])) {
+        _targetPos++;
+      }
+      if (_targetPos >= mask.length) return;
+      var _currentRaw = extractRaw(innerValue, mask, slotChar);
+      var _newRaw2 = '';
+      var _rawIdx2 = 0;
+      for (var _i2 = 0; _i2 < mask.length; _i2++) {
+        if (isMaskToken(mask[_i2])) {
+          if (_i2 !== _targetPos && _rawIdx2 < _currentRaw.length) {
+            _newRaw2 += _currentRaw[_rawIdx2];
+          }
+          _rawIdx2++;
+        }
+      }
+      var _formatted2 = applyMask(_newRaw2, mask, slotChar);
+      setInnerValue(_formatted2);
+      emitChange(_formatted2, {
+        target: input
+      });
+      requestAnimationFrame(function () {
+        input.setSelectionRange(_pos, _pos);
+      });
+    }
+    onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);
+  });
+  var handleFocus = useEventCallback(function (event) {
+    // On focus, if empty show the mask placeholder
+    if (!innerValue || extractRaw(innerValue, mask, slotChar).length === 0) {
+      var formatted = applyMask('', mask, slotChar);
+      setInnerValue(formatted);
+    }
+    requestAnimationFrame(function () {
+      var input = inputRef.current;
+      if (input) {
+        var pos = findFirstSlot(input.value, slotChar);
+        input.setSelectionRange(pos, pos);
+      }
+    });
+    onFocus === null || onFocus === void 0 ? void 0 : onFocus(event);
+  });
+  var handleBlur = useEventCallback(function (event) {
+    var raw = extractRaw(innerValue, mask, slotChar);
+    if (autoClear && raw.length > 0 && raw.length < totalSlots) {
+      var empty = applyMask('', mask, slotChar);
+      setInnerValue(empty);
+      emitChange(empty, {
+        target: event.target
+      });
+    }
+    // If completely empty, clear the formatted mask
+    if (raw.length === 0) {
+      setInnerValue('');
+    }
+    onBlur === null || onBlur === void 0 ? void 0 : onBlur(event);
+  });
+  return _jsx(FieldShell, {
+    className: className,
+    prefixCls: prefixCls,
+    size: size,
+    status: status,
+    disabled: isDisabled,
+    label: label,
+    info: info,
+    errorMsg: errorMsg,
+    required: required,
+    inputId: inputId,
+    children: _jsxs("div", {
+      className: classes('control', joinCls(isDisabled && classes('control-disabled'))),
+      children: [prefix && _jsx("span", {
+        className: classes('prefix'),
+        children: prefix
+      }), _jsx("input", Object.assign({}, rest, {
+        ref: syncRef,
+        id: inputId,
+        className: classes('field'),
+        disabled: isDisabled,
+        value: innerValue,
+        placeholder: (_a = rest.placeholder) !== null && _a !== void 0 ? _a : applyMask('', mask, slotChar),
+        onChange: handleChange,
+        onKeyDown: handleKeyDown,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        onCompositionStart: function onCompositionStart() {
+          isComposing.current = true;
+        },
+        onCompositionEnd: function onCompositionEnd(e) {
+          isComposing.current = false;
+          handleChange(e);
+        },
+        "aria-required": ariaRequired,
+        "aria-invalid": ariaInvalid
+      })), suffix && _jsx("span", {
+        className: classes('suffix'),
+        children: suffix
+      })]
+    })
+  });
+};
+export default /*#__PURE__*/memo(InputMask);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Input/Mask/Mask.js","components/Input/src/components/Input/Mask/Mask.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","useId","useRef","useControlledState","useEventCallback","default","classnames","joinCls","FieldShell","useSyncRef","MASK_TOKEN","isMaskToken","char","applyMask","raw","mask","slotChar","result","rawIndex","maskChar","re","test","extractRaw","formatted","countTokenSlots","count","findNextSlot","fromIndex","findFirstSlot","idx","InputMask","props","_a","_props$className","className","_props$prefixCls","prefixCls","_props$size","size","_props$status","status","_props$disabled","disabled","_props$loading","loading","_props$slotChar","_props$unmask","unmask","_props$autoClear","autoClear","label","info","errorMsg","required","prefix","suffix","value","_props$defaultValue","defaultValue","onChange","onComplete","onFocus","onBlur","onKeyDown","ref","externalId","id","rest","autoId","inputId","classes","_useSyncRef","_useSyncRef2","_slicedToArray","inputRef","syncRef","isComposing","totalSlots","formatValue","val","initialFormatted","controlledFormatted","undefined","_useControlledState","_useControlledState2","innerValue","setInnerValue","isDisabled","ariaRequired","ariaInvalid","emitChange","event","handleChange","current","input","target","cursorPos","selectionStart","inputValue","slice","replace","cleanRaw","ch","requestAnimationFrame","nextPos","setSelectionRange","handleKeyDown","_b","_c","key","preventDefault","pos","selEnd","selectionEnd","currentRaw","newRaw","rawIdx","targetPos","handleFocus","handleBlur","empty","children","assign","placeholder","onCompositionStart","onCompositionEnd"],"mappings":"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","file":"components/Input/Mask/Mask.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo, useId, useRef } from 'react';\nimport { useControlledState, useEventCallback } from '@1money/hooks';\nimport { default as classnames, joinCls } from '../../../utils/classnames';\nimport { FieldShell } from '../FieldShell';\nimport { useSyncRef } from '../useSyncRef';\n/** Mask token matchers: 9 = digit, a = letter, * = alphanumeric */\nconst MASK_TOKEN = {\n    '9': /\\d/,\n    'a': /[a-zA-Z]/,\n    '*': /[a-zA-Z0-9]/,\n};\nconst isMaskToken = (char) => char in MASK_TOKEN;\n/** Apply mask to raw value, returning the formatted string */\nconst applyMask = (raw, mask, slotChar) => {\n    let result = '';\n    let rawIndex = 0;\n    for (let i = 0; i < mask.length; i++) {\n        const maskChar = mask[i];\n        if (isMaskToken(maskChar)) {\n            if (rawIndex < raw.length) {\n                const re = MASK_TOKEN[maskChar];\n                // Skip invalid characters in raw\n                while (rawIndex < raw.length && !re.test(raw[rawIndex])) {\n                    rawIndex++;\n                }\n                if (rawIndex < raw.length) {\n                    result += raw[rawIndex];\n                    rawIndex++;\n                }\n                else {\n                    result += slotChar;\n                }\n            }\n            else {\n                result += slotChar;\n            }\n        }\n        else {\n            result += maskChar;\n        }\n    }\n    return result;\n};\n/** Extract raw value (only user-typed characters, no literals or slot chars) */\nconst extractRaw = (formatted, mask, slotChar) => {\n    let raw = '';\n    for (let i = 0; i < mask.length && i < formatted.length; i++) {\n        if (isMaskToken(mask[i]) && formatted[i] !== slotChar) {\n            raw += formatted[i];\n        }\n    }\n    return raw;\n};\n/** Count how many mask tokens exist in the mask pattern */\nconst countTokenSlots = (mask) => {\n    let count = 0;\n    for (let i = 0; i < mask.length; i++) {\n        if (isMaskToken(mask[i]))\n            count++;\n    }\n    return count;\n};\n/** Find the cursor position for the next available mask token slot */\nconst findNextSlot = (mask, formatted, slotChar, fromIndex) => {\n    for (let i = fromIndex; i < mask.length; i++) {\n        if (isMaskToken(mask[i]) && (i >= formatted.length || formatted[i] === slotChar)) {\n            return i;\n        }\n    }\n    return fromIndex;\n};\n/** Find the position of the first slot char in formatted value */\nconst findFirstSlot = (formatted, slotChar) => {\n    const idx = formatted.indexOf(slotChar);\n    return idx === -1 ? formatted.length : idx;\n};\nexport const InputMask = (props) => {\n    var _a;\n    const { className = '', prefixCls = 'input', size = 'large', status = 'default', disabled = false, loading = false, mask, slotChar = '_', unmask = false, autoClear = false, label, info, errorMsg, required, prefix, suffix, value, defaultValue = '', onChange, onComplete, onFocus, onBlur, onKeyDown, ref, id: externalId } = props, rest = __rest(props, [\"className\", \"prefixCls\", \"size\", \"status\", \"disabled\", \"loading\", \"mask\", \"slotChar\", \"unmask\", \"autoClear\", \"label\", \"info\", \"errorMsg\", \"required\", \"prefix\", \"suffix\", \"value\", \"defaultValue\", \"onChange\", \"onComplete\", \"onFocus\", \"onBlur\", \"onKeyDown\", \"ref\", \"id\"]);\n    const autoId = useId();\n    const inputId = externalId !== null && externalId !== void 0 ? externalId : autoId;\n    const classes = classnames(prefixCls);\n    const [inputRef, syncRef] = useSyncRef(ref);\n    const isComposing = useRef(false);\n    const totalSlots = countTokenSlots(mask);\n    // Internal state always stores the formatted value\n    const formatValue = (val) => applyMask(val, mask, slotChar);\n    const initialFormatted = defaultValue ? formatValue(defaultValue) : '';\n    const controlledFormatted = value !== undefined ? formatValue(value) : undefined;\n    const [innerValue, setInnerValue] = useControlledState(initialFormatted, controlledFormatted);\n    const isDisabled = disabled || loading;\n    const ariaRequired = required ? 'true' : 'false';\n    const ariaInvalid = status === 'error' ? 'true' : 'false';\n    const emitChange = useEventCallback((formatted, event) => {\n        const raw = extractRaw(formatted, mask, slotChar);\n        onChange === null || onChange === void 0 ? void 0 : onChange(unmask ? raw : formatted, event);\n        if (raw.length === totalSlots) {\n            onComplete === null || onComplete === void 0 ? void 0 : onComplete(unmask ? raw : formatted);\n        }\n    });\n    const handleChange = useEventCallback((event) => {\n        var _a;\n        if (isComposing.current)\n            return;\n        const input = event.target;\n        const cursorPos = (_a = input.selectionStart) !== null && _a !== void 0 ? _a : 0;\n        const inputValue = input.value;\n        // Extract only valid characters from the raw input\n        const raw = extractRaw(inputValue, mask, slotChar)\n            + inputValue.slice(cursorPos > 0 ? cursorPos - 1 : 0, cursorPos).replace(/[^\\da-zA-Z]/g, '');\n        // Re-extract from the full input to get clean raw\n        let cleanRaw = '';\n        for (let i = 0; i < inputValue.length; i++) {\n            const ch = inputValue[i];\n            if (/[\\da-zA-Z]/.test(ch))\n                cleanRaw += ch;\n        }\n        const formatted = applyMask(cleanRaw, mask, slotChar);\n        setInnerValue(formatted);\n        emitChange(formatted, event);\n        // Position cursor after the last filled slot\n        requestAnimationFrame(() => {\n            const nextPos = findFirstSlot(formatted, slotChar);\n            input.setSelectionRange(nextPos, nextPos);\n        });\n    });\n    const handleKeyDown = useEventCallback((event) => {\n        var _a, _b, _c;\n        const input = inputRef.current;\n        if (!input)\n            return;\n        if (event.key === 'Backspace') {\n            event.preventDefault();\n            const pos = (_a = input.selectionStart) !== null && _a !== void 0 ? _a : 0;\n            const selEnd = (_b = input.selectionEnd) !== null && _b !== void 0 ? _b : 0;\n            if (pos === 0 && selEnd === 0)\n                return;\n            const currentRaw = extractRaw(innerValue, mask, slotChar);\n            if (pos !== selEnd) {\n                // Selection: remove all raw chars in the selected range\n                let newRaw = '';\n                let rawIdx = 0;\n                for (let i = 0; i < mask.length && rawIdx < currentRaw.length; i++) {\n                    if (isMaskToken(mask[i])) {\n                        if (i < pos || i >= selEnd) {\n                            newRaw += currentRaw[rawIdx];\n                        }\n                        rawIdx++;\n                    }\n                }\n                const formatted = applyMask(newRaw, mask, slotChar);\n                setInnerValue(formatted);\n                emitChange(formatted, { target: input });\n                requestAnimationFrame(() => {\n                    const nextPos = findNextSlot(mask, formatted, slotChar, pos);\n                    input.setSelectionRange(nextPos, nextPos);\n                });\n            }\n            else {\n                // Single backspace: find prev token position and remove it\n                let targetPos = pos - 1;\n                while (targetPos >= 0 && !isMaskToken(mask[targetPos])) {\n                    targetPos--;\n                }\n                if (targetPos < 0)\n                    return;\n                let newRaw = '';\n                let rawIdx = 0;\n                for (let i = 0; i < mask.length; i++) {\n                    if (isMaskToken(mask[i])) {\n                        if (i !== targetPos && rawIdx < currentRaw.length) {\n                            newRaw += currentRaw[rawIdx];\n                        }\n                        rawIdx++;\n                    }\n                }\n                const formatted = applyMask(newRaw, mask, slotChar);\n                setInnerValue(formatted);\n                emitChange(formatted, { target: input });\n                requestAnimationFrame(() => {\n                    input.setSelectionRange(targetPos, targetPos);\n                });\n            }\n        }\n        if (event.key === 'Delete') {\n            event.preventDefault();\n            const pos = (_c = input.selectionStart) !== null && _c !== void 0 ? _c : 0;\n            let targetPos = pos;\n            while (targetPos < mask.length && !isMaskToken(mask[targetPos])) {\n                targetPos++;\n            }\n            if (targetPos >= mask.length)\n                return;\n            const currentRaw = extractRaw(innerValue, mask, slotChar);\n            let newRaw = '';\n            let rawIdx = 0;\n            for (let i = 0; i < mask.length; i++) {\n                if (isMaskToken(mask[i])) {\n                    if (i !== targetPos && rawIdx < currentRaw.length) {\n                        newRaw += currentRaw[rawIdx];\n                    }\n                    rawIdx++;\n                }\n            }\n            const formatted = applyMask(newRaw, mask, slotChar);\n            setInnerValue(formatted);\n            emitChange(formatted, { target: input });\n            requestAnimationFrame(() => {\n                input.setSelectionRange(pos, pos);\n            });\n        }\n        onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);\n    });\n    const handleFocus = useEventCallback((event) => {\n        // On focus, if empty show the mask placeholder\n        if (!innerValue || extractRaw(innerValue, mask, slotChar).length === 0) {\n            const formatted = applyMask('', mask, slotChar);\n            setInnerValue(formatted);\n        }\n        requestAnimationFrame(() => {\n            const input = inputRef.current;\n            if (input) {\n                const pos = findFirstSlot(input.value, slotChar);\n                input.setSelectionRange(pos, pos);\n            }\n        });\n        onFocus === null || onFocus === void 0 ? void 0 : onFocus(event);\n    });\n    const handleBlur = useEventCallback((event) => {\n        const raw = extractRaw(innerValue, mask, slotChar);\n        if (autoClear && raw.length > 0 && raw.length < totalSlots) {\n            const empty = applyMask('', mask, slotChar);\n            setInnerValue(empty);\n            emitChange(empty, { target: event.target });\n        }\n        // If completely empty, clear the formatted mask\n        if (raw.length === 0) {\n            setInnerValue('');\n        }\n        onBlur === null || onBlur === void 0 ? void 0 : onBlur(event);\n    });\n    return (_jsx(FieldShell, { className: className, prefixCls: prefixCls, size: size, status: status, disabled: isDisabled, label: label, info: info, errorMsg: errorMsg, required: required, inputId: inputId, children: _jsxs(\"div\", { className: classes('control', joinCls(isDisabled && classes('control-disabled'))), children: [prefix && _jsx(\"span\", { className: classes('prefix'), children: prefix }), _jsx(\"input\", Object.assign({}, rest, { ref: syncRef, id: inputId, className: classes('field'), disabled: isDisabled, value: innerValue, placeholder: (_a = rest.placeholder) !== null && _a !== void 0 ? _a : applyMask('', mask, slotChar), onChange: handleChange, onKeyDown: handleKeyDown, onFocus: handleFocus, onBlur: handleBlur, onCompositionStart: () => { isComposing.current = true; }, onCompositionEnd: (e) => {\n                        isComposing.current = false;\n                        handleChange(e);\n                    }, \"aria-required\": ariaRequired, \"aria-invalid\": ariaInvalid })), suffix && _jsx(\"span\", { className: classes('suffix'), children: suffix })] }) }));\n};\nexport default memo(InputMask);",null],"sourceRoot":"../../../../../../../../../../src"}

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

@@ -0,0 +1,2 @@
+export { InputMask } from './Mask';
+export { default } from './Mask';

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

@@ -0,0 +1,3 @@
+export { InputMask } from './Mask';
+export { default } from './Mask';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvSW5wdXQvc3JjL2NvbXBvbmVudHMvSW5wdXQvTWFzay9pbmRleC50cyJdLCJuYW1lcyI6WyJJbnB1dE1hc2siLCJkZWZhdWx0Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxTQUFTLFFBQVEsUUFBUTtBQUNsQyxTQUFTQyxPQUFPLFFBQVEsUUFBUSIsImZpbGUiOiJjb21wb25lbnRzL0lucHV0L01hc2svaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Input/OTP/OTP.css

@@ -0,0 +1 @@
+.om-react-ui-input-otp{display:flex;gap:var(--om-spacing-200,8px)}.om-react-ui-input-otp-cell{font-size:var(--om-body-lg-font-size);font-family:var(--om-body-lg-font-family);line-height:var(--om-body-lg-line-height);letter-spacing:var(--om-body-lg-letter-spacing);font-weight:var(--om-body-lg-font-weight);width:54px;height:var(--om-component-height-3xl,56px);color:var(--om-text-default,#131313);font-weight:500;text-align:center;background-color:var(--om-bg-default-secondary,#f8f8f8);border:1px solid var(--om-border-default,#d1d2d2);border-radius:var(--om-radius-300,12px);outline:none}.om-react-ui-input-otp-cell:hover:not(:disabled){border-color:var(--om-border-default-tertiary,#404042)}.om-react-ui-input-error .om-react-ui-input-otp-cell:hover:not(:disabled){border-color:var(--om-border-danger,#ae0000)}.om-react-ui-input-warning .om-react-ui-input-otp-cell:hover:not(:disabled){border-color:var(--om-border-warning,#db8600)}.om-react-ui-input-success .om-react-ui-input-otp-cell:hover:not(:disabled){border-color:var(--om-border-positive,#1f5800)}.om-react-ui-input-otp-cell:focus{border-color:var(--om-border-brand,#073387);box-shadow:0 0 0 1px var(--om-border-brand,#073387)}.om-react-ui-input-small .om-react-ui-input-otp-cell{width:var(--om-component-height-lg,44px);height:var(--om-component-height-lg,44px);border-radius:var(--om-radius-200,8px)}.om-react-ui-input-error .om-react-ui-input-otp-cell{color:var(--om-text-danger,#ae0000);border-color:var(--om-border-danger,#ae0000);box-shadow:0 0 0 1px var(--om-border-danger,#ae0000)}.om-react-ui-input-warning .om-react-ui-input-otp-cell{border-color:var(--om-border-warning,#db8600)}.om-react-ui-input-success .om-react-ui-input-otp-cell{border-color:var(--om-border-positive,#1f5800)}.om-react-ui-input-disabled .om-react-ui-input-otp-cell{color:var(--om-text-disabled,#bbbdc1);background-color:var(--om-bg-disabled,#f0f0f0);border-color:var(--om-border-default,#d1d2d2);cursor:not-allowed}

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

@@ -0,0 +1,5 @@
+import type { FC } from 'react';
+import type { InputOTPProps } from '../interface';
+export declare const InputOTP: FC<InputOTPProps>;
+declare const _default: import("react").NamedExoticComponent<InputOTPProps>;
+export default _default;