@js-joda/core 6.0.1 → 6.1.0

package/package.json

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

package/src/Duration.js

@@ -1209,9 +1209,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 +1232,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);
     }
 

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;