@js-joda/core 1.12.0 → 3.2.0

package/src/temporal/ChronoUnit.js

@@ -21,120 +21,59 @@ import {TemporalUnit} from './TemporalUnit';
  * just with slightly different rules.
  * The documentation of each unit explains how it operates.
  *
- * ### Static properties of Class {@link ChronoUnit}
- *
- * ChronoUnit.NANOS
- *
- * Unit that represents the concept of a nanosecond, the smallest supported unit of time.
- * For the ISO calendar system, it is equal to the 1,000,000,000th part of the second unit.
- *
- * ChronoUnit.MICROS
- *
- * Unit that represents the concept of a microsecond.
- * For the ISO calendar system, it is equal to the 1,000,000th part of the second unit.
- *
- * ChronoUnit.MILLIS
- *
- * Unit that represents the concept of a millisecond.
- * For the ISO calendar system, it is equal to the 1000th part of the second unit.
- *
- * ChronoUnit.SECONDS
- *
- * Unit that represents the concept of a second.
- * For the ISO calendar system, it is equal to the second in the SI system
- * of units, except around a leap-second.
- *
- * ChronoUnit.MINUTES
- *
- * Unit that represents the concept of a minute.
- * For the ISO calendar system, it is equal to 60 seconds.
- *
- * ChronoUnit.HOURS
- *
- * Unit that represents the concept of an hour.
- * For the ISO calendar system, it is equal to 60 minutes.
- *
- * ChronoUnit.HALF_DAYS
- *
- * Unit that represents the concept of half a day, as used in AM/PM.
- * For the ISO calendar system, it is equal to 12 hours.
- *
- * ChronoUnit.DAYS
- *
- * Unit that represents the concept of a day.
- * For the ISO calendar system, it is the standard day from midnight to midnight.
- * The estimated duration of a day is 24 hours.
- *
- * When used with other calendar systems it must correspond to the day defined by
- * the rising and setting of the Sun on Earth. It is not required that days begin
- * at midnight - when converting between calendar systems, the date should be
- * equivalent at midday.
- *
- * ChronoUnit.WEEKS
- *
- * Unit that represents the concept of a week.
- * For the ISO calendar system, it is equal to 7 days.
- *
- * When used with other calendar systems it must correspond to an integral number of days.
- *
- * ChronoUnit.MONTHS
- *
- * Unit that represents the concept of a month.
- * For the ISO calendar system, the length of the month varies by month-of-year.
- * The estimated duration of a month is one twelfth of 365.2425 days.
- *
- * When used with other calendar systems it must correspond to an integral number of days.
- *
- * ChronoUnit.YEARS
- *
- * Unit that represents the concept of a year.
- * For the ISO calendar system, it is equal to 12 months.
- * The estimated duration of a year is 365.2425 days.
- *
- * When used with other calendar systems it must correspond to an integral number of days
- * or months roughly equal to a year defined by the passage of the Earth around the Sun.
- *
- * ChronoUnit.DECADES
- *
- * Unit that represents the concept of a decade.
- * For the ISO calendar system, it is equal to 10 years.
- *
- * When used with other calendar systems it must correspond to an integral number of days
- * and is normally an integral number of years.
- *
- * ChronoUnit.CENTURIES
- *
- * Unit that represents the concept of a century.
- * For the ISO calendar system, it is equal to 100 years.
- *
- * When used with other calendar systems it must correspond to an integral number of days
- * and is normally an integral number of years.
- *
- * ChronoUnit.MILLENNIA
- *
- * Unit that represents the concept of a millennium.
- * For the ISO calendar system, it is equal to 1000 years.
- *
- * When used with other calendar systems it must correspond to an integral number of days
- * and is normally an integral number of years.
- *
- * ChronoUnit.ERAS
- *
- * Unit that represents the concept of an era.
- * The ISO calendar system doesn't have eras thus it is impossible to add
- * an era to a date or date-time.
- * The estimated duration of the era is artificially defined as {Year.MAX_VALUE} + 1.
- *
- * When used with other calendar systems there are no restrictions on the unit.
- *
- * ChronoUnit.FOREVER
- *
- * Artificial unit that represents the concept of forever.
- * This is primarily used with {@link TemporalField} to represent unbounded fields
- * such as the year or era.
- * The estimated duration of the era is artificially defined as the largest duration
- * supported by {@link Duration}.
- *
+ * ### Static properties:
+ * 
+ * - `ChronoUnit.CENTURIES`: Unit that represents the concept of a century. For the ISO calendar
+ * system, it is equal to 100 years.
+ * 
+ * - `ChronoUnit.DAYS`: Unit that represents the concept of a day. For the ISO calendar system, it
+ * is the standard day from midnight to midnight. The estimated duration of a day is 24 Hours.
+ * 
+ * - `ChronoUnit.DECADES`: Unit that represents the concept of a decade. For the ISO calendar system,
+ * it is equal to 10 years.
+ * 
+ * - `ChronoUnit.ERAS`: Unit that represents the concept of an era. The ISO calendar system doesn't
+ * have eras thus it is impossible to add an era to a date or date-time. The estimated duration of the
+ * era is artificially defined as 1,000,000,000 Years.
+ * 
+ * - `ChronoUnit.FOREVER`: Artificial unit that represents the concept of forever. This is primarily
+ * used with {@link TemporalField} to represent unbounded fields such as the year or era. The
+ * estimated duration of the era is artificially defined as the largest duration supported by
+ * {@link Duration}.
+ * 
+ * - `ChronoUnit.HALF_DAYS`: Unit that represents the concept of half a day, as used in AM/PM. For
+ * the ISO calendar system, it is equal to 12 hours.
+ *
+ * - `ChronoUnit.HOURS`: Unit that represents the concept of an hour. For the ISO calendar system,
+ * it is equal to 60 minutes.
+ * 
+ * - `ChronoUnit.MICROS`: Unit that represents the concept of a microsecond. For the ISO calendar
+ * system, it is equal to the 1,000,000th part of the second unit.
+ * 
+ * - `ChronoUnit.MILLENNIA`: Unit that represents the concept of a millennium. For the ISO calendar
+ * system, it is equal to 1,000 years.
+ * 
+ * - `ChronoUnit.MILLIS`: Unit that represents the concept of a millisecond. For the ISO calendar
+ * system, it is equal to the 1000th part of the second unit.
+ * 
+ * - `ChronoUnit.MINUTES`: Unit that represents the concept of a minute. For the ISO calendar system,
+ * it is equal to 60 seconds.
+ * 
+ * - `ChronoUnit.MONTHS`: Unit that represents the concept of a month. For the ISO calendar system,
+ * the length of the month varies by month-of-year. The estimated duration of a month is one twelfth
+ * of 365.2425 Days.
+ * 
+ * - `ChronoUnit.NANOS`: Unit that represents the concept of a nanosecond, the smallest supported unit
+ * of time. For the ISO calendar system, it is equal to the 1,000,000,000th part of the second unit.
+ * 
+ * - `ChronoUnit.SECONDS`: Unit that represents the concept of a second. For the ISO calendar system,
+ * it is equal to the second in the SI system of units, except around a leap-second.
+ * 
+ * - `ChronoUnit.WEEKS`: Unit that represents the concept of a week. For the ISO calendar system,
+ * it is equal to 7 Days.
+ * 
+ * - `ChronoUnit.YEARS`: Unit that represents the concept of a year. For the ISO calendar system, it
+ * is equal to 12 months. The estimated duration of a year is 365.2425 Days.
  */
 export class ChronoUnit extends TemporalUnit {
 
@@ -152,27 +91,14 @@ export class ChronoUnit extends TemporalUnit {
 
     //-----------------------------------------------------------------------
     /**
-     * Gets the estimated duration of this unit in the ISO calendar system.
-     *
-     * All of the units in this class have an estimated duration.
-     * Days vary due to daylight saving time, while months have different lengths.
-     *
-     * @return {Duration} the estimated duration of this unit, not null
+     * @return {Duration} the duration of this unit, which may be an estimate.
      */
     duration() {
         return this._duration;
     }
 
     /**
-     * Checks if the duration of the unit is an estimate.
-     *
-     * All time units in this class are considered to be accurate, while all date
-     * units in this class are considered to be estimated.
-     *
-     * This definition ignores leap seconds, but considers that Days vary due to
-     * daylight saving time and months have different lengths.
-     *
-     * @return {boolean} true if the duration is estimated, false if accurate
+     * @return {boolean} `true` if the duration is estimated, `false` if accurate.
      */
     isDurationEstimated() {
         return this.isDateBased() || this === ChronoUnit.FOREVER;
@@ -180,9 +106,7 @@ export class ChronoUnit extends TemporalUnit {
 
     //-----------------------------------------------------------------------
     /**
-     * Checks if this unit is a date unit.
-     *
-     * @return true if a date unit, false if a time unit
+     * @return {boolean} `true` if date unit, `false` if a time unit.
      */
     isDateBased() {
         return this.compareTo(ChronoUnit.DAYS) >= 0 && this !== ChronoUnit.FOREVER;
@@ -191,7 +115,7 @@ export class ChronoUnit extends TemporalUnit {
     /**
      * Checks if this unit is a time unit.
      *
-     * @return true if a time unit, false if a date unit
+     * @return {boolean} `true` if time unit, `false` if a date unit.
      */
     isTimeBased() {
         return this.compareTo(ChronoUnit.DAYS) < 0;
@@ -199,16 +123,8 @@ export class ChronoUnit extends TemporalUnit {
 
     //-----------------------------------------------------------------------
     /**
-     * Checks if this unit is supported by the specified temporal object.
-     *
-     * This checks that the implementing date-time can add/subtract this unit.
-     * This can be used to avoid throwing an exception.
-     *
-     * This default implementation derives the value using
-     * {@link Temporal#plus}.
-     *
-     * @param {Temporal} temporal  the temporal object to check, not null
-     * @return {boolean} true if the unit is supported
+     * @param {!Temporal} temporal the temporal object to check.
+     * @return {boolean} `true` if the unit is supported.
      */
     isSupportedBy(temporal) {
         if (this === ChronoUnit.FOREVER) {
@@ -237,37 +153,10 @@ export class ChronoUnit extends TemporalUnit {
     }
 
     /**
-     * Returns a copy of the specified temporal object with the specified period added.
-     *
-     * The period added is a multiple of this unit. For example, this method
-     * could be used to add "3 days" to a date by calling this method on the
-     * instance representing "days", passing the date and the period "3".
-     * The period to be added may be negative, which is equivalent to subtraction.
-     *
-     * There are two equivalent ways of using this method.
-     * The first is to invoke this method directly.
-     * The second is to use {@link Temporal#plus}:
-     * <pre>
-     *   // these two lines are equivalent, but the second approach is recommended
-     *   temporal = thisUnit.addTo(temporal);
-     *   temporal = temporal.plus(thisUnit);
-     * </pre>
-     * It is recommended to use the second approach, {@link plus},
-     * as it is a lot clearer to read in code.
-     *
-     * Implementations should perform any queries or calculations using the units
-     * available in {@link ChronoUnit} or the fields available in {@link ChronoField}.
-     * If the unit is not supported an {@link UnsupportedTemporalTypeException} must be thrown.
-     *
-     * Implementations must not alter 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 {Temporal} temporal  the temporal object to adjust, not null
-     * @param {Number} amount  the amount of this unit to add, positive or negative
-     * @return {Temporal} the adjusted temporal object, not null
-     * @throws DateTimeException if the amount cannot be added
-     * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
+     * @param {!Temporal} dateTime the temporal object to adjust.
+     * @param {number} periodToAdd the period of this unit to add, positive or negative.
+     * @return {Temporal} the adjusted temporal object.
+     * @throws DateTimeException if the period cannot be added.
      */
     addTo(temporal, amount) {
         return temporal.plus(amount, this);
@@ -275,58 +164,12 @@ export class ChronoUnit extends TemporalUnit {
 
     //-----------------------------------------------------------------------
     /**
-     * Calculates the amount of time between two temporal objects.
-     *
-     * This calculates the amount in terms of this unit. The start and end
-     * points are supplied as temporal objects and must be of compatible types.
-     * The implementation will convert the second type to be an instance of the
-     * first type before the calculating the amount.
-     * The result will be negative if the end is before the start.
-     * For example, the amount in hours between two temporal objects can be
-     * calculated using {@link HOURS.between}.
-     *
-     * The calculation returns a whole number, representing the number of
-     * complete units between the two temporals.
-     * For example, the amount in hours between the times 11:30 and 13:29
-     * will only be one hour as it is one minute short of two hours.
-     *
-     * There are two equivalent ways of using this method.
-     * The first is to invoke this method directly.
-     * The second is to use {@link Temporal#until}:
-     * <pre>
-     *   // these two lines are equivalent
-     *   between = thisUnit.between(start, end);
-     *   between = start.until(end, thisUnit);
-     * </pre>
-     * The choice should be made based on which makes the code more readable.
-     *
-     * For example, this method allows the number of days between two dates to
-     * be calculated:
-     * <pre>
-     *  daysBetween = DAYS.between(start, end);
-     *  // or alternatively
-     *  daysBetween = start.until(end, DAYS);
-     * </pre>
-     *
-     * Implementations should perform any queries or calculations using the units
-     * available in {@link ChronoUnit} or the fields available in {@link ChronoField}.
-     * If the unit is not supported an {@link UnsupportedTemporalTypeException} must be thrown.
-     * Implementations must not alter the specified temporal objects.
-     *
-     * @implSpec
-     * Implementations must begin by checking to if the two temporals have the
-     * same type using `.constructor.name`. If they do not, then the result must be
-     * obtained by calling `temporal1.until`.
-     *
-     * @param {Temporal} temporal1  the base temporal object, not null
-     * @param {Temporal} temporal2  the other temporal object, exclusive, not null
-     * @return {Number} the amount of time between temporal1 and temporal2
-     *  in terms of this unit; positive if temporal2 is later than
-     *  temporal1, negative if earlier
-     * @throws DateTimeException if the amount cannot be calculated, or the end
-     *  temporal cannot be converted to the same type as the start temporal
-     * @throws UnsupportedTemporalTypeException if the unit is not supported by the temporal
-     * @throws ArithmeticException if numeric overflow occurs
+     * @param {!Temporal} temporal1 the base temporal object.
+     * @param {!Temporal} temporal2 the other temporal object.
+     * @return {number} the period between temporal1 and temporal2 in terms of this unit;
+     *  positive if temporal2 is later than temporal1, negative if earlier.
+     * @throws DateTimeException if the period cannot be calculated.
+     * @throws ArithmeticException if numeric overflow occurs.
      */
     between(temporal1, temporal2) {
         return temporal1.until(temporal2, this);
@@ -338,12 +181,12 @@ export class ChronoUnit extends TemporalUnit {
     }
 
     /**
-     * Compares this ChronoUnit to the specified {TemporalUnit}.
+     * Compares this ChronoUnit to the specified {@link TemporalUnit}.
      *
      * The comparison is based on the total length of the durations.
      *
-     * @param {TemporalUnit} other  the other unit to compare to, not null
-     * @return the comparator value, negative if less, positive if greater
+     * @param {!TemporalUnit} other the other unit to compare to.
+     * @return the comparator value, negative if less, positive if greater.
      */
     compareTo(other) {
         return this.duration().compareTo(other.duration());

package/src/temporal/DefaultInterfaceTemporal.js

@@ -0,0 +1,118 @@
+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));
+    }
+}

package/src/temporal/IsoFields.js

@@ -39,9 +39,9 @@ import {ResolverStyle} from '../format/ResolverStyle';
  *
  * The complete date is expressed using three fields:
  *
- * * {@link DAY_OF_QUARTER} - the day within the quarter, from 1 to 90, 91 or 92
- * * {@link QUARTER_OF_YEAR} - the week within the week-based-year
- * * {@link ChronoField#YEAR} - the standard ISO year
+ * * `IsoFields.DAY_OF_QUARTER` - the day within the quarter, from 1 to 90, 91 or 92
+ * * `QUARTER_OF_YEAR` - the week within the week-based-year
+ * * `ChronoField.YEAR` - the standard ISO year (see {@link ChronoField})
  *
  * ### Week based years
  *
@@ -51,10 +51,10 @@ import {ResolverStyle} from '../format/ResolverStyle';
  *
  * The date is expressed using three fields:
  *
- * * {@link ChronoField#DAY_OF_WEEK} - the standard field defining the
- *   day-of-week from Monday (1) to Sunday (7)
- * * {@link WEEK_OF_WEEK_BASED_YEAR} - the week within the week-based-year
- * * {@link WEEK_BASED_YEAR} - the week-based-year
+ * * `ChronoField.DAY_OF_WEEK` - the standard field defining the
+ *   day-of-week from Monday (1) to Sunday (7) (see {@link ChronoField})
+ * * `WEEK_OF_WEEK_BASED_YEAR` - the week within the week-based-year
+ * * `WEEK_BASED_YEAR` - the week-based-year 
  *
  * The week-based-year itself is defined relative to the standard ISO proleptic year.
  * It differs from the standard year in that it always starts on a Monday.
@@ -81,11 +81,7 @@ import {ResolverStyle} from '../format/ResolverStyle';
  * * Sunday, 2009-01-04: Week 1 of week-based-year 2009
  * * Monday, 2009-01-05: Week 2 of week-based-year 2009
  *
- * ### Static properties of Class {@link IsoFields}
- *
- * IsoFields.DAY_OF_QUARTER
- *
- * The field that represents the day-of-quarter.
+ * @property {TemporalField} DAY_OF_QUARTER The field that represents the day-of-quarter.
  *
  * This field allows the day-of-quarter value to be queried and set.
  * The day-of-quarter has values from 1 to 90 in Q1 of a standard year, from 1 to 91
@@ -98,30 +94,24 @@ import {ResolverStyle} from '../format/ResolverStyle';
  * value from 1 to 92. If the quarter has less than 92 days, then day 92, and
  * potentially day 91, is in the following quarter.
  *
- * IsoFields.QUARTER_OF_YEAR
- *
- * The field that represents the quarter-of-year.
+ * @property {TemporalField} QUARTER_OF_YEAR The field that represents the quarter-of-year.
  *
  * This field allows the quarter-of-year value to be queried and set.
  * The quarter-of-year has values from 1 to 4.
  *
  * The day-of-quarter can only be calculated if the month-of-year is available.
  *
- * IsoFields.WEEK_OF_WEEK_BASED_YEAR
- *
- * The field that represents the week-of-week-based-year.
+ * @property {TemporalField} WEEK_OF_WEEK_BASED_YEAR The field that represents the
+ * week-of-week-based-year.
  *
  * This field allows the week of the week-based-year value to be queried and set.
  *
- * IsoFields.WEEK_BASED_YEAR
- *
- * The field that represents the week-based-year.
+ * @property {TemporalField} WEEK_BASED_YEAR The field that represents the week-based-year.
  *
  * This field allows the week-based-year value to be queried and set.
  *
- * IsoFields.WEEK_BASED_YEARS
- *
- * The unit that represents week-based-years for the purpose of addition and subtraction.
+ * @property {TemporalField} WEEK_BASED_YEARS The unit that represents week-based-years for
+ * the purpose of addition and subtraction.
  *
  * This allows a number of week-based-years to be added to, or subtracted from, a date.
  * The unit is equal to either 52 or 53 weeks.
@@ -132,14 +122,14 @@ import {ResolverStyle} from '../format/ResolverStyle';
  * for the week-based-year field. If the resulting week-based-year only has 52 weeks,
  * then the date will be in week 1 of the following week-based-year.
  *
- * IsoFields.QUARTER_YEARS
- *
- * Unit that represents the concept of a quarter-year.
+ * @property {TemporalField} QUARTER_YEARS Unit that represents the concept of a quarter-year.
  * For the ISO calendar system, it is equal to 3 months.
  * The estimated duration of a quarter-year is one quarter of 365.2425 days.
+ * 
+ * @typedef {Object} IsoFields
+ * @type {Object}
  */
-export class IsoFields {
-}
+export const IsoFields = {};
 
 //-----------------------------------------------------------------------
 
@@ -147,6 +137,7 @@ const QUARTER_DAYS = [0, 90, 181, 273, 0, 91, 182, 274];
 
 /**
  * Implementation of the field.
+ * @private
  */
 class Field extends TemporalField{
 
@@ -252,7 +243,7 @@ class Field extends TemporalField{
      *
      * @returns {string}
      */
-    getDisplayName(/*locale*/) {
+    displayName(/*locale*/) {
         return this.toString();
     }
 
@@ -270,7 +261,9 @@ class Field extends TemporalField{
 
 }
 
-
+/**
+ * @private
+ */
 class DAY_OF_QUARTER_FIELD extends Field {
 
     /**
@@ -407,6 +400,9 @@ class DAY_OF_QUARTER_FIELD extends Field {
     }
 }
 
+/**
+ * @private
+ */
 class QUARTER_OF_YEAR_FIELD extends Field {
 
     /**
@@ -488,6 +484,9 @@ class QUARTER_OF_YEAR_FIELD extends Field {
 
 }
 
+/**
+ * @private
+ */
 class WEEK_OF_WEEK_BASED_YEAR_FIELD extends Field {
 
     /**
@@ -615,12 +614,15 @@ class WEEK_OF_WEEK_BASED_YEAR_FIELD extends Field {
      *
      * @returns {string}
      */
-    getDisplayName() {
+    displayName() {
         return 'Week';
     }
 
 }
 
+/**
+ * @private
+ */
 class WEEK_BASED_YEAR_FIELD extends Field {
 
     /**
@@ -715,6 +717,7 @@ class WEEK_BASED_YEAR_FIELD extends Field {
 //-----------------------------------------------------------------------
 /**
  * Implementation of the period unit.
+ * @private
  */
 class Unit extends TemporalUnit {