redux-form-validators/lib/url.js

Simple validations with redux-form / react-final-form

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _validators = _interopRequireDefault(require("./validators"));

var _helpers = require("./helpers");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// user:pass BasicAuth (optional)
var BASIC_AUTH = '(?:\\S+(?::\\S*)?@)?'; // IP address dotted notation octets

var IPV4 = '(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0)\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]?|0)'; // the IPv6 matching part is from here: https://gist.github.com/syzdek/6086792
// IPv6 address in URLs are wrapped with []s

var IPV6 = "\\[(?:" + [// 1:2:3:4:5:6:7:8
'(?:[\\da-f]{1,4}:){7,7}[\\da-f]{1,4}', // 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33  (IPv4-Embedded IPv6 Address)
'(?:[\\da-f]{1,4}:){1,4}:' + IPV4, // ::255.255.255.255  ::ffff:255.255.255.255  ::ffff:0:255.255.255.255  (IPv4-mapped IPv6 addresses)
'::(?:ffff(?::0{1,4}){0,1}:){0,1}' + IPV4, // 1::3:4:5:6:7:8  1::3:4:5:6:7:8 1::8
'[\\da-f]{1,4}:(?:(?::[\\da-f]{1,4}){1,6})', // 1::4:5:6:7:8  1:2::4:5:6:7:8  1:2::8
'(?:[\\da-f]{1,4}:){1,2}(?::[\\da-f]{1,4}){1,5}', // 1::5:6:7:8  1:2:3::5:6:7:8  1:2:3::8
'(?:[\\da-f]{1,4}:){1,3}(?::[\\da-f]{1,4}){1,4}', // 1::6:7:8  1:2:3:4::6:7:8  1:2:3:4::8
'(?:[\\da-f]{1,4}:){1,4}(?::[\\da-f]{1,4}){1,3}', // 1::7:8  1:2:3:4:5::7:8  1:2:3:4:5::8
'(?:[\\da-f]{1,4}:){1,5}(?::[\\da-f]{1,4}){1,2}', // 1::8  1:2:3:4:5:6::8  1:2:3:4:5:6::8
'(?:[\\da-f]{1,4}:){1,6}:[\\da-f]{1,4}', // 1::
'(?:[\\da-f]{1,4}:){1,7}:', // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8  ::
':(?:(?::[\\da-f]{1,4}){1,7}|:)'].join('|') + ')\\]'; // host & domain names, may end with dot

var HOST = // can be replaced by
// '(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+' +
"(?![-_])(?:[-\\w\\u00a1-\\uffff]{0,63}[^-_]\\.)+" + // TLD identifier name, may end with dot
"(?:[a-z\\u00a1-\\uffff]{2,}\\.?)"; // port number (optional)

var PORT = '(?::\\d{2,5})?'; // resource path (optional)

var PATH = '(?:[/][^\\s?#]*)?';
var SEARCH = '(?:[?][^\\s#]*)?';
var HASH = '(?:[#]\\S*)?';
var DEFAULT_OPTIONS = {
  emptyProtocol: true,
  protocolIdentifier: true,
  basicAuth: true,
  local: true,
  ipv4: true,
  ipv6: true,
  host: true,
  port: true,
  path: true,
  search: true,
  hash: true
};
var STRIP_PROTOCOL_REG = /:?\/\/$/;
var CLEAN_UP_PROPS = ['protocol', 'ipv4', 'host', 'path', 'search', 'hash'];

function parseURL(url, options) {
  options = defaultOptions(options);
  var parts = url.match(buildReg(options, true));
  if (!parts) return null;
  var group = 1;
  var h = {
    protocol: parts[group++].replace(STRIP_PROTOCOL_REG, '')
  };

  if (options.basicAuth) {
    var auth = parts[group++];

    if (auth) {
      var password = auth.slice(0, -1).split(':');
      var username = password.shift();
      h.basicAuth = {
        username: username,
        password: password.length ? password.join(':') : void 0
      };
    }
  }

  if (options.ipv4) h.ipv4 = parts[group++];

  if (options.ipv6) {
    var ipv6 = parts[group++];
    if (ipv6) h.ipv6 = ipv6.slice(1, -1);
  }

  if (options.host) h.host = parts[group++];
  if (options.local) h.host = parts[group++] || h.host;

  if (options.port) {
    var port = parts[group++];
    if (port) h.port = +port.slice(1);
  }

  if (options.path) h.path = parts[group++];
  if (options.search) h.search = parts[group++];
  if (options.hash) h.hash = parts[group++]; // Clean up

  CLEAN_UP_PROPS.forEach(function (k) {
    if (!h[k]) delete h[k];
  });
  return h;
} // Uses "format" internally which is already memoized


var url = (0, _helpers.regFormat)(function (options) {
  return buildReg(defaultOptions(options), false);
}, 'url');
url.parseURL = parseURL;
var _default = url;
exports["default"] = _default;

function defaultOptions(options) {
  options = (0, _helpers.assign)({}, DEFAULT_OPTIONS, options);
  options.protocols = [].concat(options.protocol || options.protocols || _validators["default"].defaultOptions.urlProtocols).join('|');
  return options;
}

function group(option, regPart, capture) {
  return option ? capture ? "(".concat(regPart, ")") : regPart : '';
}

function buildReg(options, capture) {
  return new RegExp('^' + group(true, "(?:(?:(?:".concat(options.protocols, "):)").concat(options.emptyProtocol ? '?' : '', "\\/\\/)").concat(options.protocolIdentifier ? '' : '?'), capture) + group(options.basicAuth, BASIC_AUTH, capture) + "(?:".concat([group(options.ipv4, IPV4, capture), group(options.ipv6, IPV6, capture), group(options.host, HOST, capture), group(options.local, 'localhost', capture)].filter(function (g) {
    return g;
  }).join('|'), ")") + group(options.port, PORT, capture) + group(options.path, PATH, capture) + group(options.search, SEARCH, capture) + group(options.hash, HASH, capture) + '$', 'i');
}