@zohodesk/i18n 1.0.0-beta.3 → 1.0.0-beta.31

package/es/utils/jsxTranslations.js

@@ -0,0 +1,193 @@
+import React from 'react';
+import { unescapeUnicode } from './index';
+export function splitMatchedExp(_ref) {
+  let {
+    expression,
+    charLenToOmit,
+    string
+  } = _ref;
+  let splitString = string.split(new RegExp(expression, 'g'));
+  let matchedExpAll = string.matchAll(new RegExp(expression, 'g'));
+  let matchedExpKeys = [];
+
+  for (let match of matchedExpAll) {
+    const value = match[0];
+    matchedExpKeys.push(value.substring(charLenToOmit, value.length - charLenToOmit));
+  }
+
+  return {
+    splitString,
+    matchedExpKeys
+  };
+}
+export function generateChildren(_ref2) {
+  let {
+    children,
+    child
+  } = _ref2;
+  let newChildren = [],
+      stringPlaceHolders = {};
+
+  const handleString = string => {
+    if (string) {
+      let {
+        splitString,
+        matchedExpKeys
+      } = splitMatchedExp({
+        expression: '{[0-9]+?}',
+        charLenToOmit: 1,
+        string
+      });
+      stringPlaceHolders[newChildren.length] = matchedExpKeys;
+      newChildren.push(splitString);
+    }
+  };
+
+  let {
+    splitString: splitChild,
+    matchedExpKeys: childrenKeys
+  } = splitMatchedExp({
+    expression: '<[A-Za-z0-9]+?>',
+    charLenToOmit: 1,
+    string: child
+  });
+  childrenKeys.forEach((childKey, childIndex) => {
+    const matchedChild = splitChild[childIndex];
+    handleString(matchedChild);
+    newChildren.push(children[childKey]);
+  });
+  handleString(splitChild[childrenKeys.length]);
+  return {
+    newChildren,
+    stringPlaceHolders
+  };
+}
+export function createElement() {
+  let {
+    componentId,
+    children = [],
+    stringPlaceHolders = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function () {
+    let {
+      components = {},
+      values = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      type = React.Fragment,
+      props
+    } = components[componentId] || {};
+    const childElements = children.map((child, index) => {
+      if (typeof child === 'function') {
+        return child({
+          components,
+          values
+        });
+      }
+
+      let string = '',
+          stringIndex = 0;
+      (stringPlaceHolders[index] || []).map((stringId, index) => {
+        if (child[index]) {
+          string += child[index];
+        }
+
+        string += values[stringId];
+        stringIndex++;
+      });
+
+      if (child[stringIndex]) {
+        string += child[stringIndex];
+      }
+
+      return string;
+    });
+    return /*#__PURE__*/React.createElement(type, props, ...childElements);
+  };
+}
+;
+export function replaceWithComponentPlaceHolder(_ref3) {
+  let {
+    componentId,
+    i18nKey,
+    childrenLength
+  } = _ref3;
+  const closingTagIndex = i18nKey.indexOf(`</${componentId}>`);
+  const childWithOpenTag = i18nKey.substring(0, closingTagIndex);
+  const openTagIndex = childWithOpenTag.lastIndexOf(`<${componentId}>`);
+  return i18nKey.substring(0, openTagIndex) + `<0${childrenLength}${componentId}>` + i18nKey.substring(closingTagIndex + `${componentId}`.length + 3);
+}
+export function prepareI18NFunc() {
+  let {
+    i18nKey,
+    children = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const componentIdMatch = i18nKey.match(/<\/[A-Za-z0-9]+?>/);
+
+  if (componentIdMatch) {
+    const componentId = componentIdMatch[0].substring(2, componentIdMatch[0].length - 1);
+    const childWithOpenTag = (i18nKey.match(new RegExp(`(.*?)(?=<\/${componentId}>)`)) || [])[0] || '';
+    const child = childWithOpenTag.split(`<${componentId}>`).pop();
+    const {
+      newChildren,
+      stringPlaceHolders
+    } = generateChildren({
+      children,
+      child
+    });
+    const childrenLength = Object.keys(children).length;
+    children[`0${childrenLength}${componentId}`] = createElement({
+      componentId,
+      children: newChildren,
+      stringPlaceHolders
+    });
+    i18nKey = replaceWithComponentPlaceHolder({
+      componentId,
+      i18nKey,
+      childrenLength
+    });
+    return prepareI18NFunc({
+      i18nKey,
+      children
+    });
+  }
+
+  const {
+    newChildren,
+    stringPlaceHolders
+  } = generateChildren({
+    child: i18nKey,
+    children
+  });
+  return createElement({
+    componentId: -1,
+    children: newChildren,
+    stringPlaceHolders
+  });
+}
+export function getI18NComponent(i18n) {
+  if (typeof i18n === 'undefined') {
+    return key => key;
+  }
+
+  return key => {
+    let i18nStr = i18n[key];
+
+    if (i18nStr === undefined) {
+      return key;
+    }
+
+    if (typeof i18nStr === 'string') {
+      i18nStr = unescapeUnicode(i18nStr);
+      const value = prepareI18NFunc({
+        i18nKey: i18nStr
+      });
+      window.loadI18nChunk && window.loadI18nChunk({
+        [key]: value
+      });
+      i18nStr = value;
+    }
+
+    return i18nStr;
+  };
+}

package/lib/I18NContext.js

@@ -1,14 +1,14 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.I18NContext = undefined;
+exports.I18NContext = void 0;
 
-var _react = require('react');
+var _react = _interopRequireDefault(require("react"));
 
-var _react2 = _interopRequireDefault(_react);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var I18NContext = /*#__PURE__*/_react["default"].createContext();
 
-var I18NContext = exports.I18NContext = _react2.default.createContext();
+exports.I18NContext = I18NContext;

package/lib/components/DateTimeDiffFormat.js

@@ -1,51 +1,64 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports["default"] = void 0;
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var _react = _interopRequireDefault(require("react"));
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _propTypes = _interopRequireDefault(require("prop-types"));
 
-var _react = require('react');
+var _utils = require("../utils");
 
-var _react2 = _interopRequireDefault(_react);
+var _FormatText = _interopRequireDefault(require("./FormatText"));
 
-var _propTypes = require('prop-types');
+var _datetimejs = _interopRequireDefault(require("@zohodesk/datetimejs"));
 
-var _propTypes2 = _interopRequireDefault(_propTypes);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-var _utils = require('../utils');
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
-var _FormatText = require('./FormatText');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _FormatText2 = _interopRequireDefault(_FormatText);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-var DateTimeDiffFormat = function (_React$Component) {
+var DateTimeDiffFormat = /*#__PURE__*/function (_React$Component) {
   _inherits(DateTimeDiffFormat, _React$Component);
 
+  var _super = _createSuper(DateTimeDiffFormat);
+
   function DateTimeDiffFormat(props) {
-    _classCallCheck(this, DateTimeDiffFormat);
+    var _this;
 
-    var _this = _possibleConstructorReturn(this, (DateTimeDiffFormat.__proto__ || Object.getPrototypeOf(DateTimeDiffFormat)).call(this, props));
+    _classCallCheck(this, DateTimeDiffFormat);
 
-    _this.getSuffix = _this.getSuffix.bind(_this);
+    _this = _super.call(this, props);
+    _this.getSuffix = _this.getSuffix.bind(_assertThisInitialized(_this));
     return _this;
   }
 
   _createClass(DateTimeDiffFormat, [{
-    key: 'getSuffix',
+    key: "getSuffix",
     value: function getSuffix(min) {
-      var suffix = void 0;
+      var suffix;
+
       if (this.props.ago && min < 0) {
         suffix = this.props.ago || '';
       } else if (this.props.later || min > 0) {
@@ -53,38 +66,44 @@ var DateTimeDiffFormat = function (_React$Component) {
       } else {
         suffix = '';
       }
+
       return suffix;
     }
   }, {
-    key: 'render',
+    key: "render",
     value: function render() {
-      var _props = this.props,
-          type = _props.type,
-          from = _props.from,
-          fromTzData = _props.fromTzData,
-          to = _props.to,
-          toTzData = _props.toTzData,
-          today = _props.today,
-          yesterday = _props.yesterday,
-          tomorrow = _props.tomorrow,
-          others = _props.others,
-          format = _props.format,
-          dataId = _props.dataId,
-          _props$className = _props.className,
-          className = _props$className === undefined ? null : _props$className,
-          _props$title = _props.title,
-          title = _props$title === undefined ? null : _props$title,
-          isOverdue = _props.isOverdue;
-
-
-      var fromDateObj = (0, _utils.convertUtcToUserTz)(from, fromTzData).getTime();
-      var toDateObj = (0, _utils.convertUtcToUserTz)(to, toTzData).getTime();
+      var _this$props = this.props,
+          type = _this$props.type,
+          page = _this$props.page,
+          isNeedTime = _this$props.isNeedTime,
+          from = _this$props.from,
+          fromTzData = _this$props.fromTzData,
+          to = _this$props.to,
+          toTzData = _this$props.toTzData,
+          today = _this$props.today,
+          yesterday = _this$props.yesterday,
+          tomorrow = _this$props.tomorrow,
+          others = _this$props.others,
+          format = _this$props.format,
+          dataId = _this$props.dataId,
+          _this$props$className = _this$props.className,
+          className = _this$props$className === void 0 ? null : _this$props$className,
+          _this$props$title = _this$props.title,
+          title = _this$props$title === void 0 ? null : _this$props$title,
+          isOverdue = _this$props.isOverdue,
+          timeFormat = _this$props.timeFormat,
+          datePattern = _this$props.datePattern,
+          isEnabledCurrentYear = _this$props.isEnabledCurrentYear,
+          isDateField = _this$props.isDateField;
+
+      var fromDateObj = _datetimejs["default"].toDate(_datetimejs["default"].tz.utcToTz(from, fromTzData)).getTime();
+
+      var toDateObj = _datetimejs["default"].toDate(isDateField ? to : _datetimejs["default"].tz.utcToTz(to, toTzData)).getTime();
 
       var diffMin = new Date(to).getTime() - new Date(from).getTime();
       var suffix = this.getSuffix(diffMin);
       var diff = (0, _utils.getDiffObj)(diffMin);
       var withInAWeak = diff.y === 0 && diff.yd <= 7;
-
       var diffObj = {
         h: diff.h,
         m: diff.m,
@@ -100,13 +119,15 @@ var DateTimeDiffFormat = function (_React$Component) {
         suffix: suffix
       };
       var diffObj1 = {
+        to: to,
         type: type,
+        page: page,
+        isNeedTime: isNeedTime,
         hours: diff.h,
         minutes: diff.m,
         seconds: diff.s,
         years: diff.y,
         yDays: diff.yd,
-        yMonth: diff.m,
         isWithInAWeek: withInAWeak,
         suffix: suffix,
         crntDate: new Date(from).getDate(),
@@ -122,43 +143,53 @@ var DateTimeDiffFormat = function (_React$Component) {
         tMinutes: new Date(to).getMinutes(),
         tSeconds: new Date(to).getSeconds(),
         betweenleepYears: (0, _utils.getLyears)(from, to),
-        isOverdue: isOverdue
-      };
+        isOverdue: isOverdue,
+        timeFormat: timeFormat,
+        datePattern: datePattern,
+        dateTimePattern: "".concat(datePattern, " ").concat(timeFormat)
+      }; //In if condition we'll remove year and set date format  if the current year is not required
+      //In else part we'll set the date format as it is
+
+      if (isEnabledCurrentYear === true && diffObj1.years === 0 && diffObj1.tYear === diffObj1.crntYear) {
+        var dateFormat = (0, _utils.getDatePatternWithoutYear)(datePattern);
+        diffObj1.dateFormat = dateFormat;
+        diffObj1.dateTimeFormat = "".concat(dateFormat, " ").concat(timeFormat);
+      } else {
+        diffObj1.dateFormat = datePattern;
+        diffObj1.dateTimeFormat = "".concat(datePattern, " ").concat(timeFormat);
+      }
 
       var key = '';
       var values = [];
       var text = null;
       var isSuffixEnable = false;
+
       if (format) {
-        var years = void 0,
-            months = void 0,
-            days = void 0,
-            hours = void 0,
-            minutes = void 0,
-            seconds = void 0;
+        var years, months, days, hours, minutes, seconds;
         years = diffObj1.years > 1 ? '2' : diffObj1.years;
-
         days = diff.yd > 1 ? '2' : diff.yd;
         hours = diffObj1.hours > 1 ? '2' : diffObj1.hours;
         minutes = diffObj1.minutes > 1 ? '2' : diffObj1.minutes;
-
         var count = 0;
         var pattern = [years, days, hours, minutes].reduce(function (res, next) {
           if (count === 2) {
-            res = res + '0';
+            res = "".concat(res, "0");
           } else if (next !== 0) {
             count++;
             res = res + next;
           } else {
             res = res + next;
           }
+
           return res;
         }, '');
 
         var _value = format(diffObj1, pattern);
-        if (_value && (typeof _value === 'undefined' ? 'undefined' : _typeof(_value)) === 'object') {
+
+        if (_value && _typeof(_value) === 'object') {
           key = _value.key;
           values = (0, _utils.getValues)(_value.params, diffObj);
+
           if (pattern.indexOf('00000') === 0) {
             //suffix ignore for second hook
             isSuffixEnable = false;
@@ -169,86 +200,83 @@ var DateTimeDiffFormat = function (_React$Component) {
           text = (0, _utils.formatDate)(toDateObj, _value, diffObj1);
         }
       } else {
-        if (diff.y === 0 && (diff.yd === 0 || diff.yd === 1)) {
-          var dateObj = new Date(toDateObj);
-          var curDateObj = new Date(fromDateObj);
-          if (dateObj.getDate() === curDateObj.getDate()) {
-            if (typeof today === 'function') {
-              var value = today(diffObj1);
-              key = value.key;
-              values = (0, _utils.getValues)(value.params, diffObj);
-            } else if ((typeof today === 'undefined' ? 'undefined' : _typeof(today)) === 'object') {
-              key = today.key;
-              values = (0, _utils.getValues)(today.params, diffObj);
-              isSuffixEnable = true;
-            } else if (typeof today === 'string') {
-              text = (0, _utils.formatDate)(toDateObj, today);
-            }
-          } else if (dateObj.getDate() < curDateObj.getDate()) {
-            if (typeof yesterday === 'function') {
-              var value = yesterday(diffObj1);
-              key = value.key;
-              values = (0, _utils.getValues)(value.params, diffObj);
-            } else if ((typeof yesterday === 'undefined' ? 'undefined' : _typeof(yesterday)) === 'object') {
-              key = yesterday.key;
-              values = (0, _utils.getValues)(yesterday.params, diffObj);
-            } else if (typeof yesterday === 'string') {
-              text = (0, _utils.formatDate)(toDateObj, yesterday);
-            }
-          } else if (dateObj.getDate() > curDateObj.getDate()) {
-            if (typeof tomorrow === 'function') {
-              var value = tomorrow(diffObj1);
-              key = value.key;
-              text = (0, _utils.getValues)(value.params, diffObj);
-            } else if ((typeof tomorrow === 'undefined' ? 'undefined' : _typeof(tomorrow)) === 'object') {
-              key = tomorrow.key;
-              values = (0, _utils.getValues)(tomorrow.params, diffObj);
-            } else if (typeof tomorrow === 'string') {
-              text = (0, _utils.formatDate)(toDateObj, tomorrow);
+        var dateObj = new Date(toDateObj);
+        var curDateObj = new Date(fromDateObj);
+        var diffDayType = diffObj1.yDays; //In this condition, to calculate different days we have copied it from live --> diffDayType
+
+        if (isOverdue && dateObj.getDate() < curDateObj.getDate() && diffObj1.yDays == 0) {
+          diffDayType = -1;
+        }
+
+        if (!isOverdue) {
+          var diffHr = dateObj.getHours() - curDateObj.getHours();
+
+          if (diffHr < 0) {
+            diffDayType += 1;
+          } else if (diffHr == 0) {
+            var diffMins = dateObj.getMinutes() - curDateObj.getMinutes();
+
+            if (diffMins < 0) {
+              diffDayType += 1;
+            } else if (diffMins == 0) {
+              var diffSec = dateObj.getSeconds() - curDateObj.getSeconds();
+
+              if (diffSec < 0) {
+                diffDayType += 1;
+              }
             }
           }
-        } else {
-          var value = others(diffObj1);
-          if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
-            key = value.key;
-            values = (0, _utils.getValues)(value.params, diffObj);
-            isSuffixEnable = true;
-          } else if (typeof value === 'string') {
+        }
+
+        if (diff.y === 0 && (diffDayType === 0 || diffDayType === 1)) {
+          if (dateObj.getDate() === curDateObj.getDate()) {
+            var value = today && today(diffObj1) || others(diffObj1);
+            text = (0, _utils.formatDate)(toDateObj, value);
+          } else if (dateObj.getMonth() === curDateObj.getMonth() && dateObj.getDate() < curDateObj.getDate() || dateObj.getMonth() < curDateObj.getMonth()) {
+            var value = yesterday && yesterday(diffObj1) || others(diffObj1);
+            text = (0, _utils.formatDate)(toDateObj, value);
+          } else if (!isOverdue && diff.y === 0 && diffDayType === 1) {
+            var value = tomorrow && tomorrow(diffObj1) || others(diffObj1);
             text = (0, _utils.formatDate)(toDateObj, value);
           }
+        } else {
+          var value = others(diffObj1);
+          text = (0, _utils.formatDate)(toDateObj, value);
         }
       }
-      return text ? _react2.default.createElement(
-        'span',
-        { className: className, 'data-title': title, 'data-id': dataId },
-        text
-      ) : _react2.default.createElement(_FormatText2.default, {
-        i18NKey: isSuffixEnable && suffix !== '' ? key + '.' + suffix : key,
+
+      return text ? /*#__PURE__*/_react["default"].createElement("span", {
+        className: className,
+        "data-title": title,
+        "data-id": dataId,
+        "data-test-id": dataId
+      }, text) : /*#__PURE__*/_react["default"].createElement(_FormatText["default"], {
+        i18NKey: isSuffixEnable && suffix !== '' ? "".concat(key, ".").concat(suffix) : key,
         values: values,
         className: className,
-        'data-title': title
+        "data-title": title
       });
     }
   }]);
 
   return DateTimeDiffFormat;
-}(_react2.default.Component);
-
-exports.default = DateTimeDiffFormat;
+}(_react["default"].Component);
 
+exports["default"] = DateTimeDiffFormat;
 DateTimeDiffFormat.propTypes = {
-  ago: _propTypes2.default.string,
-  className: _propTypes2.default.string,
-  dataId: _propTypes2.default.string,
-  format: _propTypes2.default.func,
-  from: _propTypes2.default.string,
-  fromTzData: _propTypes2.default.object,
-  later: _propTypes2.default.string,
-  others: _propTypes2.default.func,
-  title: _propTypes2.default.string,
-  to: _propTypes2.default.string,
-  toTzData: _propTypes2.default.object,
-  today: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.object, _propTypes2.default.func]),
-  tomorrow: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.object, _propTypes2.default.func]),
-  yesterday: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.object, _propTypes2.default.func])
+  ago: _propTypes["default"].string,
+  className: _propTypes["default"].string,
+  dataId: _propTypes["default"].string,
+  format: _propTypes["default"].func,
+  from: _propTypes["default"].string,
+  fromTzData: _propTypes["default"].object,
+  isDateField: _propTypes["default"].bool,
+  later: _propTypes["default"].string,
+  others: _propTypes["default"].func,
+  title: _propTypes["default"].string,
+  to: _propTypes["default"].string,
+  toTzData: _propTypes["default"].object,
+  today: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].object, _propTypes["default"].func]),
+  tomorrow: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].object, _propTypes["default"].func]),
+  yesterday: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].object, _propTypes["default"].func])
 };