@bash-app/bash-common 29.67.0 → 29.69.0

package/src/utils/luxonUtils.ts

@@ -0,0 +1,906 @@
+import { DayOfWeek } from "@prisma/client";
+import { DateTime, Interval } from "luxon";
+import {
+  DayOfWeekIdx,
+  dayOfWeekIdxToDay,
+  dayOfWeekIdxToDayOfWeek,
+  dayOfWeekToIdx,
+} 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_LIKE = "yyyy-MM-dd hh:mm"; //"D t";
+// export const LUXON_DATE_FORMAT_STANDARD = "yyyy/MM/dd";
+// export const LUXON_DATE_FORMAT_ISO = "yyyy/MM/dd";
+export const LUXON_TIME_FORMAT_AM_PM = "h:mm a";
+
+export const MINUTES_PER_DAY = 1440;
+
+export function dayOfWeekGetIdx(dayOfWeek: DayOfWeek | DayOfWeekIdx) {
+  if (typeof dayOfWeek === "number") {
+    return dayOfWeek as DayOfWeekIdx;
+  } else if (typeof dayOfWeek === "string") {
+    return dayOfWeekToIdx[dayOfWeek as DayOfWeek];
+  } else {
+    throw new Error(`dayOfWeekToIdx: unhandled case`);
+  }
+}
+
+export function dateTimeFromDayTime(
+  dayOfWeek: DayOfWeek | DayOfWeekIdx,
+  hour: number = 0,
+  minute: number = 0,
+  interpretAsTimezone?: string,
+  timezoneToConvertTo?: string
+): DateTime {
+  //use date where first day of month is a known sunday
+  let res = DateTime.fromObject(
+    {
+      year: 2023,
+      month: 1,
+      // weekday: dayOfWeekGetIdx(dayOfWeek),
+      day: dayOfWeekIdxToDay[dayOfWeekGetIdx(dayOfWeek)],
+      hour: hour,
+      minute: minute,
+    },
+    {
+      zone: interpretAsTimezone,
+    }
+  );
+
+  if (timezoneToConvertTo) {
+    res = res.setZone(timezoneToConvertTo);
+  }
+
+  return res;
+}
+
+export function dateTimeFromDate(
+  date: string | Date,
+  interpretAsTimezone?: string,
+  timezoneToConvertTo?: string
+) {
+  let res =
+    typeof date === "string"
+      ? DateTime.fromISO(date, { zone: interpretAsTimezone })
+      : DateTime.fromJSDate(date, { zone: interpretAsTimezone });
+
+  if (timezoneToConvertTo) {
+    res = res.setZone(timezoneToConvertTo);
+  }
+
+  return res;
+}
+
+export type DateTimeTime = Pick<DateTime, "hour" | "minute">;
+export type DateTimeDate = Pick<DateTime, "year" | "month" | "day">;
+
+export function dateTimeToTimeComponents(dateTime: DateTime): DateTimeTime {
+  return {
+    hour: dateTime.hour,
+    minute: dateTime.minute,
+  };
+}
+
+export function dateTimeToDateComponents(dateTime: DateTime): DateTimeDate {
+  return {
+    year: dateTime.year,
+    month: dateTime.month,
+    day: dateTime.day,
+  };
+}
+
+export function dateTimeFromTime(
+  time: string | Date,
+  interpretAsTimezone?: string,
+  timezoneToConvertTo?: string
+): DateTime | null {
+  let res =
+    typeof time === "string"
+      ? DateTime.fromFormat(time, LUXON_TIME_FORMAT_AM_PM, {
+          zone: interpretAsTimezone,
+        })
+      : DateTime.fromJSDate(time, { zone: interpretAsTimezone });
+
+  if (!res.isValid) {
+    return null;
+  }
+
+  if (timezoneToConvertTo) {
+    res = res.setZone(timezoneToConvertTo);
+  }
+
+  return res;
+}
+
+export function dateTimeFromComponents(
+  date: DateTime | Date | string | null | undefined,
+  time: DateTime | Date | string | null | undefined,
+  interpretAsTimezone?: string,
+  timezoneToConvertTo?: string
+): DateTime | null {
+  let res = date
+    ? DateTime.isDateTime(date)
+      ? date.setZone(interpretAsTimezone)
+      : dateTimeFromDate(date, interpretAsTimezone, timezoneToConvertTo)
+    : DateTime.now().setZone(
+        timezoneToConvertTo ?? interpretAsTimezone ?? undefined
+      );
+
+  const timeComp = DateTime.isDateTime(time)
+    ? time.setZone(interpretAsTimezone)
+    : dateTimeFromTime(
+        time ?? "12:00 AM",
+        interpretAsTimezone,
+        timezoneToConvertTo
+      );
+
+  if (!timeComp) {
+    return null;
+  }
+
+  res = dateTimeSetTime(res, timeComp);
+
+  if (timezoneToConvertTo) {
+    res = res.setZone(timezoneToConvertTo);
+  }
+
+  return res;
+}
+
+export function dateTimeGetDateTimeTIme(dateTime: DateTime) {
+  return DateTime.fromObject(
+    {
+      // day: dayOfWeekIdxToDay[dateTime.weekday as DayOfWeekIdx],
+      hour: dateTime.hour,
+      minute: dateTime.minute,
+    },
+    {
+      zone: dateTime.zone,
+    }
+  );
+}
+
+export function dateTimeSetTime(
+  dateTime: DateTime,
+  time: DateTimeTime | DateTime = { hour: 0, minute: 0 }
+): DateTime {
+  const timeComp = DateTime.isDateTime(time)
+    ? dateTimeToTimeComponents(time as DateTime)
+    : time;
+  return dateTime.set(timeComp);
+}
+
+export function dateTimeSetDate(
+  dateTime: DateTime,
+  date: DateTimeDate | DateTime = { year: 2020, month: 1, day: 1 }
+): DateTime {
+  const dateComp = DateTime.isDateTime(date)
+    ? dateTimeToDateComponents(date)
+    : date;
+  return dateTime.set(dateComp);
+}
+
+export function dateRangeGetDateTimeTIme(dateRange: LuxonDateRange) {
+  return {
+    start: dateTimeGetDateTimeTIme(dateRange.start),
+    end: dateTimeGetDateTimeTIme(dateRange.end),
+  };
+}
+
+export function dateTimeFormatTime(dateTime: DateTime) {
+  return dateTime.toFormat(LUXON_TIME_FORMAT_AM_PM);
+}
+
+export function dateTimeWithinRange(
+  dateTime: DateTime,
+  dateRange: LuxonDateRange
+) {
+  return Interval.fromDateTimes(dateRange.start, dateRange.end).contains(
+    dateTime
+  );
+}
+
+export function dateTimeRangeIntersection(
+  lhs: LuxonDateRange,
+  rhs: LuxonDateRange
+): Interval | null {
+  const intervalFirst = Interval.fromDateTimes(lhs.start, lhs.end);
+  const intervalSecond = Interval.fromDateTimes(rhs.start, rhs.end);
+
+  return intervalFirst.intersection(intervalSecond);
+}
+
+export function dateRangeWithinDateRange(
+  dateRange: LuxonDateRange,
+  withinRange: LuxonDateRange
+) {
+  const withinInterval = Interval.fromDateTimes(
+    withinRange.start,
+    withinRange.end
+  );
+
+  return (
+    withinInterval.contains(dateRange.start) &&
+    withinInterval.contains(dateRange.end)
+  );
+}
+
+export function dateTimeRangeToInterval(
+  dateTimeRange: LuxonDateRange
+): Interval {
+  return Interval.fromDateTimes(dateTimeRange.start, dateTimeRange.end);
+}
+
+export function dateRangeDurationMatch(
+  lhs: LuxonDateRange,
+  rhs: LuxonDateRange,
+  withinSeconds: number = 60
+) {
+  return (
+    Math.abs(
+      lhs.end.diff(lhs.start).toMillis() - rhs.end.diff(rhs.end).toMillis()
+    ) <=
+    withinSeconds * 1000
+  );
+}
+
+export function utcOffsetMinutesToTimezone(utcOffsetMinutes: number) {
+  const hours = Math.floor(Math.abs(utcOffsetMinutes) / 60);
+  const minutes = Math.abs(utcOffsetMinutes) % 60;
+  const sign = utcOffsetMinutes >= 0 ? "+" : "-";
+  const offsetString = `UTC${sign}${String(hours).padStart(2, "0")}:${String(
+    minutes
+  ).padStart(2, "0")}`;
+
+  return offsetString;
+}
+
+export function dateTimeFormatDateRange(
+  startDateTimeArg: DateTime | null,
+  endDateTimeArg: DateTime | null
+): string {
+  if (startDateTimeArg?.day === endDateTimeArg?.day) {
+    return `${startDateTimeArg?.toFormat(
+      LUXON_DATETIME_FORMAT_STANDARD
+    )} to ${endDateTimeArg?.toFormat(LUXON_TIME_FORMAT_AM_PM)}`;
+  }
+
+  return `${startDateTimeArg?.toFormat(
+    LUXON_DATETIME_FORMAT_STANDARD
+  )} to ${endDateTimeArg?.toFormat(LUXON_DATETIME_FORMAT_STANDARD)}`;
+}
+
+export interface LuxonDateRange {
+  start: DateTime;
+  end: DateTime;
+}
+
+export type LuxonDayOfWeekHours = {
+  [key in DayOfWeekIdx]: LuxonDateRange[];
+};
+
+export function formatDayOfWeekHours(hours: LuxonDayOfWeekHours): string[] {
+  return Object.entries(hours).map(([dayIdx, ranges]) => {
+    const dayName =
+      dayOfWeekIdxToDayOfWeek[parseInt(dayIdx, 10) as DayOfWeekIdx]; // Convert index to day name
+    const formattedRanges = ranges
+      .map(
+        ({ start, end }) =>
+          `${start.toFormat("h:mm a")} – ${end.toFormat("h:mm a")}`
+      )
+      .join(", ");
+    return `${dayName}: ${formattedRanges}`;
+  });
+}
+
+export function mergeCrossDayHours(hours: LuxonDateRange[]): LuxonDateRange[] {
+  if (hours.length === 0) return [];
+
+  // Sort by start time
+  const sortedHours = hours.sort(
+    (a, b) => a.start.toMillis() - b.start.toMillis()
+  );
+  const mergedHours: LuxonDateRange[] = [];
+
+  for (const range of sortedHours) {
+    if (mergedHours.length === 0) {
+      mergedHours.push(range);
+      continue;
+    }
+
+    const lastMerged = mergedHours[mergedHours.length - 1];
+
+    // Calculate the time difference between last merged range end and current range start
+    const gapInMinutes = range.start.diff(lastMerged.end, "minutes").minutes;
+
+    // If the gap is 1 minute or less, merge the ranges
+    if (gapInMinutes <= 1) {
+      lastMerged.end = range.end; // Extend the end time
+    } else {
+      mergedHours.push(range); // Otherwise, treat it as a new separate range
+    }
+  }
+
+  return mergedHours;
+}
+
+export function dateTimeHoursByDay(
+  hours: LuxonDateRange[]
+): LuxonDayOfWeekHours {
+  return hours.reduce(
+    (sofar, curr): LuxonDayOfWeekHours => {
+      sofar[curr.start.weekday as DayOfWeekIdx].push(curr);
+      sofar[curr.start.weekday as DayOfWeekIdx] = mergeCrossDayHours(
+        sofar[curr.start.weekday as DayOfWeekIdx]
+      );
+      return sofar;
+    },
+    Object.keys(dayOfWeekIdxToDayOfWeek).reduce(
+      (sofar, curr): LuxonDayOfWeekHours => {
+        return {
+          ...sofar,
+          [Number(curr) as DayOfWeekIdx]: [],
+        };
+      },
+      {} as LuxonDayOfWeekHours
+    )
+  );
+}
+
+export function normalizeLuxonInterval(interval: Interval) {
+  const setArgs = { year: 0, month: 1, day: 1 } as const;
+
+  const timezone = interval?.start?.zone || interval?.end?.zone || "local";
+
+  const originalStart = interval?.start;
+  const originalEnd = interval?.end;
+
+  const start =
+    originalStart?.set(setArgs) ??
+    DateTime.fromObject(setArgs, { zone: timezone });
+
+  let end =
+    originalEnd?.set(setArgs) ??
+    DateTime.fromObject(setArgs, { zone: timezone });
+
+  if (
+    originalEnd &&
+    originalStart &&
+    originalEnd.hasSame(originalStart, "day") === false
+  ) {
+    end = end.set({ hour: 23, minute: 59 });
+  }
+
+  return Interval.fromDateTimes(start, end);
+}
+
+export function dateRangeIntervalFromWeekdayTime(dateRange: LuxonDateRange) {
+  return Interval.fromDateTimes(dateRange.start, dateRange.end);
+}
+
+// Helper function to calculate overlaps for a single day's array of hours
+function getOverlappingIntervalsList(
+  ranges: LuxonDateRange[],
+  inputInterval: Interval
+): Interval[] {
+  // Convert LuxonDateRange objects to Interval objects
+  const rangeIntervals = ranges.map(({ start, end }) =>
+    Interval.fromDateTimes(start, end)
+  );
+
+  // Find overlapping intervals between the range intervals and the single input interval
+  return rangeIntervals
+    .map((rangeInterval) => rangeInterval.intersection(inputInterval))
+    .filter((interval): interval is Interval => interval !== null);
+}
+
+//returns common horus that are overlapping with input Interval on everyday (with valid hours) within weekHours
+export function dateTimeGetOverlappingHoursCommonHelper(
+  weekHours: LuxonDayOfWeekHours,
+  inputInterval: Interval
+): LuxonDateRange | null {
+  console.log(
+    `dateTimeGetOverlappingHoursCommonHelper weekHours: ${JSON.stringify(
+      weekHours
+    )}, inputInterval: ${JSON.stringify(inputInterval)}`
+  );
+
+  let commonInterval: Interval | null = null;
+
+  // const inputIntervalNormalized = normalizeLuxonInterval(inputInterval);
+
+  for (const dayIdx in weekHours) {
+    const dayKey = parseInt(dayIdx) as DayOfWeekIdx;
+
+    // console.log(`dateTimeGetCommonOverlappingHours dayIdx: ${dayIdx}`);
+
+    if (weekHours[dayKey] == null) {
+      continue;
+    }
+
+    // Calculate overlapping intervals for the current day
+    const dailyIntervals = getOverlappingIntervalsList(
+      weekHours[dayKey],
+      inputInterval
+    );
+
+    console.log(
+      `dateTimeGetOverlappingHoursCommonHelper dayIdx: ${dayIdx}, dailyIntervals: ${JSON.stringify(
+        dailyIntervals
+      )}`
+    );
+
+    if (dailyIntervals.length === 0) {
+      // No overlap for this day, so no common interval is possible
+      continue;
+    }
+
+    // Treat each daily interval separately
+    const dailyTimeIntervals = dailyIntervals
+      .filter(
+        (dailyInterval) =>
+          dailyInterval.start !== null && dailyInterval.end !== null
+      )
+      .map((dailyInterval) => {
+        return normalizeLuxonInterval(dailyInterval);
+      });
+
+    // Find the intersection of all daily intervals with the current common interval
+    for (const dailyTimeInterval of dailyTimeIntervals) {
+      if (commonInterval === null) {
+        commonInterval = dailyTimeInterval;
+      } else {
+        commonInterval = commonInterval.intersection(dailyTimeInterval);
+        if (commonInterval === null) {
+          // If no common interval remains, return null early
+          return null;
+        }
+      }
+    }
+  }
+
+  // console.log(
+  //   `dateTimeGetCommonOverlappingHours commonInterval: ${JSON.stringify(
+  //     commonInterval
+  //   )}`
+  // );
+
+  // Convert the common interval to a LuxonDateRange if it exists
+  if (
+    commonInterval == null ||
+    commonInterval.start == null ||
+    commonInterval.end == null
+  ) {
+    return null;
+  }
+
+  return {
+    start: commonInterval.start,
+    end: commonInterval.end,
+  } as LuxonDateRange;
+}
+
+export function dateTimeGetOverlappingHoursCommon(
+  weekHours: LuxonDayOfWeekHours,
+  inputHours: LuxonDateRange
+): LuxonDateRange | null {
+  const inputInterval = Interval.fromDateTimes(
+    inputHours.start,
+    inputHours.end
+  );
+
+  return dateTimeGetOverlappingHoursCommonHelper(weekHours, inputInterval);
+}
+
+// Returns a list of overlapping hours for any dateRange in weekHours[startDay of inputRange]
+export function dateTimeGetOverlappingHoursContinuousHelper(
+  weekHours: LuxonDayOfWeekHours,
+  inputInterval: Interval
+): LuxonDateRange[] | null {
+  console.log(
+    `dateTimeGetOverlappingHoursContinuousHelper weekHours: ${JSON.stringify(
+      weekHours
+    )}, inputRange: ${JSON.stringify(inputInterval)}`
+  );
+
+  if (!inputInterval.start) {
+    return null;
+  }
+
+  const startDayIdx = inputInterval.start.weekday as keyof LuxonDayOfWeekHours;
+
+  if (!weekHours[startDayIdx]) {
+    return null;
+  }
+
+  // Calculate overlapping intervals for the start day of inputRange
+  const overlappingIntervals = getOverlappingIntervalsList(
+    weekHours[startDayIdx],
+    inputInterval
+  );
+
+  console.log(
+    `dateTimeGetOverlappingHoursContinuousHelper startDayIdx: ${startDayIdx}, overlappingIntervals: ${JSON.stringify(
+      overlappingIntervals
+    )}`
+  );
+
+  // Convert overlapping intervals back to LuxonDateRange[]
+  return overlappingIntervals
+    .filter((interval) => interval.start !== null && interval.end !== null)
+    .map(
+      (interval) =>
+        ({
+          start: interval.start,
+          end: interval.end,
+        } as LuxonDateRange)
+    );
+}
+
+export function dateTimeGetOverlappingHoursContinuous(
+  weekHours: LuxonDayOfWeekHours,
+  inputHours: LuxonDateRange
+): LuxonDateRange[] | null {
+  const inputInterval = Interval.fromDateTimes(
+    inputHours.start,
+    inputHours.end
+  );
+
+  return dateTimeGetOverlappingHoursContinuousHelper(weekHours, inputInterval);
+}
+
+export function filterConflictingIntervals(
+  availableHours: LuxonDateRange[],
+  blockedHours: LuxonDateRange[]
+): LuxonDateRange[] {
+  // Convert available hours into an array of Intervals
+  let remainingIntervals = availableHours.map(({ start, end }) =>
+    Interval.fromDateTimes(start, end)
+  );
+
+  // Convert blocked hours into Intervals and subtract them from each available interval
+  blockedHours
+    .map(({ start, end }) => Interval.fromDateTimes(start, end))
+    .forEach((blockedInterval) => {
+      remainingIntervals = remainingIntervals.flatMap((availableInterval) =>
+        availableInterval.difference(blockedInterval)
+      );
+    });
+
+  // Convert the resulting Intervals back to LuxonDateRange[]
+  return remainingIntervals.map((interval) => ({
+    start: interval.start!,
+    end: interval.end!,
+  }));
+}
+
+export function getConflictingIntervals(
+  availableHours: LuxonDateRange[],
+  blockedHours: LuxonDateRange[]
+): LuxonDateRange[] {
+  // Convert available hours and blocked hours into arrays of Luxon Intervals
+  const availableIntervals = availableHours.map(({ start, end }) =>
+    Interval.fromDateTimes(start, end)
+  );
+  const blockedIntervals = blockedHours.map(({ start, end }) =>
+    Interval.fromDateTimes(start, end)
+  );
+
+  // For each available interval, find intersections with each blocked interval
+  const conflictingIntervals: Interval[] = [];
+  availableIntervals.forEach((availableInterval) => {
+    blockedIntervals.forEach((blockedInterval) => {
+      const intersection = availableInterval.intersection(blockedInterval);
+      if (intersection) {
+        conflictingIntervals.push(intersection);
+      }
+    });
+  });
+
+  // Convert the resulting conflicting Intervals back to LuxonDateRange[]
+  return conflictingIntervals.map((interval) => ({
+    start: interval.start!,
+    end: interval.end!,
+  }));
+}
+
+export interface TimeSlots {
+  start: string[];
+  end: string[];
+}
+
+// export function generateTimeSlots(
+//   filteredHours: LuxonDateRange[],
+//   bookedRange: LuxonDateRange,
+//   businessHours: LuxonDayOfWeekHours
+// ): TimeSlots {
+//   const timeSlotsStart: string[] = [];
+//   let timeSlotsEnd: string[] = [];
+
+//   let currentTime = bookedRange.start;
+//   const endTime = bookedRange.end;
+
+//   while (currentTime < endTime) {
+//     const currentDayOfWeek = currentTime.weekday as DayOfWeekIdx;
+//     const businessDayHours = businessHours[currentDayOfWeek]?.[0];
+
+//     if (!businessDayHours) {
+//       throw new Error("No business hours found for the current day.");
+//     }
+
+//     const { start: dayStart, end: dayEnd } = businessDayHours;
+
+//     // Ensure the current time is within today's business hours
+//     if (currentTime < dayStart) {
+//       currentTime = dayStart;
+//     }
+
+//     // If adding 30 minutes exceeds today's boundary, jump to the next day's start
+//     if (currentTime.plus({ minutes: 30 }) > dayEnd) {
+//       const nextDayOfWeek = currentTime.plus({ days: 1 })
+//         .weekday as DayOfWeekIdx;
+//       const nextDayHours = businessHours[nextDayOfWeek]?.[0];
+
+//       if (!nextDayHours) {
+//         throw new Error("No business hours for the next day.");
+//       }
+
+//       currentTime = nextDayHours.start;
+//     } else {
+//       timeSlotsStart.push(dateTimeFormatTime(currentTime));
+//       currentTime = currentTime.plus({ minutes: 30 });
+//     }
+//   }
+
+//   // The last slot should match the end time, respecting endDayOfWeek business hours
+//   const endDayOfWeek = bookedRange.end.weekday as DayOfWeekIdx;
+//   const endDayHours = businessHours[endDayOfWeek]?.[0];
+
+//   if (!endDayHours) {
+//     throw new Error("No business hours for the final day.");
+//   }
+
+//   const finalEndTime =
+//     bookedRange.end > endDayHours.end ? endDayHours.end : bookedRange.end;
+//   timeSlotsEnd = [...timeSlotsStart.slice(1), dateTimeFormatTime(finalEndTime)];
+
+//   return {
+//     start: timeSlotsStart,
+//     end: timeSlotsEnd,
+//   } as TimeSlots;
+// }
+
+export function generateTimeSlots(filteredHours: LuxonDateRange[]): TimeSlots {
+  const timeSlotsStart: string[] = [];
+  let timeSlotsEnd: string[] = [];
+
+  filteredHours.forEach(({ start, end }) => {
+    let currentTime = start;
+
+    while (currentTime < end) {
+      timeSlotsStart.push(dateTimeFormatTime(currentTime)); // Add the time in "HH:mm" format
+      currentTime = currentTime.plus({ minutes: 30 }); // Increment by 30 minutes
+    }
+
+    const finalTime =
+      currentTime.hour == 0 && currentTime.minute == 0
+        ? currentTime.set({ hour: 23, minute: 59 })
+        : currentTime;
+    timeSlotsEnd = [...timeSlotsStart.slice(1), dateTimeFormatTime(finalTime)];
+  });
+
+  return {
+    start: timeSlotsStart,
+    end: timeSlotsEnd,
+  } as TimeSlots;
+}
+
+export function dateTimeNormalizeToMWY(
+  srcDate: DateTime,
+  referenceDate: DateTime
+): DateTime {
+  const srcWeekday = srcDate.weekday;
+  const firstDayOfReferenceMonth = DateTime.fromObject(
+    {
+      year: referenceDate.year,
+      month: referenceDate.month,
+      day: 1,
+    },
+    { zone: srcDate.zone }
+  );
+
+  const weekdayOffset = (srcWeekday - firstDayOfReferenceMonth.weekday + 7) % 7;
+  const referenceWeekday = firstDayOfReferenceMonth.plus({
+    days: weekdayOffset,
+  });
+
+  const referenceWeek = Math.ceil((referenceDate.day - 1 - weekdayOffset) / 7); //ceil instead of floor to ensure week wraps around forward and not backwards
+  const normalizedDate = referenceWeekday.plus({ weeks: referenceWeek }).set({
+    hour: srcDate.hour,
+    minute: srcDate.minute,
+  });
+
+  // console.log(
+  //   `dateTimeNormalizeToMWY: srcDate: ${JSON.stringify(
+  //     srcDate
+  //   )}, referenceDate: ${JSON.stringify(
+  //     referenceDate
+  //   )}, referenceDate: ${JSON.stringify(normalizedDate)}`
+  // );
+
+  return normalizedDate;
+}
+
+export function dateRangeNormalizeToMWY(
+  srcRange: LuxonDateRange,
+  referenceRange: LuxonDateRange
+): LuxonDateRange {
+  // Calculate the original duration between start and end
+  const originalDuration = srcRange.end.diff(srcRange.start, [
+    "weeks",
+    "days",
+    "hours",
+  ]);
+
+  // Normalize the start date
+  const newStart = dateTimeNormalizeToMWY(srcRange.start, referenceRange.start);
+
+  // Apply the duration to the normalized start to compute the new end
+  let newEnd = newStart.plus(originalDuration);
+
+  // Check if the end date wraps around to the next week
+  if (newEnd.weekNumber < newStart.weekNumber) {
+    // Adjust to the next week by adding one week
+    newEnd = newEnd.plus({ weeks: 1 });
+  }
+
+  const newRange = {
+    start: newStart,
+    end: newEnd,
+  } as LuxonDateRange;
+
+  // console.log(
+  //   `dateRangeNormalizeToMWY srcRange: ${JSON.stringify(
+  //     srcRange
+  //   )}, referenceRange: ${JSON.stringify(
+  //     referenceRange
+  //   )}, newRange: ${JSON.stringify(newRange)}`
+  // );
+
+  return newRange;
+}
+
+//need function to extend out businesshours until the date of the reference range
+
+//need function to merge overlap[startDate] if they continue onto the next day
+
+export function luxonDateRangeSort(dateRanges: LuxonDateRange[]) {
+  return dateRanges.sort((a, b) => a.start.toMillis() - b.start.toMillis());
+}
+
+export function dateTimeDiffHours(
+  startTime: DateTime | null,
+  endTime: DateTime | null
+): number {
+  // console.log(
+  //   `calculateHoursBetweenTimes startTime: ${JSON.stringify(
+  //     startTime
+  //   )}, endTime: ${JSON.stringify(endTime)}`
+  // );
+
+  if (startTime == null || endTime == null) {
+    return 0;
+  }
+
+  const diff = endTime.diff(startTime, ["minutes", "days"]).toObject();
+  const hours = ((diff.minutes ?? 0) + 1) / 60;
+  const days = (diff.days ?? 0) + 1;
+
+  // console.log(`calculateHoursBetweenTimes diff: ${JSON.stringify(diff)}`);
+
+  return roundToNearestDivisor(hours * days, 4); //round to nearest quarter hour
+}
+
+export function dateTimeRangeHours(dateTimeRange: LuxonDateRange) {
+  return roundToNearestDivisor(
+    dateTimeRangeToInterval(dateTimeRange).toDuration("hours").toObject()
+      ?.hours ?? 0,
+    4
+  ); //round to nearest quarter hour
+}
+
+export function dateTimeRangeCrossesMidnight(range: LuxonDateRange) {
+  return (
+    range.start.hour > range.end.hour ||
+    (range.start.hour === range.end.hour &&
+      range.start.minute >= range.end.minute)
+  );
+}
+
+/**
+ * Given an overall range, split it into segments that use the input’s
+ * start time as the daily “start” and the input’s end time as the daily “end.”
+ *
+ * Each segment will run from a day’s daily start to the next day’s daily end.
+ *
+ * For example, if the overall range is:
+ *    start: March 5, 2025 11:00 am
+ *    end:   March 9, 2025 9:00 pm
+ *
+ * then the segments produced are:
+ *    March 5, 11:00 am – March 6, 9:00 pm
+ *    March 6, 11:00 am – March 7, 9:00 pm
+ *    March 7, 11:00 am – March 8, 9:00 pm
+ *    March 8, 11:00 am – March 9, 9:00 pm
+ *
+ * (You can then filter out partial segments if you want only full “days”.)
+ */
+export function splitRangeByInputTimes(
+  range: LuxonDateRange
+): LuxonDateRange[] {
+  const startTime = dateTimeToTimeComponents(range.start);
+  const endTime = dateTimeToTimeComponents(range.end);
+
+  const segments: LuxonDateRange[] = [];
+
+  // Determine if the range crosses midnight.
+  const crossesMidnight = dateTimeRangeCrossesMidnight(range);
+
+  // Set the first segment’s start.
+  let currentStart = range.start.set(startTime);
+  if (currentStart < range.start) {
+    currentStart = currentStart.plus({ days: 1 });
+  }
+
+  while (true) {
+    // Determine current segment's end depending on whether we cross midnight.
+    const currentEnd = crossesMidnight
+      ? currentStart.plus({ days: 1 }).set(endTime)
+      : currentStart.set(endTime);
+
+    if (currentEnd > range.end) {
+      // segments.push({ start: currentStart, end: range.end });
+      break;
+    }
+    segments.push({ start: currentStart, end: currentEnd });
+
+    // Move to the next segment’s start:
+    // (Always add one day and then snap to the start time.)
+    currentStart = currentStart.plus({ days: 1 }).set(startTime);
+  }
+
+  return segments;
+}
+
+export function dateTimeRangeFromDates(
+  startDate: Date | string,
+  endDate: Date | string,
+  interpretAsTimezone?: string,
+  timezoneToConvertTo?: string
+): LuxonDateRange {
+  return {
+    start: dateTimeFromDate(
+      startDate,
+      interpretAsTimezone,
+      timezoneToConvertTo
+    ),
+    end: dateTimeFromDate(endDate, interpretAsTimezone, timezoneToConvertTo),
+  } as LuxonDateRange;
+}
+
+export function dateTimeFromString(str: string) {
+  return DateTime.fromISO(str);
+}
+
+export function dateTimeToString(dateTime: DateTime): string | null {
+  return dateTime.toISO();
+}
+
+export function dateRangesFormat(dateTimes: LuxonDateRange[]): string {
+  const result = dateTimes.join(", ");
+  return result;
+}