@elliemae/ds-controlled-form 3.0.0-next.1 → 3.0.0-next.5

package/dist/cjs/date-time-picker/utils/dateHelpers.js

@@ -0,0 +1,242 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var dateHelpers_exports = {};
+__export(dateHelpers_exports, {
+  compareTwoDatesDayEquality: () => compareTwoDatesDayEquality,
+  dateAddMonths: () => dateAddMonths,
+  dateAddYear: () => dateAddYear,
+  dateGetDaysInMonth: () => dateGetDaysInMonth,
+  dateIsLeapYear: () => dateIsLeapYear,
+  getDateStringFromDay: () => getDateStringFromDay,
+  getDateValuesFromDate: () => getDateValuesFromDate,
+  getDayFromDateString: () => getDayFromDateString,
+  getDaysInMonth: () => getDaysInMonth,
+  getFirstXDaysFromNextMonth: () => getFirstXDaysFromNextMonth,
+  getFiveBySevenCurrentMonthDaysMatrix: () => getFiveBySevenCurrentMonthDaysMatrix,
+  getHowManyDaysInMonth: () => getHowManyDaysInMonth,
+  getLastDayOfMonth: () => getLastDayOfMonth,
+  getLastXDaysFromPreviousMonth: () => getLastXDaysFromPreviousMonth,
+  getMonthNameByMonthNumber: () => getMonthNameByMonthNumber,
+  getTimeStringFromDay: () => getTimeStringFromDay,
+  getValidationDateStringMetaInfo: () => getValidationDateStringMetaInfo,
+  isLeapYear: () => isLeapYear,
+  isSameDateMoment: () => isSameDateMoment,
+  isValidDayForTheMonth: () => isValidDayForTheMonth,
+  isValidDayForTheMonthDateString: () => isValidDayForTheMonthDateString,
+  subtractMonths: () => subtractMonths,
+  subtractYears: () => subtractYears,
+  sumFromDateValues: () => sumFromDateValues,
+  sumMonths: () => sumMonths,
+  sumValuesToDate: () => sumValuesToDate,
+  sumYears: () => sumYears
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_constants = require("./constants");
+var import_stringHelpers = require("./stringHelpers");
+var import_numberHelpers = require("./numberHelpers");
+const getLastDayOfMonth = (month, year) => new Date(year, month + 1, 0);
+const isValidDayForTheMonth = (month, year, day) => new Date(year, month, day)?.getMonth?.() === month;
+const isValidDayForTheMonthDateString = (dateString) => {
+  if ((0, import_stringHelpers.isIncompleteString)(dateString))
+    return true;
+  const { month } = (0, import_stringHelpers.deconstructValuesFromDateString)(dateString);
+  const monthInt = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(month);
+  if (monthInt === -1)
+    return false;
+  const monthDateMonth = monthInt - 1;
+  return getDayFromDateString(dateString)?.getMonth?.() === monthDateMonth;
+};
+const getValidationDateStringMetaInfo = (dateString, getIsOutOfRangeDay = (day) => false, getIsDisabledDay = (day) => false) => {
+  const metaInfo = {};
+  if (!(0, import_stringHelpers.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;
+};
+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);
+const sumFromDateValues = ({ month, year, day = 1 }, { monthsToSum = 0, yearsToSum = 0, daysToSum = 0 }) => {
+  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 = (date, howManyMore = 1) => {
+  const newDate = new Date(date.getTime());
+  newDate.setFullYear(date.getFullYear() - howManyMore);
+  return newDate;
+};
+const subtractMonths = (date, howManyMore = 1) => {
+  const newDate = new Date(date.getTime());
+  newDate.setMonth(date.getMonth() - howManyMore);
+  return newDate;
+};
+const sumMonths = (date, howManyMore = 1) => {
+  const newDate = new Date(date.getTime());
+  newDate.setMonth(date.getMonth() + howManyMore);
+  return newDate;
+};
+const sumYears = (date, howManyMore = 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) => {
+  const currentMonthDays = getDaysInMonth(month, year).map((day) => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: false,
+    isNextMonthDay: false,
+    isCurrMonthDay: true,
+    isHidden: false,
+    dayBtnRef: (0, import_react.createRef)()
+  }));
+  const firstDayOfTheMonthWeekDay = currentMonthDays?.[0]?.day?.getDay();
+  const previousMonthDaysToPrepend = getLastXDaysFromPreviousMonth(month, year, firstDayOfTheMonthWeekDay).map((day) => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: true,
+    isNextMonthDay: false,
+    isCurrMonthDay: false,
+    isHidden: false,
+    dayBtnRef: (0, import_react.createRef)()
+  }));
+  const lastDayOfTheMonthWeekDay = currentMonthDays?.[currentMonthDays.length - 1]?.day?.getDay();
+  const nextMonthDaysToAppend = getFirstXDaysFromNextMonth(month, year, 6 - lastDayOfTheMonthWeekDay).map((day) => ({
+    day,
+    dayAsString: getDateStringFromDay(day),
+    isPrevMonthDay: false,
+    isNextMonthDay: true,
+    isCurrMonthDay: false,
+    isHidden: false,
+    dayBtnRef: (0, import_react.createRef)()
+  }));
+  return [...previousMonthDaysToPrepend, ...currentMonthDays, ...nextMonthDaysToAppend];
+};
+const getDateValuesFromDate = (day) => ({
+  month: day?.getMonth?.(),
+  day: day?.getDate?.(),
+  year: day?.getFullYear?.()
+});
+const getDateStringFromDay = (day) => {
+  const monthFromDay = (0, import_stringHelpers.prependStringWithPlaceHolders)(`${day.getMonth() + 1}`, 2);
+  const dayFromDay = (0, import_stringHelpers.prependStringWithPlaceHolders)(`${day.getDate()}`, 2);
+  const yearFromDay = (0, import_stringHelpers.prependStringWithPlaceHolders)(`${day.getFullYear()}`, 4);
+  return `${monthFromDay}/${dayFromDay}/${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 = (0, import_stringHelpers.prependStringWithPlaceHolders)(`${twelveHourFormat}`, 2);
+  const minutesFromDay = (0, import_stringHelpers.prependStringWithPlaceHolders)(`${minutesNum}`, 2);
+  return `${hoursFromDay}:${minutesFromDay} ${meridiem}`;
+};
+const getDayFromDateString = (dateString) => {
+  const { month, day, year } = (0, import_stringHelpers.deconstructValuesFromDateString)(dateString);
+  const monthNum = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(month);
+  const dayNum = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(day);
+  const yearNum = (0, import_numberHelpers.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) => import_constants.monthNames[monthNumber];
+const isSameDateMoment = (dateA, dateB) => dateA?.getTime?.() === dateB?.getTime?.();
+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;
+};
+module.exports = __toCommonJS(dateHelpers_exports);
+//# sourceMappingURL=dateHelpers.js.map

package/dist/cjs/date-time-picker/utils/dateHelpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/date-time-picker/utils/dateHelpers.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-lines */\nimport { createRef } from 'react';\nimport { monthNames } from './constants';\nimport { prependStringWithPlaceHolders, deconstructValuesFromDateString, isIncompleteString } from './stringHelpers';\nimport { convertToPositiveNumberIfPossible } from './numberHelpers';\nimport type { DateMonth, metaMonthDayT, internalInputsChangeMetaInfo } from '../index.d';\n\nexport const getLastDayOfMonth = (month: DateMonth, year: number): Date => new Date(year, month + 1, 0);\nexport const isValidDayForTheMonth = (month: DateMonth, year: number, day: number): boolean =>\n  new Date(year, month, day)?.getMonth?.() === month;\nexport const isValidDayForTheMonthDateString = (dateString: string): boolean => {\n  if (isIncompleteString(dateString)) return true;\n  const { month } = deconstructValuesFromDateString(dateString);\n  const monthInt = convertToPositiveNumberIfPossible(month);\n  if (monthInt === -1) return false;\n  const monthDateMonth = (monthInt - 1) as DateMonth;\n  return getDayFromDateString(dateString)?.getMonth?.() === monthDateMonth;\n};\nexport const getValidationDateStringMetaInfo = (\n  dateString: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  getIsOutOfRangeDay = (day: string) => false,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  getIsDisabledDay = (day: string) => false,\n): Partial<internalInputsChangeMetaInfo> => {\n  const metaInfo: Partial<internalInputsChangeMetaInfo> = {};\n  if (!isIncompleteString(dateString)) {\n    metaInfo.isDayPresentInMonth = isValidDayForTheMonthDateString(dateString);\n    if (!metaInfo.isDayPresentInMonth)\n      metaInfo.suggestedErrorMsg = 'The selected day is not part of the selected month';\n    const day = getDayFromDateString(dateString);\n    if (day) {\n      metaInfo.isOutOfRangeDay = getIsOutOfRangeDay(dateString);\n      metaInfo.isDisabledDay = getIsDisabledDay(dateString);\n      if (metaInfo.isOutOfRangeDay || metaInfo.isDisabledDay)\n        metaInfo.suggestedErrorMsg = 'The selected day is not allowed';\n    }\n  }\n  return metaInfo;\n};\n// code adapted from https://github.com/datejs/Datejs/blob/master/src/core.js\nexport const isLeapYear = (year: number): boolean => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n\nexport const getHowManyDaysInMonth = (year: number, month: number): number => {\n  const daysPerMonth = [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n  return daysPerMonth[month];\n};\n\nexport const dateIsLeapYear = (date: Date): boolean => isLeapYear(date.getFullYear());\n\nexport const dateGetDaysInMonth = (date: Date): number => getHowManyDaysInMonth(date.getFullYear(), date.getMonth());\n\nexport const dateAddMonths = (date: Date, value: number): Date => {\n  const copiedDate = new Date(date.getTime());\n  const n = copiedDate.getDate();\n  copiedDate.setDate(1);\n  copiedDate.setMonth(copiedDate.getMonth() + value);\n  copiedDate.setDate(Math.min(n, dateGetDaysInMonth(copiedDate)));\n  return copiedDate;\n};\nexport const dateAddYear = (date: Date, value: number): Date => dateAddMonths(date, value * 12);\n\ninterface DateValuesT {\n  month: DateMonth;\n  year: number;\n  day?: number;\n}\ninterface DateSumValuesT {\n  monthsToSum?: number;\n  yearsToSum?: number;\n  daysToSum?: number;\n}\n// sumFromDateValues supports negative values to \"subtract\"\nexport const sumFromDateValues = (\n  { month, year, day = 1 }: DateValuesT,\n  { monthsToSum = 0, yearsToSum = 0, daysToSum = 0 }: DateSumValuesT,\n): DateValuesT => {\n  let newDate = new Date(year, month, day);\n  if (yearsToSum) newDate = dateAddYear(newDate, yearsToSum);\n\n  if (monthsToSum) newDate = dateAddMonths(newDate, monthsToSum);\n\n  if (daysToSum) newDate.setDate(newDate.getDate() + daysToSum);\n\n  return {\n    month: newDate.getMonth() as DateMonth,\n    day: newDate.getDate(),\n    year: newDate.getFullYear(),\n  };\n};\nexport const sumValuesToDate = (day: Date, sumValues: DateSumValuesT): Date => {\n  const dateAsVals = getDateValuesFromDate(day);\n  const { month, year, day: newD } = sumFromDateValues(dateAsVals, sumValues);\n  return new Date(year, month, newD);\n};\nexport const subtractYears = (date: Date, howManyMore = 1): Date => {\n  const newDate = new Date(date.getTime());\n  newDate.setFullYear(date.getFullYear() - howManyMore);\n  return newDate;\n};\nexport const subtractMonths = (date: Date, howManyMore = 1): Date => {\n  const newDate = new Date(date.getTime());\n  newDate.setMonth(date.getMonth() - howManyMore);\n  return newDate;\n};\nexport const sumMonths = (date: Date, howManyMore = 1): Date => {\n  const newDate = new Date(date.getTime());\n  newDate.setMonth(date.getMonth() + howManyMore);\n  return newDate;\n};\nexport const sumYears = (date: Date, howManyMore = 1): Date => {\n  const newDate = new Date(date.getTime());\n  newDate.setFullYear(date.getFullYear() + howManyMore);\n  return newDate;\n};\n\nexport const getDaysInMonth = (month: number, year: number): Date[] => {\n  const date = new Date(year, month, 1);\n  const days: Date[] = [];\n  while (date.getMonth() === month) {\n    days.push(new Date(date));\n    date.setDate(date.getDate() + 1);\n  }\n  return days;\n};\nexport const getLastXDaysFromPreviousMonth = (month: number, year: number, howMany: number): Date[] => {\n  const date = new Date(year, month, 1);\n  const days: Date[] = [];\n  while (days.length !== howMany) {\n    date.setDate(date.getDate() - 1);\n    days.push(new Date(date));\n  }\n  return days.reverse();\n};\nexport const getFirstXDaysFromNextMonth = (month: number, year: number, howMany: number): Date[] => {\n  const date = sumMonths(new Date(year, month, 1), 1);\n  const days: Date[] = [];\n  while (days.length !== howMany) {\n    days.push(new Date(date));\n    date.setDate(date.getDate() + 1);\n  }\n  return days;\n};\n\nexport const getFiveBySevenCurrentMonthDaysMatrix = (month: number, year: number): metaMonthDayT[] => {\n  const currentMonthDays = getDaysInMonth(month, year).map((day) => ({\n    day,\n    dayAsString: getDateStringFromDay(day),\n    isPrevMonthDay: false,\n    isNextMonthDay: false,\n    isCurrMonthDay: true,\n    isHidden: false,\n    dayBtnRef: createRef<HTMLButtonElement>(),\n  }));\n  const firstDayOfTheMonthWeekDay = currentMonthDays?.[0]?.day?.getDay();\n  const previousMonthDaysToPrepend = getLastXDaysFromPreviousMonth(month, year, firstDayOfTheMonthWeekDay).map(\n    (day) => ({\n      day,\n      dayAsString: getDateStringFromDay(day),\n      isPrevMonthDay: true,\n      isNextMonthDay: false,\n      isCurrMonthDay: false,\n      isHidden: false,\n      dayBtnRef: createRef<HTMLButtonElement>(),\n    }),\n  );\n  const lastDayOfTheMonthWeekDay = currentMonthDays?.[currentMonthDays.length - 1]?.day?.getDay();\n  const nextMonthDaysToAppend = getFirstXDaysFromNextMonth(month, year, 6 - lastDayOfTheMonthWeekDay).map((day) => ({\n    day,\n    dayAsString: getDateStringFromDay(day),\n    isPrevMonthDay: false,\n    isNextMonthDay: true,\n    isCurrMonthDay: false,\n    isHidden: false,\n    dayBtnRef: createRef<HTMLButtonElement>(),\n  }));\n\n  return [...previousMonthDaysToPrepend, ...currentMonthDays, ...nextMonthDaysToAppend];\n};\nexport const getDateValuesFromDate = (day: Date): DateValuesT => ({\n  month: day?.getMonth?.() as DateMonth,\n  day: day?.getDate?.(),\n  year: day?.getFullYear?.(),\n});\nexport const getDateStringFromDay = (day: Date): string => {\n  const monthFromDay = prependStringWithPlaceHolders(`${day.getMonth() + 1}`, 2); // months from 1-12\n  const dayFromDay = prependStringWithPlaceHolders(`${day.getDate()}`, 2);\n  const yearFromDay = prependStringWithPlaceHolders(`${day.getFullYear()}`, 4);\n\n  return `${monthFromDay}/${dayFromDay}/${yearFromDay}`;\n};\nexport const getTimeStringFromDay = (day: Date): string => {\n  const hoursNum = day.getHours();\n  const meridiem = hoursNum > 12 ? 'PM' : 'AM';\n  const twelveHourFormat = hoursNum > 12 ? hoursNum - 12 : hoursNum;\n  const minutesNum = day.getMinutes();\n\n  const hoursFromDay = prependStringWithPlaceHolders(`${twelveHourFormat}`, 2);\n  const minutesFromDay = prependStringWithPlaceHolders(`${minutesNum}`, 2);\n\n  return `${hoursFromDay}:${minutesFromDay} ${meridiem}`;\n};\nexport const getDayFromDateString = (dateString: string): Date | null => {\n  const { month, day, year } = deconstructValuesFromDateString(dateString);\n  const monthNum = convertToPositiveNumberIfPossible(month);\n  const dayNum = convertToPositiveNumberIfPossible(day);\n  const yearNum = convertToPositiveNumberIfPossible(year);\n  if (\n    monthNum !== -1 &&\n    dayNum !== -1 &&\n    yearNum !== -1 &&\n    isValidDayForTheMonth((monthNum - 1) as DateMonth, yearNum, dayNum)\n  )\n    return new Date(yearNum, monthNum - 1, dayNum);\n  return null;\n};\nexport const getMonthNameByMonthNumber = (monthNumber: number): string => monthNames[monthNumber];\nexport const isSameDateMoment = (dateA: Date, dateB: Date): boolean => dateA?.getTime?.() === dateB?.getTime?.();\n\nexport const compareTwoDatesDayEquality = (dayA: Date, dayB: Date): boolean => {\n  const { day: currD, month: currM, year: currY } = getDateValuesFromDate(dayA);\n  const { day: focusD, month: focusM, year: focusY } = getDateValuesFromDate(dayB);\n  return currD === focusD && currM === focusM && currY === focusY;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/date-time-picker/utils/dateTimeHelpers.js

@@ -0,0 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var dateTimeHelpers_exports = {};
+__export(dateTimeHelpers_exports, {
+  getValidationDateTimeStringMetaInfo: () => getValidationDateTimeStringMetaInfo
+});
+var React = __toESM(require("react"));
+var import_dateHelpers = require("./dateHelpers");
+var import_timeHelpers = require("./timeHelpers");
+const getValidationDateTimeStringMetaInfo = (dateString, timeString, validators) => __spreadValues(__spreadValues({}, (0, import_dateHelpers.getValidationDateStringMetaInfo)(dateString, validators.getIsOutOfRangeDay, validators.getIsDisabledDay)), (0, import_timeHelpers.getValidationTimeStringMetaInfo)(timeString, validators.getIsDisabledTime));
+module.exports = __toCommonJS(dateTimeHelpers_exports);
+//# sourceMappingURL=dateTimeHelpers.js.map

package/dist/cjs/date-time-picker/utils/dateTimeHelpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/date-time-picker/utils/dateTimeHelpers.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { getValidationDateStringMetaInfo } from './dateHelpers';\nimport { getValidationTimeStringMetaInfo } from './timeHelpers';\nimport type { internalInputsChangeMetaInfo } from '../index.d';\n\ninterface validatorsT {\n  getIsOutOfRangeDay: (day: string) => boolean;\n  getIsDisabledDay: (day: string) => boolean;\n  getIsDisabledTime: (val: string) => boolean;\n}\nexport const getValidationDateTimeStringMetaInfo = (\n  dateString: string,\n  timeString: string,\n  validators: validatorsT,\n): Partial<internalInputsChangeMetaInfo> => ({\n  ...getValidationDateStringMetaInfo(dateString, validators.getIsOutOfRangeDay, validators.getIsDisabledDay),\n  ...getValidationTimeStringMetaInfo(timeString, validators.getIsDisabledTime),\n});\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,yBAAgD;AAChD,yBAAgD;AAQzC,MAAM,sCAAsC,CACjD,YACA,YACA,eAC2C,kCACxC,wDAAgC,YAAY,WAAW,oBAAoB,WAAW,oBACtF,wDAAgC,YAAY,WAAW;",
+  "names": []
+}

package/dist/cjs/date-time-picker/utils/hooks/useGetDayFromDateString.js

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useGetDayFromDateString_exports = {};
+__export(useGetDayFromDateString_exports, {
+  useGetDayFromDateString: () => useGetDayFromDateString
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ControlledDateTimePickerCTX = require("../../ControlledDateTimePickerCTX");
+var import_dateHelpers = require("../dateHelpers");
+const useGetDayFromDateString = () => {
+  const { dateStringFromProps } = (0, import_react.useContext)(import_ControlledDateTimePickerCTX.ControlledDateTimePickerContext);
+  return (0, import_react.useMemo)(() => (0, import_dateHelpers.getDayFromDateString)(dateStringFromProps), [dateStringFromProps]);
+};
+module.exports = __toCommonJS(useGetDayFromDateString_exports);
+//# sourceMappingURL=useGetDayFromDateString.js.map

package/dist/cjs/date-time-picker/utils/hooks/useGetDayFromDateString.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/date-time-picker/utils/hooks/useGetDayFromDateString.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useContext, useMemo } from 'react';\nimport { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX';\nimport { getDayFromDateString } from '../dateHelpers';\n\nexport const useGetDayFromDateString = (): Date => {\n  const { dateStringFromProps } = useContext(ControlledDateTimePickerContext);\n  return useMemo(() => getDayFromDateString(dateStringFromProps), [dateStringFromProps]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAoC;AACpC,yCAAgD;AAChD,yBAAqC;AAE9B,MAAM,0BAA0B,MAAY;AACjD,QAAM,EAAE,wBAAwB,6BAAW;AAC3C,SAAO,0BAAQ,MAAM,6CAAqB,sBAAsB,CAAC;AAAA;",
+  "names": []
+}

package/dist/cjs/date-time-picker/utils/hooks/useGetMonthYearFromDateStringOrEmptyStartingMonth.js

@@ -0,0 +1,53 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useGetMonthYearFromDateStringOrEmptyStartingMonth_exports = {};
+__export(useGetMonthYearFromDateStringOrEmptyStartingMonth_exports, {
+  useGetMonthYearFromDateStringOrEmptyStartingMonth: () => useGetMonthYearFromDateStringOrEmptyStartingMonth
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ControlledDateTimePickerCTX = require("../../ControlledDateTimePickerCTX");
+var import_stringHelpers = require("../stringHelpers");
+const useGetMonthYearFromDateStringOrEmptyStartingMonth = () => {
+  const {
+    dateStringFromProps,
+    props: { emptyPickerStartingMonth }
+  } = (0, import_react.useContext)(import_ControlledDateTimePickerCTX.ControlledDateTimePickerContext);
+  return (0, import_react.useMemo)(() => {
+    const emptyPickerStartingMonthDefault = `${new Date().getMonth() + 1}/__/${new Date().getFullYear()}`;
+    const { month: stringMonthVal, year: stringYearVal } = (0, import_stringHelpers.deconstructValuesFromDateString)(dateStringFromProps);
+    const { month: emptyStringSplitMonth, year: emptyStringSplitYear } = (0, import_stringHelpers.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;
+    const year = stringYearVal === "" ? userEmptyStringYear : Number.parseInt(stringYearVal, 10);
+    return { year, month };
+  }, [dateStringFromProps, emptyPickerStartingMonth]);
+};
+module.exports = __toCommonJS(useGetMonthYearFromDateStringOrEmptyStartingMonth_exports);
+//# sourceMappingURL=useGetMonthYearFromDateStringOrEmptyStartingMonth.js.map

package/dist/cjs/date-time-picker/utils/hooks/useGetMonthYearFromDateStringOrEmptyStartingMonth.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/date-time-picker/utils/hooks/useGetMonthYearFromDateStringOrEmptyStartingMonth.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useContext, useMemo } from 'react';\nimport { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX';\nimport { deconstructValuesFromDateString } from '../stringHelpers';\nimport type { DateMonth } from '../../index.d';\n\nexport const useGetMonthYearFromDateStringOrEmptyStartingMonth = (): {\n  year: number;\n  month: DateMonth;\n} => {\n  const {\n    dateStringFromProps,\n    props: { emptyPickerStartingMonth },\n  } = useContext(ControlledDateTimePickerContext);\n\n  return useMemo(() => {\n    const emptyPickerStartingMonthDefault = `${new Date().getMonth() + 1}/__/${new Date().getFullYear()}`;\n    const { month: stringMonthVal, year: stringYearVal } = deconstructValuesFromDateString(dateStringFromProps);\n\n    const { month: emptyStringSplitMonth, year: emptyStringSplitYear } = deconstructValuesFromDateString(\n      emptyPickerStartingMonth || emptyPickerStartingMonthDefault,\n    );\n    const userEmptyStringMonth = Number.parseInt(emptyStringSplitMonth, 10);\n    const userEmptyStringYear = Number.parseInt(emptyStringSplitYear, 10);\n\n    const month: DateMonth =\n      stringMonthVal === '' || stringMonthVal.length !== 2\n        ? ((userEmptyStringMonth - 1) as DateMonth)\n        : ((Number.parseInt(stringMonthVal, 10) - 1) as DateMonth); // month is 0~11 in javascript Date...\n\n    const year = stringYearVal === '' ? userEmptyStringYear : Number.parseInt(stringYearVal, 10);\n\n    return { year, month };\n  }, [dateStringFromProps, emptyPickerStartingMonth]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAoC;AACpC,yCAAgD;AAChD,2BAAgD;AAGzC,MAAM,oDAAoD,MAG5D;AACH,QAAM;AAAA,IACJ;AAAA,IACA,OAAO,EAAE;AAAA,MACP,6BAAW;AAEf,SAAO,0BAAQ,MAAM;AACnB,UAAM,kCAAkC,GAAG,IAAI,OAAO,aAAa,QAAQ,IAAI,OAAO;AACtF,UAAM,EAAE,OAAO,gBAAgB,MAAM,kBAAkB,0DAAgC;AAEvF,UAAM,EAAE,OAAO,uBAAuB,MAAM,yBAAyB,0DACnE,4BAA4B;AAE9B,UAAM,uBAAuB,OAAO,SAAS,uBAAuB;AACpE,UAAM,sBAAsB,OAAO,SAAS,sBAAsB;AAElE,UAAM,QACJ,mBAAmB,MAAM,eAAe,WAAW,IAC7C,uBAAuB,IACvB,OAAO,SAAS,gBAAgB,MAAM;AAE9C,UAAM,OAAO,kBAAkB,KAAK,sBAAsB,OAAO,SAAS,eAAe;AAEzF,WAAO,EAAE,MAAM;AAAA,KACd,CAAC,qBAAqB;AAAA;",
+  "names": []
+}

package/dist/cjs/date-time-picker/utils/hooks/useGetStartingFocusedDay.js

@@ -0,0 +1,96 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useGetStartingFocusedDay_exports = {};
+__export(useGetStartingFocusedDay_exports, {
+  useGetStartingFocusedDay: () => useGetStartingFocusedDay
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ControlledDateTimePickerCTX = require("../../ControlledDateTimePickerCTX");
+var import_stringHelpers = require("../stringHelpers");
+var import_numberHelpers = require("../numberHelpers");
+var import_dateHelpers = require("../dateHelpers");
+var import_useGetDayFromDateString = require("./useGetDayFromDateString");
+const empty = {
+  startFocusedYear: null,
+  startFocusedDay: null,
+  startFocusedMonth: null,
+  startFocusedDate: null
+};
+const useGetStartingFocusedDay = () => {
+  const {
+    props: { onCalendarOpenFocusedDay }
+  } = (0, import_react.useContext)(import_ControlledDateTimePickerCTX.ControlledDateTimePickerContext);
+  const dayFromInputValues = (0, import_useGetDayFromDateString.useGetDayFromDateString)();
+  return (0, import_react.useMemo)(() => {
+    const {
+      month: inputValuesSplitMonth,
+      day: inputValuesSplitDay,
+      year: inputValuesDaySplitYear
+    } = (0, import_dateHelpers.getDateValuesFromDate)(dayFromInputValues);
+    let startFocusedMonth = null;
+    let startFocusedDay = null;
+    let startFocusedYear = null;
+    let startFocusedDate = null;
+    const isInputFilledAndValid = inputValuesSplitMonth && inputValuesSplitDay && inputValuesDaySplitYear && (0, import_dateHelpers.isValidDayForTheMonth)(inputValuesSplitMonth, inputValuesDaySplitYear, inputValuesSplitDay);
+    const isOnCalendarOpenFocusedDayEmpty = !onCalendarOpenFocusedDay;
+    const shouldFillWithOnCalendarOpenFocusedDay = !isInputFilledAndValid && !isOnCalendarOpenFocusedDayEmpty;
+    if (isInputFilledAndValid) {
+      startFocusedMonth = inputValuesSplitMonth;
+      startFocusedDay = inputValuesSplitDay;
+      startFocusedYear = inputValuesDaySplitYear;
+      startFocusedDate = dayFromInputValues;
+    }
+    if (!isInputFilledAndValid && isOnCalendarOpenFocusedDayEmpty)
+      return empty;
+    if (shouldFillWithOnCalendarOpenFocusedDay) {
+      const {
+        month: focusedDaySplitMonth,
+        day: focusedDaySplitDay,
+        year: focusedDaySplitYear
+      } = (0, import_stringHelpers.deconstructValuesFromDateString)(onCalendarOpenFocusedDay);
+      const monthAsInt = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(focusedDaySplitMonth);
+      const dayAsInt = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(focusedDaySplitDay);
+      const yearAsInt = (0, import_numberHelpers.convertToPositiveNumberIfPossible)(focusedDaySplitYear);
+      if (monthAsInt !== -1 && dayAsInt !== -1 && yearAsInt !== -1 && (0, import_dateHelpers.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]);
+};
+module.exports = __toCommonJS(useGetStartingFocusedDay_exports);
+//# sourceMappingURL=useGetStartingFocusedDay.js.map

package/dist/cjs/date-time-picker/utils/hooks/useGetStartingFocusedDay.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/date-time-picker/utils/hooks/useGetStartingFocusedDay.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-statements */\n/* eslint-disable complexity */\nimport { useContext, useMemo } from 'react';\nimport { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX';\nimport { deconstructValuesFromDateString } from '../stringHelpers';\nimport { convertToPositiveNumberIfPossible } from '../numberHelpers';\nimport { getDateValuesFromDate, isValidDayForTheMonth } from '../dateHelpers';\nimport { useGetDayFromDateString } from './useGetDayFromDateString';\nimport type { DateMonth } from '../../index.d';\n\ninterface useGetStartingFocusedDayRT {\n  startFocusedYear: number;\n  startFocusedDay: number;\n  startFocusedMonth: number;\n  startFocusedDate: Date;\n}\nconst empty: useGetStartingFocusedDayRT = {\n  startFocusedYear: null,\n  startFocusedDay: null,\n  startFocusedMonth: null,\n  startFocusedDate: null,\n};\nexport const useGetStartingFocusedDay = (): useGetStartingFocusedDayRT => {\n  const {\n    props: { onCalendarOpenFocusedDay },\n  } = useContext(ControlledDateTimePickerContext);\n  const dayFromInputValues = useGetDayFromDateString();\n\n  return useMemo(() => {\n    const {\n      month: inputValuesSplitMonth,\n      day: inputValuesSplitDay,\n      year: inputValuesDaySplitYear,\n    } = getDateValuesFromDate(dayFromInputValues);\n\n    let startFocusedMonth = null;\n    let startFocusedDay = null;\n    let startFocusedYear = null;\n    let startFocusedDate = null;\n    const isInputFilledAndValid =\n      inputValuesSplitMonth &&\n      inputValuesSplitDay &&\n      inputValuesDaySplitYear &&\n      isValidDayForTheMonth(inputValuesSplitMonth, inputValuesDaySplitYear, inputValuesSplitDay);\n    const isOnCalendarOpenFocusedDayEmpty = !onCalendarOpenFocusedDay;\n    const shouldFillWithOnCalendarOpenFocusedDay = !isInputFilledAndValid && !isOnCalendarOpenFocusedDayEmpty;\n    // if input was filled start focus is the filled value (if it's valid day for the month)\n    if (isInputFilledAndValid) {\n      startFocusedMonth = inputValuesSplitMonth;\n      startFocusedDay = inputValuesSplitDay;\n      startFocusedYear = inputValuesDaySplitYear;\n      startFocusedDate = dayFromInputValues;\n      // if input was not filled (or filled invalid) and there is no onCalendarOpenFocusedDay start focus is not a day\n    }\n\n    // if input was not filled and there is onCalendarOpenFocusedDay start focus is onCalendarOpenFocusedDay day\n    if (!isInputFilledAndValid && isOnCalendarOpenFocusedDayEmpty) return empty;\n\n    if (shouldFillWithOnCalendarOpenFocusedDay) {\n      const {\n        month: focusedDaySplitMonth,\n        day: focusedDaySplitDay,\n        year: focusedDaySplitYear,\n      } = deconstructValuesFromDateString(onCalendarOpenFocusedDay);\n      const monthAsInt = convertToPositiveNumberIfPossible(focusedDaySplitMonth);\n      const dayAsInt = convertToPositiveNumberIfPossible(focusedDaySplitDay);\n      const yearAsInt = convertToPositiveNumberIfPossible(focusedDaySplitYear);\n      // if this condition is false, return will be the same as return empty\n      // because startFocusedMonth/Day/Year/Date will be === null\n      // which is the expected result\n      if (\n        monthAsInt !== -1 &&\n        dayAsInt !== -1 &&\n        yearAsInt !== -1 &&\n        isValidDayForTheMonth((monthAsInt - 1) as DateMonth, yearAsInt, dayAsInt)\n      ) {\n        startFocusedMonth = monthAsInt;\n        startFocusedDay = dayAsInt;\n        startFocusedYear = yearAsInt;\n        startFocusedDate = new Date(yearAsInt, monthAsInt - 1, dayAsInt);\n      }\n    }\n    return {\n      startFocusedYear,\n      startFocusedDay,\n      startFocusedMonth,\n      startFocusedDate,\n    };\n  }, [dayFromInputValues, onCalendarOpenFocusedDay]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,mBAAoC;AACpC,yCAAgD;AAChD,2BAAgD;AAChD,2BAAkD;AAClD,yBAA6D;AAC7D,qCAAwC;AASxC,MAAM,QAAoC;AAAA,EACxC,kBAAkB;AAAA,EAClB,iBAAiB;AAAA,EACjB,mBAAmB;AAAA,EACnB,kBAAkB;AAAA;AAEb,MAAM,2BAA2B,MAAkC;AACxE,QAAM;AAAA,IACJ,OAAO,EAAE;AAAA,MACP,6BAAW;AACf,QAAM,qBAAqB;AAE3B,SAAO,0BAAQ,MAAM;AACnB,UAAM;AAAA,MACJ,OAAO;AAAA,MACP,KAAK;AAAA,MACL,MAAM;AAAA,QACJ,8CAAsB;AAE1B,QAAI,oBAAoB;AACxB,QAAI,kBAAkB;AACtB,QAAI,mBAAmB;AACvB,QAAI,mBAAmB;AACvB,UAAM,wBACJ,yBACA,uBACA,2BACA,8CAAsB,uBAAuB,yBAAyB;AACxE,UAAM,kCAAkC,CAAC;AACzC,UAAM,yCAAyC,CAAC,yBAAyB,CAAC;AAE1E,QAAI,uBAAuB;AACzB,0BAAoB;AACpB,wBAAkB;AAClB,yBAAmB;AACnB,yBAAmB;AAAA;AAKrB,QAAI,CAAC,yBAAyB;AAAiC,aAAO;AAEtE,QAAI,wCAAwC;AAC1C,YAAM;AAAA,QACJ,OAAO;AAAA,QACP,KAAK;AAAA,QACL,MAAM;AAAA,UACJ,0DAAgC;AACpC,YAAM,aAAa,4DAAkC;AACrD,YAAM,WAAW,4DAAkC;AACnD,YAAM,YAAY,4DAAkC;AAIpD,UACE,eAAe,MACf,aAAa,MACb,cAAc,MACd,8CAAuB,aAAa,GAAiB,WAAW,WAChE;AACA,4BAAoB;AACpB,0BAAkB;AAClB,2BAAmB;AACnB,2BAAmB,IAAI,KAAK,WAAW,aAAa,GAAG;AAAA;AAAA;AAG3D,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA,KAED,CAAC,oBAAoB;AAAA;",
+  "names": []
+}

package/dist/cjs/date-time-picker/utils/hooks/useOnClickOutside.js

@@ -0,0 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var useOnClickOutside_exports = {};
+__export(useOnClickOutside_exports, {
+  useOnClickOutside: () => useOnClickOutside
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useOnClickOutside = (ref, handler) => {
+  (0, import_react.useEffect)(() => {
+    const listener = (event) => {
+      if (!ref || ref?.contains?.(event.target)) {
+        return;
+      }
+      handler(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref, handler]);
+};
+module.exports = __toCommonJS(useOnClickOutside_exports);
+//# sourceMappingURL=useOnClickOutside.js.map

package/dist/cjs/date-time-picker/utils/hooks/useOnClickOutside.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/date-time-picker/utils/hooks/useOnClickOutside.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useEffect } from 'react';\n\nexport const useOnClickOutside = (ref, handler): void => {\n  useEffect(() => {\n    const listener = (event) => {\n      // Do nothing if clicking ref's element or descendent elements\n      if (!ref || ref?.contains?.(event.target)) {\n        return;\n      }\n      handler(event);\n    };\n    document.addEventListener('mousedown', listener);\n    document.addEventListener('touchstart', listener);\n    return () => {\n      document.removeEventListener('mousedown', listener);\n      document.removeEventListener('touchstart', listener);\n    };\n  }, [ref, handler]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA0B;AAEnB,MAAM,oBAAoB,CAAC,KAAK,YAAkB;AACvD,8BAAU,MAAM;AACd,UAAM,WAAW,CAAC,UAAU;AAE1B,UAAI,CAAC,OAAO,KAAK,WAAW,MAAM,SAAS;AACzC;AAAA;AAEF,cAAQ;AAAA;AAEV,aAAS,iBAAiB,aAAa;AACvC,aAAS,iBAAiB,cAAc;AACxC,WAAO,MAAM;AACX,eAAS,oBAAoB,aAAa;AAC1C,eAAS,oBAAoB,cAAc;AAAA;AAAA,KAE5C,CAAC,KAAK;AAAA;",
+  "names": []
+}