@zohodesk/components 1.0.0-temp-46 → 1.0.0-temp-49

package/lib/DateTime/dateFormatUtils/dateFormat.js

@@ -0,0 +1,613 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDateDetails = getDateDetails;
+exports.getDateFormatDetails = getDateFormatDetails;
+exports.getDateFormatSelection = getDateFormatSelection;
+exports.getDateTimeString = getDateTimeString;
+exports.getIsValidDate = getIsValidDate;
+exports.getSelectedDate = getSelectedDate;
+
+var _datetimejs = _interopRequireDefault(require("@zohodesk/datetimejs"));
+
+var _index = require("./index");
+
+var _Common = require("../../utils/Common");
+
+var _common = require("../../utils/datetime/common");
+
+var _constants = require("../constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable no-param-reassign */
+
+/** * Libraries ** */
+
+/** * Methods ** */
+
+/** * Constants ** */
+function getDateFormatString() {
+  var dateFormatArr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var datePatternArr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return dateFormatArr.reduce(function (res, dateStr, index) {
+    var patternStr = datePatternArr[index] || '';
+    res += dateStr + patternStr;
+    return res;
+  }, '');
+}
+
+function getIsValidPattern() {
+  var dateFormatArr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var datePatternArr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  var isValueInArray = function isValueInArray() {
+    var possibleFormat = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return possibleFormat.some(function (str) {
+      return dateFormatArr.indexOf(str) >= 0;
+    });
+  };
+
+  var haveDay = isValueInArray(_constants.flags.day);
+  var haveMonth = isValueInArray(_constants.flags.month);
+  var haveYear = isValueInArray(_constants.flags.year);
+  var isValidPattern = datePatternArr.length && datePatternArr.length <= 2 && datePatternArr.every(function (patternStr) {
+    return _constants.supportedPatterns.indexOf(patternStr) >= 0;
+  });
+  return haveDay && haveMonth && (haveYear || !haveYear) && isValidPattern;
+}
+
+function getDateFormatDetails() {
+  var dateFormat = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+  var _ref = arguments.length > 1 ? arguments[1] : undefined,
+      isHideCurrentYear = _ref.isHideCurrentYear,
+      value = _ref.value,
+      timeZone = _ref.timeZone,
+      isDateTime = _ref.isDateTime;
+
+  var dayInfo = {};
+  var monthInfo = {};
+  var yearInfo = {};
+  var dateFormatArr = [];
+  var patternArr = [];
+
+  var _getIsCurrentYear = (0, _index.getIsCurrentYear)({
+    value: value,
+    timeZone: timeZone,
+    isDateTime: isDateTime
+  }),
+      isCurrentYear = _getIsCurrentYear.isCurrentYear;
+
+  var isHideYear = isHideCurrentYear ? isCurrentYear : false;
+
+  function getDateFormat(dateFormat) {
+    var token = /D{1,4}|M{1,4}|YY(?:YY)?|([HhmsA])\1?|[LloSZWN]|\[[^\]]*\]|'[^']*'/gi;
+    dateFormatArr = [];
+    patternArr = [];
+    var newDateFormat = dateFormat.replace(token, function (match) {
+      var dateFormatArrLen = dateFormatArr.length;
+
+      if (match in _constants.flags) {
+        dateFormatArr.push(match);
+        var type = _constants.flags[match].type;
+
+        if (type === 'day') {
+          dayInfo = Object.assign({}, _constants.flags[match], {
+            index: dateFormatArrLen
+          });
+        } else if (type === 'month') {
+          monthInfo = Object.assign({}, _constants.flags[match], {
+            index: dateFormatArrLen
+          });
+        } else if (type === 'year') {
+          yearInfo = Object.assign({}, _constants.flags[match], {
+            index: dateFormatArrLen
+          });
+        }
+
+        return _constants.patternSplitStr;
+      }
+
+      return match.slice(1, match.length - 1);
+    });
+    patternArr = newDateFormat.split(_constants.patternSplitStr).reduce(function (res, patternStr) {
+      if (patternStr) {
+        res.push(patternStr);
+      }
+
+      return res;
+    }, []);
+  }
+
+  getDateFormat(dateFormat);
+  var isValidPattern = getIsValidPattern(dateFormatArr, patternArr);
+
+  if (!isValidPattern) {
+    getDateFormat(_constants.defaultFormat);
+  }
+
+  if (isHideYear) {
+    var _removeYearPattern = (0, _index.removeYearPattern)(dateFormatArr, patternArr);
+
+    dateFormatArr = _removeYearPattern.dateFormatArr;
+    patternArr = _removeYearPattern.patternArr;
+  }
+
+  return {
+    dateFormat: getDateFormatString(dateFormatArr, patternArr),
+    dateFormatArr: dateFormatArr,
+    patternArr: patternArr,
+    dayInfo: dayInfo,
+    monthInfo: monthInfo,
+    yearInfo: yearInfo,
+    isValidPattern: isValidPattern
+  };
+}
+
+function getDisplayFormatValue(dateVal, formatVal) {
+  var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      _ref2$i18nShortMonths = _ref2.i18nShortMonths,
+      i18nShortMonths = _ref2$i18nShortMonths === void 0 ? [] : _ref2$i18nShortMonths,
+      _ref2$i18nMonths = _ref2.i18nMonths,
+      i18nMonths = _ref2$i18nMonths === void 0 ? [] : _ref2$i18nMonths;
+
+  var _ref3 = _constants.flags[formatVal] || {},
+      length = _ref3.length,
+      type = _ref3.type;
+
+  if (length === _constants.INCONSTANT) {
+    if (dateVal && formatVal === 'MMM' && i18nShortMonths.length) {
+      return i18nShortMonths[dateVal - 1];
+    } else if (dateVal && formatVal === 'MMMM' && i18nMonths.length) {
+      return i18nMonths[dateVal - 1];
+    }
+
+    return (0, _index.addZero)(dateVal, formatVal.length ? formatVal.length : 1);
+  } else if (type === 'year' && length === 2) {
+    return (0, _index.addZero)((0, _index.convertYearToTwoDigit)(dateVal), length);
+  }
+
+  return (0, _index.addZero)(dateVal, length);
+}
+
+function concatDate(values, dateFormatArr, patternArr, fillPlaceHolder) {
+  var _ref4 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+      i18nShortMonths = _ref4.i18nShortMonths,
+      i18nMonths = _ref4.i18nMonths;
+
+  var dateString = dateFormatArr.reduce(function (res, formatVal, index) {
+    var _ref5 = _constants.flags[formatVal] || {},
+        _ref5$type = _ref5.type,
+        dateFormatVal = _ref5$type === void 0 ? '' : _ref5$type;
+
+    var dateVal = values[dateFormatVal];
+    dateVal = !(0, _Common.getIsEmptyValue)(dateVal) ? getDisplayFormatValue(dateVal, formatVal, {
+      i18nShortMonths: i18nShortMonths,
+      i18nMonths: i18nMonths
+    }) : fillPlaceHolder ? formatVal : '';
+    var patternVal = patternArr[index] || '';
+    res += dateVal + patternVal;
+    return res;
+  }, '');
+  return dateString;
+}
+
+function getDateTimeString() {
+  var values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var dateFormatDetails = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var isDateTime = arguments.length > 2 ? arguments[2] : undefined;
+
+  var _ref6 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+      i18nShortMonths = _ref6.i18nShortMonths,
+      i18nMonths = _ref6.i18nMonths,
+      is24Hour = _ref6.is24Hour;
+
+  var day = values.day,
+      month = values.month,
+      year = values.year,
+      noon = values.noon;
+  var hour = values.hour,
+      minute = values.minute;
+  var _dateFormatDetails$da = dateFormatDetails.dateFormatArr,
+      dateFormatArr = _dateFormatDetails$da === void 0 ? [] : _dateFormatDetails$da,
+      _dateFormatDetails$pa = dateFormatDetails.patternArr,
+      patternArr = _dateFormatDetails$pa === void 0 ? [] : _dateFormatDetails$pa;
+  var dateString = concatDate({
+    day: day,
+    month: month,
+    year: year
+  }, dateFormatArr, patternArr, true, {
+    i18nShortMonths: i18nShortMonths,
+    i18nMonths: i18nMonths
+  });
+  var timeString = '';
+
+  if (isDateTime) {
+    hour = !(0, _Common.getIsEmptyValue)(hour) ? (0, _index.addZero)(hour, 2) : is24Hour ? 'HH' : 'hh';
+    minute = !(0, _Common.getIsEmptyValue)(minute) ? (0, _index.addZero)(minute, 2) : 'mm';
+    timeString = " ".concat(hour, ":").concat(minute, " ").concat(is24Hour ? '' : "".concat(noon || '--'));
+  }
+
+  return "".concat(dateString).concat(timeString);
+}
+
+function getDateDetails(value, localValues, isDateTime, timeZone, _ref7) {
+  var is24Hour = _ref7.is24Hour;
+  var day = localValues.day,
+      month = localValues.month,
+      year = localValues.year,
+      hour = localValues.hour,
+      minute = localValues.minute,
+      noon = localValues.noon;
+
+  if (value) {
+    var dateObj = isDateTime ? _datetimejs["default"].toDate(_datetimejs["default"].tz.utcToTz(value, timeZone)) : value ? _datetimejs["default"].toDate(value) : new Date();
+    var selectedDay = dateObj.getDate();
+    var selectedMonth = dateObj.getMonth();
+    var selectedYear = dateObj.getFullYear();
+    var newDay = day ? day : selectedDay;
+    var newMonth = month ? month : selectedMonth + 1;
+    var newYear = year ? year : selectedYear;
+
+    if (isDateTime) {
+      var selectedHour = dateObj.getHours();
+      var selectedMinute = dateObj.getMinutes();
+      var selectedNoon = selectedHour < 12 ? 'AM' : 'PM';
+
+      if (!is24Hour) {
+        selectedHour = selectedHour === 0 ? 12 : selectedHour > 12 ? selectedHour - 12 : selectedHour;
+      }
+
+      var newHour = hour ? hour : selectedHour;
+      var newMinute = minute ? minute : selectedMinute;
+      var newNoon = noon ? noon : selectedNoon;
+      return {
+        day: newDay,
+        month: newMonth,
+        year: newYear,
+        hour: newHour,
+        minute: newMinute,
+        noon: newNoon
+      };
+    }
+
+    return {
+      day: newDay,
+      month: newMonth,
+      year: newYear
+    };
+  }
+
+  return localValues;
+}
+
+function getIsValidDate(values, isDateTime, _ref8) {
+  var is24Hour = _ref8.is24Hour;
+  var day = values.day,
+      month = values.month,
+      year = values.year,
+      hour = values.hour,
+      minute = values.minute,
+      noon = values.noon;
+  var isError = false;
+  var message = '';
+  var valuesArr = isDateTime ? is24Hour ? [day, month, year, hour, minute] : [day, month, year, hour, minute, noon] : [day, month, year];
+  var haveNotAllValues = valuesArr.every(function (val, index) {
+    if (index === 2) {
+      //Year '00' to 0
+      var value = parseInt(val);
+      return (0, _Common.getIsEmptyValue)(value);
+    }
+
+    return (0, _Common.getIsEmptyValue)(val);
+  });
+  var haveAllValues = valuesArr.every(function (val, index) {
+    if (index === 4) {
+      //minute 0 support
+      return !(0, _Common.getIsEmptyValue)(val);
+    } else if (is24Hour && index === 3) {
+      //hour 0 support
+      return !(0, _Common.getIsEmptyValue)(val);
+    } else if (index === 2) {
+      //Year '00' to 0
+      return parseInt(val) ? true : false;
+    } else if (val) {
+      return true;
+    }
+
+    return false;
+  });
+
+  if (haveAllValues) {
+    var dayEnd = (0, _index.getDayEnd)(month, year);
+
+    var _getMonthDetails = (0, _index.getMonthDetails)(),
+        monthStart = _getMonthDetails.startPoint,
+        monthEnd = _getMonthDetails.endPoint;
+
+    var _getYearDetails = (0, _index.getYearDetails)(),
+        yearStart = _getYearDetails.startPoint,
+        yearEnd = _getYearDetails.endPoint;
+
+    var _getDayDetails = (0, _index.getDayDetails)(),
+        dayStart = _getDayDetails.startPoint;
+
+    var _getHourDetails = (0, _index.getHourDetails)(is24Hour),
+        hourStart = _getHourDetails.startPoint,
+        hourEnd = _getHourDetails.endPoint;
+
+    var _getMinuteDetails = (0, _index.getMinuteDetails)(),
+        minuteStart = _getMinuteDetails.startPoint,
+        minuteEnd = _getMinuteDetails.endPoint;
+
+    var _getNoonDetails = (0, _index.getNoonDetails)(),
+        noonAllowedValues = _getNoonDetails.allowedValues;
+
+    if (dayEnd < day || dayStart > day) {
+      isError = true;
+      message = 'Wrong Day';
+    } else if (monthEnd < month || monthStart > month) {
+      isError = true;
+      message = 'Wrong Month';
+    } else if (yearEnd < year || yearStart > year) {
+      isError = true;
+      message = 'Wrong Year';
+    } else if (isDateTime && (hourEnd < hour || hourStart > hour)) {
+      isError = true;
+      message = 'Wrong Hour';
+    } else if (isDateTime && (minuteEnd < minute || minuteStart > minute)) {
+      isError = true;
+      message = 'Wrong Minute';
+    } else if (isDateTime && !is24Hour && noonAllowedValues.indexOf(noon) === -1) {
+      isError = true;
+      message = 'Wrong Noon';
+    }
+  } else {
+    isError = true;
+    message = 'Empty value';
+  }
+
+  return {
+    isError: isError,
+    message: message,
+    isEmptyValError: haveNotAllValues
+  };
+}
+
+function getSelectedDate(values, props) {
+  var month = values.month,
+      hour = values.hour;
+  var year = values.year,
+      date = values.day,
+      mins = values.minute,
+      noon = values.noon;
+  var min = props.min,
+      max = props.max,
+      timeZone = props.timeZone,
+      isDateTime = props.isDateTime,
+      is24Hour = props.is24Hour;
+
+  if (!is24Hour) {
+    if (parseInt(hour) === 12) {
+      hour = noon === 'AM' ? 0 : 12;
+    }
+
+    if (noon === 'PM') {
+      if (hour < 12) {
+        hour = parseInt(hour) + 12;
+      }
+    }
+  }
+
+  month = parseInt(month) - 1;
+  var minInMillis = min ? _datetimejs["default"].millis(min) : null,
+      maxInMillis = max ? _datetimejs["default"].millis(max) : null;
+  var selectedInMillis,
+      selectedValue = '';
+
+  if (isDateTime) {
+    selectedInMillis = _datetimejs["default"].tz.tzToUtc(Date.UTC(year, month, date, hour, mins), timeZone);
+    selectedValue = _datetimejs["default"].ISO(selectedInMillis);
+  } else {
+    selectedInMillis = Date.UTC(year, month, date);
+    selectedValue = (0, _common.formatDate)(new Date(year, month, date), 'YYYY-MM-DD');
+  }
+
+  var isError = false;
+  var errorType = '';
+
+  if (minInMillis && minInMillis > selectedInMillis) {
+    isError = true;
+    errorType = 'MIN';
+  } else if (maxInMillis && maxInMillis < selectedInMillis) {
+    isError = true;
+    errorType = 'MAX';
+  }
+
+  return {
+    isError: isError,
+    errorType: errorType,
+    selectedValue: selectedValue
+  };
+}
+
+function getDateFormatLength(type, length) {
+  var formatVal = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+  var _ref9 = arguments.length > 3 ? arguments[3] : undefined,
+      i18nShortMonths = _ref9.i18nShortMonths,
+      i18nMonths = _ref9.i18nMonths,
+      selectedValue = _ref9.selectedValue,
+      day = _ref9.day,
+      month = _ref9.month,
+      year = _ref9.year,
+      hour = _ref9.hour,
+      minute = _ref9.minute,
+      noon = _ref9.noon,
+      timeZone = _ref9.timeZone,
+      isDateTime = _ref9.isDateTime,
+      is24Hour = _ref9.is24Hour;
+
+  var _getDateDetails = getDateDetails(selectedValue, {
+    day: day,
+    month: month,
+    year: year,
+    hour: hour,
+    minute: minute,
+    noon: noon
+  }, isDateTime, timeZone, {
+    is24Hour: is24Hour
+  }),
+      selectedMonth = _getDateDetails.month;
+
+  if (length === _constants.INCONSTANT) {
+    if (selectedMonth && formatVal === 'MMM' && i18nShortMonths.length) {
+      return i18nShortMonths[selectedMonth - 1].length;
+    } else if (selectedMonth && formatVal === 'MMMM' && i18nMonths.length) {
+      return i18nMonths[selectedMonth - 1].length;
+    }
+
+    return formatVal.length ? formatVal.length : 1;
+  }
+
+  return length;
+}
+
+function getDateFormatSelection(dateFormatDetails, isDateTime) {
+  var _ref10 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      i18nShortMonths = _ref10.i18nShortMonths,
+      i18nMonths = _ref10.i18nMonths,
+      selectedValue = _ref10.selectedValue,
+      day = _ref10.day,
+      month = _ref10.month,
+      year = _ref10.year,
+      hour = _ref10.hour,
+      minute = _ref10.minute,
+      noon = _ref10.noon,
+      timeZone = _ref10.timeZone,
+      is24Hour = _ref10.is24Hour;
+
+  var _dateFormatDetails$da2 = dateFormatDetails.dateFormatArr,
+      dateFormatArr = _dateFormatDetails$da2 === void 0 ? [] : _dateFormatDetails$da2,
+      _dateFormatDetails$pa2 = dateFormatDetails.patternArr,
+      patternArr = _dateFormatDetails$pa2 === void 0 ? [] : _dateFormatDetails$pa2;
+  var focusedIndex = {};
+  var clickIndex = {};
+  var order = [];
+  var tempLength = 0;
+
+  function addResult(type, length) {
+    var startIndex = tempLength;
+    var endIndex = tempLength + length;
+    var orderLen = order.length;
+    focusedIndex["".concat(startIndex, "_").concat(endIndex)] = orderLen;
+
+    for (var i = startIndex; i <= endIndex; i++) {
+      clickIndex[i] = orderLen;
+    }
+
+    order.push({
+      type: type,
+      index: [startIndex, endIndex]
+    });
+    tempLength += length;
+  }
+
+  dateFormatArr.forEach(function (formatVal, index) {
+    var _ref11 = _constants.flags[formatVal] || '',
+        type = _ref11.type,
+        length = _ref11.length;
+
+    var patternVal = patternArr[index] || '';
+    var validLength = getDateFormatLength(type, length, formatVal, {
+      i18nShortMonths: i18nShortMonths,
+      i18nMonths: i18nMonths,
+      selectedValue: selectedValue,
+      day: day,
+      month: month,
+      year: year,
+      hour: hour,
+      minute: minute,
+      noon: noon,
+      isDateTime: isDateTime,
+      timeZone: timeZone,
+      is24Hour: is24Hour
+    });
+    addResult(type, validLength);
+    tempLength += patternVal.length;
+  });
+
+  if (isDateTime) {
+    //For space between date and time
+    tempLength += 1; //hour
+
+    addResult('hour', 2); //For :
+
+    tempLength += 1; //minute
+
+    addResult('minute', 2); //For space between time and noon
+
+    tempLength += 1; //noon
+
+    if (!is24Hour) {
+      addResult('noon', 2);
+    }
+  }
+
+  return {
+    focusedIndex: focusedIndex,
+    clickIndex: clickIndex,
+    order: order
+  };
+} // export function getDateValues(date = '', dateFormatDetails = {}) {
+//   const { dateFormatArr, patternArr, dayInfo, monthInfo, yearInfo } =
+//     dateFormatDetails;
+//   const newDate = date.split('').reduce((res, str) => {
+//     if (patternArr.indexOf(str) >= 0) {
+//       res += patternChangeStr;
+//     } else {
+//       res += str;
+//     }
+//     return res;
+//   }, '');
+//   const dateArr = newDate.split(patternChangeStr);
+//   const { index: dayIndex, length: dayLength } = dayInfo;
+//   let day = dateArr[dayIndex];
+//   day = addZero(day, dayLength);
+//   const { index: monthIndex, length: monthLength } = monthInfo;
+//   let month = dateArr[monthIndex];
+//   month = addZero(month, monthLength);
+//   const { index: yearIndex, length: yearLength } = yearInfo;
+//   let year = dateArr[yearIndex];
+//   year = addZero(year, yearLength);
+//   return {
+//     day,
+//     month,
+//     year,
+//     dateString: concatDate({ day, month, year }, dateFormatArr, patternArr)
+//   };
+// }
+// export function getDateTimeValues(value = '', dateFormatDetails = {}) {
+//   const [date, time = '', noon = ''] = value.split(' ');
+//   let [hour = '', minute = ''] = time.split(':');
+//   hour = addZero(hour, 2);
+//   minute = addZero(minute, 2);
+//   const { day, month, year, dateString } = getDateValues(
+//     date,
+//     dateFormatDetails
+//   );
+//   const timeString = `${hour}:${minute}`;
+//   return {
+//     day,
+//     month,
+//     year,
+//     hour,
+//     minute,
+//     noon,
+//     dateString,
+//     timeString
+//   };
+// }

