@js-joda/core 3.2.0 → 4.2.1

package/src/ZoneOffset.js

@@ -4,17 +4,17 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from './assert';
-import {DateTimeException} from './errors';
-import {MathUtil} from './MathUtil';
+import { requireNonNull } from './assert';
+import { DateTimeException } from './errors';
+import { MathUtil } from './MathUtil';
 
-import {LocalTime} from './LocalTime';
-import {ZoneId} from './ZoneId';
+import { LocalTime } from './LocalTime';
+import { ZoneId } from './ZoneId';
 
-import {ChronoField} from './temporal/ChronoField';
-import {TemporalQueries} from './temporal/TemporalQueries';
+import { ChronoField } from './temporal/ChronoField';
+import { TemporalQueries } from './temporal/TemporalQueries';
 
-import {ZoneRules} from './zone/ZoneRules';
+import { ZoneRules } from './zone/ZoneRules';
 
 const SECONDS_CACHE = {};
 const ID_CACHE = {};
@@ -74,9 +74,9 @@ export class ZoneOffset extends ZoneId {
             const absTotalSeconds = Math.abs(totalSeconds);
             const absHours = MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_HOUR);
             const absMinutes = MathUtil.intMod(MathUtil.intDiv(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE), LocalTime.MINUTES_PER_HOUR);
