fix: Fix linting issues

Author: boutahlilsoufiane

packages/@internationalized/date/src/CalendarDate.ts

@@ -94,8 +94,8 @@ export class CalendarDate {
   }
 
   /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: DateFields): CalendarDate {
-    return set(this, fields);
+  set(fields: DateFields, ignoreDay?: boolean): CalendarDate {
+    return set(this, fields, ignoreDay);
   }
 
   /**
@@ -165,8 +165,8 @@ export class Time {
   }
 
   /** Returns a new `Time` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: TimeFields): Time {
-    return setTime(this, fields);
+  set(fields: TimeFields, ignoreDay?: boolean): Time {
+    return setTime(this, fields, ignoreDay);
   }
 
   /**
@@ -264,13 +264,13 @@ export class CalendarDateTime {
    * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime {
+  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions, ignoreDay?: boolean): CalendarDateTime {
     switch (field) {
       case 'era':
       case 'year':
       case 'month':
       case 'day':
-        return cycleDate(this, field, amount, options);
+        return cycleDate(this, field, amount, options, ignoreDay);
       default:
         return cycleTime(this, field, amount, options);
     }
@@ -329,10 +329,10 @@ export class ZonedDateTime {
   /** The UTC offset for this time, in milliseconds. */
   public readonly offset: number;
 
-  constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
-  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number);
+  constructor(year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, ignoreDay?: boolean);
+  constructor(era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, ignoreDay?: boolean);
+  constructor(calendar: Calendar, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, ignoreDay?: boolean);
+  constructor(calendar: Calendar, era: string, year: number, month: number, day: number, timeZone: string, offset: number, hour?: number, minute?: number, second?: number, millisecond?: number, ignoreDay?: boolean);
   constructor(...args: any[]) {
     let [calendar, era, year, month, day] = shiftArgs(args);
     let timeZone = args.shift();
@@ -348,16 +348,17 @@ export class ZonedDateTime {
     this.minute = args.shift() || 0;
     this.second = args.shift() || 0;
     this.millisecond = args.shift() || 0;
+    const ignoreDay = args.shift() || 0;
 
-    constrain(this);
+    constrain(this, ignoreDay);
   }
 
   /** Returns a copy of this date. */
-  copy(): ZonedDateTime {
+  copy(ignoreDay?: boolean): ZonedDateTime {
     if (this.era) {
-      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond, ignoreDay);
     } else {
-      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond, ignoreDay);
     }
   }
 
@@ -372,16 +373,16 @@ export class ZonedDateTime {
   }
 
   /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