package/lib/DateTime/dateFormatUtils/dayChange.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChangedDay = getChangedDay;
+
+var _index = require("./index");
+
+/** * Methods ** */
+function getChangedDay(values, event, focusOrders, keyActions) {
+  var keyCode = event.keyCode,
+      which = event.which;
+  var _values$day = values.day,
+      day = _values$day === void 0 ? '' : _values$day;
+  var isChanged = false;
+  var newDay = Number.parseInt(day) || 0; // const newMonth = Number.parseInt(month) || 0;
+  // const newYear = Number.parseInt(year) || 0;
+
+  var focusOrder = focusOrders.focusOrder;
+  var newFocusOrder = focusOrder;
+  var isNewType = (0, _index.getIsNewValueType)(focusOrders, keyActions);
+
+  var _getDayDetails = (0, _index.getDayDetails)(),
+      startPoint = _getDayDetails.startPoint,
+      endPoint = _getDayDetails.endPoint;
+
+  if (keyCode === 38) {
+    //up arrow
+    if (newDay === endPoint || !newDay) {
+      isChanged = true;
+      newDay = startPoint;
+    } else if (newDay) {
+      isChanged = true;
+      newDay += 1;
+    }
+  } else if (keyCode === 40) {
+    //down arrow
+    if (newDay === startPoint || !newDay) {
+      isChanged = true;
+      newDay = endPoint;
+    } else if (newDay) {
+      isChanged = true;
+      newDay -= 1;
+    }
+  } else if ((0, _index.getIsNumberTyped)(event)) {
+    var keyString = String.fromCharCode(which);
+    var newValue = isNewType ? keyString : day.toString() + keyString;
+    newValue = Number.parseInt(newValue);
+
+    if (isNewType) {
+      isChanged = true;
+
+      if (newValue * 10 > endPoint) {
+        newFocusOrder += 1;
+      }
+
+      newDay = newValue;
+    } else {
+      isChanged = true;
+      newFocusOrder += 1;
+
+      if (newValue > endPoint) {
+        newDay = endPoint;
+      } else if (!newValue) {
+        newDay = startPoint;
+      } else {
+        newDay = newValue;
+      }
+    }
+  } else if ((0, _index.getIsDeleteTyped)(keyCode)) {
+    isChanged = true;
+    newDay = '';
+  }
+
+  return {
+    day: newDay,
+    isChanged: isChanged,
+    focusOrder: newFocusOrder
+  };
+}