@root-systems/redux-form-validators/lib/date.js

Simple validations with redux-form

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseDate = parseDate;
exports.formatDate = formatDate;

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactIntl = require('react-intl');

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

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var DATE_RANGE_ERROR = _react2.default.createElement(_reactIntl.FormattedMessage, { id: 'form.errors.dateRange', defaultMessage: 'shoud be {op} {date}' });

var DATE_METHODS = {
  y: function y(d) {
    return d.getFullYear();
  },
  m: function m(d) {
    return d.getMonth() + 1;
  },
  d: function d(_d) {
    return _d.getDate();
  }
};

var PARSE_REG = /(y+|m+|d+)/g;

var TO_STRING = {}.toString;

var date = (0, _helpers.memoize)(function (_ref) {
  var format = _ref.format,
      ymd = _ref.ymd,
      eq = _ref['='],
      diff = _ref['!='],
      gt = _ref['>'],
      gte = _ref['>='],
      lt = _ref['<'],
      lte = _ref['<='],
      message = _ref.message,
      msg = _ref.msg,
      ifCond = _ref['if'],
      unless = _ref.unless,
      _ref$allowBlank = _ref.allowBlank,
      allowBlank = _ref$allowBlank === undefined ? _helpers.DEFAULT_ALLOW_BLANK : _ref$allowBlank;

  msg = (0, _helpers.formatMessage)(msg || message);
  var normFormat = normalizeFormat(format, ymd);

  return (0, _helpers.prepare)(ifCond, unless, allowBlank, function (value) {
    var date = normParseDate(value, normFormat, false);
    if ('wrongFormat' === date) {
      return msg || _react2.default.createElement(_reactIntl.FormattedMessage, { id: 'form.errors.dateFormat',
        defaultMessage: 'expected format: {format}',
        values: { format: format } });
    }
    if ('invalid' === date) {
      return msg || _react2.default.createElement(_reactIntl.FormattedMessage, { id: 'form.errors.dateInvalid', defaultMessage: 'is not a valid date' });
    }
    if (date) {
      var date2 = void 0;
      if (eq && +date !== +(date2 = getDate(eq))) {
        return msg || dateRangeError({ op: '=', date: normFormatDate(date2, normFormat) });
      }
      if (diff && +date === +(date2 = getDate(diff))) {
        return msg || dateRangeError({ op: '!=', date: normFormatDate(date2, normFormat) });
      }
      if (gt && date <= (date2 = getDate(gt))) {
        return msg || dateRangeError({ op: '>', date: normFormatDate(date2, normFormat) });
      }
      if (gte && date < (date2 = getDate(gte))) {
        return msg || dateRangeError({ op: '>=', date: normFormatDate(date2, normFormat) });
      }
      if (lt && date >= (date2 = getDate(lt))) {
        return msg || dateRangeError({ op: '<', date: normFormatDate(date2, normFormat) });
      }
      if (lte && date > (date2 = getDate(lte))) {
        return msg || dateRangeError({ op: '<=', date: normFormatDate(date2, normFormat) });
      }
    }
  });
});

exports.default = date;
function parseDate(strDate, format, ymd) {
  return normParseDate(strDate, normalizeFormat(format, ymd), true);
}

function formatDate(date, format, ymd) {
  if (!(date instanceof Date) && '[object Date]' !== TO_STRING.call(date)) {
    return null;
  }
  var t = new Date(date).getTime();
  return t !== t ? null : normFormatDate(date, normalizeFormat(format, ymd));
}

function dateRangeError(values) {
  return (0, _helpers.formatMessage)({ id: 'form.errors.dateRange', values: values });
}

function getDate(d) {
  if ('function' === typeof d) {
    return new Date(+d());
  }
  if (isNaN(d) && 'today' === ('' + d).toLowerCase()) {
    var today = new Date();
    today.setHours(0, 0, 0, 0);
    return today;
  }
  return new Date(+d);
}

// FORMAT
function normFormatDate(date, format) {
  return format.replace(PARSE_REG, function (m) {
    var sym = m.charAt(0);
    var len = m.length;
    var padded = padding(DATE_METHODS[sym](date), len);
    return 'y' === sym ? padded.slice(padded.length - len, padded.length) : padded;
  });
}
function normalizeFormat(format, ymd) {
  var _reverseMapping;

  if (!ymd) {
    return format;
  }
  var reverseMapping = (_reverseMapping = {}, _defineProperty(_reverseMapping, ymd.charAt(0), 'y'), _defineProperty(_reverseMapping, ymd.charAt(1), 'm'), _defineProperty(_reverseMapping, ymd.charAt(2), 'd'), _reverseMapping);
  return format.replace(new RegExp('[' + ymd + ']', 'g'), function (sym) {
    return reverseMapping[sym];
  });
}
function padding(num, pad) {
  return '0'.repeat(Math.max(0, pad - ('' + num).length)) + num;
}

// PARSE
function normParseDate(value, format, parse) {
  var order = [];
  var reg = new RegExp('^' + format.replace(PARSE_REG, function (m) {
    order.push(m.charAt(0));
    return '([0-9]{' + m.length + '})';
  }) + '$');
  var match = value.match(reg);
  if (match) {
    var flags = {};
    order.forEach(function (token, index) {
      flags[token] = +match[index + 1];
    });
    var comparable = null != flags.y ? null != flags.m ? true : null == flags.d : false;
    flags = Object.assign({ y: 1970, m: 1, d: 1 }, flags);
    if (flags.y < 100) {
      flags.y = currentCentury(flags.y >= 69 ? -1 : 0) * 100 + flags.y;
    }
    var _date = new Date(flags.y, flags.m - 1, flags.d);
    return checkFlags(_date, flags) ? comparable || parse ? _date : null : parse ? new Date(NaN) : 'invalid';
  }
  return parse ? new Date(NaN) : 'wrongFormat';
}

function currentCentury(add) {
  var century = (0, _helpers.trunc)(new Date().getFullYear() / 100);
  return century < 0 ? century - add : century + add;
}

function checkFlags(date, flags) {
  var _ref2 = [date.getFullYear(), date.getMonth() + 1, date.getDate()],
      year = _ref2[0],
      month = _ref2[1],
      day = _ref2[2];

  return year === flags.y && month === flags.m && day === flags.d;
}