@js-joda/core 3.2.0 → 4.2.1

package/src/temporal/TemporalQueriesFactory.js

@@ -4,13 +4,13 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {ChronoField} from './ChronoField';
-import {createTemporalQuery} from './TemporalQuery';
-import {TemporalQueries} from './TemporalQueries';
+import { ChronoField } from './ChronoField';
+import { createTemporalQuery } from './TemporalQuery';
+import { TemporalQueries } from './TemporalQueries';
 
-import {LocalDate} from '../LocalDate';
-import {LocalTime} from '../LocalTime';
-import {ZoneOffset} from '../ZoneOffset';
+import { LocalDate } from '../LocalDate';
+import { LocalTime } from '../LocalTime';
+import { ZoneOffset } from '../ZoneOffset';
 
 
 export function _init() {

package/src/temporal/TemporalQuery.js

@@ -4,8 +4,8 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {abstractMethodFail} from '../assert';
-import {Enum} from '../Enum';
+import { abstractMethodFail } from '../assert';
+import { Enum } from '../Enum';
 
 
 /**
@@ -92,6 +92,8 @@ export class TemporalQuery  extends Enum {
 }
 
 /**
+ * @private
+ *
  * Factory to create something similar to the JSR-310 {TemporalQuery} interface, takes a function and returns a new TemporalQuery object that presents that function
  * as the queryFrom() function.
  * @param name for the underlying Enum

package/src/temporal/TemporalUnit.js

@@ -4,7 +4,7 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {abstractMethodFail} from '../assert';
+import { abstractMethodFail } from '../assert';
 
 /**
  * A unit of date-time, such as Days or Hours.

package/src/temporal/ValueRange.js

@@ -4,9 +4,9 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {assert} from '../assert';
-import {DateTimeException, IllegalArgumentException} from '../errors';
-import {MathUtil} from '../MathUtil';
+import { assert } from '../assert';
+import { DateTimeException, IllegalArgumentException } from '../errors';
+import { MathUtil } from '../MathUtil';
 
 /**
  * The range of valid values for a date-time field.
@@ -34,12 +34,12 @@ export class ValueRange {
      * @private
      */
     constructor(minSmallest, minLargest, maxSmallest, maxLargest) {
-        assert(!(minSmallest > minLargest), 'Smallest minimum value \'' + minSmallest +
-            '\' must be less than largest minimum value \'' + minLargest + '\'', IllegalArgumentException);
-        assert(!(maxSmallest > maxLargest), 'Smallest maximum value \'' + maxSmallest +
-            '\' must be less than largest maximum value \'' + maxLargest + '\'', IllegalArgumentException);
-        assert(!(minLargest > maxLargest), 'Minimum value \'' + minLargest +
-            '\' must be less than maximum value \'' + maxLargest + '\'', IllegalArgumentException);
+        assert(!(minSmallest > minLargest), `Smallest minimum value '${minSmallest 
+        }' must be less than largest minimum value '${minLargest}'`, IllegalArgumentException);
+        assert(!(maxSmallest > maxLargest), `Smallest maximum value '${maxSmallest 
+        }' must be less than largest maximum value '${maxLargest}'`, IllegalArgumentException);
+        assert(!(minLargest > maxLargest), `Minimum value '${minLargest 
+        }' must be less than maximum value '${maxLargest}'`, IllegalArgumentException);
 
         this._minSmallest = minSmallest;
         this._minLargest = minLargest;
@@ -109,9 +109,9 @@ export class ValueRange {
         let msg;
         if (!this.isValidValue(value)) {
             if (field != null) {
-                msg = ('Invalid value for ' + field + ' (valid values ' + (this.toString()) + '): ') + value;
+                msg = `Invalid value for ${field} (valid values ${this.toString()}): ${value}`;
             } else {
-                msg = ('Invalid value (valid values ' + (this.toString()) + '): ') + value;
+                msg = `Invalid value (valid values ${this.toString()}): ${value}`;
             }
             return assert(false, msg, DateTimeException);
         }
@@ -132,7 +132,7 @@ export class ValueRange {
      */
     checkValidIntValue(value, field) {
         if (this.isValidIntValue(value) === false) {
-            throw new DateTimeException('Invalid int value for ' + field + ': ' + value);
+            throw new DateTimeException(`Invalid int value for ${field}: ${value}`);
         }
         return value;
     }
@@ -206,9 +206,9 @@ export class ValueRange {
      * @return {string} a string representation of this range, not null
      */
     toString() {
-        let str = this.minimum() + (this.minimum() !== this.largestMinimum() ? '/' + (this.largestMinimum()) : '');
+        let str = this.minimum() + (this.minimum() !== this.largestMinimum() ? `/${this.largestMinimum()}` : '');
         str += ' - ';
-        str += this.smallestMaximum() + (this.smallestMaximum() !== this.maximum() ? '/' + (this.maximum()) : '');
+        str += this.smallestMaximum() + (this.smallestMaximum() !== this.maximum() ? `/${this.maximum()}` : '');
         return str;
     }
 
@@ -251,7 +251,7 @@ export class ValueRange {
         } else if (arguments.length === 4) {
             return new ValueRange(arguments[0], arguments[1], arguments[2], arguments[3]);
         } else {
-            return assert(false, 'Invalid number of arguments ' + arguments.length, IllegalArgumentException);
+            return assert(false, `Invalid number of arguments ${arguments.length}`, IllegalArgumentException);
         }
     }
 }

package/src/use.js

@@ -1,4 +1,9 @@
-
+/**
+ * @private
+ *
+ * @param jsJoda
+ * @returns {function(*=): *}
+ */
 export function bindUse(jsJoda) {
     const used = [];
 

package/src/zone/SystemDefaultZoneId.js

@@ -3,8 +3,8 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {SystemDefaultZoneRules} from './SystemDefaultZoneRules';
-import {ZoneId} from '../ZoneId';
+import { SystemDefaultZoneRules } from './SystemDefaultZoneRules';
+import { ZoneId } from '../ZoneId';
 
 export class SystemDefaultZoneId extends ZoneId {
 

package/src/zone/SystemDefaultZoneRules.js

@@ -3,9 +3,9 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {ZoneRules} from './ZoneRules';
-import {ZoneOffset} from '../ZoneOffset';
-import {DateTimeException} from '../errors';
+import { ZoneRules } from './ZoneRules';
+import { ZoneOffset } from '../ZoneOffset';
+import { DateTimeException } from '../errors';
 
 export class SystemDefaultZoneRules extends ZoneRules {
 

package/src/zone/ZoneOffsetTransition.js

@@ -4,11 +4,11 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull} from '../assert';
-import {IllegalArgumentException} from '../errors';
+import { requireNonNull } from '../assert';
+import { IllegalArgumentException } from '../errors';
 
-import {Duration} from '../Duration';
-import {LocalDateTime} from '../LocalDateTime';
+import { Duration } from '../Duration';
+import { LocalDateTime } from '../LocalDateTime';
 
 /**
  * A transition between two offsets caused by a discontinuity in the local time-line.
@@ -281,9 +281,9 @@ export class ZoneOffsetTransition {
      * @return {string} a string for debugging, not null
      */
     toString() {
-        return 'Transition[' + (this.isGap() ? 'Gap' : 'Overlap') +
-            ' at ' + this._transition.toString() + this._offsetBefore.toString() +
-            ' to ' + this._offsetAfter + ']';
+        return `Transition[${this.isGap() ? 'Gap' : 'Overlap' 
+        } at ${this._transition.toString()}${this._offsetBefore.toString() 
+        } to ${this._offsetAfter}]`;
     }
 
 }

package/src/zone/ZoneRules.js

@@ -4,10 +4,10 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {requireNonNull, abstractMethodFail} from '../assert';
+import { requireNonNull, abstractMethodFail } from '../assert';
 
-import {Duration} from '../Duration';
-import {Instant} from '../Instant';
+import { Duration } from '../Duration';
+import { Instant } from '../Instant';
 
 export class ZoneRules {
 
@@ -458,7 +458,7 @@ class Fixed extends ZoneRules{
      * @returns {string}
      */
     toString() {
-        return 'FixedRules:' + this._offset.toString();
+        return `FixedRules:${this._offset.toString()}`;
     }
 
 }

package/src/zone/ZoneRulesProvider.js

@@ -4,7 +4,7 @@
  * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
  */
 
-import {DateTimeException} from '../errors';
+import { DateTimeException } from '../errors';
 
 export class ZoneRulesProvider {
     /**
@@ -18,7 +18,7 @@ export class ZoneRulesProvider {
      * @return {ZoneRules}
      */
     static getRules(zoneId){
-        throw new DateTimeException('unsupported ZoneId:' + zoneId);
+        throw new DateTimeException(`unsupported ZoneId:${zoneId}`);
     }
 
 

package/src/temporal/DefaultInterfaceTemporal.js

@@ -1,118 +0,0 @@
-import {MAX_SAFE_INTEGER, MIN_SAFE_INTEGER} from '../MathUtil';
-import {requireInstance, requireNonNull} from '../assert';
-import {TemporalAdjuster} from './TemporalAdjuster';
-import {TemporalAmount} from './TemporalAmount';
-import {TemporalUnit} from './TemporalUnit';
-import {Temporal} from './Temporal';
-
-export class DefaultInterfaceTemporal extends Temporal {
-    /**
-     * Returns an adjusted object of the same type as this object with the adjustment made.
-     * This adjusts this date-time according to the rules of the specified adjuster. A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the date to the last day of the month. A selection of common adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of the month" and "next Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years.
-     *
-     * Some example code indicating how and why this method is used:
-     *
-     * <pre>
-     *   date = date.with(Month.JULY);        // most key classes implement TemporalAdjuster
-     *   date = date.with(lastDayOfMonth());  // static import from TemporalAdjusters
-     *   date = date.with(next(WEDNESDAY));   // static import from TemporalAdjusters and DayOfWeek
-     * </pre>
-     *
-     * ### Specification for implementors
-     * Implementations must not alter either this object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
-     *
-     * @param {TemporalAdjuster} adjuster - the adjuster to use, not null
-     * @return {Temporal} an object of the same type with the specified adjustment made, not null
-     * @throws DateTimeException - if unable to make the adjustment
-     * @throws ArithmeticException - if numeric overflow occurs
-     */
-    withAdjuster(adjuster) {
-        requireNonNull(adjuster, 'adjuster');
-        requireInstance(adjuster, TemporalAdjuster, 'adjuster');
-        return adjuster.adjustInto(this);
-    }
-
-    /**
-     * Returns an object of the same type as this object with an amount added.
-     * This adjusts this temporal, adding according to the rules of the specified amount. The amount is typically a {@link Period} but may be any other type implementing the {@link TemporalAmount} interface, such as {@link Duration}.
-     *
-     * Some example code indicating how and why this method is used:
-     *
-     * <pre>
-     *   date = date.plus(period);                  // add a Period instance
-     *   date = date.plus(duration);                // add a Duration instance
-     *   date = date.plus(workingDays(6));          // example user-written workingDays method
-     * </pre>
-     *
-     * Note that calling plus followed by minus is not guaranteed to return the same date-time.
-     *
-     * ### Specification for implementors
-     * Implementations must not alter either this object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
-     *
-     * @param {TemporalAmount} amount - the amount to add, not null
-     * @return {Temporal} an object of the same type with the specified adjustment made, not null
-     * @throws DateTimeException - if the addition cannot be made
-     * @throws ArithmeticException - if numeric overflow occurs
-     */
-    plusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        requireInstance(amount, TemporalAmount, 'amount');
-        return amount.addTo(this);
-    }
-
-    /**
-     * Returns an object of the same type as this object with an amount subtracted.
-     * This adjusts this temporal, subtracting according to the rules of the specified amount. The
-     * amount is typically a {@link Period} but may be any other type implementing the {@link TemporalAmount} interface, such as Duration.
-     *
-     * Some example code indicating how and why this method is used:
-     *
-     * <pre>
-     *   date = date.minus(period);                  // subtract a Period instance
-     *   date = date.minus(duration);                // subtract a Duration instance
-     *   date = date.minus(workingDays(6));          // example user-written workingDays method
-     * </pre>
-     *
-     * Note that calling plus followed by minus is not guaranteed to return the same date-time.
-     *
-     * ### Specification for implementors
-     * Implementations must not alter either this object. Instead, an adjusted copy of the original
-     * must be returned. This provides equivalent, safe behavior for immutable and mutable
-     * implementations.
-     *
-     * @param {TemporalAmount} amount - the amount to subtract, not null
-     * @return {Temporal} an object of the same type with the specified adjustment made, not null
-     * @throws DateTimeException - if the subtraction cannot be made
-     * @throws ArithmeticException - if numeric overflow occurs
-     */
-    minusAmount(amount) {
-        requireNonNull(amount, 'amount');
-        requireInstance(amount, TemporalAmount, 'amount');
-        return amount.subtractFrom(this);
-    }
-
-    /**
-     * Returns an object of the same type as this object with the specified period subtracted.
-     * This method returns a new object based on this one with the specified period subtracted. For example, on a {@link LocalDate}, this could be used to subtract a number of years, months or days. The returned object will have the same observable type as this object.
-     *
-     * In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st March, then subtracting one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
-     *
-     * If the implementation represents a date-time that has boundaries, such {@link as} LocalTime, then the permitted units must include the boundary unit, but no multiples of the boundary unit. For example, {@link LocalTime} must accept `DAYS` but not `WEEKS` or `MONTHS`.
-     *
-     * ### Specification for implementors
-     * Implementations must behave in a manor equivalent to the default method behavior.
-     * Implementations must not alter either this object or the specified temporal object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
-     *
-     * @param {number} amountToSubtract - the amount of the specified unit to subtract, may be negative
-     * @param {TemporalUnit} unit - the unit of the period to subtract, not null
-     * @return {Temporal} an object of the same type with the specified period subtracted, not null
-     * @throws DateTimeException - if the unit cannot be subtracted
-     * @throws ArithmeticException - if numeric overflow occurs
-     */
-    minusAmountUnit(amountToSubtract, unit) {
-        requireNonNull(amountToSubtract, 'amountToSubtract');
-        requireNonNull(unit, 'unit');
-        requireInstance(unit, TemporalUnit, 'unit');
-        return (amountToSubtract === MIN_SAFE_INTEGER ? this.plusAmountUnit(MAX_SAFE_INTEGER, unit).plusAmountUnit(1, unit) : this.plusAmount(-amountToSubtract, unit));
-    }
-}