@js-joda/core 6.1.0 → 6.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/core",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "a date and time library for javascript",
   "repository": {
     "type": "git",
@@ -47,5 +47,5 @@
     "sourceMap": false,
     "instrument": false
   },
-  "gitHead": "d82df374b19b312796817f40945c22783536170b"
+  "gitHead": "8c0a3b1b555bc09fced243dac13fdf5ef9746dc7"
 }

package/src/Duration.js

@@ -893,10 +893,18 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         if (divisor === 1) {
             return this;
         }
-        const secs = MathUtil.intDiv(this._seconds, divisor);
-        const secsMod = MathUtil.roundDown(((this._seconds/ divisor) - secs) * LocalTime.NANOS_PER_SECOND);
-        let nos = MathUtil.intDiv(this._nanos, divisor);
-        nos = secsMod + nos;
+        // Give both components the same sign before truncating the quotient.
+        // Otherwise the positive nano adjustment of a negative duration is
+        // truncated separately and can move the result away from zero.
+        let seconds = this._seconds;
+        let nanos = this._nanos;
+        if (seconds < 0 && nanos > 0) {
+            seconds += 1;
+            nanos -= LocalTime.NANOS_PER_SECOND;
+        }
+        const secs = MathUtil.intDiv(seconds, divisor);
+        const remainder = MathUtil.intMod(seconds, divisor);
+        const nos = MathUtil.intDiv(remainder * LocalTime.NANOS_PER_SECOND + nanos, divisor);
         return Duration.ofSeconds(secs, nos);
     }
 
@@ -1081,6 +1089,21 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
     }
 
     //-----------------------------------------------------------------------
+    /**
+     * Extracts the number of days in the duration.
+     *
+     * This returns the total number of days in the duration by dividing the
+     * number of seconds by 86400.
+     * This is based on the standard definition of a day as 24 hours.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {number} the number of days in the duration, may be negative
+     */
+    toDaysPart() {
+        return MathUtil.intDiv(this._seconds, LocalTime.SECONDS_PER_DAY);
+    }
+
     /**
      * Extracts the number of hours part in the duration.
      *
@@ -1143,6 +1166,22 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         return MathUtil.intDiv(this._nanos, 1000000);
     }
 
+    /**
+     * Get the nanoseconds part within seconds of the duration.
+     *
+     * The length of the duration is stored using two fields - seconds and nanoseconds.
+     * The nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to
+     * the length in seconds.
+     * The total duration is defined by calling {@link Duration.nano} and {@link Duration.seconds}.
+     *
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @return {number} the nanoseconds within the second part of the length of the duration, from 0 to 999,999,999
+     */
+    toNanosPart() {
+        return this._nanos;
+    }
+
     //-----------------------------------------------------------------------
     /**
      * Compares this duration to the specified {@link Duration}.

package/src/Instant.js

@@ -823,9 +823,17 @@ export class Instant extends Temporal {
      * @private
      */
     _microsUntil(end) {
-        const secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());
+        let secsDiff = MathUtil.safeSubtract(end.epochSecond(), this.epochSecond());
+        let nanosDiff = end.nano() - this.nano();
+        if (secsDiff > 0 && nanosDiff < 0) {
+            secsDiff--;
+            nanosDiff += LocalTime.NANOS_PER_SECOND;
+        } else if (secsDiff < 0 && nanosDiff > 0) {
+            secsDiff++;
+            nanosDiff -= LocalTime.NANOS_PER_SECOND;
+        }
         const totalMicros = MathUtil.safeMultiply(secsDiff, 1000000);
-        return MathUtil.safeAdd(totalMicros, MathUtil.intDiv(end.nano() - this.nano(), 1000));
+        return MathUtil.safeAdd(totalMicros, MathUtil.intDiv(nanosDiff, 1000));
     }
 
     /**
@@ -908,6 +916,12 @@ export class Instant extends Temporal {
      * @throws ArithmeticException if numeric overflow occurs
      */
     toEpochMilli() {
+        if (this._seconds < 0 && this._nanos > 0) {
+            // avoid an overflow of seconds * 1000 for instants close to the minimum epoch milli
+            const millis = MathUtil.safeMultiply(this._seconds + 1, 1000);
+            const adjustment = MathUtil.intDiv(this._nanos, NANOS_PER_MILLI) - 1000;
+            return MathUtil.safeAdd(millis, adjustment);
+        }
         const millis = MathUtil.safeMultiply(this._seconds, 1000);
         return millis + MathUtil.intDiv(this._nanos, NANOS_PER_MILLI);
     }

package/src/MonthDay.js

@@ -25,7 +25,7 @@ import { ZoneId } from './ZoneId';
  * A month-day in the ISO-8601 calendar system, such as `--12-03`.
  *
  * {@link MonthDay} is an immutable date-time object that represents the combination
