@js-joda/core 6.2.0 → 6.3.1

package/src/temporal/TemporalField.js

@@ -199,7 +199,7 @@ export class TemporalField {
      * Checks if this field is supported by the temporal object.
      *
      * This determines whether the temporal accessor supports this field.
-     * If this returns false, the the temporal cannot be queried for this field.
+     * If this returns false, the temporal cannot be queried for this field.
      *
      * There are two equivalent ways of using this method.
      * The first is to invoke this method directly.

package/src/zone/SystemDefaultZoneRules.js

@@ -7,6 +7,29 @@ import { ZoneRules } from './ZoneRules';
 import { ZoneOffset } from '../ZoneOffset';
 import { DateTimeException } from '../errors';
 
+// the range of a Date in epoch millis (ECMA-262), a Date outside of it is invalid
+const MAX_DATE_EPOCH_MILLI = 8640000000000000;
+
+// the timezone offset of a Date in minutes, as Date.getTimezoneOffset(); an epoch milli outside
+// the range of a Date is clamped to it, so that far instants get the offset at the end of the range
+function timezoneOffsetInMinutes(epochMilli) {
+    const clamped = Math.max(-MAX_DATE_EPOCH_MILLI, Math.min(MAX_DATE_EPOCH_MILLI, epochMilli));
+    return new Date(clamped).getTimezoneOffset();
+}
+
+// the epoch milli of the instant, clamped to the range of a Date; Instant.toEpochMilli() would
+// overflow for instants like Instant.MAX
+function clampedEpochMilli(instant) {
+    const epochSecond = instant.epochSecond();
+    if (epochSecond > MAX_DATE_EPOCH_MILLI / 1000) {
+        return MAX_DATE_EPOCH_MILLI;
+    }
+    if (epochSecond < -MAX_DATE_EPOCH_MILLI / 1000) {
+        return -MAX_DATE_EPOCH_MILLI;
+    }
+    return instant.toEpochMilli();
+}
+
 export class SystemDefaultZoneRules extends ZoneRules {
 
     isFixedOffset(){
@@ -19,7 +42,7 @@ export class SystemDefaultZoneRules extends ZoneRules {
      * @returns {ZoneOffset}
      */
     offsetOfInstant(instant){
-        const offsetInMinutes = new Date(instant.toEpochMilli()).getTimezoneOffset();
+        const offsetInMinutes = timezoneOffsetInMinutes(clampedEpochMilli(instant));
         return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
     }
 
@@ -29,7 +52,7 @@ export class SystemDefaultZoneRules extends ZoneRules {
      * @returns {ZoneOffset}
      */
     offsetOfEpochMilli(epochMilli){
-        const offsetInMinutes = new Date(epochMilli).getTimezoneOffset();
+        const offsetInMinutes = timezoneOffsetInMinutes(epochMilli);
         return ZoneOffset.ofTotalMinutes(offsetInMinutes * -1);
     }
 
@@ -48,9 +71,9 @@ export class SystemDefaultZoneRules extends ZoneRules {
      */
     offsetOfLocalDateTime(localDateTime){
         const epochMilli = localDateTime.toEpochSecond(ZoneOffset.UTC) * 1000;
-        const offsetInMinutesBeforePossibleTransition = new Date(epochMilli).getTimezoneOffset();
+        const offsetInMinutesBeforePossibleTransition = timezoneOffsetInMinutes(epochMilli);
         const epochMilliSystemZone = epochMilli + offsetInMinutesBeforePossibleTransition * 60000;
-        const offsetInMinutesAfterPossibleTransition = new Date(epochMilliSystemZone).getTimezoneOffset();
+        const offsetInMinutesAfterPossibleTransition = timezoneOffsetInMinutes(epochMilliSystemZone);
         return ZoneOffset.ofTotalMinutes(offsetInMinutesAfterPossibleTransition * -1);
     }
 

package/src/zone/ZoneOffsetTransition.js

@@ -17,7 +17,7 @@ import { LocalDateTime } from '../LocalDateTime';
  * The discontinuity is normally a gap in spring and an overlap in autumn.
  * {@link ZoneOffsetTransition} models the transition between the two offsets.
  *
- * Gaps occur where there are local date-times that simply do not not exist.
+ * Gaps occur where there are local date-times that simply do not exist.
  * An example would be when the offset changes from `+03:00` to `+04:00`.
  * This might be described as 'the clocks will move forward one hour tonight at 1am'.
  *
@@ -178,7 +178,7 @@ export class ZoneOffsetTransition {
     /**
      * Does this transition represent a gap in the local time-line.
      *
-     * Gaps occur where there are local date-times that simply do not not exist.
+     * Gaps occur where there are local date-times that simply do not exist.
      * An example would be when the offset changes from `+01:00` to `+02:00`.
      * This might be described as 'the clocks will move forward one hour tonight at 1am'.
      *

package/typings/js-joda.d.ts

@@ -1110,6 +1110,7 @@ export class Duration extends TemporalAmount {
     minus(amount: number, unit: TemporalUnit): Duration;
     minus(duration: Duration): Duration;
     minusDays(daysToSubtract: number): Duration;
+    minusDuration(duration: Duration): Duration;
     minusHours(hoursToSubtract: number): Duration;
     minusMillis(millisToSubtract: number): Duration;
     minusMinutes(minutesToSubtract: number): Duration;
@@ -1136,10 +1137,12 @@ export class Duration extends TemporalAmount {
     toMillis(): number;
     toMinutes(): number;
     toNanos(): number;
+    toDaysPart(): number;
     toHoursPart(): number;
     toMinutesPart(): number;
     toSecondsPart(): number;
     toMillisPart(): number;
+    toNanosPart(): number;
     toString(): string;
     units(): TemporalUnit[];
     withNanos(nanoOfSecond: number): Duration;
@@ -1534,6 +1537,7 @@ export class Year extends Temporal implements TemporalAdjuster {
     atMonthDay(monthDay: MonthDay): LocalDate;
     compareTo(other: Year): number;
     equals(other: any): boolean;
+    format(formatter: DateTimeFormatter): string;
     getLong(field: TemporalField): number;
     isAfter(other: Year): boolean;
     isBefore(other: Year): boolean;
@@ -1700,6 +1704,7 @@ export class OffsetDateTime extends Temporal implements TemporalAdjuster {
     toLocalTime(): LocalTime;
     toOffsetTime(): OffsetTime;
     toString(): string;
+    toZonedDateTime(): ZonedDateTime;
     truncatedTo(unit: TemporalUnit): OffsetDateTime;
     until(endExclusive: Temporal, unit: TemporalUnit): number;
     with(adjuster: TemporalAdjuster): OffsetDateTime;
@@ -2069,6 +2074,7 @@ export class ZoneOffset extends ZoneId implements TemporalAdjuster {
     getLong(field: TemporalField): number;
     hashCode(): number;
     id(): string;
+    query<R>(query: TemporalQuery<R>): R | null;
     rules(): ZoneRules;
     toString(): string;
     totalSeconds(): number;
@@ -2219,6 +2225,8 @@ export class DateTimeFormatterBuilder {
 }
 
 export class DecimalStyle {
+    static STANDARD: DecimalStyle;
+
     private constructor();
 
     decimalSeparator(): string;
@@ -2227,6 +2235,10 @@ export class DecimalStyle {
     negativeSign(): string;
     positiveSign(): string;
     toString(): string;
+    withDecimalSeparator(decimalSeparator: string): DecimalStyle;
+    withNegativeSign(negativeSign: string): DecimalStyle;
+    withPositiveSign(positiveSign: string): DecimalStyle;
+    withZeroDigit(zeroDigit: string): DecimalStyle;
     zeroDigit(): string;
 }
 
@@ -2456,10 +2468,13 @@ export class ZoneRulesProvider {
 export type Chronology = IsoChronology;
 
 export abstract class IsoChronology {
+    static INSTANCE: IsoChronology;
+
     static isLeapYear(prolepticYear: number): boolean;
 
     private constructor();
 
+    date(temporal: TemporalAccessor): LocalDate;
     equals(other: any): boolean;
     resolveDate(fieldValues: any, resolverStyle: any): any;
     toString(): string;

package/typings/js-joda.flow.js

@@ -108,10 +108,12 @@ declare module "js-joda" {
         toMillis(): number;
         toMinutes(): number;
         toNanos(): number;
+        toDaysPart(): number;
         toHoursPart(): number;
         toMinutesPart(): number;
         toSecondsPart(): number;
         toMillisPart(): number;
+        toNanosPart(): number;
         toString(): string;
         units(): any;
         withNanos(nanoOfSecond: number): Duration;
@@ -737,6 +739,7 @@ declare module "js-joda" {
         now(zoneIdOrClock?: ZoneId | Clock): Year; of(isoYear: number): Year;
         parse(text: string, formatter?: DateTimeFormatter): Year;
         atMonth(monthOrNumber: Month | number): Year;
+        format(formatter: DateTimeFormatter): string;
         plus(amountOrNumber: TemporalAmount | number, unit?: TemporalUnit): Year;
         minus(amountOrNumber: TemporalAmount | number, unit?: TemporalUnit): Year
     }
@@ -938,7 +941,9 @@ declare module "js-joda" {
     }
 
     declare class IsoChronology {
+        INSTANCE: IsoChronology;
         isLeapYear(prolepticYear: number): boolean;
+        date(temporal: TemporalAccessor): LocalDate;
         resolveDate(fieldValues: any, resolverStyle: any): any;
         equals(other: any): boolean;
         toString(): string