Rebase up to December 2024

index.d.ts

@@ -494,6 +494,9 @@ export namespace Temporal {
    */
   export type TransitionDirection = 'next' | 'previous' | { direction: 'next' | 'previous' };
 
+  // Handle Intl.LocalesArgument regardless of whether the TS version has it yet
+  type LocalesArgument = ConstructorParameters<typeof Intl.DateTimeFormat>[0];
+
   export type DurationLike = {
     years?: number;
     months?: number;
@@ -552,7 +555,7 @@ export namespace Temporal {
     subtract(other: Temporal.Duration | DurationLike | string): Temporal.Duration;
     round(roundTo: DurationRoundTo): Temporal.Duration;
     total(totalOf: DurationTotalOf): number;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ToStringPrecisionOptions): string;
     valueOf(): never;
@@ -600,7 +603,7 @@ export namespace Temporal {
       roundTo: RoundTo<'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond' | 'nanosecond'>
     ): Temporal.Instant;
     toZonedDateTimeISO(tzLike: TimeZoneLike): Temporal.ZonedDateTime;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: InstantToStringOptions): string;
     valueOf(): never;
@@ -678,7 +681,7 @@ export namespace Temporal {
     ): Temporal.ZonedDateTime;
     toPlainYearMonth(): Temporal.PlainYearMonth;
     toPlainMonthDay(): Temporal.PlainMonthDay;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ShowCalendarOption): string;
     valueOf(): never;
@@ -781,7 +784,7 @@ export namespace Temporal {
     toZonedDateTime(tzLike: TimeZoneLike, options?: ToInstantOptions): Temporal.ZonedDateTime;
     toPlainDate(): Temporal.PlainDate;
     toPlainTime(): Temporal.PlainTime;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: CalendarTypeToStringOptions): string;
     valueOf(): never;
@@ -817,7 +820,7 @@ export namespace Temporal {
     equals(other: Temporal.PlainMonthDay | PlainMonthDayLike | string): boolean;
     with(monthDayLike: PlainMonthDayLike, options?: AssignmentOptions): Temporal.PlainMonthDay;
     toPlainDate(year: { year: number }): Temporal.PlainDate;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ShowCalendarOption): string;
     valueOf(): never;
@@ -883,7 +886,7 @@ export namespace Temporal {
     round(
       roundTo: RoundTo<'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond' | 'nanosecond'>
     ): Temporal.PlainTime;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ToStringPrecisionOptions): string;
     valueOf(): never;
@@ -952,7 +955,7 @@ export namespace Temporal {
       options?: DifferenceOptions<'year' | 'month'>
     ): Temporal.Duration;
     toPlainDate(day: { day: number }): Temporal.PlainDate;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ShowCalendarOption): string;
     valueOf(): never;