- * of a year and month. Any field that can be derived from a month and day, such as
+ * of a month and day. Any field that can be derived from a month and day, such as
  * quarter-of-year, can be obtained.
  *
  * This class does not store or represent a year, time or time-zone.

package/src/ZonedDateTime.js

@@ -319,7 +319,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      *
      * Converting an instant to a zoned date-time is simple as there is only one valid
      * offset for each instant. If the valid offset is different to the offset specified,
-     * the the date-time and offset of the zoned date-time will differ from those specified.
+     * the date-time and offset of the zoned date-time will differ from those specified.
      *
      * If the {@link ZoneId} to be used is a {@link ZoneOffset}, this method is equivalent
      * to {@link of}.

package/src/format/DateTimeBuilder.js

@@ -14,13 +14,16 @@ import { ResolverStyle } from './ResolverStyle';
 import { IsoChronology } from '../chrono/IsoChronology';
 import { ChronoLocalDate } from '../chrono/ChronoLocalDate';
 import { ChronoField } from '../temporal/ChronoField';
+import { IsoFields } from '../temporal/IsoFields';
 import { TemporalAccessor } from '../temporal/TemporalAccessor';
 import { TemporalQueries } from '../temporal/TemporalQueries';
 
+import { Instant } from '../Instant';
 import { LocalTime } from '../LocalTime';
 import { LocalDate } from '../LocalDate';
 import { Period } from '../Period';
 