-            let buf = '' + (totalSeconds < 0 ? '-' : '+')
-                + (absHours < 10 ? '0' : '') + (absHours)
-                + (absMinutes < 10 ? ':0' : ':') + (absMinutes);
+            let buf = `${totalSeconds < 0 ? '-' : '+'
+            }${absHours < 10 ? '0' : ''}${absHours
+            }${absMinutes < 10 ? ':0' : ':'}${absMinutes}`;
             const absSeconds = MathUtil.intMod(absTotalSeconds, LocalTime.SECONDS_PER_MINUTE);
             if (absSeconds !== 0) {
                 buf += (absSeconds < 10 ? ':0' : ':') + (absSeconds);
@@ -106,8 +106,8 @@ export class ZoneOffset extends ZoneId {
      */
     static _validate(hours, minutes, seconds) {
         if (hours < -18 || hours > 18) {
-            throw new DateTimeException('Zone offset hours not in valid range: value ' + hours +
-                    ' is not in the range -18 to 18');
+            throw new DateTimeException(`Zone offset hours not in valid range: value ${hours 
+            } is not in the range -18 to 18`);
         }
         if (hours > 0) {
             if (minutes < 0 || seconds < 0) {
@@ -121,12 +121,12 @@ export class ZoneOffset extends ZoneId {
             throw new DateTimeException('Zone offset minutes and seconds must have the same sign');
         }
         if (Math.abs(minutes) > 59) {
-            throw new DateTimeException('Zone offset minutes not in valid range: abs(value) ' +
-                    Math.abs(minutes) + ' is not in the range 0 to 59');
+            throw new DateTimeException(`Zone offset minutes not in valid range: abs(value) ${ 
+                Math.abs(minutes)} is not in the range 0 to 59`);
         }
         if (Math.abs(seconds) > 59) {
-            throw new DateTimeException('Zone offset seconds not in valid range: abs(value) ' +
-                    Math.abs(seconds) + ' is not in the range 0 to 59');
+            throw new DateTimeException(`Zone offset seconds not in valid range: abs(value) ${ 
+                Math.abs(seconds)} is not in the range 0 to 59`);
         }
         if (Math.abs(hours) === 18 && (Math.abs(minutes) > 0 || Math.abs(seconds) > 0)) {
             throw new DateTimeException('Zone offset not in valid range: -18:00 to +18:00');
@@ -176,7 +176,7 @@ export class ZoneOffset extends ZoneId {
         let hours, minutes, seconds;
         switch (offsetId.length) {
             case 2:
-                offsetId = offsetId[0] + '0' + offsetId[1];  // fallthru
+                offsetId = `${offsetId[0]}0${offsetId[1]}`;  // fallthru
             // eslint-disable-next-line no-fallthrough
             case 3:
                 hours = ZoneOffset._parseNumber(offsetId, 1, false);
@@ -204,11 +204,11 @@ export class ZoneOffset extends ZoneId {
                 seconds = ZoneOffset._parseNumber(offsetId, 7, true);
                 break;
             default:
-                throw new DateTimeException('Invalid ID for ZoneOffset, invalid format: ' + offsetId);
+                throw new DateTimeException(`Invalid ID for ZoneOffset, invalid format: ${offsetId}`);
         }
         const first = offsetId[0];
         if (first !== '+' && first !== '-') {
-            throw new DateTimeException('Invalid ID for ZoneOffset, plus/minus not found when expected: ' + offsetId);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, plus/minus not found when expected: ${offsetId}`);
         }
         if (first === '-') {
             return ZoneOffset.ofHoursMinutesSeconds(-hours, -minutes, -seconds);
@@ -227,12 +227,12 @@ export class ZoneOffset extends ZoneId {
      */
     static _parseNumber(offsetId, pos, precededByColon) {
         if (precededByColon && offsetId[pos - 1] !== ':') {
-            throw new DateTimeException('Invalid ID for ZoneOffset, colon not found when expected: ' + offsetId);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, colon not found when expected: ${offsetId}`);
         }
         const ch1 = offsetId[pos];
         const ch2 = offsetId[pos + 1];
         if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
-            throw new DateTimeException('Invalid ID for ZoneOffset, non numeric characters found: ' + offsetId);
+            throw new DateTimeException(`Invalid ID for ZoneOffset, non numeric characters found: ${offsetId}`);
         }
         return (ch1.charCodeAt(0) - 48) * 10 + (ch2.charCodeAt(0) - 48);
     }
@@ -362,7 +362,7 @@ export class ZoneOffset extends ZoneId {
         if (field === ChronoField.OFFSET_SECONDS) {
             return this._totalSeconds;
         } else if (field instanceof ChronoField) {
-            throw new DateTimeException('Unsupported field: ' + field);
+            throw new DateTimeException(`Unsupported field: ${field}`);
         }
         return field.getFrom(this);
     }

package/src/ZoneRegion.js

@@ -5,8 +5,8 @@
  */
 
 
-import {ZoneId} from './ZoneId';
-import {ZoneRulesProvider} from './zone/ZoneRulesProvider';
+import { ZoneId } from './ZoneId';
+import { ZoneRulesProvider } from './zone/ZoneRulesProvider';
 
 /**
  * A geographical region where the same time-zone rules apply.

package/src/ZonedDateTime.js

@@ -4,25 +4,25 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from './assert';
-import {DateTimeException, IllegalArgumentException} from './errors';
-import {MathUtil} from './MathUtil';
-
-import {Clock} from './Clock';
-import {Instant} from './Instant';
-import {LocalDate} from './LocalDate';
-import {LocalDateTime} from './LocalDateTime';
-import {LocalTime} from './LocalTime';
-import {OffsetDateTime} from './OffsetDateTime';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
-
-import {ChronoZonedDateTime} from './chrono/ChronoZonedDateTime';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {TemporalQueries} from './temporal/TemporalQueries';
+import { requireNonNull } from './assert';
+import { DateTimeException, IllegalArgumentException } from './errors';
+import { MathUtil } from './MathUtil';
+
+import { Clock } from './Clock';
+import { Instant } from './Instant';
+import { LocalDate } from './LocalDate';
+import { LocalDateTime } from './LocalDateTime';
+import { LocalTime } from './LocalTime';
+import { OffsetDateTime } from './OffsetDateTime';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+
+import { ChronoZonedDateTime } from './chrono/ChronoZonedDateTime';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { TemporalQueries } from './temporal/TemporalQueries';
 
 /**
  * A date-time with a time-zone in the ISO-8601 calendar system,
@@ -378,12 +378,12 @@ export class ZonedDateTime extends ChronoZonedDateTime {
             if (trans != null && trans.isGap()) {
                 // error message says daylight savings for simplicity
                 // even though there are other kinds of gaps
-                throw new DateTimeException('LocalDateTime ' + localDateTime +
-                        ' does not exist in zone ' + zone +
-                        ' due to a gap in the local time-line, typically caused by daylight savings');
+                throw new DateTimeException(`LocalDateTime ${localDateTime 
+                } does not exist in zone ${zone 
+                } due to a gap in the local time-line, typically caused by daylight savings`);
             }
-            throw new DateTimeException('ZoneOffset "' + offset + '" is not valid for LocalDateTime "' +
-                localDateTime + '" in zone "' + zone + '"');
+            throw new DateTimeException(`ZoneOffset "${offset}" is not valid for LocalDateTime "${ 
+                localDateTime}" in zone "${zone}"`);
         }
         return new ZonedDateTime(localDateTime, offset, zone);
     }
@@ -1029,7 +1029,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws DateTimeException if the adjustment cannot be made
      * @throws ArithmeticException if numeric overflow occurs
      */
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         // optimizations
         if (adjuster instanceof LocalDate) {
             return this._resolveLocal(LocalDateTime.of(adjuster, this._dateTime.toLocalTime()));
@@ -1043,8 +1043,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
         } else if (adjuster instanceof ZoneOffset) {
             return this._resolveOffset(adjuster);
         }
-        requireNonNull(adjuster, 'adjuster');
-        return adjuster.adjustInto(this);
+        return super._withAdjuster(adjuster);
     }
 
     /**
@@ -1098,7 +1097,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @throws UnsupportedTemporalTypeException if the field is not supported
      * @throws ArithmeticException if numeric overflow occurs
      */
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         if (field instanceof ChronoField) {
             switch (field) {
                 case ChronoField.INSTANT_SECONDS: return ZonedDateTime._create(newValue, this.nano(), this._zone);
@@ -1325,27 +1324,6 @@ export class ZonedDateTime extends ChronoZonedDateTime {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this date-time with the specified period added.
-     *
-     * This method returns a new date-time based on this time with the specified period added.
-     * The amount is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link plus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {!TemporalAmount} amount - the amount to add, not null
-     * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the addition made, not null
-     * @throws DateTimeException if the addition cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    plusAmount(amount) {
-        requireNonNull(amount);
-        return amount.addTo(this);
-    }
-
     /**
      * Returns a copy of this date-time with the specified period added.
      *
@@ -1375,7 +1353,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the specified period added, not null
      * @throws DateTimeException if the unit cannot be added to this type
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         if (unit instanceof ChronoUnit) {
             if (unit.isDateBased()) {
                 return this._resolveLocal(this._dateTime.plus(amountToAdd, unit));
@@ -1556,27 +1534,6 @@ export class ZonedDateTime extends ChronoZonedDateTime {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * Returns a copy of this date-time with the specified period subtracted.
-     *
-     * This method returns a new date-time based on this time with the specified period subtracted.
-     * The amount is typically {@link Period} but may be any other type implementing
-     * the {@link TemporalAmount} interface.
-     * The calculation is delegated to the specified adjuster, which typically calls
-     * back to {@link minus}.
-     *
-     * This instance is immutable and unaffected by this method call.
-     *
-     * @param {TemporalAmount} amount - the amount to subtract, not null
-     * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the subtraction made, not null
-     * @throws DateTimeException if the subtraction cannot be made
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    minusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        return amount.subtractFrom(this);
-    }
-
     /**
      * Returns a copy of this date-time with the specified period subtracted.
      *
@@ -1606,8 +1563,8 @@ export class ZonedDateTime extends ChronoZonedDateTime {
      * @return {ZonedDateTime} a {@link ZonedDateTime} based on this date-time with the specified period subtracted, not null
      * @throws DateTimeException if the unit cannot be added to this type
      */
-    minusAmountUnit(amountToSubtract, unit) {
-        return this.plusAmountUnit(-1 * amountToSubtract, unit);
+    _minusUnit(amountToSubtract, unit) {
+        return this._plusUnit(-1 * amountToSubtract, unit);
     }
 
     //-----------------------------------------------------------------------
@@ -1974,7 +1931,7 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     toString() {
         let str = this._dateTime.toString() + this._offset.toString();
         if (this._offset !== this._zone) {
-            str += '[' + this._zone.toString() + ']';
+            str += `[${this._zone.toString()}]`;
         }
         return str;
     }

package/src/_init.js

@@ -3,31 +3,31 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {_init as ZoneOffsetInit} from './ZoneOffset';
-import {_init as DayOfWeekInit} from './DayOfWeek';
-import {_init as DurationInit} from './Duration';
-import {_init as InstantInit} from './Instant';
-import {_init as LocalDateInit} from './LocalDate';
-import {_init as LocalTimeInit} from './LocalTime';
-import {_init as LocalDateTimeInit} from './LocalDateTime';
-import {_init as MonthInit} from './Month';
-import {_init as MonthDayInit} from './MonthDay';
-import {_init as OffsetDateTimeInit} from './OffsetDateTime';
-import {_init as OffsetTimeInit} from './OffsetTime';
-import {_init as PeriodInit} from './Period';
-import {_init as YearInit} from './Year';
-import {_init as YearConstantsInit} from './YearConstants';
-import {_init as YearMonthInit} from './YearMonth';
-import {_init as ZonedDateTimeInit} from './ZonedDateTime';
-import {_init as IsoChronologyInit} from './chrono/IsoChronology';
-import {_init as DateTimeFormatterInit} from './format/DateTimeFormatter';
-import {_init as ChronoFieldInit} from './temporal/ChronoField';
-import {_init as ChronoUnitInit} from './temporal/ChronoUnit';
-import {_init as IsoFieldsInit} from './temporal/IsoFields';
-import {_init as DateTimeFormatterBuilderInit} from './format/DateTimeFormatterBuilder';
+import { _init as ZoneOffsetInit } from './ZoneOffset';
+import { _init as DayOfWeekInit } from './DayOfWeek';
+import { _init as DurationInit } from './Duration';
+import { _init as InstantInit } from './Instant';
+import { _init as LocalDateInit } from './LocalDate';
+import { _init as LocalTimeInit } from './LocalTime';
+import { _init as LocalDateTimeInit } from './LocalDateTime';
+import { _init as MonthInit } from './Month';
+import { _init as MonthDayInit } from './MonthDay';
+import { _init as OffsetDateTimeInit } from './OffsetDateTime';
+import { _init as OffsetTimeInit } from './OffsetTime';
+import { _init as PeriodInit } from './Period';
+import { _init as YearInit } from './Year';
+import { _init as YearConstantsInit } from './YearConstants';
+import { _init as YearMonthInit } from './YearMonth';
+import { _init as ZonedDateTimeInit } from './ZonedDateTime';
+import { _init as IsoChronologyInit } from './chrono/IsoChronology';
+import { _init as DateTimeFormatterInit } from './format/DateTimeFormatter';
+import { _init as ChronoFieldInit } from './temporal/ChronoField';
+import { _init as ChronoUnitInit } from './temporal/ChronoUnit';
+import { _init as IsoFieldsInit } from './temporal/IsoFields';
+import { _init as DateTimeFormatterBuilderInit } from './format/DateTimeFormatterBuilder';
 
-import {_init as TemporalQueriesInit} from './temporal/TemporalQueriesFactory';
-import {_init as ZoneIdInit} from './ZoneIdFactory';
+import { _init as TemporalQueriesInit } from './temporal/TemporalQueriesFactory';
+import { _init as ZoneIdInit } from './ZoneIdFactory';
 
 let isInit = false;
 

package/src/assert.js

@@ -2,8 +2,15 @@
  * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
-import {NullPointerException, IllegalArgumentException} from './errors';
+import { NullPointerException, IllegalArgumentException } from './errors';
 
+/**
+ * @private
+ *
+ * @param assertion
+ * @param msg
+ * @param error
+ */
 export function assert(assertion, msg, error) {
     if(!assertion){
         if (error) {
@@ -14,20 +21,40 @@ export function assert(assertion, msg, error) {
     }
 }
 
+/**
+ * @private
+ *
+ * @param value
+ * @param parameterName
+ * @returns {*}
+ */
 export function requireNonNull(value, parameterName) {
     if (value == null) {
-        throw new NullPointerException(parameterName + ' must not be null');
+        throw new NullPointerException(`${parameterName} must not be null`);
     }
     return value;
 }
 
+/**
+ * @private
+ *
+ * @param value
+ * @param _class
+ * @param parameterName
+ * @returns {_class}
+ */
 export function requireInstance(value, _class, parameterName) {
     if (!(value instanceof _class)) {
-        throw new IllegalArgumentException(parameterName + ' must be an instance of ' + (_class.name ? _class.name : _class) + (value && value.constructor && value.constructor.name ? ', but is ' + value.constructor.name : ''));
+        throw new IllegalArgumentException(`${parameterName} must be an instance of ${_class.name ? _class.name : _class}${value && value.constructor && value.constructor.name ? `, but is ${value.constructor.name}` : ''}`);
     }
     return value;
 }
 
+/**
+ * @private
+ *
+ * @param methodName
+ */
 export function abstractMethodFail(methodName){
-    throw new TypeError('abstract method "' + methodName + '" is not implemented');
+    throw new TypeError(`abstract method "${methodName}" is not implemented`);
 }

package/src/chrono/ChronoLocalDate.js

@@ -4,15 +4,15 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull, requireInstance} from '../assert';
+import { requireNonNull, requireInstance } from '../assert';
 
-import {ChronoField} from '../temporal/ChronoField';
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {DateTimeFormatter} from '../format/DateTimeFormatter';
-import {TemporalQueries} from '../temporal/TemporalQueries';
-import {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
+import { ChronoField } from '../temporal/ChronoField';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { DateTimeFormatter } from '../format/DateTimeFormatter';
+import { TemporalQueries } from '../temporal/TemporalQueries';
+import { Temporal } from '../temporal/Temporal';
 
-import {LocalDate} from '../LocalDate';
+import { LocalDate } from '../LocalDate';
 
 /**
  * A date without time-of-day or time-zone in an arbitrary chronology, intended
@@ -180,7 +180,7 @@ import {LocalDate} from '../LocalDate';
  * In JDK 8, this is an interface with default methods.
  * Since there are no default methods in JDK 7, an abstract class is used.
  */
-export class ChronoLocalDate extends DefaultInterfaceTemporal {
+export class ChronoLocalDate extends Temporal {
 
     isSupported(fieldOrUnit) {
         if (fieldOrUnit instanceof ChronoField) {

package/src/chrono/ChronoLocalDateTime.js

@@ -4,16 +4,16 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull, requireInstance} from '../assert';
-import {MathUtil} from '../MathUtil';
+import { requireNonNull, requireInstance } from '../assert';
+import { MathUtil } from '../MathUtil';
 
-import {LocalDate} from '../LocalDate';
-import {Instant} from '../Instant';
-import {ZoneOffset} from '../ZoneOffset';
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {ChronoField} from '../temporal/ChronoField';
-import {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
-import {TemporalQueries} from '../temporal/TemporalQueries';
+import { LocalDate } from '../LocalDate';
+import { Instant } from '../Instant';
+import { ZoneOffset } from '../ZoneOffset';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { ChronoField } from '../temporal/ChronoField';
+import { Temporal } from '../temporal/Temporal';
+import { TemporalQueries } from '../temporal/TemporalQueries';
 
 /**
  * A date-time without a time-zone in an arbitrary chronology, intended
@@ -49,7 +49,7 @@ import {TemporalQueries} from '../temporal/TemporalQueries';
  *
  * @param D the date type
  */
-export class ChronoLocalDateTime extends DefaultInterfaceTemporal {
+export class ChronoLocalDateTime extends Temporal {
     /* <D extends ChronoLocalDate>
         extends DefaultInterfaceTemporal
         implements Temporal, TemporalAdjuster, Comparable<ChronoLocalDateTime<?>> */

package/src/chrono/ChronoZonedDateTime.js

@@ -4,16 +4,16 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from '../assert';
-import {Instant} from '../Instant';
-import {LocalDate} from '../LocalDate';
-import {MathUtil} from '../MathUtil';
+import { requireNonNull } from '../assert';
+import { Instant } from '../Instant';
+import { LocalDate } from '../LocalDate';
+import { MathUtil } from '../MathUtil';
 
-import {ChronoUnit} from '../temporal/ChronoUnit';
-import {DefaultInterfaceTemporal} from '../temporal/DefaultInterfaceTemporal';
-import {TemporalQueries} from '../temporal/TemporalQueries';
+import { ChronoUnit } from '../temporal/ChronoUnit';
+import { Temporal } from '../temporal/Temporal';
+import { TemporalQueries } from '../temporal/TemporalQueries';
 
-export class ChronoZonedDateTime  extends DefaultInterfaceTemporal {
+export class ChronoZonedDateTime extends Temporal {
     query(query) {
         if (query === TemporalQueries.zoneId() || query === TemporalQueries.zone()) {
             return this.zone();

package/src/chrono/IsoChronology.js

@@ -4,19 +4,19 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {Enum} from '../Enum';
-import {requireNonNull} from '../assert';
-import {DateTimeException} from '../errors';
-import {MathUtil} from '../MathUtil';
+import { Enum } from '../Enum';
+import { requireNonNull } from '../assert';
+import { DateTimeException } from '../errors';
+import { MathUtil } from '../MathUtil';
 
-import {DayOfWeek} from '../DayOfWeek';
-import {LocalDate} from '../LocalDate';
-import {Month} from '../Month';
-import {Year} from '../Year';
+import { DayOfWeek } from '../DayOfWeek';
+import { LocalDate } from '../LocalDate';
+import { Month } from '../Month';
+import { Year } from '../Year';
 
-import {ChronoField} from '../temporal/ChronoField';
-import {ResolverStyle} from '../format/ResolverStyle';
-import {TemporalAdjusters} from '../temporal/TemporalAdjusters';
+import { ChronoField } from '../temporal/ChronoField';
+import { ResolverStyle } from '../format/ResolverStyle';
+import { TemporalAdjusters } from '../temporal/TemporalAdjusters';
 
 export class IsoChronology extends Enum{
     /**
@@ -56,7 +56,7 @@ export class IsoChronology extends Enum{
         requireNonNull(field, 'field');
         const current = fieldValues.get(field);
         if (current != null && current !== value) {
-            throw new DateTimeException('Invalid state, field: ' + field + ' ' + current + ' conflicts with ' + field + ' ' + value);
+            throw new DateTimeException(`Invalid state, field: ${field} ${current} conflicts with ${field} ${value}`);
         }
         fieldValues.put(field, value);
     }
@@ -102,7 +102,7 @@ export class IsoChronology extends Enum{
             } else if (era === 0) {
                 this._updateResolveMap(fieldValues, ChronoField.YEAR, MathUtil.safeSubtract(1, yoeLong));
             } else {
-                throw new DateTimeException('Invalid value for era: ' + era);
+                throw new DateTimeException(`Invalid value for era: ${era}`);
             }
         } else if (fieldValues.containsKey(ChronoField.ERA)) {
             ChronoField.ERA.checkValidValue(fieldValues.get(ChronoField.ERA));  // always validated

package/src/convert.js

@@ -3,23 +3,27 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {IllegalArgumentException} from './errors';
+import { IllegalArgumentException } from './errors';
 
-import {LocalDate} from './LocalDate';
-import {LocalDateTime} from './LocalDateTime';
-import {ZonedDateTime} from './ZonedDateTime';
-import {ZoneId} from './ZoneId';
+import { LocalDate } from './LocalDate';
+import { LocalDateTime } from './LocalDateTime';
+import { ZonedDateTime } from './ZonedDateTime';
+import { ZoneId } from './ZoneId';
+import { Instant } from './Instant';
 
 class ToNativeJsConverter {
     /**
-     * @param {!(LocalDate|LocalDateTime|ZonedDateTime)} temporal - a joda temporal instance
+     * @param {!(LocalDate|LocalDateTime|ZonedDateTime|Instant)} temporal - a joda temporal instance
      * @param {ZoneId} [zone] - the zone of the temporal,
      *  the default value for LocalDate and LocalDateTime is ZoneId.systemDefault().
      */
     constructor(temporal, zone){
         let zonedDateTime;
 
-        if(temporal instanceof LocalDate) {
+        if(temporal instanceof Instant) {
+            this.instant = temporal;
+            return;
+        } else if(temporal instanceof LocalDate) {
             zone = zone == null ?  ZoneId.systemDefault() : zone;
             zonedDateTime = temporal.atStartOfDay(zone);
         } else if (temporal instanceof LocalDateTime) {
@@ -32,7 +36,7 @@ class ToNativeJsConverter {
                 zonedDateTime = temporal.withZoneSameInstant(zone);
             }
         } else {
-            throw new IllegalArgumentException('unsupported instance for convert operation:' + temporal);
+            throw new IllegalArgumentException(`unsupported instance for convert operation:${temporal}`);
         }
 
         this.instant = zonedDateTime.toInstant();

package/src/errors.js

@@ -33,16 +33,16 @@ export const NullPointerException = createErrorType('NullPointerException');
 function messageWithCause(message, cause = null) {
     let msg = message || this.name;
     if (cause !== null && cause instanceof Error) {
-        msg += '\n-------\nCaused by: ' + cause.stack + '\n-------\n';
+        msg += `\n-------\nCaused by: ${cause.stack}\n-------\n`;
     }
     this.message = msg;
 }
 
 function messageForDateTimeParseException(message, text = '', index = 0, cause = null) {
     let msg = message || this.name;
-    msg += ': ' + text + ', at index: ' + index;
+    msg += `: ${text}, at index: ${index}`;
     if (cause !== null && cause instanceof Error) {
-        msg += '\n-------\nCaused by: ' + cause.stack + '\n-------\n';
+        msg += `\n-------\nCaused by: ${cause.stack}\n-------\n`;
     }
     this.message = msg;
     this.parsedString = () => {