@momo-kits/foundation 0.165.2-beta.1 → 0.165.2-beta.2

package/Input/InputMoney.tsx

@@ -9,8 +9,10 @@ import React, {
 } from 'react';
 import {
   NativeSyntheticEvent,
+  Platform,
   TextInput,
   TextInputFocusEventData,
+  TextInputSelectionChangeEventData,
   TouchableOpacity,
   View,
 } from 'react-native';
@@ -32,9 +34,124 @@ import {
 } from './common';
 import { InputMoneyProps } from './index';
 import styles from './styles';
-import { formatNumberToMoney } from './utils';
 import SystemTextInput from './SystemTextInput';
 
+type Selection = { start: number; end: number };
+type Edit = { start: number; end: number; inserted: string };
+
+const countDigits = (text: string) => text.replace(/\D/g, '').length;
+
+const groupDigits = (digits: string) =>
+  digits.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+
+// Caret position right after the `digitIndex`-th digit of `display`.
+const caretFromDigitIndex = (display: string, digitIndex: number) => {
+  let count = 0;
+  for (let i = 0; i < display.length && count < digitIndex; i++) {
+    if (/\d/.test(display[i])) {
+      count += 1;
+      if (count === digitIndex) return i + 1;
+    }
+  }
+  return 0;
+};
+
+// Finds which range of `old` was replaced to produce `next`. `selection` is
+// the pre-edit selection on iOS and already the post-edit caret on Android,
+// where onSelectionChange fires before onChangeText.
+const detectEdit = (old: string, next: string, selection: Selection): Edit => {
+  const { start, end } = selection;
+  const removed = old.length - next.length;
+  const preEdit: Edit[] = [
+    {
+      start,
+      end,
+      inserted: next.slice(start, next.length - (old.length - end)),
+    },
+    { start: start - removed, end: start, inserted: '' },
+    { start, end: start + removed, inserted: '' },
+  ];
+  const postEdit: Edit[] = [];
+  const tail = next.length - start;
+  if (start === end && tail <= old.length) {
+    let prefix = 0;
+    while (
+      prefix < Math.min(start, old.length - tail) &&
+      old[prefix] === next[prefix]
+    ) {
+      prefix += 1;
+    }
+    postEdit.push({
+      start: prefix,
+      end: old.length - tail,
+      inserted: next.slice(prefix, start),
+    });
+  }
+  const candidates =
+    Platform.OS === 'android'
+      ? [...postEdit, ...preEdit]
+      : [...preEdit, ...postEdit];
+  const match = candidates.find(
+    e =>
+      e.start >= 0 &&
+      e.end >= e.start &&
+      e.end <= old.length &&
+      old.slice(0, e.start) + e.inserted + old.slice(e.end) === next,
+  );
+  if (match) return match;
+
+  let prefix = 0;
+  while (
+    prefix < Math.min(old.length, next.length) &&
+    old[prefix] === next[prefix]
+  ) {
+    prefix += 1;
+  }
+  let suffix = 0;
+  while (
+    suffix < Math.min(old.length, next.length) - prefix &&
+    old[old.length - 1 - suffix] === next[next.length - 1 - suffix]
+  ) {
+    suffix += 1;
+  }
+  return {
+    start: prefix,
+    end: old.length - suffix,
+    inserted: next.slice(prefix, next.length - suffix),
+  };
+};
+
+// Applies `edit` to the digits of `display`. Separators and currency are never
+// deleted: removing a separator deletes the digit before it instead, removing
+// only the currency leaves the digits untouched.
+const applyEdit = (display: string, edit: Edit, digitLimit: number) => {
+  const digits = display.replace(/\D/g, '');
+  let left = countDigits(display.slice(0, edit.start));
+  let removed = countDigits(display.slice(edit.start, edit.end));
+  const inserted = edit.inserted.replace(/\D/g, '');
+  if (
+    !removed &&
+    !inserted &&
+    left > 0 &&
+    display.slice(edit.start, edit.end).includes('.')
+  ) {
+    left -= 1;
+    removed = 1;
+  }
+  const next = digits.slice(0, left) + inserted + digits.slice(left + removed);
+  const trimmed = next.replace(/^0+(?=\d)/, '');
+  if ((!removed && !inserted) || trimmed.length > digitLimit) {
+    return { digits, caretDigit: left };
+  }
+  return {
+    digits: trimmed,
+    caretDigit: Math.max(
+      0,
+      left + inserted.length - (next.length - trimmed.length),
+    ),
+  };
+};
+
 const InputMoney = forwardRef(
   (
     {
@@ -73,7 +190,8 @@ const InputMoney = forwardRef(
     const [focused, setFocused] = useState(false);
     const [displayValue, setDisplayValue] = useState('');
     const [numericValue, setNumericValue] = useState('');
-    const [lastDisplayValue, setLastDisplayValue] = useState('');
+    const [selection, setSelection] = useState<Selection>();
+    const selectionRef = useRef<Selection>({ start: 0, end: 0 });
     const inputRef = useRef<TextInput>(null);
     const componentName = 'InputMoney';
 
@@ -91,25 +209,21 @@ const InputMoney = forwardRef(
 
     useEffect(() => {
       if (value !== undefined && typeof value === 'string') {
-        const cleanValue = value.replace(/\D/g, '');
+        const cleanValue = value.replace(/\D/g, '').replace(/^0+(?=\d)/, '');
         if (cleanValue !== numericValue) {
-          setNumericValue(cleanValue);
-          updateDisplayValue(cleanValue);
+          commit(cleanValue, cleanValue.length);
         }
       }
     }, [value]);
 
-    useEffect(() => {
-      setLastDisplayValue(displayValue);
-    }, [displayValue]);
-
-    const updateDisplayValue = (numeric: string) => {
-      if (!numeric) {
-        setDisplayValue('');
-        return;
-      }
-      const formatted = formatNumberToMoney(Number(numeric));
-      setDisplayValue(formatted ? `${formatted}${currency}` : '');
+    const commit = (digits: string, caretDigit: number) => {
+      const display = digits ? `${groupDigits(digits)}${currency}` : '';
+      const caret = caretFromDigitIndex(display, caretDigit);
+      selectionRef.current = { start: caret, end: caret };
+      setSelection({ start: caret, end: caret });
+      setDisplayValue(display);
+      setNumericValue(digits);
+      return digits !== numericValue;
     };
 
     const parseInputText = (text: string): string => {
@@ -119,47 +233,35 @@ const InputMoney = forwardRef(
       return textWithoutCurrency.replace(/[^\d]/g, '');
     };
 
-    const updateNumericValue = (val: string) => {
-      let next = val.replace(/[^\d]/g, '');
-      if (next.length > digitLimit) next = next.slice(0, digitLimit);
-      if (/^\d*$/.test(next)) {
-        setNumericValue(next);
-        updateDisplayValue(next);
-        onChangeText?.(next);
-      }
-    };
-
     const onClearText = () => {
       inputRef?.current?.clear();
       inputRef.current?.setNativeProps({ text: '' });
-      setDisplayValue('');
-      setNumericValue('');
+      commit('', 0);
       onChangeText?.('');
     };
 
     const _onChangeText = (text: string) => {
-      if (!text) {
-        setDisplayValue('');
-        setNumericValue('');
-        onChangeText?.('');
-        return;
-      }
-      if (text.length < lastDisplayValue.length) {
-        const lastChar = lastDisplayValue.charAt(lastDisplayValue.length - 1);
-        const isRemovingCurrency =
-          lastDisplayValue.endsWith(currency) || lastChar === ' ';
-        const isRemovingDot = lastChar === '.';
-        if (isRemovingCurrency || isRemovingDot) {
-          const currentNumericValue = numericValue;
-          if (currentNumericValue.length > 0) {
-            const newNumericValue = currentNumericValue.slice(0, -1);
-            updateNumericValue(newNumericValue);
-            return;
-          }
-        }
+      const { digits, caretDigit } = text
+        ? applyEdit(
+            displayValue,
+            detectEdit(displayValue, text, selectionRef.current),
+            digitLimit,
+          )
+        : { digits: '', caretDigit: 0 };
+      if (commit(digits, caretDigit)) {
+        onChangeText?.(digits);
       }
-      const newNumericValue = parseInputText(text);
-      updateNumericValue(newNumericValue);
+    };
+
+    // Keeps the caret out of the currency suffix.
+    const _onSelectionChange = (
+      e: NativeSyntheticEvent<TextInputSelectionChangeEventData>,
+    ) => {
+      const { start, end } = e.nativeEvent.selection;
+      selectionRef.current = { start, end };
+      const max = displayValue ? displayValue.length - currency.length : 0;
+      setSelection({ start: Math.min(start, max), end: Math.min(end, max) });
+      props.onSelectionChange?.(e);
     };
 
     const _onFocus = (e: NativeSyntheticEvent<TextInputFocusEventData>) => {
@@ -174,13 +276,16 @@ const InputMoney = forwardRef(
 
     const _setText = (text: string) => {
       if (!text) {
-        setDisplayValue('');
-        setNumericValue('');
+        commit('', 0);
         onChangeText?.('');
         return;
       }
-      const newNumericValue = parseInputText(text);
-      updateNumericValue(newNumericValue);
+      const digits = parseInputText(text)
+        .replace(/^0+(?=\d)/, '')
+        .slice(0, digitLimit);
+      if (commit(digits, digits.length)) {
+        onChangeText?.(digits);
+      }
     };
 
     useImperativeHandle(ref, () => {
@@ -247,6 +352,8 @@ const InputMoney = forwardRef(
               textBreakStrategy="highQuality"
               value={displayValue}
               onChangeText={_onChangeText}
+              selection={selection}
+              onSelectionChange={_onSelectionChange}
               onFocus={_onFocus}
               onBlur={_onBlur}
               placeholder={placeholder}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@momo-kits/foundation",
-    "version": "0.165.2-beta.1",
+    "version": "0.165.2-beta.2",
     "description": "React Native Component Kits",
     "main": "index.ts",
     "scripts": {},