-  set(fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
-    return setZoned(this, fields, disambiguation);
+  set(fields: DateFields & TimeFields, disambiguation?: Disambiguation, ignoreDay?: boolean): ZonedDateTime {
+    return setZoned(this, fields, disambiguation, ignoreDay);
   }
 
   /**
    * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
    * When the resulting value reaches the limits of the field, it wraps around.
    */
-  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
-    return cycleZoned(this, field, amount, options);
+  cycle(field: DateField | TimeField, amount: number, options?: CycleTimeOptions, ignoreDay?: boolean): ZonedDateTime {
+    return cycleZoned(this, field, amount, options, ignoreDay);
   }
 
   /** Converts the date to a native JavaScript Date object. */

packages/@internationalized/date/src/manipulation.ts

@@ -173,10 +173,10 @@ export function set(date: CalendarDate | CalendarDateTime, fields: DateFields, i
   return mutableDate;
 }
 
-export function setTime(value: CalendarDateTime, fields: TimeFields): CalendarDateTime;
-export function setTime(value: Time, fields: TimeFields): Time;
-export function setTime(value: Time | CalendarDateTime, fields: TimeFields): Mutable<Time | CalendarDateTime> {
-  let mutableValue: Mutable<Time | CalendarDateTime> = value.copy();
+export function setTime(value: CalendarDateTime, fields: TimeFields, ignoreDay?: boolean): CalendarDateTime;
+export function setTime(value: Time, fields: TimeFields, ignoreDay?: boolean): Time;
+export function setTime(value: Time | CalendarDateTime, fields: TimeFields, ignoreDay?: boolean): Mutable<Time | CalendarDateTime> {
+  let mutableValue: Mutable<Time | CalendarDateTime> = value.copy(ignoreDay);
 
   if (fields.hour != null) {
     mutableValue.hour = fields.hour;
@@ -404,7 +404,7 @@ export function subtractZoned(dateTime: ZonedDateTime, duration: DateTimeDuratio
   return addZoned(dateTime, invertDuration(duration));
 }
 
-export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime {
+export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions, ignoreDay?: boolean): ZonedDateTime {
   // For date fields, we want the time to remain consistent and the UTC offset to potentially change to account for DST changes.
   // For time fields, we want the time to change by the amount given. This may result in the hour field staying the same, but the UTC
   // offset changing in the case of a backward DST transition, or skipping an hour in the case of a forward DST transition.
@@ -458,7 +458,7 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
     case 'year':
     case 'month':
     case 'day': {
-      let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options);
+      let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options, ignoreDay);
       let ms = toAbsolute(res, dateTime.timeZone);
       return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
     }
@@ -467,11 +467,11 @@ export function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField
   }
 }
 
-export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime {
+export function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation, ignoreDay?: boolean): ZonedDateTime {
   // Set the date/time fields, and recompute the UTC offset to account for DST changes.
   // We also need to validate by converting back to a local time in case hours are skipped during forward DST transitions.
   let plainDateTime = toCalendarDateTime(dateTime);
-  let res = setTime(set(plainDateTime, fields), fields);
+  let res = setTime(set(plainDateTime, fields, ignoreDay), fields);
 
   // If the resulting plain date time values are equal, return the original time.
   // We don't want to change the offset when setting the time to the same value.

packages/@react-stately/datepicker/src/useDateFieldState.ts

@@ -455,14 +455,14 @@ export function useDateFieldState<T extends DateValue = DateValue>(props: DateFi
         let isPM = displayValue.hour >= 12;
         let shouldBePM = placeholder.hour >= 12;
         if (isPM && !shouldBePM) {
-          value = displayValue.set({hour: displayValue.hour - 12}, true);
+          value = displayValue.set({hour: displayValue.hour - 12}, undefined, true);
         } else if (!isPM && shouldBePM) {
-          value = displayValue.set({hour: displayValue.hour + 12}, true);
+          value = displayValue.set({hour: displayValue.hour + 12}, undefined, true);
         }
       } else if (part === 'hour' && 'hour' in displayValue && displayValue.hour >= 12 && validSegments.dayPeriod) {
-        value = displayValue.set({hour: placeholder['hour'] + 12}, true);
+        value = displayValue.set({hour: placeholder['hour'] + 12}, undefined, true);
       } else if (part in displayValue) {
-        value = displayValue.set({[part]: placeholder[part]}, true);
+        value = displayValue.set({[part]: placeholder[part]}, undefined, true);
       }
       updatePlaceholder(value);
     },
@@ -652,7 +652,7 @@ function addSegment(value: DateValue, part: string, amount: number, options: Int
       case 'dayPeriod': {
         let hours = value.hour;
         let isPM = hours >= 12;
-        return value.set({hour: isPM ? hours - 12 : hours + 12}, true);
+        return value.set({hour: isPM ? hours - 12 : hours + 12}, undefined, true);
       }
       case 'hour':
       case 'minute':
@@ -673,7 +673,7 @@ function setSegment(value: DateValue, part: string, segmentValue: number | strin
     case 'month':
     case 'year':
     case 'era':
-      return value.set({[part]: segmentValue}, true);
+      return value.set({[part]: segmentValue}, undefined, true);
   }
 
   if ('hour' in value && typeof segmentValue === 'number') {
@@ -685,7 +685,7 @@ function setSegment(value: DateValue, part: string, segmentValue: number | strin
         if (isPM === wasPM) {
           return value;
         }
-        return value.set({hour: wasPM ? hours - 12 : hours + 12}, true);
+        return value.set({hour: wasPM ? hours - 12 : hours + 12}, undefined, true);
       }
       case 'hour':
         // In 12 hour time, ensure that AM/PM does not change
@@ -702,7 +702,7 @@ function setSegment(value: DateValue, part: string, segmentValue: number | strin
         // fallthrough
       case 'minute':
       case 'second':
-        return value.set({[part]: segmentValue}, true);
+        return value.set({[part]: segmentValue}, undefined, true);
     }
   }