@js-joda/core 3.2.0 → 4.2.1

package/src/LocalDate.js

@@ -4,33 +4,33 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {assert, requireNonNull, requireInstance} from './assert';
-
-import {MathUtil} from './MathUtil';
-import {DateTimeException, UnsupportedTemporalTypeException, NullPointerException, IllegalArgumentException} from './errors';
-
-import {IsoChronology} from './chrono/IsoChronology';
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {ChronoLocalDate} from './chrono/ChronoLocalDate';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {createTemporalQuery} from './temporal/TemporalQuery';
-import {ValueRange} from './temporal/ValueRange';
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-
-import {Clock} from './Clock';
-import {DayOfWeek} from './DayOfWeek';
-import {OffsetDateTime} from './OffsetDateTime';
-import {OffsetTime} from './OffsetTime';
-import {Month} from './Month';
-import {Period} from './Period';
-import {YearConstants} from './YearConstants';
-import {LocalTime} from './LocalTime';
-import {LocalDateTime} from './LocalDateTime';
-import {Year} from './Year';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
-import {ZonedDateTime} from './ZonedDateTime';
+import { assert, requireNonNull, requireInstance } from './assert';
+
+import { MathUtil } from './MathUtil';
+import { DateTimeException, UnsupportedTemporalTypeException, NullPointerException, IllegalArgumentException } from './errors';
+
+import { IsoChronology } from './chrono/IsoChronology';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { ChronoLocalDate } from './chrono/ChronoLocalDate';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { createTemporalQuery } from './temporal/TemporalQuery';
+import { ValueRange } from './temporal/ValueRange';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+
+import { Clock } from './Clock';
+import { DayOfWeek } from './DayOfWeek';
+import { OffsetDateTime } from './OffsetDateTime';
+import { OffsetTime } from './OffsetTime';
+import { Month } from './Month';
+import { Period } from './Period';
+import { YearConstants } from './YearConstants';
+import { LocalTime } from './LocalTime';
+import { LocalDateTime } from './LocalDateTime';
+import { Year } from './Year';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
+import { ZonedDateTime } from './ZonedDateTime';
 
 /**
  * The number of days in a 400 year cycle.
@@ -158,7 +158,7 @@ export class LocalDate extends ChronoLocalDate{
         //TODO: ChronoField.DAY_OF_YEAR.checkValidValue(dayOfYear);
         const leap = IsoChronology.isLeapYear(year);
         if (dayOfYear === 366 && leap === false) {
-            assert(false, 'Invalid date \'DayOfYear 366\' as \'' + year + '\' is not a leap year', DateTimeException);
+            assert(false, `Invalid date 'DayOfYear 366' as '${year}' is not a leap year`, DateTimeException);
         }
         let moy = Month.of(Math.floor((dayOfYear - 1) / 31 + 1));
         const monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;
@@ -323,9 +323,9 @@ export class LocalDate extends ChronoLocalDate{
             }
             if (dayOfMonth > dom) {
                 if (dayOfMonth === 29) {
-                    assert(false, 'Invalid date \'February 29\' as \'' + year + '\' is not a leap year', DateTimeException);
+                    assert(false, `Invalid date 'February 29' as '${year}' is not a leap year`, DateTimeException);
                 } else {
-                    assert(false, 'Invalid date \'' + year + '\' \'' + month + '\' \'' + dayOfMonth + '\'', DateTimeException);
+                    assert(false, `Invalid date '${year}' '${month}' '${dayOfMonth}'`, DateTimeException);
                 }
             }
         }
@@ -405,7 +405,7 @@ export class LocalDate extends ChronoLocalDate{
                 }
                 return field.range();
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.rangeRefinedBy(this);
     }
@@ -476,7 +476,7 @@ export class LocalDate extends ChronoLocalDate{
             case ChronoField.YEAR: return this._year;
             case ChronoField.ERA: return (this._year >= 1 ? 1 : 0);
         }
-        throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+        throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
     }
 
     /**
@@ -651,14 +651,13 @@ export class LocalDate extends ChronoLocalDate{
      * @throws {DateTimeException} if the adjustment cannot be made
      * @throws {ArithmeticException} if numeric overflow occurs
      */
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         // optimizations
         if (adjuster instanceof LocalDate) {
             return adjuster;
         }
