@elliemae/ds-controlled-form 1.61.0 → 2.0.0-alpha.12

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

@@ -4,36 +4,34 @@ import { deconstructValuesFromDateString } from '../stringHelpers.js';
 import { convertToPositiveNumberIfPossible } from '../numberHelpers.js';
 import { getDateValuesFromDate, isValidDayForTheMonth } from '../dateHelpers.js';
 import { useGetDayFromDateString } from './useGetDayFromDateString.js';
-import '../../ControlledDateTimePickerTypes.js';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import '../constants.js';
-import '@babel/runtime/helpers/esm/toConsumableArray';
 
 /* eslint-disable max-statements */
-var empty = {
+const empty = {
   startFocusedYear: null,
   startFocusedDay: null,
   startFocusedMonth: null,
   startFocusedDate: null
 };
-var useGetStartingFocusedDay = function useGetStartingFocusedDay() {
-  var _useContext = useContext(ControlledDateTimePickerContext),
-      onCalendarOpenFocusedDay = _useContext.props.onCalendarOpenFocusedDay;
-
-  var dayFromInputValues = useGetDayFromDateString();
-  return useMemo(function () {
-    var _getDateValuesFromDat = getDateValuesFromDate(dayFromInputValues),
-        inputValuesSplitMonth = _getDateValuesFromDat.month,
-        inputValuesSplitDay = _getDateValuesFromDat.day,
-        inputValuesDaySplitYear = _getDateValuesFromDat.year;
-
-    var startFocusedMonth = null;
-    var startFocusedDay = null;
-    var startFocusedYear = null;
-    var startFocusedDate = null;
-    var isInputFilledAndValid = inputValuesSplitMonth && inputValuesSplitDay && inputValuesDaySplitYear && isValidDayForTheMonth(inputValuesSplitMonth, inputValuesDaySplitYear, inputValuesSplitDay);
-    var isOnCalendarOpenFocusedDayEmpty = !onCalendarOpenFocusedDay;
-    var shouldFillWithOnCalendarOpenFocusedDay = !isInputFilledAndValid && !isOnCalendarOpenFocusedDayEmpty; // if input was filled start focus is the filled value (if it's valid day for the month)
+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;
@@ -46,14 +44,14 @@ var useGetStartingFocusedDay = function useGetStartingFocusedDay() {
     if (!isInputFilledAndValid && isOnCalendarOpenFocusedDayEmpty) return empty;
 
     if (shouldFillWithOnCalendarOpenFocusedDay) {
-      var _deconstructValuesFro = deconstructValuesFromDateString(onCalendarOpenFocusedDay),
-          focusedDaySplitMonth = _deconstructValuesFro.month,
-          focusedDaySplitDay = _deconstructValuesFro.day,
-          focusedDaySplitYear = _deconstructValuesFro.year;
-
-      var monthAsInt = convertToPositiveNumberIfPossible(focusedDaySplitMonth);
-      var dayAsInt = convertToPositiveNumberIfPossible(focusedDaySplitDay);
-      var yearAsInt = convertToPositiveNumberIfPossible(focusedDaySplitYear); // if this condition is false, return will be the same as return empty
+      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
 
@@ -66,13 +64,12 @@ var useGetStartingFocusedDay = function useGetStartingFocusedDay() {
     }
 
     return {
-      startFocusedYear: startFocusedYear,
-      startFocusedDay: startFocusedDay,
-      startFocusedMonth: startFocusedMonth,
-      startFocusedDate: startFocusedDate
+      startFocusedYear,
+      startFocusedDay,
+      startFocusedMonth,
+      startFocusedDate
     };
   }, [dayFromInputValues, onCalendarOpenFocusedDay]);
 };
 
 export { useGetStartingFocusedDay };
-//# sourceMappingURL=useGetStartingFocusedDay.js.map

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

@@ -1,8 +1,8 @@
 import { useEffect } from 'react';
 
-var useOnClickOutside = function useOnClickOutside(ref, handler) {
-  useEffect(function () {
-    var listener = function listener(event) {
+const useOnClickOutside = (ref, handler) => {
+  useEffect(() => {
+    const listener = event => {
       var _ref$contains;
 
       // Do nothing if clicking ref's element or descendent elements
@@ -15,7 +15,7 @@ var useOnClickOutside = function useOnClickOutside(ref, handler) {
 
     document.addEventListener('mousedown', listener);
     document.addEventListener('touchstart', listener);
-    return function () {
+    return () => {
       document.removeEventListener('mousedown', listener);
       document.removeEventListener('touchstart', listener);
     };
@@ -23,4 +23,3 @@ var useOnClickOutside = function useOnClickOutside(ref, handler) {
 };
 
 export { useOnClickOutside };
-//# sourceMappingURL=useOnClickOutside.js.map

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

@@ -1,8 +1,7 @@
-var convertToPositiveNumberIfPossible = function convertToPositiveNumberIfPossible(numberString) {
-  var convertedNum = Number.parseInt(numberString, 10);
+const convertToPositiveNumberIfPossible = numberString => {
+  const convertedNum = Number.parseInt(numberString, 10);
   if (Number.isNaN(convertedNum)) return -1;
   return convertedNum;
 };
 
 export { convertToPositiveNumberIfPossible };
-//# sourceMappingURL=numberHelpers.js.map

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

@@ -1,72 +1,53 @@
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+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 */
 
-var prependStringWithPlaceHolders = function prependStringWithPlaceHolders(val, finalLength) {
-  var placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
+const prependStringWithPlaceHolders = function (val, finalLength) {
+  let placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
   if (val.length === finalLength) return val;
-  var stringAsAnArray = val.split('').reverse();
-  return new Array(finalLength).fill(placeholder).map(function (_c, i) {
-    return stringAsAnArray[i] ? stringAsAnArray[i] : placeholder;
-  }).reverse().join('');
+  const stringAsAnArray = val.split('').reverse();
+  return new Array(finalLength).fill(placeholder).map((_c, i) => stringAsAnArray[i] ? stringAsAnArray[i] : placeholder).reverse().join('');
 };
-var fillStringWithPlaceHolders = function fillStringWithPlaceHolders(val, finalLength) {
-  var placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '_';
+const fillStringWithPlaceHolders = function (val, finalLength) {
+  let placeholder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '_';
   if (val.length === finalLength) return val;
-  var stringAsAnArray = val.split('');
-  return new Array(finalLength).fill(placeholder).map(function (_c, i) {
-    return stringAsAnArray[i] ? stringAsAnArray[i] : placeholder;
-  }).join('');
+  const stringAsAnArray = val.split('');
+  return new Array(finalLength).fill(placeholder).map((_c, i) => stringAsAnArray[i] ? stringAsAnArray[i] : placeholder).join('');
 };
-var getFormattedDateString = function getFormattedDateString(_ref) {
-  var month = _ref.month,
-      day = _ref.day,
-      year = _ref.year;
-  var finalMonth = fillStringWithPlaceHolders(month, 2);
-  var finalDay = fillStringWithPlaceHolders(day, 2);
-  var finalYear = fillStringWithPlaceHolders(year, 4);
+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);
 };
-var dateTimeToDate = function dateTimeToDate(dateTime) {
+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];
 };
-var deconstructValuesFromDateString = function deconstructValuesFromDateString(dateString) {
-  var _dateString$split = dateString === null || dateString === void 0 ? void 0 : dateString.split('/'),
-      _dateString$split2 = _slicedToArray(_dateString$split, 3),
-      _dateString$split2$ = _dateString$split2[0],
-      dirtyMonth = _dateString$split2$ === void 0 ? '' : _dateString$split2$,
-      _dateString$split2$2 = _dateString$split2[1],
-      dirtyDay = _dateString$split2$2 === void 0 ? '' : _dateString$split2$2,
-      _dateString$split2$3 = _dateString$split2[2],
-      dirtyYear = _dateString$split2$3 === void 0 ? '' : _dateString$split2$3;
-
-  var replaceAllRegexp = /_/g;
+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, '')
   };
 };
-var deconstructValuesFromTimeString = function deconstructValuesFromTimeString(timeString) {
-  var _timeString$split = timeString === null || timeString === void 0 ? void 0 : timeString.split(':'),
-      _timeString$split2 = _slicedToArray(_timeString$split, 2),
-      _timeString$split2$ = _timeString$split2[0],
-      dirtyHour = _timeString$split2$ === void 0 ? '' : _timeString$split2$,
-      _timeString$split2$2 = _timeString$split2[1],
-      dirtyMintuesAndMeridiem = _timeString$split2$2 === void 0 ? '' : _timeString$split2$2;
-
-  var _dirtyMintuesAndMerid = dirtyMintuesAndMeridiem === null || dirtyMintuesAndMeridiem === void 0 ? void 0 : dirtyMintuesAndMeridiem.split(' '),
-      _dirtyMintuesAndMerid2 = _slicedToArray(_dirtyMintuesAndMerid, 2),
-      _dirtyMintuesAndMerid3 = _dirtyMintuesAndMerid2[0],
-      dirtyMinutes = _dirtyMintuesAndMerid3 === void 0 ? '' : _dirtyMintuesAndMerid3,
-      _dirtyMintuesAndMerid4 = _dirtyMintuesAndMerid2[1],
-      dirtyMeridiem = _dirtyMintuesAndMerid4 === void 0 ? '' : _dirtyMintuesAndMerid4;
-
-  var replaceAllRegexp = /_/g;
+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, ''),
@@ -74,63 +55,51 @@ var deconstructValuesFromTimeString = function deconstructValuesFromTimeString(t
   };
 }; // https://regex101.com/r/U5r5lh/1/
 
-var dateRegExp = /^[0-9_][0-9_]\/[0-9_][0-9_]\/[0-9_]{4}$/;
-var isValidDateString = function isValidDateString(testString) {
+const dateRegExp = /^[0-9_][0-9_]\/[0-9_][0-9_]\/[0-9_]{4}$/;
+const isValidDateString = testString => {
   if (testString === '') return true;
-  var isValidDateRegexp = dateRegExp.test(testString);
+  const isValidDateRegexp = dateRegExp.test(testString);
   if (!isValidDateRegexp) return false;
-
-  var _deconstructValuesFro = deconstructValuesFromDateString(testString),
-      month = _deconstructValuesFro.month,
-      day = _deconstructValuesFro.day,
-      year = _deconstructValuesFro.year;
-
+  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;
 };
-var getFormattedTimeString = function getFormattedTimeString(_ref2) {
-  var hours = _ref2.hours,
-      minutes = _ref2.minutes,
-      meridiem = _ref2.meridiem;
-  var finalHour = fillStringWithPlaceHolders(hours, 2);
-  var finalMinutes = fillStringWithPlaceHolders(minutes, 2); // const finalSeconds = fillStringWithPlaceHolders(seconds, 2); // <-- seconds format
-
-  var finalMeridiem = fillStringWithPlaceHolders(meridiem, 2); // return `${finalHour}:${finalMinutes}:${finalSeconds} ${finalMeridiem}`;// <-- seconds format
+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);
 };
-var dateTimeToTime = function dateTimeToTime(dateTime) {
-  var _dateTime$split4;
-
-  var _dateTime$split2 = dateTime === null || dateTime === void 0 ? void 0 : (_dateTime$split4 = dateTime.split) === null || _dateTime$split4 === void 0 ? void 0 : _dateTime$split4.call(dateTime, ' '),
-      _dateTime$split3 = _slicedToArray(_dateTime$split2, 3);
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _dateTime$split3[0];
-      var _dateTime$split3$ = _dateTime$split3[1],
-      timeNumbers = _dateTime$split3$ === void 0 ? '__:__' : _dateTime$split3$,
-      _dateTime$split3$2 = _dateTime$split3[2],
-      timeMeridiem = _dateTime$split3$2 === void 0 ? '__' : _dateTime$split3$2;
+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);
 };
-var deconstructTimeValues = function deconstructTimeValues(timeString) {
-  var _timeString$split5, _dirtyTimes$split3;
-
-  var _timeString$split3 = timeString === null || timeString === void 0 ? void 0 : (_timeString$split5 = timeString.split) === null || _timeString$split5 === void 0 ? void 0 : _timeString$split5.call(timeString, ' '),
-      _timeString$split4 = _slicedToArray(_timeString$split3, 2),
-      dirtyTimes = _timeString$split4[0],
-      dirtyMeridiem = _timeString$split4[1]; // <--['__:__','__']
+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, ' '); // <--['__:__','__']
 
-  var _dirtyTimes$split = (_dirtyTimes$split3 = dirtyTimes.split) === null || _dirtyTimes$split3 === void 0 ? void 0 : _dirtyTimes$split3.call(dirtyTimes, ':'),
-      _dirtyTimes$split2 = _slicedToArray(_dirtyTimes$split, 2),
-      dirtyHours = _dirtyTimes$split2[0],
-      dirtyMinutes = _dirtyTimes$split2[1]; // <--['__','__']
+  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
 
-  var regex = /_/g; // Note the 'g' flag, which matches all occurrences of the expression
-
-  var newValues = {
+  const newValues = {
     hours: (dirtyHours || '').replace(regex, ''),
     minutes: (dirtyMinutes || '').replace(regex, ''),
     // seconds: (dirtySeconds||"").replace(regex, ''),
@@ -139,44 +108,36 @@ var deconstructTimeValues = function deconstructTimeValues(timeString) {
   return newValues;
 }; // https://regex101.com/r/jeBmNT/1
 
-var timeRegExp = /^[0-9_][0-9_]:[0-9_][0-9_]\s[aApP_][mM_]$/;
-var isValidTimeString = function isValidTimeString(testString) {
+const timeRegExp = /^[0-9_][0-9_]:[0-9_][0-9_]\s[aApP_][mM_]$/;
+const isValidTimeString = testString => {
   if (testString === '') return true;
-  var isValidTimeRegexp = timeRegExp.test(testString);
+  const isValidTimeRegexp = timeRegExp.test(testString);
   if (!isValidTimeRegexp) return false;
-
-  var _deconstructTimeValue = deconstructTimeValues(testString),
-      hours = _deconstructTimeValue.hours,
-      minutes = _deconstructTimeValue.minutes;
-
+  const {
+    hours,
+    minutes
+  } = deconstructTimeValues(testString);
   if (Number.parseInt(hours, 10) > 12 || Number.parseInt(minutes, 10) > 60) return false;
   return true;
 };
-var isIncompleteString = function isIncompleteString(testString) {
-  var placeholder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_';
+const isIncompleteString = function (testString) {
+  let placeholder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '_';
   return testString === '' || testString.includes(placeholder);
 };
-var isEmptyDateStringMask = function isEmptyDateStringMask(testString) {
-  return testString === '__/__/____';
-};
-var isEmptyTimeStringMask = function isEmptyTimeStringMask(testString) {
-  return testString === '__:__ __';
-};
-var isEmptyDateTimeStringMask = function isEmptyDateTimeStringMask(testString) {
-  return testString === '__/__/____ __:__ __';
-};
-var getAriaDayFromDateString = function getAriaDayFromDateString(dateString) {
-  var _deconstructValuesFro2 = deconstructValuesFromDateString(dateString),
-      monthString = _deconstructValuesFro2.month,
-      dayString = _deconstructValuesFro2.day,
-      yearString = _deconstructValuesFro2.year;
-
-  var monthNum = convertToPositiveNumberIfPossible(monthString);
-  var dayNum = convertToPositiveNumberIfPossible(dayString);
-  var yearNum = convertToPositiveNumberIfPossible(yearString);
+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 };
-//# sourceMappingURL=stringHelpers.js.map

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

@@ -1,13 +1,8 @@
 import { isIncompleteString } from './stringHelpers.js';
-import '@babel/runtime/helpers/esm/slicedToArray';
-import './constants.js';
-import './numberHelpers.js';
 
-var getValidationTimeStringMetaInfo = function getValidationTimeStringMetaInfo(timeString) {
-  var getIsDisabledTime = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (timeS) {
-    return false;
-  };
-  var metaInfo = {};
+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);
@@ -18,4 +13,3 @@ var getValidationTimeStringMetaInfo = function getValidationTimeStringMetaInfo(t
 };
 
 export { getValidationTimeStringMetaInfo };
-//# sourceMappingURL=timeHelpers.js.map

package/esm/controlled-toggle/ControlledToggle.js

@@ -1,63 +1,60 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
-import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+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 _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
 import { uid } from 'uid';
 import { describe } from 'react-desc';
 import { propTypes } from './propTypes.js';
 import { StyledContainer, StyledInput, StyledLabel, StyledVisibleContent, StyledCircle, StyledText, SetLabelWidth } from './styles.js';
 import { defaultProps } from './defaultProps.js';
 import { addTooltipOnReadOnly } from './utils/addTooltipOnReadOnly.js';
-import 'styled-components';
-import './utils/styleHelpers.js';
-import '@elliemae/ds-tooltip';
+import { jsxs, jsx } from 'react/jsx-runtime';
 
-var DSControlledToggle = function DSControlledToggle(_ref) {
-  var labelOn = _ref.labelOn,
-      labelOff = _ref.labelOff,
-      name = _ref.name,
-      value = _ref.value,
-      checked = _ref.checked,
-      onChange = _ref.onChange,
-      size = _ref.size,
-      readOnly = _ref.readOnly,
-      active = _ref.active,
-      disabled = _ref.disabled,
-      containerProps = _ref.containerProps,
-      id = _ref.id;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-  var _useState = useState(false),
-      _useState2 = _slicedToArray(_useState, 2),
-      isLongerTextRendering = _useState2[0],
-      setIsLongerTextRendering = _useState2[1];
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-  var _useState3 = useState(0),
-      _useState4 = _slicedToArray(_useState3, 2),
-      width = _useState4[0],
-      setWidth = _useState4[1];
-
-  var labelTextRef = useRef(null);
-  var widthTextRef = useRef(null);
-  var longerText = useMemo(function () {
-    return labelOn.length > labelOff.length ? labelOn : labelOff;
-  }, [labelOff, labelOn]);
-  var instanceUID = useMemo(function () {
-    return uid(5);
-  }, []);
-  useEffect(function () {
+const DSControlledToggle = _ref => {
+  let {
+    labelOn,
+    labelOff,
+    name,
+    value,
+    checked,
+    onChange,
+    size,
+    readOnly,
+    active,
+    disabled,
+    containerProps,
+    id
+  } = _ref;
+  const [isLongerTextRendering, setIsLongerTextRendering] = useState(false);
+  const [width, setWidth] = useState(0);
+  const labelTextRef = useRef(null);
+  const widthTextRef = useRef(null);
+  const longerText = useMemo(() => labelOn.length > labelOff.length ? labelOn : labelOff, [labelOff, labelOn]);
+  const instanceUID = useMemo(() => uid(5), []);
+  useEffect(() => {
     if (labelTextRef.current) {
       setIsLongerTextRendering(labelTextRef.current.innerText === longerText);
     }
   }, [labelTextRef, longerText, checked]);
-  useEffect(function () {
+  useEffect(() => {
     if (widthTextRef.current) {
       setWidth(widthTextRef.current.clientWidth);
     }
   }, [widthTextRef]);
-  var handleOnChange = useCallback(function () {
+  const handleOnChange = useCallback(() => {
     if (disabled || readOnly) return;
     onChange();
   }, [disabled, readOnly, onChange]);
-  var handleKeyDown = useCallback(function (e) {
+  const handleKeyDown = useCallback(e => {
     if (disabled || readOnly) {
       e.preventDefault();
     }
@@ -67,54 +64,56 @@ var DSControlledToggle = function DSControlledToggle(_ref) {
       onChange();
     }
   }, [disabled, onChange, readOnly]);
-  return addTooltipOnReadOnly( /*#__PURE__*/React.createElement(StyledContainer, _extends({
+  return addTooltipOnReadOnly( /*#__PURE__*/jsxs(StyledContainer, _objectSpread(_objectSpread({
     size: size,
     "data-testid": "ds-controlled-toggle"
-  }, containerProps), /*#__PURE__*/React.createElement(StyledInput, {
-    type: "checkbox",
-    name: name,
-    value: value,
-    checked: checked,
-    "data-testid": "ds-controlled-toggle-checkbox",
-    id: id || instanceUID,
-    "aria-disabled": disabled,
-    "aria-checked": checked,
-    tabIndex: 0,
-    onChange: handleOnChange,
-    onKeyDown: handleKeyDown
-  }), /*#__PURE__*/React.createElement(StyledLabel, {
-    checked: checked,
-    size: size,
-    width: width
-  }, /*#__PURE__*/React.createElement(StyledVisibleContent, {
-    checked: checked,
-    size: size,
-    readOnly: readOnly,
-    active: active,
-    disabled: disabled,
-    htmlFor: id ? undefined : instanceUID,
-    as: id ? 'p' : 'label'
-  }, /*#__PURE__*/React.createElement(StyledCircle, {
-    checked: checked,
-    size: size,
-    readOnly: readOnly,
-    disabled: disabled
-  }), /*#__PURE__*/React.createElement(StyledText, {
-    ref: labelTextRef,
-    isLongerTextRendering: isLongerTextRendering,
-    checked: checked,
-    size: size,
-    disabled: disabled
-  }, checked ? labelOn : labelOff))), /*#__PURE__*/React.createElement(SetLabelWidth, {
-    size: size,
-    ref: widthTextRef
-  }, longerText)), readOnly);
+  }, containerProps), {}, {
+    children: [/*#__PURE__*/_jsx(StyledInput, {
+      type: "checkbox",
+      name: name,
+      value: value,
+      checked: checked,
+      "data-testid": "ds-controlled-toggle-checkbox",
+      id: id || instanceUID,
+      "aria-disabled": disabled,
+      "aria-checked": checked,
+      tabIndex: 0,
+      onChange: handleOnChange,
+      onKeyDown: handleKeyDown
+    }), /*#__PURE__*/_jsx(StyledLabel, {
+      checked: checked,
+      size: size,
+      width: width
+    }, void 0, /*#__PURE__*/_jsx(StyledVisibleContent, {
+      checked: checked,
+      size: size,
+      readOnly: readOnly,
+      active: active,
+      disabled: disabled,
+      htmlFor: id ? undefined : instanceUID,
+      as: id ? 'p' : 'label'
+    }, void 0, /*#__PURE__*/_jsx(StyledCircle, {
+      checked: checked,
+      size: size,
+      readOnly: readOnly,
+      disabled: disabled
+    }), /*#__PURE__*/jsx(StyledText, {
+      ref: labelTextRef,
+      isLongerTextRendering: isLongerTextRendering,
+      checked: checked,
+      size: size,
+      disabled: disabled,
+      children: checked ? labelOn : labelOff
+    }))), /*#__PURE__*/jsx(SetLabelWidth, {
+      size: size,
+      ref: widthTextRef,
+      children: longerText
+    })]
+  })), readOnly);
 };
 
 DSControlledToggle.defaultProps = defaultProps;
-DSControlledToggle.propTypes = propTypes;
-var DSControlledToggleWithSchema = describe(DSControlledToggle);
+const DSControlledToggleWithSchema = describe(DSControlledToggle);
 DSControlledToggleWithSchema.propTypes = propTypes;
 
 export { DSControlledToggle, DSControlledToggleWithSchema };
-//# sourceMappingURL=ControlledToggle.js.map