@elliemae/ds-controlled-form 2.3.0-alpha.9 → 2.3.0-next.0

package/esm/controlled-date-time-picker/utils/dateHelpers.js

@@ -0,0 +1,242 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { createRef } from 'react';
+import { monthNames } from './constants.js';
+import { isIncompleteString, deconstructValuesFromDateString, prependStringWithPlaceHolders } from './stringHelpers.js';
+import { convertToPositiveNumberIfPossible } from './numberHelpers.js';
+
+const getLastDayOfMonth = (month, year) => new Date(year, month + 1, 0);
+const isValidDayForTheMonth = (month, year, day) => {
+  var _Date, _Date$getMonth;
+
+  return ((_Date = new Date(year, month, day)) === null || _Date === void 0 ? void 0 : (_Date$getMonth = _Date.getMonth) === null || _Date$getMonth === void 0 ? void 0 : _Date$getMonth.call(_Date)) === month;
+};
+const isValidDayForTheMonthDateString = dateString => {
+  var _getDayFromDateString, _getDayFromDateString2;
+
+  if (isIncompleteString(dateString)) return true;
+  const {
+    month
+  } = deconstructValuesFromDateString(dateString);
+  const monthInt = convertToPositiveNumberIfPossible(month);
+  if (monthInt === -1) return false;
+  const monthDateMonth = monthInt - 1;
+  return ((_getDayFromDateString = getDayFromDateString(dateString)) === null || _getDayFromDateString === void 0 ? void 0 : (_getDayFromDateString2 = _getDayFromDateString.getMonth) === null || _getDayFromDateString2 === void 0 ? void 0 : _getDayFromDateString2.call(_getDayFromDateString)) === monthDateMonth;
+};
+const getValidationDateStringMetaInfo = function (dateString) {
+  let getIsOutOfRangeDay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : day => false;
+  let getIsDisabledDay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : day => false;
+  const metaInfo = {};
+
+  if (!isIncompleteString(dateString)) {
+    metaInfo.isDayPresentInMonth = isValidDayForTheMonthDateString(dateString);
+    if (!metaInfo.isDayPresentInMonth) metaInfo.suggestedErrorMsg = 'The selected day is not part of the selected month';
+    const day = getDayFromDateString(dateString);
+
+    if (day) {
+      metaInfo.isOutOfRangeDay = getIsOutOfRangeDay(dateString);
+      metaInfo.isDisabledDay = getIsDisabledDay(dateString);
+      if (metaInfo.isOutOfRangeDay || metaInfo.isDisabledDay) metaInfo.suggestedErrorMsg = 'The selected day is not allowed';
+    }
+  }
+
+  return metaInfo;
+}; // code adapted from https://github.com/datejs/Datejs/blob/master/src/core.js
+
+const isLeapYear = year => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+const getHowManyDaysInMonth = (year, month) => {
+  const daysPerMonth = [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return daysPerMonth[month];
+};
+const dateIsLeapYear = date => isLeapYear(date.getFullYear());
+const dateGetDaysInMonth = date => getHowManyDaysInMonth(date.getFullYear(), date.getMonth());
+const dateAddMonths = (date, value) => {
+  const copiedDate = new Date(date.getTime());
+  const n = copiedDate.getDate();
+  copiedDate.setDate(1);
+  copiedDate.setMonth(copiedDate.getMonth() + value);
+  copiedDate.setDate(Math.min(n, dateGetDaysInMonth(copiedDate)));
+  return copiedDate;
+};
+const dateAddYear = (date, value) => dateAddMonths(date, value * 12);
+// sumFromDateValues supports negative values to "subtract"
+const sumFromDateValues = (_ref, _ref2) => {
+  let {
+    month,
+    year,
+    day = 1
+  } = _ref;
+  let {
+    monthsToSum = 0,
+    yearsToSum = 0,
+    daysToSum = 0
+  } = _ref2;
+  let newDate = new Date(year, month, day);
+  if (yearsToSum) newDate = dateAddYear(newDate, yearsToSum);
+  if (monthsToSum) newDate = dateAddMonths(newDate, monthsToSum);
+  if (daysToSum) newDate.setDate(newDate.getDate() + daysToSum);
+  return {
+    month: newDate.getMonth(),
+    day: newDate.getDate(),
+    year: newDate.getFullYear()
+  };
+};
+const sumValuesToDate = (day, sumValues) => {
+  const dateAsVals = getDateValuesFromDate(day);
+  const {
+    month,
+    year,
+    day: newD
+  } = sumFromDateValues(dateAsVals, sumValues);
+  return new Date(year, month, newD);
+};
+const subtractYears = function (date) {
+  let howManyMore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  const newDate = new Date(date.getTime());
+  newDate.setFullYear(date.getFullYear() - howManyMore);
+  return newDate;
+};
+const subtractMonths = function (date) {
+  let howManyMore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  const newDate = new Date(date.getTime());
+  newDate.setMonth(date.getMonth() - howManyMore);
+  return newDate;
+};
+const sumMonths = function (date) {
+  let howManyMore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  const newDate = new Date(date.getTime());
+  newDate.setMonth(date.getMonth() + howManyMore);
+  return newDate;
+};
+const sumYears = function (date) {
+  let howManyMore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  const newDate = new Date(date.getTime());
+  newDate.setFullYear(date.getFullYear() + howManyMore);
+  return newDate;
+};
+const getDaysInMonth = (month, year) => {
+  const date = new Date(year, month, 1);
+  const days = [];
+
+  while (date.getMonth() === month) {
+    days.push(new Date(date));
+    date.setDate(date.getDate() + 1);
+  }
+
+  return days;
+};
+const getLastXDaysFromPreviousMonth = (month, year, howMany) => {
+  const date = new Date(year, month, 1);
+  const days = [];
+
+  while (days.length !== howMany) {
+    date.setDate(date.getDate() - 1);
+    days.push(new Date(date));
+  }
+
+  return days.reverse();
+};
+const getFirstXDaysFromNextMonth = (month, year, howMany) => {
+  const date = sumMonths(new Date(year, month, 1), 1);
+  const days = [];
+
+  while (days.length !== howMany) {
+    days.push(new Date(date));
+    date.setDate(date.getDate() + 1);
+  }
+
+  return days;
+};
+const getFiveBySevenCurrentMonthDaysMatrix = (month, year) => {
+  var _currentMonthDays$, _currentMonthDays$$da, _currentMonthDays, _currentMonthDays$day;
+
+  const currentMonthDays = getDaysInMonth(month, year).map(day => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: false,
+    isNextMonthDay: false,
+    isCurrMonthDay: true,
+    isHidden: false,
+    dayBtnRef: /*#__PURE__*/createRef()
+  }));
+  const firstDayOfTheMonthWeekDay = currentMonthDays === null || currentMonthDays === void 0 ? void 0 : (_currentMonthDays$ = currentMonthDays[0]) === null || _currentMonthDays$ === void 0 ? void 0 : (_currentMonthDays$$da = _currentMonthDays$.day) === null || _currentMonthDays$$da === void 0 ? void 0 : _currentMonthDays$$da.getDay();
+  const previousMonthDaysToPrepend = getLastXDaysFromPreviousMonth(month, year, firstDayOfTheMonthWeekDay).map(day => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: true,
+    isNextMonthDay: false,
+    isCurrMonthDay: false,
+    isHidden: false,
+    dayBtnRef: /*#__PURE__*/createRef()
+  }));
+  const lastDayOfTheMonthWeekDay = currentMonthDays === null || currentMonthDays === void 0 ? void 0 : (_currentMonthDays = currentMonthDays[currentMonthDays.length - 1]) === null || _currentMonthDays === void 0 ? void 0 : (_currentMonthDays$day = _currentMonthDays.day) === null || _currentMonthDays$day === void 0 ? void 0 : _currentMonthDays$day.getDay();
+  const nextMonthDaysToAppend = getFirstXDaysFromNextMonth(month, year, 6 - lastDayOfTheMonthWeekDay).map(day => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: false,
+    isNextMonthDay: true,
+    isCurrMonthDay: false,
+    isHidden: false,
+    dayBtnRef: /*#__PURE__*/createRef()
+  }));
+  return [...previousMonthDaysToPrepend, ...currentMonthDays, ...nextMonthDaysToAppend];
+};
+const getDateValuesFromDate = day => {
+  var _day$getMonth, _day$getDate, _day$getFullYear;
+
+  return {
+    month: day === null || day === void 0 ? void 0 : (_day$getMonth = day.getMonth) === null || _day$getMonth === void 0 ? void 0 : _day$getMonth.call(day),
+    day: day === null || day === void 0 ? void 0 : (_day$getDate = day.getDate) === null || _day$getDate === void 0 ? void 0 : _day$getDate.call(day),
+    year: day === null || day === void 0 ? void 0 : (_day$getFullYear = day.getFullYear) === null || _day$getFullYear === void 0 ? void 0 : _day$getFullYear.call(day)
+  };
+};
+const getDateStringFromDay = day => {
+  const monthFromDay = prependStringWithPlaceHolders("".concat(day.getMonth() + 1), 2); // months from 1-12
+
+  const dayFromDay = prependStringWithPlaceHolders("".concat(day.getDate()), 2);
+  const yearFromDay = prependStringWithPlaceHolders("".concat(day.getFullYear()), 4);
+  return "".concat(monthFromDay, "/").concat(dayFromDay, "/").concat(yearFromDay);
+};
+const getTimeStringFromDay = day => {
+  const hoursNum = day.getHours();
+  const meridiem = hoursNum > 12 ? 'PM' : 'AM';
+  const twelveHourFormat = hoursNum > 12 ? hoursNum - 12 : hoursNum;
+  const minutesNum = day.getMinutes();
+  const hoursFromDay = prependStringWithPlaceHolders("".concat(twelveHourFormat), 2);
+  const minutesFromDay = prependStringWithPlaceHolders("".concat(minutesNum), 2);
+  return "".concat(hoursFromDay, ":").concat(minutesFromDay, " ").concat(meridiem);
+};
+const getDayFromDateString = dateString => {
+  const {
+    month,
+    day,
+    year
+  } = deconstructValuesFromDateString(dateString);
+  const monthNum = convertToPositiveNumberIfPossible(month);
+  const dayNum = convertToPositiveNumberIfPossible(day);
+  const yearNum = convertToPositiveNumberIfPossible(year);
+  if (monthNum !== -1 && dayNum !== -1 && yearNum !== -1 && isValidDayForTheMonth(monthNum - 1, yearNum, dayNum)) return new Date(yearNum, monthNum - 1, dayNum);
+  return null;
+};
+const getMonthNameByMonthNumber = monthNumber => monthNames[monthNumber];
+const isSameDateMoment = (dateA, dateB) => {
+  var _dateA$getTime, _dateB$getTime;
+
+  return (dateA === null || dateA === void 0 ? void 0 : (_dateA$getTime = dateA.getTime) === null || _dateA$getTime === void 0 ? void 0 : _dateA$getTime.call(dateA)) === (dateB === null || dateB === void 0 ? void 0 : (_dateB$getTime = dateB.getTime) === null || _dateB$getTime === void 0 ? void 0 : _dateB$getTime.call(dateB));
+};
+const compareTwoDatesDayEquality = (dayA, dayB) => {
+  const {
+    day: currD,
+    month: currM,
+    year: currY
+  } = getDateValuesFromDate(dayA);
+  const {
+    day: focusD,
+    month: focusM,
+    year: focusY
+  } = getDateValuesFromDate(dayB);
+  return currD === focusD && currM === focusM && currY === focusY;
+};
+
+export { compareTwoDatesDayEquality, dateAddMonths, dateAddYear, dateGetDaysInMonth, dateIsLeapYear, getDateStringFromDay, getDateValuesFromDate, getDayFromDateString, getDaysInMonth, getFirstXDaysFromNextMonth, getFiveBySevenCurrentMonthDaysMatrix, getHowManyDaysInMonth, getLastDayOfMonth, getLastXDaysFromPreviousMonth, getMonthNameByMonthNumber, getTimeStringFromDay, getValidationDateStringMetaInfo, isLeapYear, isSameDateMoment, isValidDayForTheMonth, isValidDayForTheMonthDateString, subtractMonths, subtractYears, sumFromDateValues, sumMonths, sumValuesToDate, sumYears };