-        assert(typeof adjuster.adjustInto === 'function', 'adjuster', IllegalArgumentException);
-        return adjuster.adjustInto(this);
+        return super._withAdjuster(adjuster);
     }
 
     /**
@@ -761,7 +760,7 @@ export class LocalDate extends ChronoLocalDate{
      * @throws {DateTimeException} if the field cannot be set
      * @throws {ArithmeticException} if numeric overflow occurs
      */
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         assert(field != null, 'field', NullPointerException);
         if (field instanceof ChronoField) {
             const f = field;
@@ -781,7 +780,7 @@ export class LocalDate extends ChronoLocalDate{
                 case ChronoField.YEAR: return this.withYear(newValue);
                 case ChronoField.ERA: return (this.getLong(ChronoField.ERA) === newValue ? this : this.withYear(1 - this._year));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
+            throw new UnsupportedTemporalTypeException(`Unsupported field: ${field}`);
         }
         return field.adjustInto(this, newValue);
     }
@@ -852,25 +851,6 @@ export class LocalDate extends ChronoLocalDate{
         return LocalDate.ofYearDay(this._year, dayOfYear);
     }
 
-    /**
-     * Returns a copy of this date with the specified period added.
-     *
-     * This method returns a new date based on this date 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 LocalDate.plusAmountUnit}.
-     *
-     * @param {!TemporalAmount} amount - the amount to add, not null
-     * @return {LocalDate} a {@link LocalDate} based on this date with the addition made, not null
-     * @throws {DateTimeException} if the addition cannot be made
-     * @throws {ArithmeticException} if numeric overflow occurs
-     */
-    plusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        return amount.addTo(this);
-    }
-
     /**
      * Returns a copy of this date with the specified period added.
      *
@@ -884,7 +864,7 @@ export class LocalDate extends ChronoLocalDate{
      * @return {LocalDate} a {@link LocalDate} based on this date with the specified period added, not null
      * @throws {DateTimeException} if the unit cannot be added to this type
      */