@@ -1046,7 +1049,7 @@ export namespace Temporal {
     toPlainDateTime(): Temporal.PlainDateTime;
     toPlainDate(): Temporal.PlainDate;
     toPlainTime(): Temporal.PlainTime;
-    toLocaleString(locales?: string | string[], options?: globalThis.Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: LocalesArgument, options?: globalThis.Intl.DateTimeFormatOptions): string;
     toJSON(): string;
     toString(options?: ZonedDateTimeToStringOptions): string;
     valueOf(): never;

lib/calendar.ts

@@ -201,7 +201,7 @@ export interface CalendarImpl {
   monthDayToISOReferenceDate(fields: ResolveFieldsReturn<'month-day'>, overflow: Overflow): ISODate;
   dateAdd(date: ISODate, duration: Partial<DateDuration>, overflow: Overflow): ISODate;
   dateUntil(one: ISODate, two: ISODate, largestUnit: 'year' | 'month' | 'week' | 'day'): DateDuration;
-  extraFields(): FieldKey[];
+  extraFields(fields: FieldKey[]): FieldKey[];
   fieldKeysToIgnore(keys: FieldKey[]): FieldKey[];
 }
 
@@ -2267,9 +2267,11 @@ class DangiHelper extends ChineseBaseHelper {
  */
 class NonIsoCalendar implements CalendarImpl {
   constructor(private readonly helper: HelperBase) {}
-  extraFields(type: ISODateToFieldsType = 'date'): FieldKey[] {
-    if (type === 'month-day') return [];
-    return ['era', 'eraYear'];
+  extraFields(fields: FieldKey[]): FieldKey[] {
+    if (this.helper.hasEra && Call(ArrayPrototypeIncludes, fields, ['year'])) {
+      return ['era', 'eraYear'];
+    }
+    return [];
   }
   resolveFields(fields: CalendarFieldsRecord /* , type */) {
     if (this.helper.calendarType !== 'lunisolar') {

lib/duration.ts

@@ -37,6 +37,7 @@ import {
   SetSlot,
   TIME_ZONE
 } from './slots';
+import { TimeDuration } from './timeduration';
 import type { Temporal } from '..';
 import type { DurationParams as Params, DurationReturn as Return } from './internaltypes';
 import JSBI from 'jsbi';
@@ -230,7 +231,7 @@ export class Duration implements Temporal.Duration {
     }
 
     if (zonedRelativeTo) {
-      let duration = ES.NormalizeDuration(this);
+      let duration = ES.ToInternalDurationRecord(this);
       const timeZone = GetSlot(zonedRelativeTo, TIME_ZONE);
       const calendar = GetSlot(zonedRelativeTo, CALENDAR);
       const relativeEpochNs = GetSlot(zonedRelativeTo, EPOCHNANOSECONDS);
@@ -246,12 +247,12 @@ export class Duration implements Temporal.Duration {
         roundingMode
       );
       if (ES.TemporalUnitCategory(largestUnit) === 'date') largestUnit = 'hour';
-      return ES.UnnormalizeDuration(duration, largestUnit);
+      return ES.TemporalDurationFromInternal(duration, largestUnit);
     }
 
     if (plainRelativeTo) {
-      let duration = ES.NormalizeDurationWith24HourDays(this);
-      const targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.norm);
+      let duration = ES.ToInternalDurationRecordWith24HourDays(this);
+      const targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.time);
 
       // Delegate the date part addition to the calendar
       const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
@@ -270,7 +271,7 @@ export class Duration implements Temporal.Duration {
         smallestUnit,
         roundingMode
       );
-      return ES.UnnormalizeDuration(duration, largestUnit);
+      return ES.TemporalDurationFromInternal(duration, largestUnit);
     }
 
     // No reference date to calculate difference relative to
@@ -281,9 +282,19 @@ export class Duration implements Temporal.Duration {
       throw new RangeErrorCtor(`a starting point is required for ${largestUnit}s balancing`);
     }
     assert(!ES.IsCalendarUnit(smallestUnit), 'smallestUnit was larger than largestUnit');
-    let duration = ES.NormalizeDurationWith24HourDays(this);
-    duration = ES.RoundTimeDuration(duration, roundingIncrement, smallestUnit, roundingMode);
-    return ES.UnnormalizeDuration(duration, largestUnit);
+    let internalDuration = ES.ToInternalDurationRecordWith24HourDays(this);
+    if (smallestUnit === 'day') {
+      // First convert time units up to days
+      const { quotient, remainder } = internalDuration.time.divmod(ES.DAY_NANOS);
+      let days = internalDuration.date.days + quotient + ES.TotalTimeDuration(remainder, 'day');
+      days = ES.RoundNumberToIncrement(days, roundingIncrement, roundingMode);
+      const dateDuration = { years: 0, months: 0, weeks: 0, days };
+      internalDuration = ES.CombineDateAndTimeDuration(dateDuration, TimeDuration.ZERO);
+    } else {
+      const timeDuration = ES.RoundTimeDuration(internalDuration.time, roundingIncrement, smallestUnit, roundingMode);
+      internalDuration = ES.CombineDateAndTimeDuration(ES.ZeroDateDuration(), timeDuration);
+    }
+    return ES.TemporalDurationFromInternal(internalDuration, largestUnit);
   }
   total(optionsParam: Params['total'][0]): Return['total'] {
     if (!ES.IsTemporalDuration(this)) throw new TypeErrorCtor('invalid receiver');
@@ -297,7 +308,7 @@ export class Duration implements Temporal.Duration {
     const unit = ES.GetTemporalUnitValuedOption(options, 'unit', 'datetime', ES.REQUIRED);
 
     if (zonedRelativeTo) {
-      const duration = ES.NormalizeDuration(this);
+      const duration = ES.ToInternalDurationRecord(this);
       const timeZone = GetSlot(zonedRelativeTo, TIME_ZONE);
       const calendar = GetSlot(zonedRelativeTo, CALENDAR);
       const relativeEpochNs = GetSlot(zonedRelativeTo, EPOCHNANOSECONDS);
@@ -306,8 +317,8 @@ export class Duration implements Temporal.Duration {
     }
 
     if (plainRelativeTo) {
-      const duration = ES.NormalizeDurationWith24HourDays(this);
-      let targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.norm);
+      const duration = ES.ToInternalDurationRecordWith24HourDays(this);
+      let targetTime = ES.AddTime(ES.MidnightTimeRecord(), duration.time);
 
       // Delegate the date part addition to the calendar
       const isoRelativeToDate = GetSlot(plainRelativeTo, ISO_DATE);
@@ -328,8 +339,8 @@ export class Duration implements Temporal.Duration {
     if (ES.IsCalendarUnit(unit)) {
       throw new RangeErrorCtor(`a starting point is required for ${unit}s total`);
     }
-    const duration = ES.NormalizeDurationWith24HourDays(this);
-    return ES.TotalTimeDuration(duration.norm, unit);
+    const duration = ES.ToInternalDurationRecordWith24HourDays(this);
+    return ES.TotalTimeDuration(duration.time, unit);
   }
   toString(options: Params['toString'][0] = undefined): string {
     if (!ES.IsTemporalDuration(this)) throw new TypeErrorCtor('invalid receiver');
@@ -349,9 +360,13 @@ export class Duration implements Temporal.Duration {
     if (unit === 'nanosecond' && increment === 1) return ES.TemporalDurationToString(this, precision);
 
     const largestUnit = ES.DefaultTemporalLargestUnit(this);
-    let duration = ES.NormalizeDuration(this);
-    duration = ES.RoundTimeDuration(duration, increment, unit, roundingMode);
-    const roundedDuration = ES.UnnormalizeDuration(duration, ES.LargerOfTwoTemporalUnits(largestUnit, 'second'));
+    let internalDuration = ES.ToInternalDurationRecord(this);
+    const timeDuration = ES.RoundTimeDuration(internalDuration.time, increment, unit, roundingMode);
+    internalDuration = ES.CombineDateAndTimeDuration(internalDuration.date, timeDuration);
+    const roundedDuration = ES.TemporalDurationFromInternal(
+      internalDuration,
+      ES.LargerOfTwoTemporalUnits(largestUnit, 'second')
+    );
     return ES.TemporalDurationToString(roundedDuration, precision);
   }
   toJSON(): Return['toJSON'] {
@@ -402,8 +417,8 @@ export class Duration implements Temporal.Duration {
 
     const largestUnit1 = ES.DefaultTemporalLargestUnit(one);
     const largestUnit2 = ES.DefaultTemporalLargestUnit(two);
-    const duration1 = ES.NormalizeDuration(one);
-    const duration2 = ES.NormalizeDuration(two);
+    const duration1 = ES.ToInternalDurationRecord(one);
+    const duration2 = ES.ToInternalDurationRecord(two);
 
     if (
       zonedRelativeTo &&
@@ -424,12 +439,12 @@ export class Duration implements Temporal.Duration {
       if (!plainRelativeTo) {
         throw new RangeErrorCtor('A starting point is required for years, months, or weeks comparison');
       }
-      d1 = ES.UnbalanceDateDurationRelative(duration1.date, plainRelativeTo);
-      d2 = ES.UnbalanceDateDurationRelative(duration2.date, plainRelativeTo);
+      d1 = ES.DateDurationDays(duration1.date, plainRelativeTo);
+      d2 = ES.DateDurationDays(duration2.date, plainRelativeTo);
     }
-    const norm1 = duration1.norm.add24HourDays(d1);
-    const norm2 = duration2.norm.add24HourDays(d2);
-    return norm1.cmp(norm2);
+    const timeDuration1 = duration1.time.add24HourDays(d1);
+    const timeDuration2 = duration2.time.add24HourDays(d2);
+    return timeDuration1.cmp(timeDuration2);
   }
   [Symbol.toStringTag]!: 'Temporal.Duration';
 }