+import { ZonedDateTime } from '../ZonedDateTime';
 import { ZoneOffset } from '../ZoneOffset';
 
 /**
@@ -145,25 +148,46 @@ export class DateTimeBuilder extends TemporalAccessor {
             this.fieldValues.retainAll(resolverFields);
         }
         // handle standard fields
-        // this._mergeInstantFields();
+        this._mergeInstantFields();
+        this._resolveFields(resolverStyle);
         this._mergeDate(resolverStyle);
         this._mergeTime(resolverStyle);
-        //if (resolveFields(resolverStyle)) {
-        //    mergeInstantFields();
-        //    mergeDate(resolverStyle);
-        //    mergeTime(resolverStyle);
-        //}
         this._resolveTimeInferZeroes(resolverStyle);
-        //this._crossCheck();
+        this._crossCheck();
         if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
             this.date = this.date.plus(this.excessDays);
             this.excessDays = Period.ZERO;
         }
-        //resolveFractional();
+        this._resolveFractional();
         this._resolveInstant();
         return this;
     }
 
+    /**
+     * Resolves the date fields that are not {@link ChronoField}s by delegating to their own
+     * `resolve()`, the step java.time performs generically. As parsed values are held in a
+     * name-keyed map, the ISO fields that define a `resolve()` (week-of-week-based-year and
+     * day-of-quarter) are handled here. They do not depend on one another, so one pass is
+     * sufficient. Returns whether a date was produced.
+     *
+     * @param {ResolverStyle} resolverStyle
+     * @return {boolean}
+     * @private
+     */
+    _resolveFields(resolverStyle) {
+        let resolved = false;
+        for (const field of [IsoFields.WEEK_OF_WEEK_BASED_YEAR, IsoFields.DAY_OF_QUARTER]) {
+            if (this.fieldValues.containsKey(field)) {
+                const date = field.resolve(this.fieldValues, this, resolverStyle);
+                if (date != null) {
+                    this._checkDate(date);
+                    resolved = true;
+                }
+            }
+        }
+        return resolved;
+    }
+
     /**
      *
      * @param {ResolverStyle} resolverStyle
@@ -446,6 +470,122 @@ export class DateTimeBuilder extends TemporalAccessor {
         }
     }
 
+    /**
+     * Converts a parsed instant-seconds into a date and a second-of-day, using the parsed zone
+     * or, if there is none, the parsed offset. Without a zone or offset, the instant-seconds
+     * are left unchanged.
+     *
+     * @private
+     */
+    _mergeInstantFields() {
+        if (this.fieldValues.containsKey(ChronoField.INSTANT_SECONDS)) {
+            if (this.zone != null) {
+                this._mergeInstantFields0(this.zone);
+            } else {
+                const offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);
+                if (offsetSecs != null) {
+                    this._mergeInstantFields0(ZoneOffset.ofTotalSeconds(offsetSecs));
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {ZoneId} selectedZone
+     * @private
+     */
+    _mergeInstantFields0(selectedZone) {
+        const instant = Instant.ofEpochSecond(this.fieldValues.remove(ChronoField.INSTANT_SECONDS));
+        const zdt = ZonedDateTime.ofInstant(instant, selectedZone);
+        if (this.date == null) {
+            this._addObject(zdt.toLocalDate());
+        } else {
+            this._resolveMakeChanges(ChronoField.INSTANT_SECONDS, zdt.toLocalDate());
+        }
+        this._addFieldValue(ChronoField.SECOND_OF_DAY, zdt.toLocalTime().toSecondOfDay());
+    }
+
+    /**
+     * @param {TemporalField} targetField
+     * @param {LocalDate} date
+     * @private
+     */
+    _resolveMakeChanges(targetField, date) {
+        const epochDay = date.toEpochDay();
+        const old = this.fieldValues.get(ChronoField.EPOCH_DAY);
+        this.fieldValues.put(ChronoField.EPOCH_DAY, epochDay);
+        if (old != null && old !== epochDay) {
+            throw new DateTimeException(`Conflict found: ${LocalDate.ofEpochDay(old)} differs from ${LocalDate.ofEpochDay(epochDay)} while resolving  ${targetField}`);
+        }
+    }
+
+    /**
+     * Checks the remaining field values against the resolved date and time, and removes the
+     * ones that match.
+     *
+     * @private
+     */
+    _crossCheck() {
+        if (this.date != null && this.time != null) {
+            this._crossCheck0(this.date.atTime(this.time));
+        } else if (this.date != null) {
+            this._crossCheck0(this.date);
+        } else if (this.time != null) {
+            this._crossCheck0(this.time);
+        }
+    }
+
+    /**
+     * @param {TemporalAccessor} temporal
+     * @private
+     */
+    _crossCheck0(temporal) {
+        for (const fieldName in this.fieldValues.keySet()) {
+            const field = ChronoField.byName(fieldName);
+            if (field && this.fieldValues.get(field) !== undefined) { // undefined if "removed" in EnumMap
+                if (temporal.isSupported(field)) {
+                    let temporalValue;
+                    try {
+                        temporalValue = temporal.getLong(field);
+                    } catch (ex) {
+                        if (ex instanceof DateTimeException) {
+                            continue;
+                        }
+                        throw ex;
+                    }
+                    const value = this.fieldValues.get(field);
+                    if (temporalValue !== value) {
+                        throw new DateTimeException(`Cross check failed: ${field} ${temporalValue} vs ${field} ${value}`);
+                    }
+                    this.fieldValues.remove(field);
+                }
+            }
+        }
+    }
+
+    /**
+     * Without a time, adds the fraction-of-second fields to a parsed instant-seconds,
+     * second-of-day or second-of-minute, with zero if no nano-of-second was parsed.
+     *
+     * @private
+     */
+    _resolveFractional() {
+        if (this.time == null &&
+                (this.fieldValues.containsKey(ChronoField.INSTANT_SECONDS) ||
+                    this.fieldValues.containsKey(ChronoField.SECOND_OF_DAY) ||
+                    this.fieldValues.containsKey(ChronoField.SECOND_OF_MINUTE))) {
+            if (this.fieldValues.containsKey(ChronoField.NANO_OF_SECOND)) {
+                const nos = this.fieldValues.get(ChronoField.NANO_OF_SECOND);
+                this.fieldValues.put(ChronoField.MICRO_OF_SECOND, MathUtil.intDiv(nos, 1000));
+                this.fieldValues.put(ChronoField.MILLI_OF_SECOND, MathUtil.intDiv(nos, 1000000));
+            } else {
+                this.fieldValues.put(ChronoField.NANO_OF_SECOND, 0);
+                this.fieldValues.put(ChronoField.MICRO_OF_SECOND, 0);
+                this.fieldValues.put(ChronoField.MILLI_OF_SECOND, 0);
+            }
+        }
+    }
+
     _resolveInstant() {
         if (this.date != null && this.time != null) {
             const offsetSecs = this.fieldValues.get(ChronoField.OFFSET_SECONDS);

package/src/format/DateTimeFormatter.js

@@ -21,6 +21,7 @@ import { ResolverStyle } from './ResolverStyle';
 
 import { IsoChronology } from '../chrono/IsoChronology';
 import { ChronoField } from '../temporal/ChronoField';
+import { IsoFields } from '../temporal/IsoFields';
 import { createTemporalQuery } from '../temporal/TemporalQuery';
 
 /**
@@ -696,12 +697,13 @@ export function _init() {
         .toFormatter(ResolverStyle.STRICT);
 
     DateTimeFormatter.ISO_WEEK_DATE = new DateTimeFormatterBuilder()
-        .appendValue(ChronoField.YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
+        .parseCaseInsensitive()
+        .appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
         .appendLiteral('-W')
-        .appendValue(ChronoField.ALIGNED_WEEK_OF_YEAR)
+        .appendValue(IsoFields.WEEK_OF_WEEK_BASED_YEAR, 2)
         .appendLiteral('-')
-        .appendValue(ChronoField.DAY_OF_WEEK)
-        .toFormatter(ResolverStyle.STRICT);
+        .appendValue(ChronoField.DAY_OF_WEEK, 1)
+        .toFormatter(ResolverStyle.STRICT).withChronology(IsoChronology.INSTANCE);
 
     DateTimeFormatter.ISO_DATE = new DateTimeFormatterBuilder()
         .parseCaseInsensitive()

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/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