@bash-app/bash-common 30.49.0 → 30.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash-app/bash-common",
-  "version": "30.49.0",
+  "version": "30.50.0",
   "description": "Common data and scripts to use on the frontend and backend",
   "type": "module",
   "main": "src/index.ts",
@@ -30,7 +30,6 @@
   },
   "peerDependencies": {
     "@prisma/client": "^6.1.0",
-    "dayjs": "^1.11.13",
     "luxon": "^3.5.0",
     "prisma": "^6.1.0",
     "react-tailwindcss-datepicker": "^1.6.6",

package/src/utils/dateTimeUtils.ts

@@ -1,19 +1,14 @@
+import { DateTime } from "luxon";
 import { DateType, DateValueType } from "react-tailwindcss-datepicker";
-import dayjs, { Dayjs } from "dayjs";
-import dayjsUtc from "dayjs/plugin/utc";
-import dayjsTimeZone from "dayjs/plugin/timezone";
 import { DateTimeArgType } from "../definitions";
 
-dayjs.extend(dayjsUtc);
-dayjs.extend(dayjsTimeZone);
-
 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 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;
@@ -21,42 +16,46 @@ export interface ITime {
   ampm: "AM" | "PM";
 }
 
+export function getLocalTimezoneName(): string {
+  return DateTime.local().zoneName;
+}
+
 export function formatDateRangeBasic(
   startDateTimeArg: Date | null,
   endDateTimeArg: Date | null
 ): string {
-  const startDateTime = dayjs(startDateTimeArg).tz(dayjs.tz.guess());
-  const endDateTime = dayjs(endDateTimeArg).tz(dayjs.tz.guess());
-  if (startDateTime.isSame(endDateTime, "day")) {
-    return `${startDateTime.format(
+  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.format(TIME_FORMAT_AM_PM)}`;
+    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
   }
 
-  return `${startDateTime.format(
+  return `${startDateTime.toFormat(
     DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.format(DATETIME_FORMAT_STANDARD)}`;
+  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
 }
 
 export function formatDateRange(
   startDateTimeArg: Date | null,
   endDateTimeArg: Date | null
 ): string {
-  const startDateTime = ensureDateTimeIsLocalDateTime(startDateTimeArg).tz(
-    dayjs.tz.guess()
-  );
-  const endDateTime = ensureDateTimeIsLocalDateTime(endDateTimeArg).tz(
-    dayjs.tz.guess()
-  );
-  if (startDateTime.isSame(endDateTime, "day")) {
-    return `${startDateTime.format(
+  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.format(TIME_FORMAT_AM_PM)}`;
+    )} to ${endDateTime.toFormat(TIME_FORMAT_AM_PM)}`;
   }
 
-  return `${startDateTime.format(
+  return `${startDateTime.toFormat(
     DATETIME_FORMAT_STANDARD
-  )} to ${endDateTime.format(DATETIME_FORMAT_STANDARD)}`;
+  )} to ${endDateTime.toFormat(DATETIME_FORMAT_STANDARD)}`;
 }
 
 export function ensureIsDateTime(
@@ -84,8 +83,9 @@ export function normalizeDate(
   }
 
   // Normalize to UTC and start of minute
-  return dayjs(date).utc().startOf("minute").toDate();
+  return DateTime.fromJSDate(date).toUTC().startOf("minute").toJSDate();
 }
+
 export function normalizeDates(
   dates: (Date | string | undefined | null)[]
 ): Date[] {
@@ -108,12 +108,11 @@ export function dateWithinDateRange(
   date: DateTimeArgType,
   dateRange: DateValueType | undefined
 ): boolean {
-  const startDate = dayjs(dateRange?.startDate).startOf("day").toDate();
-  const endDate = dayjs(dateRange?.endDate).endOf("day").toDate();
+  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 (
-    compareDateTime(date, startDate) >= 0 && compareDateTime(date, endDate) < 0
-  );
+  return checkDate >= startDate && checkDate < endDate;
 }
 
 export function findLatestDateTime(
@@ -197,76 +196,82 @@ export function setDateButPreserveTime(
   }
 
   // Get local timezone
-  const localTimeZone = dayjs.tz.guess();
-
-  // Format date and time parts
-  const datePart = dayjs(dateArg).tz(localTimeZone).format("YYYY-MM-DD"); // Local date
-  const timePart = dayjs(dateWithTheTimeYouWantToKeep)
-    .tz(localTimeZone)
-    .format("HH:mm"); // Local time
+  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
+  });
 
-  // Combine into an ISO string
-  const combinedDateTimeString = `${datePart}T${timePart}`;
   console.log("Combining date and time:", {
-    datePart,
-    timePart,
-    combinedDateTimeString,
+    dateOnly: dateOnly.toISO(),
+    timeOnly: timeOnly.toFormat("HH:mm"),
+    combinedDateTime: combinedDateTime.toISO(),
     localTimeZone,
   });
 
-  // Convert to UTC
-  const combinedDateTime = dayjs
-    .tz(combinedDateTimeString, localTimeZone)
-    .toDate();
-  if (isNaN(combinedDateTime.getTime())) {
-    console.error("Invalid combined datetime:", combinedDateTimeString);
+  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):", combinedDateTime);
-  return combinedDateTime;
+  console.log("Final combined DateTime (UTC):", result);
+  return result;
 }
 
 export function setTimeOnDate(
   date: DateType | Date | undefined,
   parsedTime: ITime | null
 ): Date {
-  const isValidDate = dayjs(date).isValid();
-  const dateTime = new Date(isValidDate && date ? date : Date.now());
+  const dateTime = DateTime.fromJSDate(date ? new Date(date) : new Date());
+  
   if (parsedTime) {
-    const parsedTimeDate = new Date();
-    parsedTimeDate.setHours(parsedTime.hours, parsedTime.minutes, 0); // Will change the date depending on time; corrected later
-    const correctTimeOnDate = setDateButPreserveTime(dateTime, parsedTimeDate);
-    return correctTimeOnDate;
+    const updatedDateTime = dateTime.set({
+      hour: parsedTime.hours,
+      minute: parsedTime.minutes,
+      second: 0,
+      millisecond: 0
+    });
+    return setDateButPreserveTime(dateTime.toJSDate(), updatedDateTime.toJSDate());
   }
-  return dateTime;
+  return dateTime.toJSDate();
 }
 
 export function ensureDateTimeIsLocalDateTime(
-  dateArg: DateType | Dayjs | undefined
-): Dayjs {
-  if (dayjs(dateArg).isUTC()) {
-    const dateLocalTimeZone = dayjs(dateArg);
-    return dateLocalTimeZone;
-  } else {
-    return dayjs(dateArg ?? Date.now());
+  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 {
-  date = new Date(date ?? Date.now());
-  const result = dayjs(date).format("h:mm A");
-  return result;
+  const dt = DateTime.fromJSDate(new Date(date ?? Date.now()));
+  return dt.toFormat("h:mm a");
 }
 
 export function formatDateTimeToTimeString24hr(
   date: Date | string | undefined | null
 ): string {
-  date = new Date(date ?? Date.now());
-  const result = dayjs(date).format("h:mm");
-  return result;
+  const dt = DateTime.fromJSDate(new Date(date ?? Date.now()));
+  return dt.toFormat("H:mm");
 }
 
 export function parseTimeString(timeStr: string): ITime | null {
@@ -293,6 +298,7 @@ export function parseTimeString(timeStr: string): ITime | null {
   }
   return null;
 }
+
 export function timestampMinutesFromNow(minutes: number): number {
-  return Math.floor(new Date().getTime() / 1000 + minutes * 60);
+  return Math.floor(DateTime.local().plus({ minutes }).toSeconds());
 }

package/src/utils/luxonUtils.ts

@@ -281,11 +281,6 @@ export function getLocalTimezone() {
   return utcOffsetMinutesToTimezone(localDateTime.offset);
 }
 
-export function getLocalTimezoneName() {
-  const localDateTime = DateTime.local();
-  return localDateTime.zoneName;
-}
-
 export function dateTimeFormatDateRange(
   startDateTimeArg: DateTime | null,
   endDateTimeArg: DateTime | null

package/src/utils/recurrenceUtils.ts

@@ -1,11 +1,7 @@
-import {DayOfWeek, Recurrence, RecurringFrequency} from "@prisma/client";
-import dayjs, {Dayjs} from "dayjs";
-import dayjsWeekDay from "dayjs/plugin/weekday";
-import {DateTimeArgType} from "../definitions";
-import {compareDateTime, DATETIME_FORMAT_ISO_LIKE} from "./dateTimeUtils";
-
-dayjs.extend(dayjsWeekDay);
-
+import { DayOfWeek, Recurrence, RecurringFrequency } from "@prisma/client";
+import { DateTime, WeekdayNumbers } from "luxon";
+import { DateTimeArgType } from "../definitions";
+import { compareDateTime, DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
 
 export function getRecurringBashEventPossibleDateTimes(startDateTime: DateTimeArgType,
                                                        recurrence: Recurrence | undefined | null): Date[] {
@@ -13,20 +9,19 @@ export function getRecurringBashEventPossibleDateTimes(startDateTime: DateTimeAr
 }
 
 export function getRecurringBashEventPossibleDayjsTimes(startDateTime: DateTimeArgType,
-                                                        recurrence: Recurrence | undefined | null): Dayjs[] {
-  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, false) as Dayjs[];
+                                                        recurrence: Recurrence | undefined | null): DateTime[] {
+  return getRecurringBashEventPossibleDatesTimesInternal(startDateTime, recurrence, false) as DateTime[];
 }
 
-
 function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTimeArgType,
                                                          recurrence: Recurrence | undefined | null,
-                                                         toDate: boolean): (Dayjs | Date)[] {
+                                                         toDate: boolean): (DateTime | Date)[] {
   if (!recurrence || !recurrence.frequency || recurrence.frequency === RecurringFrequency.Never) {
     return [];
   }
 
-  let recurrenceDates: Dayjs[] = [];
-  const beginningDate = findEarliestPossibleBashEventDate(startDateTime) as Dayjs; // Don't allow dates before the current date
+  let recurrenceDates: DateTime[] = [];
+  const beginningDate = findEarliestPossibleBashEventDate(startDateTime) as DateTime; // Don't allow dates before the current date
 
   switch (recurrence.frequency) {
     case RecurringFrequency.Weekly:
@@ -35,14 +30,15 @@ function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTime
     default:
       console.error(`Only weekly frequency is currently supported`);
   }
-  return recurrenceDates.map((date: Dayjs): string => date.format(DATETIME_FORMAT_ISO_LIKE))
+  return recurrenceDates.map((date: DateTime): string => date.toFormat(DATETIME_FORMAT_ISO_LIKE))
                         .sort()
-                        .map((dateStr: string): Dayjs | Date => {
+                        .map((dateStr: string): DateTime | Date => {
+                          const luxonDate = DateTime.fromFormat(dateStr, DATETIME_FORMAT_ISO_LIKE);
                           if (toDate) {
-                            return dayjs(dateStr).toDate();
+                            return luxonDate.toJSDate();
                           }
                           else {
-                            return dayjs(dateStr);
+                            return luxonDate;
                           }
                         });
 }
@@ -52,25 +48,25 @@ function getRecurringBashEventPossibleDatesTimesInternal(startDateTime: DateTime
  * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.
  * @param recurrence
  */
-function getWeeklyRecurringDates(beginningDateTime: Dayjs, recurrence: Recurrence): Dayjs[] {
+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.`);
   }
 
   const interval = recurrence.interval ?? 1;
-  const recurrenceEnds = dayjs(recurrence.ends).endOf('day'); // Get the end of the day to not miss the last day
-  const numberOfDays = recurrenceEnds.diff(beginningDateTime, 'days');
+  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 recurrenceDates: Dayjs[] = [];
+  const recurrenceDates: DateTime[] = [];
   let theNextWeekOfRecurrences = beginningDateTime;
 
   // Go week by week getting the next recurrence date
   for (let i = 0; i < numberOfWeeks; i++) {
-    let weekday: Dayjs | null = null;
+    let weekday: DateTime | null = null;
     for (const dayOfWeekEnum of recurrence.repeatOnDays) {
       const dayOfWeekNum = dayOfWeekEnumToDayNumber(dayOfWeekEnum);
-      weekday = theNextWeekOfRecurrences.weekday(dayOfWeekNum);
+        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
       }
@@ -85,21 +81,22 @@ function getWeeklyRecurringDates(beginningDateTime: Dayjs, recurrence: Recurrenc
   return recurrenceDates;
 }
 
-function copyTimeToDate(dateWithTimeToCopy: Dayjs, dateWhoseTimeToChange: Dayjs): Dayjs {
-  if (dateWithTimeToCopy.second() !== 0) {
+function copyTimeToDate(dateWithTimeToCopy: DateTime, dateWhoseTimeToChange: DateTime): DateTime {
+  if (dateWithTimeToCopy.second !== 0) {
     console.warn(`dateWithTimeToCopy has non-zero seconds: ${dateWithTimeToCopy.toString()} \nFixing...`);
-    dateWithTimeToCopy = dateWithTimeToCopy.set('seconds', 0);
+    dateWithTimeToCopy = dateWithTimeToCopy.set({second: 0});
   }
-  dateWhoseTimeToChange = dateWhoseTimeToChange.set('hours', dateWithTimeToCopy.hour());
-  dateWhoseTimeToChange = dateWhoseTimeToChange.set('minutes', dateWithTimeToCopy.minute());
-  dateWhoseTimeToChange = dateWhoseTimeToChange.set('seconds', 0); // Should be 0
-  return dateWhoseTimeToChange;
+  return dateWhoseTimeToChange.set({
+    hour: dateWithTimeToCopy.hour,
+    minute: dateWithTimeToCopy.minute,
+    second: 0
+  });
 }
 
 function dayOfWeekEnumToDayNumber(dayEnum: DayOfWeek): number {
   switch (dayEnum) {
     case DayOfWeek.Sunday:
-      return 0;
+      return 7; // Luxon uses 1-7 where 7 is Sunday
     case DayOfWeek.Monday:
       return 1;
     case DayOfWeek.Tuesday:
@@ -122,13 +119,13 @@ function dayOfWeekEnumToDayNumber(dayEnum: DayOfWeek): number {
  * @param date
  * @param interval
  */
-function getBeginningOfWeekInterval(date: Dayjs, interval: number): Dayjs {
+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').add(numberOfDaysToAdd, 'day');
+  return date.endOf('week').plus({ days: numberOfDaysToAdd });
 }
 
 export function freqToGrammarString(freq: RecurringFrequency, interval: number | undefined, toLowerCase: boolean = false): string {
@@ -154,18 +151,18 @@ export function freqToGrammarString(freq: RecurringFrequency, interval: number |
   return toLowerCase ? result.toLowerCase() : result;
 }
 
-export function findEarliestPossibleBashEventDate(startDateTimeArg: DateTimeArgType): Dayjs | undefined {
+export function findEarliestPossibleBashEventDate(startDateTimeArg: DateTimeArgType): DateTime | undefined {
   return findEarliestOrLatestPossibleBashEventDate(startDateTimeArg, true);
 }
 
-function findEarliestOrLatestPossibleBashEventDate(startDateTimeArg: DateTimeArgType, findEarly: boolean): Dayjs | undefined {
+function findEarliestOrLatestPossibleBashEventDate(startDateTimeArg: DateTimeArgType, findEarly: boolean): DateTime | undefined {
   if (!startDateTimeArg) {
     return;
   }
   // Don't allow dates before the current date
-  const startDateTime = dayjs(startDateTimeArg);
-  const currentDateTime = dayjs();
-  const comparedDateTime = compareDateTime(currentDateTime.toDate(), startDateTimeArg);
+  const startDateTime = DateTime.fromJSDate(new Date(startDateTimeArg));
+  const currentDateTime = DateTime.local();
+  const comparedDateTime = compareDateTime(currentDateTime.toJSDate(), startDateTimeArg);
   if (findEarly) {
     return comparedDateTime > 0 ? currentDateTime : startDateTime;
   }

package/src/utils/ticketListUtils.ts

@@ -1,10 +1,10 @@
-import dayjs from "dayjs";
+import { DateTime } from "luxon";
 import {
-  NumberOfTicketsForDate,
-  URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
-  URL_PARAMS_TICKET_TIER_ID_NUMBER_OF_TICKETS_DATE_DELIM,
-  URL_PARAMS_TICKET_LIST_DELIM,
-  URL_PARAMS_TICKETS_DATE_DELIM
+    NumberOfTicketsForDate,
+    URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
+    URL_PARAMS_TICKET_LIST_DELIM,
+    URL_PARAMS_TICKET_TIER_ID_NUMBER_OF_TICKETS_DATE_DELIM,
+    URL_PARAMS_TICKETS_DATE_DELIM
 } from "../definitions";
 import { DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
 
@@ -60,11 +60,11 @@ export function ticketListStrToTicketList(ticketListStr: string): Map<string, Nu
     for (const ticketNumAndDateStr of ticketNumAndDates) {
       // [numberOfTickets];;[date]
       const [numberOfTickets, ticketDateTimeStr] = ticketNumAndDateStr.split(URL_PARAMS_TICKETS_DATE_DELIM);
-      const ticketDateTime = dayjs(ticketDateTimeStr);
+      const ticketDateTime = DateTime.fromISO(ticketDateTimeStr);
       let ticketDateTimeFormattedStr: string | undefined = undefined;
 
-      if (ticketDateTime.isValid()) {
-        ticketDateTimeFormattedStr = ticketDateTime.format(DATETIME_FORMAT_ISO_LIKE);
+      if (ticketDateTime.isValid) {
+        ticketDateTimeFormattedStr = ticketDateTime.toFormat(DATETIME_FORMAT_ISO_LIKE);
       }
 
       ticketNumAndDatesArr.push({