@js-joda/core 6.0.1 → 6.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@js-joda/core",
-  "version": "6.0.1",
+  "version": "6.2.0",
   "description": "a date and time library for javascript",
   "repository": {
     "type": "git",
@@ -47,5 +47,5 @@
     "sourceMap": false,
     "instrument": false
   },
-  "gitHead": "a7f1bec40afb1e84ffc0ce2d88d72d690fe72f6a"
+  "gitHead": "bb36ea96b26ee93408068c8ad8ebe8b094e96a10"
 }

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);
     }
 
@@ -1209,9 +1217,22 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         if (this === Duration.ZERO) {
             return 'PT0S';
         }
-        const hours = MathUtil.intDiv(this._seconds, LocalTime.SECONDS_PER_HOUR);
-        const minutes = MathUtil.intDiv(MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_HOUR), LocalTime.SECONDS_PER_MINUTE);
-        const secs = MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_MINUTE);
+        // A negative duration is stored as a negative second count plus a
+        // non-negative nano offset, e.g. -0.5s is held as seconds = -1,
+        // nanos = 500000000. To render ISO-8601 components that all carry the
+        // duration's sign, recover the signed whole-second part and the
+        // magnitude of the sub-second fraction separately: when the duration is
+        // negative and has a fractional offset, one second of that offset
+        // belongs to the whole part, and the remaining fraction is its
+        // complement against a full second.
+        const negativeFraction = this._seconds < 0 && this._nanos > 0;
+        const wholeSeconds = negativeFraction ? this._seconds + 1 : this._seconds;
+        const fractionNanos = negativeFraction ? LocalTime.NANOS_PER_SECOND - this._nanos : this._nanos;
+
+        const hours = MathUtil.intDiv(wholeSeconds, LocalTime.SECONDS_PER_HOUR);
+        const minutes = MathUtil.intDiv(MathUtil.intMod(wholeSeconds, LocalTime.SECONDS_PER_HOUR), LocalTime.SECONDS_PER_MINUTE);
+        const secs = MathUtil.intMod(wholeSeconds, LocalTime.SECONDS_PER_MINUTE);
+
         let rval = 'PT';
         if (hours !== 0) {
             rval += `${hours}H`;
@@ -1219,32 +1240,28 @@ export class Duration extends TemporalAmount /*implements TemporalAmount, Compar
         if (minutes !== 0) {
             rval += `${minutes}M`;
         }
-        if (secs === 0 && this._nanos === 0 && rval.length > 2) {
+        if (secs === 0 && fractionNanos === 0 && rval.length > 2) {
             return rval;
         }
-        if (secs < 0 && this._nanos > 0) {
-            if (secs === -1) {
-                rval += '-0';
-            } else {
-                rval += secs + 1;
-            }
+        // The seconds field needs an explicit minus sign when the whole-second
+        // part is zero but the duration is a negative fraction (e.g. -0.5s
+        // prints as "-0.5S", not "0.5S").
+        if (secs === 0 && negativeFraction) {
+            rval += '-0';
         } else {
-            rval += secs;
+            rval += `${secs}`;
         }
-        if (this._nanos > 0) {
-            rval += '.';
-            let nanoString;
-            if (secs < 0) {
-                nanoString = `${2 * LocalTime.NANOS_PER_SECOND - this._nanos}`;
-            } else {
-                nanoString = `${LocalTime.NANOS_PER_SECOND + this._nanos}`;
+        if (fractionNanos > 0) {
+            // fractionNanos is a magnitude in [1, 1e9); print it as a fixed
+            // nine-digit fraction with any trailing zeros removed.
+            let fraction = `${fractionNanos}`;
+            while (fraction.length < 9) {
+                fraction = `0${fraction}`;
             }
-            // remove the leading '1'
-            nanoString = nanoString.slice(1, nanoString.length);
-            rval += nanoString;
-            while (rval.charAt(rval.length - 1) === '0') {
-                rval = rval.slice(0, rval.length - 1);
+            while (fraction.charAt(fraction.length - 1) === '0') {
+                fraction = fraction.slice(0, fraction.length - 1);
             }
+            rval += `.${fraction}`;
         }
         rval += 'S';
         return rval;

package/src/Instant.js

@@ -520,7 +520,7 @@ export class Instant extends Temporal {
             throw new DateTimeException('Unit must divide into a standard day without remainder');
         }
         const nod = MathUtil.intMod(this._seconds, LocalTime.SECONDS_PER_DAY) * LocalTime.NANOS_PER_SECOND + this._nanos;
-        const result = MathUtil.intDiv(nod, dur) * dur;
+        const result = MathUtil.floorDiv(nod, dur) * dur;
         return this.plusNanos(result - nod);
     }
 
@@ -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));
     }
 
     /**

package/src/format/DateTimeBuilder.js

@@ -14,6 +14,7 @@ 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';
 
@@ -146,13 +147,11 @@ export class DateTimeBuilder extends TemporalAccessor {
         }
         // handle standard fields
         // this._mergeInstantFields();
+        if (this._resolveFields(resolverStyle)) {
+            // this._mergeInstantFields();
+        }
         this._mergeDate(resolverStyle);
         this._mergeTime(resolverStyle);
-        //if (resolveFields(resolverStyle)) {
-        //    mergeInstantFields();
-        //    mergeDate(resolverStyle);
-        //    mergeTime(resolverStyle);
-        //}
         this._resolveTimeInferZeroes(resolverStyle);
         //this._crossCheck();
         if (this.excessDays != null && this.excessDays.isZero() === false && this.date != null && this.time != null) {
@@ -164,6 +163,31 @@ export class DateTimeBuilder extends TemporalAccessor {
         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

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/format/DateTimeFormatterBuilder.js

@@ -1516,7 +1516,7 @@ class InstantPrinterParser  {
         const parser = new DateTimeFormatterBuilder()
             .append(DateTimeFormatter.ISO_LOCAL_DATE).appendLiteral('T')
             .appendValue(ChronoField.HOUR_OF_DAY, 2).appendLiteral(':').appendValue(ChronoField.MINUTE_OF_HOUR, 2).appendLiteral(':')
-            .appendValue(ChronoField.SECOND_OF_MINUTE, 2).appendFraction(ChronoField.NANO_OF_SECOND, minDigits, maxDigits, true).appendLiteral('Z')
+            .appendValue(ChronoField.SECOND_OF_MINUTE, 2).appendFraction(ChronoField.NANO_OF_SECOND, minDigits, maxDigits, true).appendOffsetId()
             .toFormatter()._toPrinterParser(false);
         const pos = parser.parse(newContext, text, position);
         if (pos < 0) {
@@ -1531,6 +1531,10 @@ class InstantPrinterParser  {
         const min = newContext.getParsed(ChronoField.MINUTE_OF_HOUR);
         const secVal = newContext.getParsed(ChronoField.SECOND_OF_MINUTE);
         const nanoVal = newContext.getParsed(ChronoField.NANO_OF_SECOND);
+        // The instant is parsed with an offset id (which also accepts 'Z' as
+        // zero), so resolve against the parsed offset rather than assuming UTC.
+        const offsetSecs = newContext.getParsed(ChronoField.OFFSET_SECONDS);
+        const offset = (offsetSecs != null ? offsetSecs : 0);
         let sec = (secVal != null ? secVal : 0);
         const nano = (nanoVal != null ? nanoVal : 0);
         const year = MathUtil.intMod(yearParsed, 10000);
@@ -1545,7 +1549,7 @@ class InstantPrinterParser  {
         let instantSecs;
         try {
             const ldt = LocalDateTime.of(year, month, day, hour, min, sec, 0).plusDays(days);
-            instantSecs = ldt.toEpochSecond(ZoneOffset.UTC);
+            instantSecs = ldt.toEpochSecond(ZoneOffset.ofTotalSeconds(offset));
             instantSecs += MathUtil.safeMultiply(MathUtil.intDiv(yearParsed, 10000), SECONDS_PER_10000_YEARS);
         } catch (ex) {
             return ~position;

package/src/format/DateTimeParseContext.js

@@ -9,6 +9,7 @@ import { assert, requireNonNull } from '../assert';
 import { DateTimeBuilder } from './DateTimeBuilder';
 import { EnumMap } from './EnumMap';
 
+import { Period } from '../Period';
 import { IsoChronology } from '../chrono/IsoChronology';
 import { Temporal } from '../temporal/Temporal';
 import { TemporalQueries } from '../temporal/TemporalQueries';
@@ -244,6 +245,7 @@ class Parsed extends Temporal {
         this.zone = null;
         this.fieldValues = new EnumMap();
         this.leapSecond = false;
+        this.excessDays = Period.ZERO;
         this.dateTimeParseContext = dateTimeParseContext;
     }
 

package/src/format/parser/ZoneIdPrinterParser.js

@@ -71,7 +71,67 @@ export class ZoneIdPrinterParser {
             return ~position;
         }
 
-        // handle fixed time-zone IDs
+        // A fixed ID (Z, UT, UTC, GMT, an offset) can also be the start of a
+        // longer region id such as GMT0 or Zulu, so parse both and keep the
+        // longest match (as the class doc above promises).
+        const region = this._parseRegion(text, position);
+        const fixedEndPos = this._parseFixedId(context, text, position);
+
+        const fixedLength = fixedEndPos >= 0 ? fixedEndPos - position : 0;
+        if (region != null && region.parseLength > fixedLength) {
+            context.setParsedZone(ZoneRegion.ofId(region.parsedZoneId));
+            return position + region.parseLength;
+        }
+        return fixedEndPos;
+    }
+
+    /**
+     * Finds the longest available zone region id matching text at position,
+     * without touching the parse context.
+     *
+     * @param {String} text
+     * @param {number} position
+     * @return {?{parsedZoneId: string, parseLength: number}}
+     */
+    _parseRegion(text, position) {
+        const availableZoneIds = ZoneRulesProvider.getAvailableZoneIds();
+        if (availableZoneIds.length === 0) {
+            return null;
+        }
+        if (zoneIdTree.size !== availableZoneIds.length) {
+            zoneIdTree = ZoneIdTree.createTreeMap(availableZoneIds);
+        }
+
+        const maxParseLength = text.length - position;
+        let treeMap = zoneIdTree.treeMap;
+        let parsedZoneId = null;
+        let parseLength = 0;
+        while(treeMap != null) {
+            const parsedSubZoneId = text.substr(position, Math.min(treeMap.length, maxParseLength));
+            treeMap = treeMap.get(parsedSubZoneId);
+            if (treeMap != null && treeMap.isLeaf) {
+                parsedZoneId = parsedSubZoneId;
+                parseLength = treeMap.length;
+            }
+        }
+        if (parsedZoneId == null) {
+            return null;
+        }
+        return { parsedZoneId, parseLength };
+    }
+
+    /**
+     * Parses a fixed zone id (an offset, a UT/UTC/GMT prefixed offset, SYSTEM
+     * or Z) and sets it on the context. Returns the end position, or ~position
+     * if no fixed id matches at position.
+     *
+     * @param {DateTimeParseContext} context
+     * @param {String} text
+     * @param {number} position
+     * @return {number}
+     */
+    _parseFixedId(context, text, position) {
+        const length = text.length;
         const nextChar = text.charAt(position);
         if (nextChar === '+' || nextChar === '-') {
             const newContext = context.copy();
@@ -80,8 +140,7 @@ export class ZoneIdPrinterParser {
                 return endPos;
             }
             const offset = newContext.getParsed(ChronoField.OFFSET_SECONDS);
-            const zone = ZoneOffset.ofTotalSeconds(offset);
-            context.setParsedZone(zone);
+            context.setParsedZone(ZoneOffset.ofTotalSeconds(offset));
             return endPos;
         } else if (length >= position + 2) {
             const nextNextChar = text.charAt(position + 1);
@@ -104,35 +163,10 @@ export class ZoneIdPrinterParser {
             context.setParsedZone(ZoneId.systemDefault());
             return position + 6;
         }
-
-        // ...
         if (context.charEquals(nextChar, 'Z')) {
             context.setParsedZone(ZoneOffset.UTC);
             return position + 1;
         }
-
-        const availableZoneIds = ZoneRulesProvider.getAvailableZoneIds();
-        if (zoneIdTree.size !== availableZoneIds.length) {
-            zoneIdTree = ZoneIdTree.createTreeMap(availableZoneIds);
-        }
-
-        const maxParseLength = length - position;
-        let treeMap = zoneIdTree.treeMap;
-        let parsedZoneId = null;
-        let parseLength = 0;
-        while(treeMap != null) {
-            const parsedSubZoneId = text.substr(position, Math.min(treeMap.length, maxParseLength));
-            treeMap = treeMap.get(parsedSubZoneId);
-            if (treeMap != null && treeMap.isLeaf) {
-                parsedZoneId = parsedSubZoneId;
-                parseLength = treeMap.length;
-            }
-        }
-        if (parsedZoneId != null) {
-            context.setParsedZone(ZoneRegion.ofId(parsedZoneId));
-            return position + parseLength;
-        }
-
         return ~position;
     }
 

package/typings/js-joda.flow.js

@@ -110,7 +110,7 @@ declare module "js-joda" {
         toNanos(): number;
         toHoursPart(): number;
         toMinutesPart(): number;
-        toSecondspart(): number;
+        toSecondsPart(): number;
         toMillisPart(): number;
         toString(): string;
         units(): any;