react-use-password-validator/dist/index.js

React Hooks Password Validator

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var React = require('react');
var React__default = _interopDefault(React);
var passwordValidator = _interopDefault(require('password-validator'));

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 defaultRules = {
  min: 6,
  max: 100,
  spaces: false,
  letters: true
};
function usePasswordValidator(option) {
  var _useState = React.useState(false),
      isValid = _useState[0],
      setIsValid = _useState[1];

  var _option = React.useMemo(function () {
    return Object.assign({}, defaultRules, option);
  }, []);

  var schema = React.useMemo(function () {
    function checkUseRule(val) {
      if (val === undefined) return [undefined, undefined];
      if (val === false) return [false, undefined];
      if (val === 0) return [false, undefined];

      if (val === true) {
        return [true, undefined];
      }
      return [true, val];
    }

    var _schema = new passwordValidator();

    for (var _i = 0, _Object$entries = Object.entries(_option); _i < _Object$entries.length; _i++) {
      var _Object$entries$_i = _Object$entries[_i],
          key = _Object$entries$_i[0],
          value = _Object$entries$_i[1];

      if (key === 'min') {
        _schema.is().min(value);

        continue;
      }

      if (key === 'max') {
        _schema.is().max(value);

        continue;
      }

      var _checkUseRule = checkUseRule(value),
          use = _checkUseRule[0],
          count = _checkUseRule[1];

      if (use === undefined) continue;

      switch (key) {
        case 'spaces':
          if (use) _schema.has().spaces(count);else _schema.has().not().spaces();
          break;

        case 'symbols':
          if (use) _schema.has().symbols(count);else _schema.has().not().symbols();
          break;

        case 'lowercase':
          if (use) _schema.has().lowercase(count);else _schema.has().not().lowercase();
          break;

        case 'uppercase':
          if (use) _schema.has().uppercase(count);else _schema.has().not().uppercase();
          break;

        case 'letters':
          if (use) _schema.has().letters(count);else _schema.has().not().letters();
          break;

        case 'digits':
          if (use) _schema.has().digits(count);else _schema.has().not().digits();
          break;
      }
    }
    return _schema;
  }, [_option]);
  return [isValid, function (password) {
    var valid = schema.validate(password);
    setIsValid(valid);
  }];
}

function withValidState(WrappedComponent, option) {
  return function (props) {
    var _usePasswordValidator = usePasswordValidator(option),
        isValid = _usePasswordValidator[0],
        setIsValid = _usePasswordValidator[1];

    var newProps = _extends({}, props, {
      isValid: isValid,
      setIsValid: setIsValid
    });

    return React__default.createElement(WrappedComponent, Object.assign({}, newProps));
  };
}

exports.default = usePasswordValidator;
exports.withValidState = withValidState;
//# sourceMappingURL=index.js.map