@evervault/react-native 2.5.1 → 2.6.1

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

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactNative = require('react-native');
+var useMaskedInputProps = require('./useMaskedInputProps.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+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__namespace.forwardRef(function (props, ref) {
+  const {
+    mask,
+    value,
+    onChangeText,
+    placeholderFillCharacter = '_',
+    obfuscationCharacter,
+    showObfuscatedValue,
+    selection,
+    maskAutoComplete,
+    ...rest
+  } = props;
+  const maskedInputProps = useMaskedInputProps.default({
+    value,
+    mask,
+    maskAutoComplete,
+    obfuscationCharacter,
+    onChangeText,
+    placeholderFillCharacter,
+    showObfuscatedValue
+  });
+  return /*#__PURE__*/React__namespace.createElement(reactNative.TextInput, _extends({
+    placeholder: maskedInputProps.placeholder
+  }, rest, {
+    selection: maskedInputProps.selection || selection,
+    value: maskedInputProps.value,
+    onChangeText: maskedInputProps.onChangeText,
+    ref: ref
+  }));
+});
+
+exports.default = MaskInput;

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

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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
+  };
+}
+
+exports.default = formatWithMask;

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

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var MaskInput = require('./MaskInput.js');
+require('react');
+
+
+
+exports.default = MaskInput.default;

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

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var formatWithMask = require('./formatWithMask.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+var useMaskedInputProps = (props => {
+  const {
+    value,
+    mask,
+    onChangeText,
+    placeholderFillCharacter = '_',
+    obfuscationCharacter,
+    showObfuscatedValue,
+    maskAutoComplete
+  } = props;
+  const maskArray = React__namespace.useMemo(() => typeof mask === 'function' ? mask(value) : mask, [mask, value]);
+  const formattedValueResult = React__namespace.useMemo(() => {
+    return formatWithMask.default({
+      text: value || '',
+      mask,
+      obfuscationCharacter
+    });
+  }, [mask, obfuscationCharacter, value]);
+  const maskHasObfuscation = React__namespace.useMemo(() => maskArray && !!maskArray.find(maskItem => Array.isArray(maskItem)), [maskArray]);
+  const isValueObfuscated = React__namespace.useMemo(() => !!maskHasObfuscation && !!showObfuscatedValue, [maskHasObfuscation, showObfuscatedValue]);
+  const handleChangeText = React__namespace.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.default({
+      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__namespace.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
+  };
+});
+
+exports.default = useMaskedInputProps;