@dereekb/date 10.1.29 → 10.2.0

package/index.cjs.js

@@ -1973,6 +1973,8 @@ function utcDayForDate(date) {
  * For example, if it is currently 9PM:
  * - if 10PM on any day is passed then 9PM the next day will be returned.
  * - if 11PM on any day is passed, 11PM today will be returned.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function takeNextUpcomingTime(date, roundDownToMinute) {
   date = copyHoursAndMinutesFromDateToToday(date, roundDownToMinute);
@@ -1983,18 +1985,24 @@ function takeNextUpcomingTime(date, roundDownToMinute) {
 }
 /**
  * Creates a new date and copies the hours/minutes from the previous date and applies them to a date for today.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromDateToToday(fromDate, roundDownToMinute) {
   return copyHoursAndMinutesFromDate(new Date(), fromDate, roundDownToMinute);
 }
 /**
  * Copies the hours/minutes from now to the target date.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromNow(target, roundDownToMinute) {
   return copyHoursAndMinutesFromDate(target, new Date(), roundDownToMinute);
 }
 /**
  * Creates a new date and copies the hours/minutes from the input date to the target date.
+ *
+ * @deprecated Fails in the rare case where it is the first two hours of a day in a daylight savings zone when daylight savings changes.
  */
 function copyHoursAndMinutesFromDate(target, fromDate, roundDownToMinute) {
   return copyHoursAndMinutesToDate({
@@ -2034,22 +2042,56 @@ const copyHoursAndMinutesToToday = copyHoursAndMinutesToDate;
  * Removes the seconds and milliseconds from the input date, or returns the current date with no seconds or milliseconds.
  */
 function roundDownToMinute(date = new Date()) {
-  return dateFns.set(date, {
-    seconds: 0,
-    milliseconds: 0
-  });
+  return roundDateDownTo(date, 'minute');
 }
 /**
- * Removes all minutes,
+ * Removes the minutes, seconds and milliseconds from the input date, or returns the current date with no mkinutes, seconds or milliseconds.
+ */
+function roundDownToHour(date = new Date()) {
+  return roundDateDownTo(date, 'hour');
+}
+function roundDateDownTo(date, roundToUnit) {
+  return roundDateToDate(date, roundToUnit, 'floor');
+}
+function roundDateTo(date, roundToUnit, roundType = 'floor') {
+  return typeof date === 'number' ? roundDateToUnixDateTimeNumber(date, roundToUnit, roundType) : roundDateTo(date, roundToUnit, roundType);
+}
+function roundDateToDate(date, roundToUnit, roundType = 'floor') {
+  return new Date(roundDateToUnixDateTimeNumber(date, roundToUnit, roundType));
+}
+/**
+ * Rounds the input Date value down to the nearest hour, minute, or second.
+ *
  * @param date
+ * @param roundToUnit
+ * @param roundType
  * @returns
  */
-function roundDownToHour(date) {
-  return dateFns.set(date, {
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0
-  });
+function roundDateToUnixDateTimeNumber(date, roundToUnit, roundType = 'floor') {
+  const inputTimeUnrounded = typeof date === 'number' ? date : date.getTime();
+  let roundAmount = 0;
+  switch (roundToUnit) {
+    case 'hour':
+      roundAmount = util.MS_IN_HOUR;
+      break;
+    case 'second':
+      roundAmount = util.MS_IN_SECOND;
+      break;
+    default:
+    case 'minute':
+      roundAmount = util.MS_IN_MINUTE;
+      break;
+  }
+  const secondsAndMs = inputTimeUnrounded % roundAmount; // determine the number of seconds and milliseconds (prepare to round to nearest minute)
+  let roundedTime = inputTimeUnrounded;
+  if (secondsAndMs !== 0) {
+    roundedTime = inputTimeUnrounded - secondsAndMs; // remove seconds and ms as it will throw off the final tzOffset
+    if (roundType === 'ceil') {
+      roundedTime += roundAmount; // round up by adding the units
+    }
+  }
+
+  return roundedTime;
 }
 function reduceDatesFunction(reduceDates) {
   return inputDates => {
@@ -2840,6 +2882,58 @@ function isSameDurationSpan(a, b) {
   return util.safeCompareEquality(a, b, (a, b) => a.duration === b.duration && isSameDate(a.startsAt, b.startsAt));
 }
 
+const DATE_TODAY_START_VALUE = 'today_start';
+const DATE_TODAY_END_VALUE = 'today_end';
+const DATE_WEEK_START_VALUE = 'this_week_start';
+const DATE_WEEK_END_VALUE = 'this_week_end';
+function logicalDateStringCodeDateFactory(logicalDateStringCode) {
+  let mapFn;
+  switch (logicalDateStringCode.toLocaleLowerCase()) {
+    case util.DATE_NOW_VALUE:
+      mapFn = util.mapIdentityFunction();
+      break;
+    case DATE_TODAY_START_VALUE:
+      mapFn = dateFns.startOfDay;
+      break;
+    case DATE_TODAY_END_VALUE:
+      mapFn = dateFns.endOfDay;
+      break;
+    case DATE_WEEK_START_VALUE:
+      mapFn = dateFns.startOfWeek;
+      break;
+    case DATE_WEEK_END_VALUE:
+      mapFn = dateFns.endOfWeek;
+      break;
+    default:
+      throw new Error(`Unknown logical date string "${logicalDateStringCode}"`);
+  }
+  return (now = new Date()) => mapFn(now);
+}
+function dateFromLogicalDate(logicalDate, now = new Date()) {
+  let result;
+  if (typeof logicalDate === 'string') {
+    result = logicalDateStringCodeDateFactory(logicalDate)(now);
+  } else {
+    result = logicalDate;
+  }
+  return result;
+}
+function isLogicalDateStringCode(logicalDate) {
+  let isLogicalDateStringCode = false;
+  if (typeof logicalDate === 'string') {
+    switch (logicalDate.toLocaleLowerCase()) {
+      case util.DATE_NOW_VALUE:
+      case DATE_TODAY_START_VALUE:
+      case DATE_TODAY_END_VALUE:
+      case DATE_WEEK_START_VALUE:
+      case DATE_WEEK_END_VALUE:
+        isLogicalDateStringCode = true;
+        break;
+    }
+  }
+  return isLogicalDateStringCode;
+}
+
 /**
  * Returns true if any DateTimezoneConversionConfig configuration value is provided.
  *
@@ -2874,7 +2968,8 @@ function isSameDateTimezoneConversionConfig(a, b) {
  * @returns
  */
 function getCurrentSystemOffsetInMs(date) {
-  return minutesToMs(getCurrentSystemOffsetInMinutes(date));
+  const systemTimezone = requireCurrentTimezone();
+  return calculateTimezoneOffset(systemTimezone, date);
 }
 /**
  * Returns the current system time offset in hours.
@@ -2883,20 +2978,25 @@ function getCurrentSystemOffsetInMs(date) {
  * @returns
  */
 function getCurrentSystemOffsetInHours(date) {
-  return dateFns.minutesToHours(getCurrentSystemOffsetInMinutes(date));
+  return dateFns.millisecondsToHours(getCurrentSystemOffsetInMs(date));
 }
 /**
- * Equivalent to -date.getTimezoneOffset().
+ * Returns the system offset for the input date, in minutes.
+ *
+ * The offset corresponds positively with the UTC offset, so UTC-6 is negative 6 hours, in milliseconds.
  *
  * @param date
  * @returns
  */
 function getCurrentSystemOffsetInMinutes(date) {
-  return -date.getTimezoneOffset();
+  return dateFns.millisecondsToMinutes(getCurrentSystemOffsetInMs(date));
 }
 /**
  * Returns the timezone offset in milliseconds.
  *
+ * This is preferential to Date.getTimezoneOffset() or date-fns's getTimezoneOffset() as those are currently wrong for the first
+ * two hours when daylight savings changes.
+ *
  * I.E. GMT-5 = -5 hours (in milliseconds)
  *
  * @param timezone
@@ -2910,14 +3010,17 @@ function calculateTimezoneOffset(timezone, date) {
   
   const tzOffset = getTimezoneOffset(timezone, date);
   */
-  // WORKAROUND: This is the current workaround. Performance hit seems negligible for all UI use cases.
-  const zoneDate = dateFnsTz.utcToZonedTime(date, timezone);
+  /*
+   * WORKAROUND: This is the current workaround. Performance hit seems negligible for all UI use cases.
+   */
+  // inputTimeDate.setSeconds(0);         // NOTE: setting seconds/milliseconds during the daylight savings epoch will also remove an hour
+  // inputTimeDate.setMilliseconds(0);    // do not clear seconds in this way.
+  const inputTimeUnrounded = date.getTime();
+  const secondsAndMs = inputTimeUnrounded % util.MS_IN_MINUTE; // determine the number of seconds and milliseconds (prepare to round to nearest minute)
+  const inputTime = inputTimeUnrounded - secondsAndMs; // remove seconds and ms as it will throw off the final tzOffset
+  const zoneDate = dateFnsTz.utcToZonedTime(inputTime, timezone);
   const zoneDateStr = dateFnsTz.format(zoneDate, 'yyyy-MM-dd HH:mm'); // ignore seconds, etc.
   const zoneDateTime = new Date(zoneDateStr + 'Z').getTime();
-  const inputTime = dateFns.set(date, {
-    seconds: 0,
-    milliseconds: 0
-  }).getTime();
   const tzOffset = zoneDateTime - inputTime;
   return tzOffset;
 }
@@ -2976,6 +3079,7 @@ class DateTimezoneUtcNormalInstance {
     return timezone !== null && timezone !== void 0 ? timezone : this.config.useSystemTimezone ? guessCurrentTimezone() : undefined;
   }
   constructor(config) {
+    this._setOnDate = util.cachedGetter(() => setOnDateWithTimezoneNormalFunction(this));
     let getOffsetInMsFn;
     function useTimezone(timezone) {
       getOffsetInMsFn = date => calculateTimezoneOffset(timezone, date);
@@ -3045,10 +3149,44 @@ class DateTimezoneUtcNormalInstance {
     }
     this.hasConversion = hasConversion;
   }
-  _computeOffsetDate(date, from, to) {
+  convertDate(date, from, to) {
     return dateFns.addMilliseconds(date, this._getOffset(date, from, to));
   }
+  /**
+   * A "safer" conversion that will return a "mirrored" offset. Only functional with a "to" UTC value.
+   *
+   * This is required in cases where "reverse" offset will be used and must be consistent so they reverse in both directions the same amount compared to the base.
+   *
+   * For example, when daylight savings changed on November 3, 2024 the offset returned was 5 but to get back to the original an offset of 6 was required.
+   * This is where some contextual data was not being used. This function uses that contextual data to make sure the reverse will be consistent.
+   *
+   * @param baseDate The base date. Should have been derived from the originalContextDate using the convertDate() function
+   * @param originalContextDate Original date used to derive the baseDate.
+   * @param fromOrTo the "type" of date the originalContextDate is
+   */
+  safeMirroredConvertDate(baseDate, originalContextDate, contextType, safeConvert = true) {
+    if (contextType === 'base') {
+      return {
+        date: baseDate,
+        daylightSavingsOffset: 0
+      };
+    } else {
+      const reverseConversion = this.convertDate(baseDate, contextType, 'base');
+      // in some cases where daylight savings ends (november 3rd),
+      // the input startsAt time will not be properly recovered due to loss of timezone information
+      // (cannot determine whether or not to apply the -5 or -6 offset after daylight savings ends)
+      const daylightSavingsOffset = safeConvert ? dateFns.differenceInHours(originalContextDate, reverseConversion) : 0;
+      const date = daylightSavingsOffset ? dateFns.addHours(reverseConversion, daylightSavingsOffset) : reverseConversion;
+      return {
+        date,
+        daylightSavingsOffset
+      };
+    }
+  }
   // MARK: DateTimezoneBaseDateConverter
+  get setOnDate() {
+    return this._setOnDate();
+  }
   getCurrentOffset(date, from, to) {
     return this._getOffset(date, from, to);
   }
@@ -3062,22 +3200,22 @@ class DateTimezoneUtcNormalInstance {
     return transformDateRangeToTimezoneFunction(this, transformType);
   }
   targetDateToBaseDate(date) {
-    return this._computeOffsetDate(date, 'target', 'base');
+    return this.convertDate(date, 'target', 'base');
   }
   baseDateToTargetDate(date) {
-    return this._computeOffsetDate(date, 'base', 'target');
+    return this.convertDate(date, 'base', 'target');
   }
   baseDateToSystemDate(date) {
-    return this._computeOffsetDate(date, 'base', 'system');
+    return this.convertDate(date, 'base', 'system');
   }
   systemDateToBaseDate(date) {
-    return this._computeOffsetDate(date, 'system', 'base');
+    return this.convertDate(date, 'system', 'base');
   }
   targetDateToSystemDate(date) {
-    return this._computeOffsetDate(date, 'target', 'system');
+    return this.convertDate(date, 'target', 'system');
   }
   systemDateToTargetDate(date) {
-    return this._computeOffsetDate(date, 'system', 'target');
+    return this.convertDate(date, 'system', 'target');
   }
   getOffset(date, transform) {
     return this[`${transform}Offset`](date);
@@ -3106,6 +3244,9 @@ class DateTimezoneUtcNormalInstance {
   systemDateToTargetDateOffset(date) {
     return this._getOffset(date, 'system', 'target');
   }
+  conversionOffset(date, from, to) {
+    return this._getOffset(date, from, to);
+  }
   calculateAllOffsets(date, map) {
     return calculateAllConversions(date, this, map);
   }
@@ -3317,6 +3458,77 @@ function startOfDayInTimezoneDayStringFactory(timezone) {
 function startOfDayInTimezoneFromISO8601DayString(day, timezone) {
   return startOfDayInTimezoneDayStringFactory(timezone)(day);
 }
+/**
+ * Creates a new SetONDateFunction using the input
+ */
+function setOnDateWithTimezoneNormalFunction(timezone) {
+  const timezoneInstance = dateTimezoneUtcNormal(timezone);
+  const fn = input => {
+    const {
+      date: inputDate,
+      copyFrom: copyFromInput,
+      copyHours,
+      copyMinutes,
+      inputType: inputInputType,
+      outputType,
+      hours: inputHours,
+      minutes: inputMinutes,
+      roundDownToMinute
+    } = input;
+    const DEFAULT_TYPE = 'target';
+    const inputType = inputInputType !== null && inputInputType !== void 0 ? inputInputType : DEFAULT_TYPE;
+    let baseDate;
+    let copyFrom;
+    // set copyFrom
+    if (copyFromInput != null) {
+      copyFrom = dateFromLogicalDate(copyFromInput); // read the logical date and set initial value
+      // if the input matches the copyFrom values, then skip conversion
+      // this step is also crucial for returning the correct value for daylight savings ending changes
+      if (inputDate != null && isSameDate(copyFrom, inputDate) && copyHours !== false && copyMinutes !== false) {
+        return roundDownToMinute ? roundDateDownTo(inputDate, 'minute') : inputDate;
+      }
+      if (inputType !== 'base') {
+        copyFrom = copyFrom != null ? timezoneInstance.convertDate(copyFrom, 'base', inputType) : undefined;
+      }
+    }
+    // set baseDate
+    if (inputDate != null) {
+      if (inputType === 'base') {
+        // use dates directly as UTC
+        baseDate = inputDate;
+      } else {
+        baseDate = timezoneInstance.convertDate(inputDate, 'base', inputType);
+      }
+    } else {
+      baseDate = new Date();
+    }
+    const hours = inputHours !== null && inputHours !== void 0 ? inputHours : copyHours !== false ? copyFrom === null || copyFrom === void 0 ? void 0 : copyFrom.getUTCHours() : undefined;
+    const minutes = inputMinutes !== null && inputMinutes !== void 0 ? inputMinutes : copyMinutes !== false ? copyFrom === null || copyFrom === void 0 ? void 0 : copyFrom.getUTCMinutes() : undefined;
+    // NOTE: We do the math this way to avoid issues surrounding daylight savings
+    const time = baseDate.getTime();
+    const currentDayMillseconds = time % util.MS_IN_DAY;
+    const minutesSecondsAndMillseconds = currentDayMillseconds % util.MS_IN_HOUR;
+    const hoursInTimeInMs = currentDayMillseconds - minutesSecondsAndMillseconds;
+    const secondsAndMilliseconds = minutesSecondsAndMillseconds % util.MS_IN_MINUTE;
+    const minutesInTime = minutesSecondsAndMillseconds - secondsAndMilliseconds;
+    const nextDay = time - currentDayMillseconds;
+    const nextMinutes = minutes != null ? minutes * util.MS_IN_MINUTE : minutesInTime;
+    const nextHours = hours != null ? hours * util.MS_IN_HOUR : hoursInTimeInMs;
+    const nextTime = nextDay + nextHours + nextMinutes + (roundDownToMinute ? 0 : secondsAndMilliseconds);
+    const nextBaseDate = new Date(nextTime);
+    let result = timezoneInstance.convertDate(nextBaseDate, outputType !== null && outputType !== void 0 ? outputType : inputType, 'base');
+    // one more test to limit the "range" of the change
+    // if it is over 1 day, then we can infer there is a timezone mismatch issue. It only occurs in one direction here, so we can safely
+    // infer that the real valid result can be derived by subtracting one day
+    const inputToResultDifferenceInHours = inputDate != null ? dateFns.differenceInHours(result, inputDate) : 0;
+    if (inputToResultDifferenceInHours >= 24) {
+      result = dateFns.addHours(result, -24);
+    }
+    return result;
+  };
+  fn._timezoneInstance = timezoneInstance;
+  return fn;
+}
 // MARK: Timezone Utilities
 /**
  * Convenience function for calling copyHoursAndMinutesFromDatesWithTimezoneNormal() with now.
@@ -3326,10 +3538,10 @@ function startOfDayInTimezoneFromISO8601DayString(day, timezone) {
  * @returns
  */
 function copyHoursAndMinutesFromNowWithTimezoneNormal(input, timezone) {
-  return copyHoursAndMinutesFromDateWithTimezoneNormal(input, new Date(), timezone);
+  return copyHoursAndMinutesFromDateWithTimezoneNormal(input, 'now', timezone);
 }
 /**
- * Converts the two input dates, which are dates in the same timezone/normal but than the current system, using the input DateTimezoneUtcNormalFunctionInput.
+ * Converts the two input dates, which are dates in the same timezone/normal instead of the current system, using the input DateTimezoneUtcNormalFunctionInput.
  *
  * This converts the dates to the system timezone normal, copies the values, then back to the original timezone normal.
  *
@@ -3339,15 +3551,13 @@ function copyHoursAndMinutesFromNowWithTimezoneNormal(input, timezone) {
  */
 function copyHoursAndMinutesFromDateWithTimezoneNormal(input, copyFrom, timezone) {
   const timezoneInstance = dateTimezoneUtcNormal(timezone);
-  const inputInSystemTimezone = timezoneInstance.systemDateToTargetDate(input);
-  const copyFromInSystemTimezone = timezoneInstance.systemDateToTargetDate(copyFrom);
-  // handle the potential system date time offset when the system's timezone offset changes between dates...
-  const inputInSystemTimezoneOffset = inputInSystemTimezone.getTimezoneOffset();
-  const copyFromInSystemTimezoneOffset = copyFromInSystemTimezone.getTimezoneOffset();
-  const offsetDifference = inputInSystemTimezoneOffset - copyFromInSystemTimezoneOffset;
-  // copy the minutes then add the offset difference to get the appropriate time.
-  const copiedInSystemTimezone = dateFns.addMinutes(copyHoursAndMinutesFromDate(inputInSystemTimezone, copyFromInSystemTimezone), offsetDifference);
-  const result = timezoneInstance.targetDateToSystemDate(copiedInSystemTimezone);
+  const result = timezoneInstance.setOnDate({
+    date: input,
+    copyFrom,
+    inputType: 'target',
+    copyHours: true,
+    copyMinutes: true
+  });
   return result;
 }
 
@@ -3878,9 +4088,7 @@ function IsKnownTimezone(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isKnownTimezone,
-        defaultMessage(args) {
-          return `"${args.value}" is not a known timezone.`;
-        }
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args === null || args === void 0 ? void 0 : args.value}" is not a known timezone.`, validationOptions)
       }
     });
   };
@@ -4416,7 +4624,8 @@ function dateCellTiming(durationInput, rangeInput, timezoneInput) {
     startsAt: inputStartsAt
   } = durationInput;
   // it is important that startsAt is evaluated the base time normal so we can avoid daylight savings issues
-  let startsAtInUtc = normalInstance.baseDateToTargetDate(inputStartsAt);
+  const startsAtInUtcInitial = normalInstance.baseDateToTargetDate(inputStartsAt);
+  let startsAtInUtc = startsAtInUtcInitial;
   let numberOfDayBlocks;
   let hasRangeFromInput = false;
   let rangeInUtc;
@@ -4458,12 +4667,18 @@ function dateCellTiming(durationInput, rangeInput, timezoneInput) {
     startsAtInUtc = roundDownToMinute(startsAtInUtc); // clear seconds and milliseconds from startsAt
   }
 
-  const lastStartsAtInBaseTimezone = dateFns.addHours(startsAtInUtc, numberOfDayBlocks * 24); // use addDays so the system (if it experiences daylight savings) can account for change for daylight savings
-  // calculate end to be the ending date/time of the final duration span
-  const end = dateFns.addMinutes(normalInstance.targetDateToBaseDate(lastStartsAtInBaseTimezone), duration);
   const utcDay = formatToISO8601DayStringForUTC(startsAtInUtc);
   const start = normalInstance.startOfDayInTargetTimezone(utcDay);
-  const startsAt = normalInstance.targetDateToBaseDate(startsAtInUtc);
+  const safeMirror = util.isEqualDate(startsAtInUtc, startsAtInUtcInitial);
+  const {
+    date: startsAt,
+    daylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(startsAtInUtc, inputStartsAt, 'target', safeMirror);
+  // calculate end to be the ending date/time of the final duration span
+  const lastStartsAtInBaseTimezone = dateFns.addHours(startsAtInUtc, numberOfDayBlocks * 24 + daylightSavingsOffset); // use addHours instead of addDays, since addDays will take into account a daylight savings change if the system time changes
+  const lastStartInTarget = normalInstance.targetDateToBaseDate(lastStartsAtInBaseTimezone);
+  const end = dateFns.addMinutes(lastStartInTarget, duration);
+  // console.log({ lastStartsAtInBaseTimezone, inputStartsAt, startsAtInUtcInitial, startsAtInUtc, startsAt, daylightSavingsOffset, start, lastStartInTarget, end });
   return {
     start,
     end,
@@ -4725,11 +4940,24 @@ function calculateExpectedDateCellTimingDurationPair(timing) {
     timezone
   } = timing;
   const normalInstance = dateTimezoneUtcNormal(timezone);
-  const startsAtInUtcNormal = normalInstance.baseDateToTargetDate(startsAt); // convert to UTC normal
-  const endInUtcNormal = normalInstance.baseDateToTargetDate(end);
+  let startsAtInUtcNormal = normalInstance.baseDateToTargetDate(startsAt); // convert to UTC normal
+  let endInUtcNormal = normalInstance.baseDateToTargetDate(end);
+  const {
+    daylightSavingsOffset: startDaylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(startsAtInUtcNormal, startsAt, 'target');
+  const {
+    daylightSavingsOffset: endDaylightSavingsOffset
+  } = normalInstance.safeMirroredConvertDate(endInUtcNormal, end, 'target');
+  if (startDaylightSavingsOffset) {
+    startsAtInUtcNormal = dateFns.addHours(startsAtInUtcNormal, startDaylightSavingsOffset);
+  }
+  if (endDaylightSavingsOffset) {
+    endInUtcNormal = dateFns.addHours(endInUtcNormal, endDaylightSavingsOffset);
+  }
   const finalMsDifferenceBetweenStartAndEnd = dateFns.differenceInMilliseconds(endInUtcNormal, startsAtInUtcNormal);
   const duration = finalMsDifferenceBetweenStartAndEnd / util.MS_IN_MINUTE % util.MINUTES_IN_DAY || util.MINUTES_IN_DAY;
-  const expectedFinalStartsAt = normalInstance.targetDateToBaseDate(dateFns.addMinutes(endInUtcNormal, -duration));
+  const expectedFinalStartsAtUtc = dateFns.addMinutes(endInUtcNormal, -duration);
+  const expectedFinalStartsAt = normalInstance.targetDateToBaseDate(expectedFinalStartsAtUtc); // 2024-11-03T03:00:00.000Z
   return {
     duration,
     expectedFinalStartsAt
@@ -7371,9 +7599,7 @@ function IsValidDateCellTiming(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellTiming,
-        defaultMessage(args) {
-          return `"${JSON.stringify(args.value)}" is not a valid DateCellTiming.`;
-        }
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellTiming.`, validationOptions)
       }
     });
   };
@@ -7390,9 +7616,7 @@ function IsValidDateCellRange(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellRange,
-        defaultMessage(args) {
-          return `"${JSON.stringify(args.value)}" is not a valid DateCellRange.`;
-        }
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellRange.`, validationOptions)
       }
     });
   };
@@ -7409,9 +7633,7 @@ function IsValidDateCellRangeSeries(validationOptions) {
       options: validationOptions,
       validator: {
         validate: isValidDateCellRangeSeries,
-        defaultMessage(args) {
-          return `"${JSON.stringify(args.value)}" is not a valid DateCellRange series. Items must be sorted in ascending order and have no repeat indexes.`;
-        }
+        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${JSON.stringify(args === null || args === void 0 ? void 0 : args.value)}" is not a valid DateCellRange series. Items must be sorted in ascending order and have no repeat indexes.`, validationOptions)
       }
     });
   };
@@ -7480,58 +7702,6 @@ class DateSet extends util.HashSet {
   }
 }
 
-const DATE_TODAY_START_VALUE = 'today_start';
-const DATE_TODAY_END_VALUE = 'today_end';
-const DATE_WEEK_START_VALUE = 'this_week_start';
-const DATE_WEEK_END_VALUE = 'this_week_end';
-function logicalDateStringCodeDateFactory(logicalDateStringCode) {
-  let mapFn;
-  switch (logicalDateStringCode.toLocaleLowerCase()) {
-    case util.DATE_NOW_VALUE:
-      mapFn = util.mapIdentityFunction();
-      break;
-    case DATE_TODAY_START_VALUE:
-      mapFn = dateFns.startOfDay;
-      break;
-    case DATE_TODAY_END_VALUE:
-      mapFn = dateFns.endOfDay;
-      break;
-    case DATE_WEEK_START_VALUE:
-      mapFn = dateFns.startOfWeek;
-      break;
-    case DATE_WEEK_END_VALUE:
-      mapFn = dateFns.endOfWeek;
-      break;
-    default:
-      throw new Error(`Unknown logical date string "${logicalDateStringCode}"`);
-  }
-  return (now = new Date()) => mapFn(now);
-}
-function dateFromLogicalDate(logicalDate, now = new Date()) {
-  let result;
-  if (typeof logicalDate === 'string') {
-    result = logicalDateStringCodeDateFactory(logicalDate)(now);
-  } else {
-    result = logicalDate;
-  }
-  return result;
-}
-function isLogicalDateStringCode(logicalDate) {
-  let isLogicalDateStringCode = false;
-  if (typeof logicalDate === 'string') {
-    switch (logicalDate.toLocaleLowerCase()) {
-      case util.DATE_NOW_VALUE:
-      case DATE_TODAY_START_VALUE:
-      case DATE_TODAY_END_VALUE:
-      case DATE_WEEK_START_VALUE:
-      case DATE_WEEK_END_VALUE:
-        isLogicalDateStringCode = true;
-        break;
-    }
-  }
-  return isLogicalDateStringCode;
-}
-
 function dateOrDayStringRangeToDateRange(range) {
   return {
     start: toJsDayDate(range.start),
@@ -9717,14 +9887,19 @@ exports.readDaysOfWeekNames = readDaysOfWeekNames;
 exports.readableTimeStringToDate = readableTimeStringToDate;
 exports.reduceDatesFunction = reduceDatesFunction;
 exports.requireCurrentTimezone = requireCurrentTimezone;
+exports.roundDateDownTo = roundDateDownTo;
 exports.roundDateTimeDown = roundDateTimeDown;
 exports.roundDateTimeDownToSteps = roundDateTimeDownToSteps;
+exports.roundDateTo = roundDateTo;
+exports.roundDateToDate = roundDateToDate;
+exports.roundDateToUnixDateTimeNumber = roundDateToUnixDateTimeNumber;
 exports.roundDownToHour = roundDownToHour;
 exports.roundDownToMinute = roundDownToMinute;
 exports.roundToMinuteSteps = roundToMinuteSteps;
 exports.safeFormatToISO8601DateString = safeFormatToISO8601DateString;
 exports.safeToJsDate = safeToJsDate;
 exports.searchTimezoneInfos = searchTimezoneInfos;
+exports.setOnDateWithTimezoneNormalFunction = setOnDateWithTimezoneNormalFunction;
 exports.shiftDateCellTimingToSystemTimezone = shiftDateCellTimingToSystemTimezone;
 exports.shiftDateCellTimingToTimezone = shiftDateCellTimingToTimezone;
 exports.shiftDateCellTimingToTimezoneFunction = shiftDateCellTimingToTimezoneFunction;