@js-joda/extra 0.8.1 → 0.9.0

package/dist/js-joda-extra.esm.js

@@ -1,9 +1,25 @@
-//! @version @js-joda/extra - 0.8.1
+//! @version @js-joda/extra - 0.9.0
 //! @copyright (c) 2015-present, Philipp Thürwächter, Pattrick Hüper & js-joda contributors
 //! @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
 //! @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
 
-import { NullPointerException, IllegalArgumentException, Instant, DateTimeException, Duration, ZonedDateTime, DateTimeParseException, use } from '@js-joda/core';
+import { NullPointerException, IllegalArgumentException, _, ChronoField, UnsupportedTemporalTypeException, TemporalQueries, IsoChronology, Month, MonthDay, TemporalAccessor, ZoneId, Clock, LocalDate, DateTimeException, TemporalQuery, Year, Instant, Duration, ZonedDateTime, DateTimeParseException, use } from '@js-joda/core';
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
 
 /**
  * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
@@ -24,6 +40,364 @@ function requireInstance(value, _class, parameterName) {
   return value;
 }
 
+var MathUtil$1 = _.MathUtil;
+var DayOfMonth = function (_TemporalAccessor) {
+  _inheritsLoose(DayOfMonth, _TemporalAccessor);
+
+  DayOfMonth.now = function now(zoneIdOrClock) {
+    switch (arguments.length) {
+      case 0:
+        return DayOfMonth.now0();
+
+      case 1:
+        requireNonNull(zoneIdOrClock, 'clockOrZone');
+
+        if (zoneIdOrClock instanceof ZoneId) {
+          return DayOfMonth.nowZoneId(zoneIdOrClock);
+        }
+
+        if (zoneIdOrClock instanceof Clock) {
+          return DayOfMonth.nowClock(zoneIdOrClock);
+        }
+
+        throw new IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
+
+      default:
+        throw new IllegalArgumentException("Invalid number of arguments: " + arguments.length);
+    }
+  };
+
+  DayOfMonth.now0 = function now0() {
+    return this.now(Clock.systemDefaultZone());
+  };
+
+  DayOfMonth.nowZoneId = function nowZoneId(zone) {
+    return this.now(Clock.system(zone));
+  };
+
+  DayOfMonth.nowClock = function nowClock(clock) {
+    var now = LocalDate.now(clock);
+    return DayOfMonth.of(now.dayOfMonth());
+  };
+
+  DayOfMonth.of = function of(dayOfMonth) {
+    if (1 <= dayOfMonth && dayOfMonth <= 31) {
+      return DayOfMonth.VALUES[dayOfMonth - 1];
+    } else {
+      throw new DateTimeException("Invalid value for DayOfMonth: " + dayOfMonth);
+    }
+  };
+
+  DayOfMonth.from = function from(temporal) {
+    if (temporal instanceof DayOfMonth) {
+      return temporal;
+    }
+
+    requireNonNull(temporal, 'temporal');
+
+    try {
+      return DayOfMonth.of(temporal.get(ChronoField.DAY_OF_MONTH));
+    } catch (ex) {
+      throw new DateTimeException("Unable to obtain DayOfMonth from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+    }
+  };
+
+  function DayOfMonth(dayOfMonth) {
+    var _this;
+
+    _this = _TemporalAccessor.call(this) || this;
+    _this._day = MathUtil$1.safeToInt(dayOfMonth);
+    return _this;
+  }
+
+  var _proto = DayOfMonth.prototype;
+
+  _proto.value = function value() {
+    return this._day;
+  };
+
+  _proto.isSupported = function isSupported(field) {
+    if (field instanceof ChronoField) {
+      return field === ChronoField.DAY_OF_MONTH;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+
+    if (field === ChronoField.DAY_OF_MONTH) {
+      return field.range();
+    }
+
+    return _TemporalAccessor.prototype.range.call(this, field);
+  };
+
+  _proto.get = function get(field) {
+    return this.range(field).checkValidIntValue(this.getLong(field), field);
+  };
+
+  _proto.getLong = function getLong(field) {
+    requireNonNull(field, 'field');
+
+    if (field === ChronoField.DAY_OF_MONTH) {
+      return this._day;
+    } else if (field instanceof ChronoField) {
+      throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+    }
+
+    return field.getFrom(this);
+  };
+
+  _proto.isValidYearMonth = function isValidYearMonth(yearMonth) {
+    return yearMonth != null && yearMonth.isValidDay(this._day);
+  };
+
+  _proto.query = function query(_query) {
+    requireNonNull(_query, 'query');
+    requireInstance(_query, TemporalQuery, 'query');
+
+    if (_query === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    }
+
+    return _TemporalAccessor.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    requireNonNull(temporal, 'temporal');
+    return temporal.with(ChronoField.DAY_OF_MONTH, this._day);
+  };
+
+  _proto.atMonth = function atMonth(month) {
+    requireNonNull(month, 'month');
+
+    if (month instanceof Month) {
+      return MonthDay.of(month, Math.min(this._day, month.maxLength()));
+    } else {
+      return MonthDay.of(month, Math.min(this._day, Month.of(month).maxLength()));
+    }
+  };
+
+  _proto.atYearMonth = function atYearMonth(yearMonth) {
+    requireNonNull(yearMonth, 'yearMonth');
+    return yearMonth.atDay(Math.min(this._day, yearMonth.lengthOfMonth()));
+  };
+
+  _proto.compareTo = function compareTo(other) {
+    requireNonNull(other, 'other');
+    requireInstance(other, DayOfMonth, 'other');
+    return this._day - other._day;
+  };
+
+  _proto.equals = function equals(obj) {
+    if (this === obj) {
+      return true;
+    }
+
+    if (obj instanceof DayOfMonth) {
+      return this._day === obj._day;
+    }
+
+    return false;
+  };
+
+  _proto.hashCode = function hashCode() {
+    return this._day;
+  };
+
+  _proto.toString = function toString() {
+    return "DayOfMonth:" + this._day;
+  };
+
+  return DayOfMonth;
+}(TemporalAccessor);
+function _init$2() {
+  DayOfMonth.VALUES = new Array(31);
+
+  for (var i = 0; i < 31; i++) {
+    DayOfMonth.VALUES[i] = new DayOfMonth(i + 1);
+  }
+}
+
+var MathUtil = _.MathUtil;
+var DayOfYear = function (_TemporalAccessor) {
+  _inheritsLoose(DayOfYear, _TemporalAccessor);
+
+  DayOfYear.now = function now(zoneIdOrClock) {
+    switch (arguments.length) {
+      case 0:
+        return DayOfYear.now0();
+
+      case 1:
+        requireNonNull(zoneIdOrClock, 'clockOrZone');
+
+        if (zoneIdOrClock instanceof ZoneId) {
+          return DayOfYear.nowZoneId(zoneIdOrClock);
+        }
+
+        if (zoneIdOrClock instanceof Clock) {
+          return DayOfYear.nowClock(zoneIdOrClock);
+        }
+
+        throw new IllegalArgumentException("zoneIdOrClock must be an instance of ZoneId or Clock, but is " + zoneIdOrClock.constructor.name);
+
+      default:
+        throw new IllegalArgumentException("Invalid number of arguments: " + arguments.length);
+    }
+  };
+
+  DayOfYear.now0 = function now0() {
+    return DayOfYear.now(Clock.systemDefaultZone());
+  };
+
+  DayOfYear.nowZoneId = function nowZoneId(zone) {
+    return DayOfYear.now(Clock.system(zone));
+  };
+
+  DayOfYear.nowClock = function nowClock(clock) {
+    var now = LocalDate.now(clock);
+    return DayOfYear.of(now.dayOfYear());
+  };
+
+  DayOfYear.of = function of(dayOfYear) {
+    if (1 <= dayOfYear && dayOfYear <= 366) {
+      return DayOfYear.VALUES[dayOfYear - 1];
+    } else {
+      throw new DateTimeException("Invalid value for DayOfYear: " + dayOfYear);
+    }
+  };
+
+  DayOfYear.from = function from(temporal) {
+    requireNonNull(temporal, 'temporal');
+    requireInstance(temporal, TemporalAccessor, 'temporal');
+
+    if (temporal instanceof DayOfYear) {
+      return temporal;
+    }
+
+    try {
+      return DayOfYear.of(temporal.get(ChronoField.DAY_OF_YEAR));
+    } catch (ex) {
+      throw new DateTimeException("Unable to obtain DayOfYear from TemporalAccessor: " + temporal + " of type " + temporal.constructor.name, ex);
+    }
+  };
+
+  function DayOfYear(dayOfYear) {
+    var _this;
+
+    _this = _TemporalAccessor.call(this) || this;
+    _this._day = MathUtil.safeToInt(dayOfYear);
+    return _this;
+  }
+
+  var _proto = DayOfYear.prototype;
+
+  _proto.value = function value() {
+    return this._day;
+  };
+
+  _proto.isSupported = function isSupported(field) {
+    if (field instanceof ChronoField) {
+      return field === ChronoField.DAY_OF_YEAR;
+    }
+
+    return field != null && field.isSupportedBy(this);
+  };
+
+  _proto.range = function range(field) {
+    requireNonNull(field, 'field');
+
+    if (field === ChronoField.DAY_OF_YEAR) {
+      return field.range();
+    }
+
+    return _TemporalAccessor.prototype.range.call(this, field);
+  };
+
+  _proto.get = function get(field) {
+    return this.range(field).checkValidIntValue(this.getLong(field), field);
+  };
+
+  _proto.getLong = function getLong(field) {
+    requireNonNull(field, 'field');
+
+    if (field === ChronoField.DAY_OF_YEAR) {
+      return this._day;
+    } else if (field instanceof ChronoField) {
+      throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+    }
+
+    return field.getFrom(this);
+  };
+
+  _proto.isValidYear = function isValidYear(year) {
+    return this._day < 366 || Year.isLeap(year);
+  };
+
+  _proto.query = function query(_query) {
+    requireNonNull(_query, 'query');
+    requireInstance(_query, TemporalQuery, 'query');
+
+    if (_query === TemporalQueries.chronology()) {
+      return IsoChronology.INSTANCE;
+    }
+
+    return _TemporalAccessor.prototype.query.call(this, _query);
+  };
+
+  _proto.adjustInto = function adjustInto(temporal) {
+    requireNonNull(temporal, 'temporal');
+    return temporal.with(ChronoField.DAY_OF_YEAR, this._day);
+  };
+
+  _proto.atYear = function atYear(year) {
+    requireNonNull(year, 'year');
+
+    if (year instanceof Year) {
+      return year.atDay(this._day);
+    } else {
+      return LocalDate.ofYearDay(year, this._day);
+    }
+  };
+
+  _proto.compareTo = function compareTo(other) {
+    requireNonNull(other, 'other');
+    requireInstance(other, DayOfYear, 'other');
+    return this._day - other._day;
+  };
+
+  _proto.equals = function equals(obj) {
+    if (this === obj) {
+      return true;
+    }
+
+    if (obj instanceof DayOfYear) {
+      return this._day === obj._day;
+    }
+
+    return false;
+  };
+
+  _proto.hashCode = function hashCode() {
+    return this._day;
+  };
+
+  _proto.toString = function toString() {
+    return "DayOfYear:" + this._day;
+  };
+
+  return DayOfYear;
+}(TemporalAccessor);
+function _init$1() {
+  DayOfYear.VALUES = new Array(366);
+
+  for (var i = 0; i < 366; i++) {
+    DayOfYear.VALUES[i] = new DayOfYear(i + 1);
+  }
+}
+
 /*
  * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
  * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
@@ -300,6 +674,8 @@ function init() {
   }
 
   isInit = true;
+  _init$2();
+  _init$1();
   _init();
 }
 
@@ -317,5 +693,5 @@ function plug () {}
  */
 use(plug);
 
-export { Interval };
+export { DayOfMonth, DayOfYear, Interval };
 //# sourceMappingURL=js-joda-extra.esm.js.map