@zohodesk/components/es/DateTime/dateFormatUtils/index.js

In this Package, we Provide Some Basic Components to Build Web App

/* eslint-disable no-param-reassign */

/** * Methods ** */
import { getMonthEnd } from "../../utils/datetime/common";
/** * Constants ** */

import { flags, INVALID_DATE } from "../constants";
import { getDateText } from "./dateFormat";
export function convertYearToTwoDigit(year) {
  return parseInt(year.toString().slice(-2));
}
export function addZero() {
  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  let length = arguments.length > 1 ? arguments[1] : undefined;
  let newValue = value.toString();

  for (let i = 0; i < length; i++) {
    if (newValue.length < length) {
      newValue = `0${newValue}`;
    } else {
      break;
    }
  }

  return newValue;
}
export function getDayEnd(month, year) {
  month -= 1;
  const monthend = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

  if (month && year) {
    return getMonthEnd(month, year);
  } else if (month) {
    return monthend[month];
  }

  return 31;
}
export function getIsNumberTyped(event) {
  const {
    keyCode,
    ctrlKey,
    metaKey,
    shiftKey
  } = event;

  if ((keyCode >= 48 && keyCode <= 57 || keyCode >= 96 && keyCode <= 105) && !ctrlKey && !metaKey && !shiftKey) {
    return true;
  }

  return false;
}
export function getIsDeleteTyped(keyCode) {
  if (keyCode === 8) {
    return true;
  }

  return false;
}
export function getIsNewValueType(focusOrders, keyActions) {
  const {
    focusOrder,
    oldFocusOrder
  } = focusOrders;
  const {
    oldKeyAction,
    keyAction
  } = keyActions;
  return focusOrder !== oldFocusOrder || oldKeyAction !== keyAction;
}
export function getDayDetails() {
  return {
    startPoint: 1,
    endPoint: 31
  };
}
export function getMonthDetails() {
  return {
    startPoint: 1,
    endPoint: 12
  };
}
export function getYearDetails(yearLength) {
  const dateObj = new Date();
  const year = dateObj.getFullYear();

  if (yearLength === 2) {
    return {
      startPoint: 0,
      endPoint: 99,
      currentYear: year
    };
  }

  return {
    startPoint: 1850,
    endPoint: 9999,
    currentYear: year
  };
}
export function convertTwoDigitToYear() {
  let digitValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  let selectedYear = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  const dateObj = new Date();
  let year = dateObj.getFullYear();
  const digitValueStr = addZero(digitValue.toString(), 2);
  year = selectedYear ? selectedYear : year;

  if (digitValueStr && digitValueStr.length <= 2) {
    return parseInt(year.toString().slice(0, 2) + digitValueStr);
  }

  return digitValue;
}
export function getHourDetails(is24Hour) {
  return {
    startPoint: is24Hour ? 0 : 1,
    endPoint: is24Hour ? 23 : 12
  };
}
export function getHourSuggestions(is24Hour) {
  const {
    startPoint,
    endPoint
  } = getHourDetails(is24Hour);
  const hourArr = [];

  for (let hour = startPoint; hour <= endPoint; hour++) {
    const htxt = addZeroIfNeeded(hour);
    hourArr.push(htxt);
  }

  return hourArr;
}
export function getMinuteDetails() {
  return {
    startPoint: 0,
    endPoint: 59
  };
}
export function getMinuteSuggestions() {
  const {
    startPoint,
    endPoint
  } = getMinuteDetails();
  const minArr = [];

  for (let minute = startPoint; minute <= endPoint; minute++) {
    const mtxt = addZeroIfNeeded(minute);
    minArr.push(mtxt);
  }

  return minArr;
}
export function addZeroIfNeeded(value) {
  return value < 10 ? `0${value}` : value;
}
export function getIsNoonValueTyped(event) {
  const {
    keyCode
  } = event;

  if (keyCode === 65 || keyCode === 77 || keyCode === 80) {
    //A -65
    //M -77
    //P -80
    return true;
  }

  return false;
}
export function getNoonDetails() {
  return {
    allowedValues: ['AM', 'PM']
  };
}

function getIsArrowTyped(keyCode) {
  const arrowKeycodes = [37, 38, 39, 40];

  if (arrowKeycodes.indexOf(keyCode) >= 0) {
    return true;
  }

  return false;
}

export function getIsSupportedKey(event) {
  const {
    keyCode
  } = event;

  if (getIsArrowTyped(keyCode) || getIsDeleteTyped(keyCode) || getIsNumberTyped(event) || getIsNoonValueTyped(event)) {
    return true;
  }

  return false;
}
export function arrayIsNotEqual(a, b) {
  return a.some((val, index) => val !== b[index]);
}

function getIsEmptyValue(value, startPoint, endPoint) {
  const newValue = parseInt(value) || 0;

  if (newValue >= startPoint && newValue <= endPoint) {
    return false;
  }

  return true;
}

export function getIsEmptyHour(value, is24Hour) {
  const {
    startPoint,
    endPoint
  } = getHourDetails(is24Hour);
  return getIsEmptyValue(value, startPoint, endPoint);
}
export function getIsEmptyYear(value, yearLength) {
  const {
    startPoint,
    endPoint
  } = getYearDetails(yearLength);
  return getIsEmptyValue(value, startPoint, endPoint);
}
export function getIsCurrentYear(_ref) {
  let {
    isDateTime,
    value,
    timeZone
  } = _ref;
  let isCurrentYear = false;

  if (value && value !== INVALID_DATE) {
    const dateObj = getDateText(value, isDateTime, timeZone);
    const currentDateObj = new Date();
    const currentYear = currentDateObj.getFullYear();
    const selectedYear = dateObj.getFullYear();
    isCurrentYear = currentYear === selectedYear;
  }

  return {
    isCurrentYear
  };
}
export function removeYearPattern(dateFormatArr, patternArr) {
  const newDateFormatArr = [];
  let newPatternArr = [];
  let yearIndex = '';
  dateFormatArr.forEach((val, index) => {
    const {
      type
    } = flags[val];

    if (type === 'year') {
      yearIndex = index;
    } else {
      newDateFormatArr.push(val);
    }
  });
  newPatternArr = patternArr.slice(0, yearIndex - 1);
  return {
    dateFormatArr: newDateFormatArr,
    patternArr: newPatternArr
  };
}