package/esm/controlled-date-time-picker/utils/dateTimeHelpers.js

@@ -0,0 +1,15 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { getValidationDateStringMetaInfo } from './dateHelpers.js';
+import { getValidationTimeStringMetaInfo } from './timeHelpers.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+const getValidationDateTimeStringMetaInfo = (dateString, timeString, validators) => _objectSpread(_objectSpread({}, getValidationDateStringMetaInfo(dateString, validators.getIsOutOfRangeDay, validators.getIsDisabledDay)), getValidationTimeStringMetaInfo(timeString, validators.getIsDisabledTime));
+
+export { getValidationDateTimeStringMetaInfo };

package/esm/controlled-date-time-picker/utils/hooks/useGetDayFromDateString.js

@@ -0,0 +1,12 @@
+import { useContext, useMemo } from 'react';
+import { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX.js';
+import { getDayFromDateString } from '../dateHelpers.js';
+
+const useGetDayFromDateString = () => {
+  const {
+    dateStringFromProps
+  } = useContext(ControlledDateTimePickerContext);
+  return useMemo(() => getDayFromDateString(dateStringFromProps), [dateStringFromProps]);
+};
+
+export { useGetDayFromDateString };

package/esm/controlled-date-time-picker/utils/hooks/useGetMonthYearFromDateStringOrEmptyStartingMonth.js

@@ -0,0 +1,34 @@
+import { useContext, useMemo } from 'react';
+import { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX.js';
+import { deconstructValuesFromDateString } from '../stringHelpers.js';
+
+const useGetMonthYearFromDateStringOrEmptyStartingMonth = () => {
+  const {
+    dateStringFromProps,
+    props: {
+      emptyPickerStartingMonth
+    }
+  } = useContext(ControlledDateTimePickerContext);
+  return useMemo(() => {
+    const emptyPickerStartingMonthDefault = "".concat(new Date().getMonth() + 1, "/__/").concat(new Date().getFullYear());
+    const {
+      month: stringMonthVal,
+      year: stringYearVal
+    } = deconstructValuesFromDateString(dateStringFromProps);
+    const {
+      month: emptyStringSplitMonth,
+      year: emptyStringSplitYear
+    } = deconstructValuesFromDateString(emptyPickerStartingMonth || emptyPickerStartingMonthDefault);
+    const userEmptyStringMonth = Number.parseInt(emptyStringSplitMonth, 10);
+    const userEmptyStringYear = Number.parseInt(emptyStringSplitYear, 10);
+    const month = stringMonthVal === '' || stringMonthVal.length !== 2 ? userEmptyStringMonth - 1 : Number.parseInt(stringMonthVal, 10) - 1; // month is 0~11 in javascript Date...
+
+    const year = stringYearVal === '' ? userEmptyStringYear : Number.parseInt(stringYearVal, 10);
+    return {
+      year,
+      month
+    };
+  }, [dateStringFromProps, emptyPickerStartingMonth]);
+};
+
+export { useGetMonthYearFromDateStringOrEmptyStartingMonth };

package/esm/controlled-date-time-picker/utils/hooks/useGetStartingFocusedDay.js

@@ -0,0 +1,75 @@
+import { useContext, useMemo } from 'react';
+import { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX.js';
+import { deconstructValuesFromDateString } from '../stringHelpers.js';
+import { convertToPositiveNumberIfPossible } from '../numberHelpers.js';
+import { getDateValuesFromDate, isValidDayForTheMonth } from '../dateHelpers.js';
+import { useGetDayFromDateString } from './useGetDayFromDateString.js';
+
+/* eslint-disable max-statements */
+const empty = {
+  startFocusedYear: null,
+  startFocusedDay: null,
+  startFocusedMonth: null,
+  startFocusedDate: null
+};
+const useGetStartingFocusedDay = () => {
+  const {
+    props: {
+      onCalendarOpenFocusedDay
+    }
+  } = useContext(ControlledDateTimePickerContext);
+  const dayFromInputValues = useGetDayFromDateString();
+  return useMemo(() => {
+    const {
+      month: inputValuesSplitMonth,
+      day: inputValuesSplitDay,
+      year: inputValuesDaySplitYear
+    } = getDateValuesFromDate(dayFromInputValues);
+    let startFocusedMonth = null;
+    let startFocusedDay = null;
+    let startFocusedYear = null;
+    let startFocusedDate = null;
+    const isInputFilledAndValid = inputValuesSplitMonth && inputValuesSplitDay && inputValuesDaySplitYear && isValidDayForTheMonth(inputValuesSplitMonth, inputValuesDaySplitYear, inputValuesSplitDay);
+    const isOnCalendarOpenFocusedDayEmpty = !onCalendarOpenFocusedDay;
+    const shouldFillWithOnCalendarOpenFocusedDay = !isInputFilledAndValid && !isOnCalendarOpenFocusedDayEmpty; // if input was filled start focus is the filled value (if it's valid day for the month)
+
+    if (isInputFilledAndValid) {
+      startFocusedMonth = inputValuesSplitMonth;
+      startFocusedDay = inputValuesSplitDay;
+      startFocusedYear = inputValuesDaySplitYear;
+      startFocusedDate = dayFromInputValues; // if input was not filled (or filled invalid) and there is no onCalendarOpenFocusedDay start focus is not a day
+    } // if input was not filled and there is onCalendarOpenFocusedDay start focus is onCalendarOpenFocusedDay day
+
+
+    if (!isInputFilledAndValid && isOnCalendarOpenFocusedDayEmpty) return empty;
+
+    if (shouldFillWithOnCalendarOpenFocusedDay) {
+      const {
+        month: focusedDaySplitMonth,
+        day: focusedDaySplitDay,
+        year: focusedDaySplitYear
+      } = deconstructValuesFromDateString(onCalendarOpenFocusedDay);
+      const monthAsInt = convertToPositiveNumberIfPossible(focusedDaySplitMonth);
+      const dayAsInt = convertToPositiveNumberIfPossible(focusedDaySplitDay);
+      const yearAsInt = convertToPositiveNumberIfPossible(focusedDaySplitYear); // if this condition is false, return will be the same as return empty
+      // because startFocusedMonth/Day/Year/Date will be === null
+      // which is the expected result
+
+      if (monthAsInt !== -1 && dayAsInt !== -1 && yearAsInt !== -1 && isValidDayForTheMonth(monthAsInt - 1, yearAsInt, dayAsInt)) {
+        startFocusedMonth = monthAsInt;
+        startFocusedDay = dayAsInt;
+        startFocusedYear = yearAsInt;
+        startFocusedDate = new Date(yearAsInt, monthAsInt - 1, dayAsInt);
+      }
+    }
+
+    return {
+      startFocusedYear,
+      startFocusedDay,
+      startFocusedMonth,
+      startFocusedDate
+    };
+  }, [dayFromInputValues, onCalendarOpenFocusedDay]);
+};
+
+export { useGetStartingFocusedDay };

package/esm/controlled-date-time-picker/utils/hooks/useOnClickOutside.js

@@ -0,0 +1,25 @@
+import { useEffect } from 'react';
+
+const useOnClickOutside = (ref, handler) => {
+  useEffect(() => {
+    const listener = event => {
+      var _ref$contains;
+
+      // Do nothing if clicking ref's element or descendent elements
+      if (!ref || ref !== null && ref !== void 0 && (_ref$contains = ref.contains) !== null && _ref$contains !== void 0 && _ref$contains.call(ref, event.target)) {
+        return;
+      }
+
+      handler(event);
+    };
+
+    document.addEventListener('mousedown', listener);
+    document.addEventListener('touchstart', listener);
+    return () => {
+      document.removeEventListener('mousedown', listener);
+      document.removeEventListener('touchstart', listener);
+    };
+  }, [ref, handler]);
+};
+
+export { useOnClickOutside };

package/esm/controlled-date-time-picker/utils/numberHelpers.js

@@ -0,0 +1,7 @@
+const convertToPositiveNumberIfPossible = numberString => {
+  const convertedNum = Number.parseInt(numberString, 10);
+  if (Number.isNaN(convertedNum)) return -1;
+  return convertedNum;
+};
+
+export { convertToPositiveNumberIfPossible };

package/esm/controlled-date-time-picker/utils/stringHelpers.js

@@ -0,0 +1,143 @@
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.string.replace.js';
+import { monthNames, announcableCardinalDays } from './constants.js';
+import { convertToPositiveNumberIfPossible } from './numberHelpers.js';
+
+/* eslint-disable max-lines */
+
+const prependStringWithPlaceHolders = function (val, finalLength) {
+  let placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
+  if (val.length === finalLength) return val;
+  const stringAsAnArray = val.split('').reverse();
+  return new Array(finalLength).fill(placeholder).map((_c, i) => stringAsAnArray[i] ? stringAsAnArray[i] : placeholder).reverse().join('');
+};
+const fillStringWithPlaceHolders = function (val, finalLength) {
+  let placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '_';
+  if (val.length === finalLength) return val;
+  const stringAsAnArray = val.split('');
+  return new Array(finalLength).fill(placeholder).map((_c, i) => stringAsAnArray[i] ? stringAsAnArray[i] : placeholder).join('');
+};
+const getFormattedDateString = _ref => {
+  let {
+    month,
+    day,
+    year
+  } = _ref;
+  const finalMonth = fillStringWithPlaceHolders(month, 2);
+  const finalDay = fillStringWithPlaceHolders(day, 2);
+  const finalYear = fillStringWithPlaceHolders(year, 4);
+  return "".concat(finalMonth, "/").concat(finalDay, "/").concat(finalYear);
+};
+const dateTimeToDate = dateTime => {
+  var _dateTime$split, _dateTime$split$call;
+
+  return dateTime === null || dateTime === void 0 ? void 0 : (_dateTime$split = dateTime.split) === null || _dateTime$split === void 0 ? void 0 : (_dateTime$split$call = _dateTime$split.call(dateTime, ' ')) === null || _dateTime$split$call === void 0 ? void 0 : _dateTime$split$call[0];
+};
+const deconstructValuesFromDateString = dateString => {
+  const [dirtyMonth = '', dirtyDay = '', dirtyYear = ''] = dateString === null || dateString === void 0 ? void 0 : dateString.split('/');
+  const replaceAllRegexp = /_/g;
+  return {
+    month: (dirtyMonth || '').replace(replaceAllRegexp, ''),
+    day: (dirtyDay || '').replace(replaceAllRegexp, ''),
+    year: (dirtyYear || '').replace(replaceAllRegexp, '')
+  };
+};
+const deconstructValuesFromTimeString = timeString => {
+  const [dirtyHour = '', dirtyMintuesAndMeridiem = ''] = timeString === null || timeString === void 0 ? void 0 : timeString.split(':');
+  const [dirtyMinutes = '', dirtyMeridiem = ''] = dirtyMintuesAndMeridiem === null || dirtyMintuesAndMeridiem === void 0 ? void 0 : dirtyMintuesAndMeridiem.split(' ');
+  const replaceAllRegexp = /_/g;
+  return {
+    hours: (dirtyHour || '').replace(replaceAllRegexp, ''),
+    minutes: (dirtyMinutes || '').replace(replaceAllRegexp, ''),
+    meridiem: (dirtyMeridiem || '').replace(replaceAllRegexp, '')
+  };
+}; // https://regex101.com/r/U5r5lh/1/
+
+const dateRegExp = /^[0-9_][0-9_]\/[0-9_][0-9_]\/[0-9_]{4}$/;
+const isValidDateString = testString => {
+  if (testString === '') return true;
+  const isValidDateRegexp = dateRegExp.test(testString);
+  if (!isValidDateRegexp) return false;
+  const {
+    month,
+    day,
+    year
+  } = deconstructValuesFromDateString(testString);
+  if (Number.parseInt(month, 10) > 12 || Number.parseInt(day, 10) > 31 || Number.parseInt(year, 10) > 9999) return false;
+  return true;
+};
+const getFormattedTimeString = _ref2 => {
+  let {
+    hours,
+    minutes,
+    // seconds,
+    meridiem
+  } = _ref2;
+  const finalHour = fillStringWithPlaceHolders(hours, 2);
+  const finalMinutes = fillStringWithPlaceHolders(minutes, 2); // const finalSeconds = fillStringWithPlaceHolders(seconds, 2); // <-- seconds format
+
+  const finalMeridiem = fillStringWithPlaceHolders(meridiem, 2); // return `${finalHour}:${finalMinutes}:${finalSeconds} ${finalMeridiem}`;// <-- seconds format
+
+  return "".concat(finalHour, ":").concat(finalMinutes, " ").concat(finalMeridiem);
+};
+const dateTimeToTime = dateTime => {
+  var _dateTime$split2;
+
+  const [// eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _date, // timeNumbers = '__:__:__', // <-- seconds format
+  timeNumbers = '__:__', timeMeridiem = '__'] = dateTime === null || dateTime === void 0 ? void 0 : (_dateTime$split2 = dateTime.split) === null || _dateTime$split2 === void 0 ? void 0 : _dateTime$split2.call(dateTime, ' ');
+  return "".concat(timeNumbers, " ").concat(timeMeridiem);
+};
+const deconstructTimeValues = timeString => {
+  var _timeString$split, _dirtyTimes$split;
+
+  const [dirtyTimes, dirtyMeridiem] = timeString === null || timeString === void 0 ? void 0 : (_timeString$split = timeString.split) === null || _timeString$split === void 0 ? void 0 : _timeString$split.call(timeString, ' '); // <--['__:__','__']
+
+  const [dirtyHours, dirtyMinutes] = (_dirtyTimes$split = dirtyTimes.split) === null || _dirtyTimes$split === void 0 ? void 0 : _dirtyTimes$split.call(dirtyTimes, ':'); // <--['__','__']
+
+  const regex = /_/g; // Note the 'g' flag, which matches all occurrences of the expression
+
+  const newValues = {
+    hours: (dirtyHours || '').replace(regex, ''),
+    minutes: (dirtyMinutes || '').replace(regex, ''),
+    // seconds: (dirtySeconds||"").replace(regex, ''),
+    meridiem: (dirtyMeridiem || '').replace(regex, '')
+  };
+  return newValues;
+}; // https://regex101.com/r/jeBmNT/1
+
+const timeRegExp = /^[0-9_][0-9_]:[0-9_][0-9_]\s[aApP_][mM_]$/;
+const isValidTimeString = testString => {
+  if (testString === '') return true;
+  const isValidTimeRegexp = timeRegExp.test(testString);
+  if (!isValidTimeRegexp) return false;
+  const {
+    hours,
+    minutes
+  } = deconstructTimeValues(testString);
+  if (Number.parseInt(hours, 10) > 12 || Number.parseInt(minutes, 10) > 60) return false;
+  return true;
+};
+const isIncompleteString = function (testString) {
+  let placeholder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_';
+  return testString === '' || testString.includes(placeholder);
+};
+const isEmptyDateStringMask = testString => testString === '__/__/____';
+const isEmptyTimeStringMask = testString => testString === '__:__ __';
+const isEmptyDateTimeStringMask = testString => testString === '__/__/____ __:__ __';
+const getAriaDayFromDateString = dateString => {
+  const {
+    month: monthString,
+    day: dayString,
+    year: yearString
+  } = deconstructValuesFromDateString(dateString);
+  const monthNum = convertToPositiveNumberIfPossible(monthString);
+  const dayNum = convertToPositiveNumberIfPossible(dayString);
+  const yearNum = convertToPositiveNumberIfPossible(yearString);
+  if (monthNum === -1 || dayNum === -1 || yearNum === -1) return '';
+  return "".concat(monthNames[monthNum - 1], " ").concat(announcableCardinalDays[dayNum], " ").concat(yearNum);
+};
+
+export { dateTimeToDate, dateTimeToTime, deconstructTimeValues, deconstructValuesFromDateString, deconstructValuesFromTimeString, fillStringWithPlaceHolders, getAriaDayFromDateString, getFormattedDateString, getFormattedTimeString, isEmptyDateStringMask, isEmptyDateTimeStringMask, isEmptyTimeStringMask, isIncompleteString, isValidDateString, isValidTimeString, prependStringWithPlaceHolders };

package/esm/controlled-date-time-picker/utils/timeHelpers.js

@@ -0,0 +1,15 @@
+import { isIncompleteString } from './stringHelpers.js';
+
+const getValidationTimeStringMetaInfo = function (timeString) {
+  let getIsDisabledTime = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : timeS => false;
+  const metaInfo = {};
+
+  if (!isIncompleteString(timeString)) {
+    metaInfo.isDisabledTime = getIsDisabledTime(timeString);
+    if (metaInfo.isDisabledTime) metaInfo.suggestedErrorMsg = 'The selected time is not allowed';
+  }
+
+  return metaInfo;
+};
+
+export { getValidationTimeStringMetaInfo };