@evervault/react-native 2.5.1 → 2.6.1

package/build/esm/node_modules/react-native-mask-input/lib/module/MaskInput.js

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { TextInput } from 'react-native';
+import useMaskedInputProps from './useMaskedInputProps.js';
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+var MaskInput = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  const {
+    mask,
+    value,
+    onChangeText,
+    placeholderFillCharacter = '_',
+    obfuscationCharacter,
+    showObfuscatedValue,
+    selection,
+    maskAutoComplete,
+    ...rest
+  } = props;
+  const maskedInputProps = useMaskedInputProps({
+    value,
+    mask,
+    maskAutoComplete,
+    obfuscationCharacter,
+    onChangeText,
+    placeholderFillCharacter,
+    showObfuscatedValue
+  });
+  return /*#__PURE__*/React.createElement(TextInput, _extends({
+    placeholder: maskedInputProps.placeholder
+  }, rest, {
+    selection: maskedInputProps.selection || selection,
+    value: maskedInputProps.value,
+    onChangeText: maskedInputProps.onChangeText,
+    ref: ref
+  }));
+});
+
+export { MaskInput as default };

package/build/esm/node_modules/react-native-mask-input/lib/module/formatWithMask.js

@@ -0,0 +1,88 @@
+function formatWithMask(props) {
+  const {
+    text,
+    mask,
+    obfuscationCharacter = '*',
+    maskAutoComplete = false
+  } = props; // make sure it'll not break with null or undefined inputs
+
+  if (!text) return {
+    masked: '',
+    unmasked: '',
+    obfuscated: ''
+  };
+  if (!mask) return {
+    masked: text || '',
+    unmasked: text || '',
+    obfuscated: text || ''
+  };
+  let maskArray = typeof mask === 'function' ? mask(text) : mask;
+  let masked = '';
+  let obfuscated = '';
+  let unmasked = '';
+  let maskCharIndex = 0;
+  let valueCharIndex = 0;
+
+  while (true) {
+    // if mask is ended, break.
+    if (maskCharIndex === maskArray.length) {
+      break;
+    }
+
+    let maskChar = maskArray[maskCharIndex];
+    let valueChar = text[valueCharIndex]; // if value is ended, break.
+
+    if (valueCharIndex === text.length) {
+      if (typeof maskChar === 'string' && maskAutoComplete) {
+        masked += maskChar;
+        obfuscated += maskChar;
+        maskCharIndex += 1;
+        continue;
+      }
+
+      break;
+    } // value equals mask: add to masked result and advance on both mask and value indexes
+
+
+    if (maskChar === valueChar) {
+      masked += maskChar;
+      obfuscated += maskChar;
+      valueCharIndex += 1;
+      maskCharIndex += 1;
+      continue;
+    }
+
+    let unmaskedValueChar = text[valueCharIndex]; // it's a regex maskChar: let's advance on value index and validate the value within the regex
+
+    if (typeof maskChar === 'object') {
+      // advance on value index
+      valueCharIndex += 1;
+      const shouldObsfucateChar = Array.isArray(maskChar);
+      const maskCharRegex = Array.isArray(maskChar) ? maskChar[0] : maskChar;
+      const matchRegex = RegExp(maskCharRegex).test(valueChar); // value match regex: add to masked and unmasked result and advance on mask index too
+
+      if (matchRegex) {
+        masked += valueChar;
+        obfuscated += shouldObsfucateChar ? obfuscationCharacter : valueChar;
+        unmasked += unmaskedValueChar;
+        maskCharIndex += 1;
+      }
+
+      continue;
+    } else {
+      // it's a fixed maskChar: add to maskedResult and advance on mask index
+      masked += maskChar;
+      obfuscated += maskChar;
+      maskCharIndex += 1;
+      continue;
+    }
+  }
+
+  return {
+    masked,
+    unmasked,
+    obfuscated
+  };
+}
+
+export { formatWithMask as default };

package/build/esm/node_modules/react-native-mask-input/lib/module/index.js

@@ -0,0 +1,6 @@
+import MaskInput from './MaskInput.js';
+import 'react';
+
+
+
+export { MaskInput as default };

package/build/esm/node_modules/react-native-mask-input/lib/module/useMaskedInputProps.js

@@ -0,0 +1,70 @@
+import * as React from 'react';
+import formatWithMask from './formatWithMask.js';
+
+var useMaskedInputProps = (props => {
+  const {
+    value,
+    mask,
+    onChangeText,
+    placeholderFillCharacter = '_',
+    obfuscationCharacter,
+    showObfuscatedValue,
+    maskAutoComplete
+  } = props;
+  const maskArray = React.useMemo(() => typeof mask === 'function' ? mask(value) : mask, [mask, value]);
+  const formattedValueResult = React.useMemo(() => {
+    return formatWithMask({
+      text: value || '',
+      mask,
+      obfuscationCharacter
+    });
+  }, [mask, obfuscationCharacter, value]);
+  const maskHasObfuscation = React.useMemo(() => maskArray && !!maskArray.find(maskItem => Array.isArray(maskItem)), [maskArray]);
+  const isValueObfuscated = React.useMemo(() => !!maskHasObfuscation && !!showObfuscatedValue, [maskHasObfuscation, showObfuscatedValue]);
+  const handleChangeText = React.useCallback(text => {
+    let textToFormat = text;
+
+    if (isValueObfuscated) {
+      textToFormat = formattedValueResult.masked || '';
+
+      if (textToFormat.length > text.length) {
+        textToFormat = textToFormat.slice(0, -1);
+      } else if (textToFormat.length < text.length) {
+        textToFormat = textToFormat + text[text.length - 1];
+      }
+    }
+
+    const result = formatWithMask({
+      text: textToFormat,
+      mask,
+      obfuscationCharacter,
+      maskAutoComplete: maskAutoComplete && textToFormat.length > formattedValueResult.masked.length
+    });
+    onChangeText && onChangeText(result.masked, result.unmasked, result.obfuscated);
+  }, [isValueObfuscated, mask, obfuscationCharacter, onChangeText, formattedValueResult.masked, maskAutoComplete]);
+  const defaultPlaceholder = React.useMemo(() => {
+    if (maskArray) {
+      return maskArray.map(maskChar => {
+        if (typeof maskChar === 'string') {
+          return maskChar;
+        } else {
+          return placeholderFillCharacter;
+        }
+      }).join('');
+    } else {
+      return undefined;
+    }
+  }, [maskArray, placeholderFillCharacter]);
+  const inputValue = isValueObfuscated ? formattedValueResult.obfuscated : formattedValueResult.masked;
+  return {
+    onChangeText: handleChangeText,
+    value: inputValue,
+    selection: isValueObfuscated ? {
+      start: inputValue.length,
+      end: inputValue.length
+    } : undefined,
+    placeholder: defaultPlaceholder
+  };
+});
+
+export { useMaskedInputProps as default };