@bash-app/bash-common 30.57.0 → 30.58.0

package/src/utils/dateTimeUtils.ts

@@ -4,12 +4,6 @@ import { DateTimeArgType } from "../definitions";
 
 const PARSE_TIME_REG = /^(\d{1,2}):(\d{2}) ?([APM]{0,2})$/i;
 
-export const DATETIME_FORMAT_STANDARD = "MMM d, yyyy - h:mm a";
-export const DATETIME_FORMAT_ISO_LIKE = "yyyy-MM-dd HH:mm";
-export const DATE_FORMAT_STANDARD = "MM/dd/yyyy";
-export const DATE_FORMAT_ISO = "yyyy-MM-dd";
-export const TIME_FORMAT_AM_PM = "h:mm a";
-
 export interface ITime {
   hours: number;
   minutes: number;
@@ -20,84 +14,6 @@ export function getLocalTimezoneName(): string {
   return DateTime.local().zoneName;
 }
 
-export function formatDateRangeBasic(
-  startDateTimeArg: Date | null,
-  endDateTimeArg: Date | null
-): string {
-  const userTimezone = getLocalTimezoneName();
-  const startDateTime = DateTime.fromJSDate(startDateTimeArg || new Date()).setZone(userTimezone);
-  const endDateTime = DateTime.fromJSDate(endDateTimeArg || new Date()).setZone(userTimezone);
-  
-  if (startDateTime.hasSame(endDateTime, "day")) {
-    return `${startDateTime.toFormat(
-      DATETIME_FORMAT_STANDARD
-    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
-  }
-
-  return `${startDateTime.toFormat(
-    DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
-}
-
-export function formatDateRangeBasicWithTimezone(
-  startDateTimeArg: Date | null,
-  endDateTimeArg: Date | null,
-  timezone?: string
-): string {
-  const targetTimezone = timezone || getLocalTimezoneName();
-  const startDateTime = DateTime.fromJSDate(startDateTimeArg || new Date()).setZone(targetTimezone);
-  const endDateTime = DateTime.fromJSDate(endDateTimeArg || new Date()).setZone(targetTimezone);
-  
-  if (startDateTime.hasSame(endDateTime, "day")) {
-    return `${startDateTime.toFormat(
-      DATETIME_FORMAT_STANDARD
-    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
-  }
-
-  return `${startDateTime.toFormat(
-    DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
-}
-
-export function formatDateRange(
-  startDateTimeArg: Date | null,
-  endDateTimeArg: Date | null
-): string {
-  const userTimezone = getLocalTimezoneName();
-  const startDateTime = ensureDateTimeIsLocalDateTime(startDateTimeArg).setZone(userTimezone);
-  const endDateTime = ensureDateTimeIsLocalDateTime(endDateTimeArg).setZone(userTimezone);
-  
-  if (startDateTime.hasSame(endDateTime, "day")) {
-    return `${startDateTime.toFormat(
-      DATETIME_FORMAT_STANDARD
-    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
-  }
-
-  return `${startDateTime.toFormat(
-    DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
-}
-
-export function formatDateRangeWithTimezone(
-  startDateTimeArg: Date | null,
-  endDateTimeArg: Date | null,
-  timezone?: string
-): string {
-  const targetTimezone = timezone || getLocalTimezoneName();
-  const startDateTime = ensureDateTimeIsLocalDateTime(startDateTimeArg).setZone(targetTimezone);
-  const endDateTime = ensureDateTimeIsLocalDateTime(endDateTimeArg).setZone(targetTimezone);
-  
-  if (startDateTime.hasSame(endDateTime, "day")) {
-    return `${startDateTime.toFormat(
-      DATETIME_FORMAT_STANDARD
-    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
-  }
-
-  return `${startDateTime.toFormat(
-    DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
-}
-
 export function ensureIsDateTime(
   possiblyADate: DateTimeArgType
 ): Date | undefined {
@@ -134,23 +50,17 @@ export function normalizeDates(
     .filter((date): date is Date => !!date); // Filter out invalid dates
 }
 
-export function formatDateTimeToISODateTimeString(
-  date: DateTimeArgType
-): string | undefined {
-  if (!date) {
-    return undefined;
-  }
-  date = new Date(date);
-  return date.toISOString();
-}
-
 export function dateWithinDateRange(
   date: DateTimeArgType,
   dateRange: DateValueType | undefined
 ): boolean {
-  const startDate = DateTime.fromJSDate(dateRange?.startDate || new Date()).startOf("day");
-  const endDate = DateTime.fromJSDate(dateRange?.endDate || new Date()).endOf("day");
-  const checkDate = DateTime.fromJSDate(new Date(date || ''));
+  const startDate = DateTime.fromJSDate(
+    dateRange?.startDate || new Date()
+  ).startOf("day");
+  const endDate = DateTime.fromJSDate(dateRange?.endDate || new Date()).endOf(
+    "day"
+  );
+  const checkDate = DateTime.fromJSDate(new Date(date || ""));
 
   return checkDate >= startDate && checkDate < endDate;
 }
@@ -221,99 +131,6 @@ export function compareDateTime(
   }
 }
 
-export function setDateButPreserveTime(
-  dateArg: DateType,
-  dateWithTheTimeYouWantToKeep: DateType | undefined
-): Date {
-  if (!dateArg || !dateWithTheTimeYouWantToKeep) {
-    console.error("Invalid arguments:", {
-      dateArg,
-      dateWithTheTimeYouWantToKeep,
-    });
-    throw new Error(
-      "Both dateArg and dateWithTheTimeYouWantToKeep are required."
-    );
-  }
-
-  // Get local timezone
-  const localTimeZone = getLocalTimezoneName();
-
-  // Extract date and time components using Luxon
-  const dateOnly = DateTime.fromJSDate(new Date(dateArg)).setZone(localTimeZone);
-  const timeOnly = DateTime.fromJSDate(new Date(dateWithTheTimeYouWantToKeep)).setZone(localTimeZone);
-
-  // Combine date from first argument with time from second argument
-  const combinedDateTime = dateOnly.set({
-    hour: timeOnly.hour,
-    minute: timeOnly.minute,
-    second: 0,
-    millisecond: 0
-  });
-
-  console.log("Combining date and time:", {
-    dateOnly: dateOnly.toISO(),
-    timeOnly: timeOnly.toFormat("HH:mm"),
-    combinedDateTime: combinedDateTime.toISO(),
-    localTimeZone,
-  });
-
-  const result = combinedDateTime.toJSDate();
-  if (isNaN(result.getTime())) {
-    console.error("Invalid combined datetime:", combinedDateTime.toISO());
-    throw new Error("Invalid date or time format.");
-  }
-
-  console.log("Final combined DateTime (UTC):", result);
-  return result;
-}
-
-export function setTimeOnDate(
-  date: DateType | Date | undefined,
-  parsedTime: ITime | null
-): Date {
-  const dateTime = DateTime.fromJSDate(date ? new Date(date) : new Date());
-  
-  if (parsedTime) {
-    const updatedDateTime = dateTime.set({
-      hour: parsedTime.hours,
-      minute: parsedTime.minutes,
-      second: 0,
-      millisecond: 0
-    });
-    return setDateButPreserveTime(dateTime.toJSDate(), updatedDateTime.toJSDate());
-  }
-  return dateTime.toJSDate();
-}
-
-export function ensureDateTimeIsLocalDateTime(
-  dateArg: DateType | DateTime | undefined
-): DateTime {
-  if (!dateArg) {
-    return DateTime.local();
-  }
-  
-  if (dateArg instanceof DateTime) {
-    return dateArg.setZone(getLocalTimezoneName());
-  }
-  
-  const dt = DateTime.fromJSDate(new Date(dateArg));
-  return dt.setZone(getLocalTimezoneName());
-}
-
-export function formatDateTimeToTimeString(
-  date: Date | string | undefined | null
-): string {
-  const dt = DateTime.fromJSDate(new Date(date ?? Date.now()));
-  return dt.toFormat("h:mm a");
-}
-
-export function formatDateTimeToTimeString24hr(
-  date: Date | string | undefined | null
-): string {
-  const dt = DateTime.fromJSDate(new Date(date ?? Date.now()));
-  return dt.toFormat("H:mm");
-}
-
 export function parseTimeString(timeStr: string): ITime | null {
   const match = timeStr.match(PARSE_TIME_REG);
 

package/src/utils/luxonUtils.ts

@@ -8,11 +8,11 @@ import {
 } from "./generalDateTimeUtils";
 import { roundToNearestDivisor } from "./mathUtils";
 
-const PARSE_TIME_REG = /^(\d{1,2}):(\d{2}) ?([APM]{0,2})$/i;
-
 // export const LUXON_DATETIME_FORMAT_STANDARD = "MM/dd/yyyy - hh:mm a";
 export const LUXON_DATETIME_FORMAT_STANDARD = "D t";
+export const LUXON_DATETIME_FORMAT_ISO = "D t"; //"D t";
 export const LUXON_DATETIME_FORMAT_ISO_LIKE = "D t"; //"D t";
+export const LUXON_DATETIME_FORMAT_STANDARD_EXTENDED = "cccc D T";
 // export const LUXON_DATE_FORMAT_STANDARD = "yyyy/MM/dd";
 // export const LUXON_DATE_FORMAT_ISO = "yyyy/MM/dd";
 export const LUXON_DATETIME_FORMAT_DATE = "D"; //"D t";
@@ -20,6 +20,19 @@ export const LUXON_TIME_FORMAT_AM_PM = "h:mm a";
 
 export const MINUTES_PER_DAY = 1440;
 
+export const INVALID_DATETIME_STR = "Invalid date";
+export const INVALID_DATETIME_RANGE_STR = "Invalid date range";
+
+export interface LuxonDateRange {
+  start: DateTime;
+  end: DateTime;
+}
+
+export interface LuxonDateRangeN {
+  start?: DateTime | undefined | null;
+  end?: DateTime | undefined | null;
+}
+
 export function dayOfWeekGetIdx(dayOfWeek: DayOfWeek | DayOfWeekIdx) {
   if (typeof dayOfWeek === "number") {
     return dayOfWeek as DayOfWeekIdx;
@@ -30,6 +43,16 @@ export function dayOfWeekGetIdx(dayOfWeek: DayOfWeek | DayOfWeekIdx) {
   }
 }
 
+export function dayOfWeekFromIdx(dayOfWeek: DayOfWeek | DayOfWeekIdx) {
+  if (typeof dayOfWeek === "number") {
+    return dayOfWeekIdxToDayOfWeek[dayOfWeek as DayOfWeekIdx];
+  } else if (typeof dayOfWeek === "string") {
+    return dayOfWeek as DayOfWeek;
+  } else {
+    throw new Error(`dayOfWeekToIdx: unhandled case`);
+  }
+}
+
 export function dateTimeFromDayTime(
   dayOfWeek: DayOfWeek | DayOfWeekIdx,
   hour: number = 0,
@@ -192,12 +215,25 @@ export function dateRangeGetDateTimeTIme(dateRange: LuxonDateRange) {
   };
 }
 
-export function dateTimeFormat(dateTime?: DateTime | null) {
+export function dateTimeFormat(dateTime?: DateTime | undefined | null) {
   return dateTime?.toFormat(LUXON_DATETIME_FORMAT_STANDARD) ?? "";
 }
 
-export function dateTimeFormatLong(dateTime?: DateTime | null) {
-  return `${dateTime?.weekdayLong} ${dateTimeFormatWeek(dateTime)}`;
+export function dateTimeFormatExt(
+  dateTime?: DateTime | undefined | null
+): string {
+  return dateTime
+    ? `${dateTime.toFormat(LUXON_DATETIME_FORMAT_STANDARD_EXTENDED)}`
+    : "";
+}
+
+export function dateTimeFormatISO(
+  dateTime?: DateTime | undefined | null
+): string | null {
+  if (!dateTime) {
+    return null;
+  }
+  return dateTime.toISO();
 }
 
 export function dateTimeFormatWeek(dateTime?: DateTime | null) {
@@ -296,6 +332,21 @@ export function dateTimeFormatDateRange(
   )}`;
 }
 
+export function dateTimeFormatDateRangeExt(
+  startDateTimeArg: DateTime | null,
+  endDateTimeArg: DateTime | null
+): string {
+  if (startDateTimeArg?.day === endDateTimeArg?.day) {
+    return `${dateTimeFormatExt(startDateTimeArg)} to ${dateTimeFormatTime(
+      endDateTimeArg
+    )}`;
+  }
+
+  return `${dateTimeFormatExt(startDateTimeArg)} to ${dateTimeFormat(
+    endDateTimeArg
+  )}`;
+}
+
 export function dateTimeFormatDateRangeDate(
   startDateTimeArg: DateTime | null,
   endDateTimeArg: DateTime | null
@@ -333,11 +384,6 @@ export function dateTimeFormatDateRangeList(
   };
 }
 
-export interface LuxonDateRange {
-  start: DateTime;
-  end: DateTime;
-}
-
 export type LuxonDayOfWeekHours = {
   [key in DayOfWeekIdx]: LuxonDateRange[];
 };

package/src/utils/recurrenceUtils.ts

@@ -1,27 +1,54 @@
 import { DayOfWeek, Recurrence, RecurringFrequency } from "@prisma/client";
 import { DateTime, WeekdayNumbers } from "luxon";
 import { DateTimeArgType } from "../definitions";
-import { compareDateTime, DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
+import {
+  dateTimeFromDate,
+  dateTimeSetTime,
+  dayOfWeekGetIdx,
+  LUXON_DATETIME_FORMAT_ISO_LIKE,
+} from "./luxonUtils";
+import { compareDateTime } from "./dateTimeUtils";
+import { dayOfWeekToIdx } from "./generalDateTimeUtils";
 
-export function getRecurringBashEventPossibleDateTimes(startDateTime: DateTimeArgType,
-                                                       recurrence: Recurrence | undefined | null): Date[] {
-  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, true) as Date[];
+export function getRecurringBashEventPossibleDateTimes(
+  startDateTime: DateTimeArgType,
+  recurrence: Recurrence | undefined | null
+): Date[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(
+    startDateTime,
+    recurrence,
+    true
+  ) as Date[];
 }
 
-export function getRecurringBashEventPossibleDayjsTimes(startDateTime: DateTimeArgType,
-                                                        recurrence: Recurrence | undefined | null): DateTime[] {
-  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, false) as DateTime[];
+export function getRecurringBashEventPossibleLuxonTimes(
+  startDateTime: DateTimeArgType,
+  recurrence: Recurrence | undefined | null
+): DateTime[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(
+    startDateTime,
+    recurrence,
+    false
+  ) as DateTime[];
 }
 
-function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTimeArgType,
-                                                         recurrence: Recurrence | undefined | null,
-                                                         toDate: boolean): (DateTime | Date)[] {
-  if (!recurrence || !recurrence.frequency || recurrence.frequency === RecurringFrequency.Never) {
+function getRecurringBashEventPossibleDatesTimesInternal(
+  startDateTime: DateTimeArgType,
+  recurrence: Recurrence | undefined | null,
+  toDate: boolean
+): (DateTime | Date)[] {
+  if (
+    !recurrence ||
+    !recurrence.frequency ||
+    recurrence.frequency === RecurringFrequency.Never
+  ) {
     return [];
   }
 
   let recurrenceDates: DateTime[] = [];
-  const beginningDate = findEarliestPossibleBashEventDate(startDateTime) as DateTime; // Don't allow dates before the current date
+  const beginningDate = findEarliestPossibleBashEventDate(
+    startDateTime
+  ) as DateTime; // Don't allow dates before the current date
 
   switch (recurrence.frequency) {
     case RecurringFrequency.Weekly:
@@ -30,17 +57,22 @@ function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTime
     default:
       console.error(`Only weekly frequency is currently supported`);
   }
-  return recurrenceDates.map((date: DateTime): string => date.toFormat(DATETIME_FORMAT_ISO_LIKE))
-                        .sort()
-                        .map((dateStr: string): DateTime | Date => {
-                          const luxonDate = DateTime.fromFormat(dateStr, DATETIME_FORMAT_ISO_LIKE);
-                          if (toDate) {
-                            return luxonDate.toJSDate();
-                          }
-                          else {
-                            return luxonDate;
-                          }
-                        });
+  return recurrenceDates
+    .map((date: DateTime): string =>
+      date.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE)
+    )
+    .sort()
+    .map((dateStr: string): DateTime | Date => {
+      const luxonDate = DateTime.fromFormat(
+        dateStr,
+        LUXON_DATETIME_FORMAT_ISO_LIKE
+      );
+      if (toDate) {
+        return luxonDate.toJSDate();
+      } else {
+        return luxonDate;
+      }
+    });
 }
 
 /**
@@ -48,15 +80,20 @@ function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTime
  * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.
  * @param recurrence
  */
-function getWeeklyRecurringDates(beginningDateTime: DateTime, recurrence: Recurrence): DateTime[] {
+function getWeeklyRecurringDates(
+  beginningDateTime: DateTime,
+  recurrence: Recurrence
+): DateTime[] {
   if (recurrence.frequency !== RecurringFrequency.Weekly) {
-    throw new Error(`Cannot do a weekly recurrence if the frequency isn't weekly.`);
+    throw new Error(
+      `Cannot do a weekly recurrence if the frequency isn't weekly.`
+    );
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = DateTime.fromJSDate(new Date(recurrence.ends || '')).endOf('day'); // Get the end of the day to not miss the last day
-  const numberOfDays = recurrenceEnds.diff(beginningDateTime, 'days').days;
-  const numberOfWeeks = Math.ceil((numberOfDays / 7) / interval); // Get the number of days and then round up so that we include the ending date
+  const recurrenceEnds = dateTimeFromDate(recurrence.ends).endOf("day"); // Get the end of the day to not miss the last day
+  const numberOfDays = recurrenceEnds.diff(beginningDateTime, "days").days;
+  const numberOfWeeks = Math.ceil(numberOfDays / 7 / interval); // Get the number of days and then round up so that we include the ending date
 
   const recurrenceDates: DateTime[] = [];
   let theNextWeekOfRecurrences = beginningDateTime;
@@ -65,13 +102,15 @@ function getWeeklyRecurringDates(beginningDateTime: DateTime, recurrence: Recurr
   for (let i = 0; i < numberOfWeeks; i++) {
     let weekday: DateTime | null = null;
     for (const dayOfWeekEnum of recurrence.repeatOnDays) {
-      const dayOfWeekNum = dayOfWeekEnumToDayNumber(dayOfWeekEnum);
-        weekday = theNextWeekOfRecurrences.set({ weekday: dayOfWeekNum as WeekdayNumbers });
+      const dayOfWeekNum = dayOfWeekGetIdx(dayOfWeekEnum);
+      weekday = theNextWeekOfRecurrences.set({
+        weekday: dayOfWeekNum as WeekdayNumbers,
+      });
       if (weekday > recurrenceEnds || weekday < beginningDateTime) {
         continue; // Continue because repeatOnDays isn't sorted by the day of the week
       }
       // Set the time on the date so that it matches the time when the event starts
-      weekday = copyTimeToDate(beginningDateTime, weekday);
+      weekday = dateTimeSetTime(weekday, beginningDateTime);
       recurrenceDates.push(weekday);
     }
     if (weekday) {
@@ -81,54 +120,28 @@ function getWeeklyRecurringDates(beginningDateTime: DateTime, recurrence: Recurr
   return recurrenceDates;
 }
 
-function copyTimeToDate(dateWithTimeToCopy: DateTime, dateWhoseTimeToChange: DateTime): DateTime {
-  if (dateWithTimeToCopy.second !== 0) {
-    console.warn(`dateWithTimeToCopy has non-zero seconds: ${dateWithTimeToCopy.toString()} \nFixing...`);
-    dateWithTimeToCopy = dateWithTimeToCopy.set({second: 0});
-  }
-  return dateWhoseTimeToChange.set({
-    hour: dateWithTimeToCopy.hour,
-    minute: dateWithTimeToCopy.minute,
-    second: 0
-  });
-}
-
-function dayOfWeekEnumToDayNumber(dayEnum: DayOfWeek): number {
-  switch (dayEnum) {
-    case DayOfWeek.Sunday:
-      return 7; // Luxon uses 1-7 where 7 is Sunday
-    case DayOfWeek.Monday:
-      return 1;
-    case DayOfWeek.Tuesday:
-      return 2;
-    case DayOfWeek.Wednesday:
-      return 3;
-    case DayOfWeek.Thursday:
-      return 4;
-    case DayOfWeek.Friday:
-      return 5;
-    case DayOfWeek.Saturday:
-      return 6;
-    default:
-      throw new Error(`How did this happen? Invalid DayOfWeek: ${dayEnum}`); // Shouldn't happen
-  }
-}
-
 /**
  * Get the next week determined by the interval by going to the end of the week interval and adding one day
  * @param date
  * @param interval
  */
-function getBeginningOfWeekInterval(date: DateTime, interval: number): DateTime {
+function getBeginningOfWeekInterval(
+  date: DateTime,
+  interval: number
+): DateTime {
   if (!interval) {
     interval = 1; // Avoid 0
   }
   // An interval of 2 would be (2 - 1) * 7 + 1 = 8 days to add to skip a week and go into the next week
   const numberOfDaysToAdd = interval > 1 ? (interval - 1) * 7 + 1 : 1;
-  return date.endOf('week').plus({ days: numberOfDaysToAdd });
+  return date.endOf("week").plus({ days: numberOfDaysToAdd });
 }
 
-export function freqToGrammarString(freq: RecurringFrequency, interval: number | undefined, toLowerCase: boolean = false): string {
+export function freqToGrammarString(
+  freq: RecurringFrequency,
+  interval: number | undefined,
+  toLowerCase: boolean = false
+): string {
   if (!interval) {
     return freq;
   }
@@ -136,37 +149,44 @@ export function freqToGrammarString(freq: RecurringFrequency, interval: number |
   let result: string = freq;
   switch (freq) {
     case RecurringFrequency.Daily:
-      result = isPlural ? 'Days' : 'Day';
+      result = isPlural ? "Days" : "Day";
       break;
     case RecurringFrequency.Weekly:
-      result = isPlural ? 'Weeks' : 'Week';
+      result = isPlural ? "Weeks" : "Week";
       break;
     case RecurringFrequency.Monthly:
-      result = isPlural ? 'Months' : 'Month';
+      result = isPlural ? "Months" : "Month";
       break;
     case RecurringFrequency.Yearly:
-      result = isPlural ? 'Years' : 'Year';
+      result = isPlural ? "Years" : "Year";
       break;
   }
   return toLowerCase ? result.toLowerCase() : result;
 }
 
-export function findEarliestPossibleBashEventDate(startDateTimeArg: DateTimeArgType): DateTime | undefined {
+export function findEarliestPossibleBashEventDate(
+  startDateTimeArg: DateTimeArgType
+): DateTime | undefined {
   return findEarliestOrLatestPossibleBashEventDate(startDateTimeArg, true);
 }
 
-function findEarliestOrLatestPossibleBashEventDate(startDateTimeArg: DateTimeArgType, findEarly: boolean): DateTime | undefined {
+function findEarliestOrLatestPossibleBashEventDate(
+  startDateTimeArg: DateTimeArgType,
+  findEarly: boolean
+): DateTime | undefined {
   if (!startDateTimeArg) {
     return;
   }
   // Don't allow dates before the current date
-  const startDateTime = DateTime.fromJSDate(new Date(startDateTimeArg));
+  const startDateTime = dateTimeFromDate(startDateTimeArg);
   const currentDateTime = DateTime.local();
-  const comparedDateTime = compareDateTime(currentDateTime.toJSDate(), startDateTimeArg);
+  const comparedDateTime = compareDateTime(
+    currentDateTime.toJSDate(),
+    startDateTimeArg
+  );
   if (findEarly) {
     return comparedDateTime > 0 ? currentDateTime : startDateTime;
-  }
-  else {
+  } else {
     return comparedDateTime < 0 ? currentDateTime : startDateTime;
   }
 }