-    plusAmountUnit(amountToAdd, unit) {
+    _plusUnit(amountToAdd, unit) {
         requireNonNull(amountToAdd, 'amountToAdd');
         requireNonNull(unit, 'unit');
         if (unit instanceof ChronoUnit) {
@@ -898,7 +878,7 @@ export class LocalDate extends ChronoLocalDate{
                 case ChronoUnit.MILLENNIA: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 1000));
                 case ChronoUnit.ERAS: return this.with(ChronoField.ERA, MathUtil.safeAdd(this.getLong(ChronoField.ERA), amountToAdd));
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.addTo(this, amountToAdd);
     }
@@ -995,25 +975,6 @@ export class LocalDate extends ChronoLocalDate{
         return LocalDate.ofEpochDay(mjDay);
     }
 
-    /**
-     * Returns a copy of this date with the specified period subtracted.
-     *
-     * This method returns a new date based on this date 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}.
-     *
-     * @param {!TemporalAmount} amount - the amount to subtract, not null
-     * @return {LocalDate} a {@link LocalDate} based on this date 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 with the specified period subtracted.
      *
@@ -1027,10 +988,10 @@ export class LocalDate extends ChronoLocalDate{
      * @return {LocalDate} a {@link LocalDate} based on this date with the specified period subtracted, not null
      * @throws {DateTimeException} if the unit cannot be added to this type
      */
-    minusAmountUnit(amountToSubtract, unit) {
+    _minusUnit(amountToSubtract, unit) {
         requireNonNull(amountToSubtract, 'amountToSubtract');
         requireNonNull(unit, 'unit');
-        return this.plusAmountUnit(-1 * amountToSubtract, unit);
+        return this._plusUnit(-1 * amountToSubtract, unit);
     }
 
     /**
@@ -1232,7 +1193,7 @@ export class LocalDate extends ChronoLocalDate{
                 case ChronoUnit.MILLENNIA: return MathUtil.intDiv(this._monthsUntil(end), 12000);
                 case ChronoUnit.ERAS: return end.getLong(ChronoField.ERA) - this.getLong(ChronoField.ERA);
             }
-            throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+            throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
         }
         return unit.between(this, end);
     }
@@ -1344,8 +1305,8 @@ export class LocalDate extends ChronoLocalDate{
         } else if (time instanceof OffsetTime) {
             return this._atTimeOffsetTime(time);
         } else {
-            throw new IllegalArgumentException('time must be an instance of LocalTime or OffsetTime' +
-                (time && time.constructor && time.constructor.name ? ', but is ' + time.constructor.name : ''));
+            throw new IllegalArgumentException(`time must be an instance of LocalTime or OffsetTime${ 
+                time && time.constructor && time.constructor.name ? `, but is ${time.constructor.name}` : ''}`);
         }
     }
 
@@ -1388,12 +1349,29 @@ export class LocalDate extends ChronoLocalDate{
      * This returns a {@link LocalDateTime} formed from this date at the time of
      * midnight, 00:00, at the start of this date.
      *
-     * @param {ZoneId} zone - if zone is not null @see {@link LocalDate.atStartOfDayWithZone}
+     * If zone is not null, this returns a {@link ZonedDateTime} formed from this date at the
+     * specified zone, with the time set to be the earliest valid time according
+     * to the rules in the time-zone.
+     *
+     * Time-zone rules, such as daylight savings, mean that not every local date-time
+     * is valid for the specified zone, thus the local date-time may not be midnight.
+     *
+     * In most cases, there is only one valid offset for a local date-time.
+     * In the case of an overlap, there are two valid offsets, and the earlier one is used,
+     * corresponding to the first occurrence of midnight on the date.
+     * In the case of a gap, the zoned date-time will represent the instant just after the gap.
+     *
+     * If the zone ID is a {@link ZoneOffset}, then the result always has a time of midnight.
+     *
+     * To convert to a specific time in a given time-zone call {@link atTime}
+     * followed by {@link LocalDateTime#atZone}.
+     *
+     * @param {ZoneId} zone - optional ZoneId or ZoneOffset
      * @return {LocalDateTime|ZonedDateTime} the local date-time of midnight at the start of this date, not null
      */
     atStartOfDay(zone) {
         if(zone != null){
-            return this.atStartOfDayWithZone(zone);
+            return this._atStartOfDayWithZone(zone);
         } else {
             return LocalDateTime.of(this, LocalTime.MIDNIGHT);
         }
@@ -1423,7 +1401,7 @@ export class LocalDate extends ChronoLocalDate{
      * @param {!ZoneId} zone - the zone ID to use, not null
      * @return {ZonedDateTime} the zoned date-time formed from this date and the earliest valid time for the zone, not null
      */
-    atStartOfDayWithZone(zone) {
+    _atStartOfDayWithZone(zone) {
         requireNonNull(zone, 'zone');
         let ldt = this.atTime(LocalTime.MIDNIGHT);
         // need to handle case where there is a gap from 11:30 to 00:30
@@ -1632,28 +1610,28 @@ export class LocalDate extends ChronoLocalDate{
 
         if (absYear < 1000) {
             if (yearValue < 0) {
-                yearString = '-' + ('' + (yearValue - 10000)).slice(-4);
+                yearString = `-${(`${yearValue - 10000}`).slice(-4)}`;
             } else {
-                yearString = ('' + (yearValue + 10000)).slice(-4);
+                yearString = (`${yearValue + 10000}`).slice(-4);
             }
         } else {
             if (yearValue > 9999) {
-                yearString = '+' + yearValue;
+                yearString = `+${yearValue}`;
             } else {
-                yearString = '' + yearValue;
+                yearString = `${yearValue}`;
             }
         }
 
         if (monthValue < 10) {
-            monthString = '-0' + monthValue;
+            monthString = `-0${monthValue}`;
         } else {
-            monthString = '-' + monthValue;
+            monthString = `-${monthValue}`;
         }
 
         if (dayValue < 10) {
-            dayString = '-0' + dayValue;
+            dayString = `-0${dayValue}`;
         } else {
-            dayString = '-' + dayValue;
+            dayString = `-${dayValue}`;
         }
 
         return yearString + monthString + dayString;

package/src/LocalDateTime.js

@@ -4,27 +4,27 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {MathUtil} from './MathUtil';
-import {assert, requireNonNull, requireInstance} from './assert';
-import {DateTimeException, UnsupportedTemporalTypeException, IllegalArgumentException} from './errors';
+import { MathUtil } from './MathUtil';
+import { requireNonNull, requireInstance } from './assert';
+import { DateTimeException, UnsupportedTemporalTypeException } from './errors';
 
-import {Clock} from './Clock';
-import {Instant} from './Instant';
-import {LocalDate} from './LocalDate';
-import {LocalTime} from './LocalTime';
-import {OffsetDateTime} from './OffsetDateTime';
-import {ZonedDateTime} from './ZonedDateTime';
-import {ZoneId} from './ZoneId';
-import {ZoneOffset} from './ZoneOffset';
+import { Clock } from './Clock';
+import { Instant } from './Instant';
+import { LocalDate } from './LocalDate';
+import { LocalTime } from './LocalTime';
+import { OffsetDateTime } from './OffsetDateTime';
+import { ZonedDateTime } from './ZonedDateTime';
+import { ZoneId } from './ZoneId';
+import { ZoneOffset } from './ZoneOffset';
 
 
-import {DateTimeFormatter} from './format/DateTimeFormatter';
-import {ChronoField} from './temporal/ChronoField';
-import {ChronoUnit} from './temporal/ChronoUnit';
-import {TemporalQueries} from './temporal/TemporalQueries';
-import {createTemporalQuery} from './temporal/TemporalQuery';
+import { DateTimeFormatter } from './format/DateTimeFormatter';
+import { ChronoField } from './temporal/ChronoField';
+import { ChronoUnit } from './temporal/ChronoUnit';
+import { TemporalQueries } from './temporal/TemporalQueries';
+import { createTemporalQuery } from './temporal/TemporalQuery';
 
-import {ChronoLocalDateTime} from './chrono/ChronoLocalDateTime';
+import { ChronoLocalDateTime } from './chrono/ChronoLocalDateTime';
 
 /**
  * A date-time without a time-zone in the ISO-8601 calendar system,
@@ -637,7 +637,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
      * @throws {DateTimeException} if the adjustment cannot be made
      * @throws {ArithmeticException} if numeric overflow occurs
      */
-    withAdjuster(adjuster) {
+    _withAdjuster(adjuster) {
         requireNonNull(adjuster, 'adjuster');
         // optimizations
         if (adjuster instanceof LocalDate) {
@@ -647,8 +647,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
         } else if (adjuster instanceof LocalDateTime) {
             return adjuster;
         }
-        assert(typeof adjuster.adjustInto === 'function', 'adjuster', IllegalArgumentException);
-        return adjuster.adjustInto(this);
+        return super._withAdjuster(adjuster);
     }
 
     /**
@@ -683,7 +682,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
      * @throws {DateTimeException} if the field cannot be set
      * @throws {ArithmeticException} if numeric overflow occurs
      */
-    withFieldValue(field, newValue) {
+    _withField(field, newValue) {
         requireNonNull(field, 'field');
         if (field instanceof ChronoField) {
             if (field.isTimeBased()) {
@@ -840,27 +839,6 @@ implements Temporal, TemporalAdjuster, Serializable */ {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * 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 {LocalDateTime} 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, 'amount');
-        return amount.addTo(this);
-    }
-
     /**
      * Returns a copy of this date-time with the specified period added.
      *
@@ -876,7 +854,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
      * @return {LocalDateTime} a {@link LocalDateTime} 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) {
         requireNonNull(unit, 'unit');
         if (unit instanceof ChronoUnit) {
             switch (unit) {
@@ -1037,27 +1015,6 @@ implements Temporal, TemporalAdjuster, Serializable */ {
 
     //-----------------------------------------------------------------------
 
-    /**
-     * 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 {LocalDateTime} 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.
      *
@@ -1073,9 +1030,9 @@ implements Temporal, TemporalAdjuster, Serializable */ {
      * @return {LocalDateTime} a {@link LocalDateTime} 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) {
+    _minusUnit(amountToSubtract, unit) {
         requireNonNull(unit, 'unit');
-        return this.plusAmountUnit(-1 * amountToSubtract, unit);
+        return this._plusUnit(-1 * amountToSubtract, unit);
     }
 
     //-----------------------------------------------------------------------
@@ -1391,7 +1348,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
                         amount = MathUtil.safeMultiply(amount, 2);
                         return MathUtil.safeAdd(amount, MathUtil.intDiv(timeUntil, (LocalTime.NANOS_PER_HOUR * 12)));
                 }
-                throw new UnsupportedTemporalTypeException('Unsupported unit: ' + unit);
+                throw new UnsupportedTemporalTypeException(`Unsupported unit: ${unit}`);
             }
             let endDate = end._date;
             const endTime = end._time;
@@ -1638,7 +1595,7 @@ implements Temporal, TemporalAdjuster, Serializable */ {
      * @return {string} a string representation of this date-time, not null
      */
     toString() {
-        return this._date.toString() + 'T' + this._time.toString();
+        return `${this._date.toString()}T${this._time.toString()}`;
     }
 
     /**