/**
|
* @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
|
* @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
|
* @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 { 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';
|
|
export class IsoChronology extends Enum{
|
/**
|
* Checks if the year is a leap year, according to the ISO proleptic
|
* calendar system rules.
|
*
|
* This method applies the current rules for leap years across the whole time-line.
|
* In general, a year is a leap year if it is divisible by four without
|
* remainder. However, years divisible by 100, are not leap years, with
|
* the exception of years divisible by 400 which are.
|
*
|
* For example, 1904 is a leap year it is divisible by 4.
|
* 1900 was not a leap year as it is divisible by 100, however 2000 was a
|
* leap year as it is divisible by 400.
|
*
|
* The calculation is proleptic - applying the same rules into the far future and far past.
|
* This is historically inaccurate, but is correct for the ISO-8601 standard.
|
*
|
* @param {number} prolepticYear - the ISO proleptic year to check
|
* @return {boolean} true if the year is leap, false otherwise
|
*/
|
static isLeapYear(prolepticYear) {
|
return ((prolepticYear & 3) === 0) && ((prolepticYear % 100) !== 0 || (prolepticYear % 400) === 0);
|
}
|
|
/**
|
* Updates the map of field-values during resolution.
|
*
|
* @param {EnumMap} fieldValues the fieldValues map to update, not null
|
* @param {ChronoField} field the field to update, not null
|
* @param {number} value the value to update, not null
|
* @throws DateTimeException if a conflict occurs
|
*/
|
_updateResolveMap(fieldValues, field, value) {
|
// TODO: this function is in Chronology in threetenbp, maybe needs to be moved?
|
requireNonNull(fieldValues, 'fieldValues');
|
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}`);
|
}
|
fieldValues.put(field, value);
|
}
|
|
resolveDate(fieldValues, resolverStyle) {
|
if (fieldValues.containsKey(ChronoField.EPOCH_DAY)) {
|
return LocalDate.ofEpochDay(fieldValues.remove(ChronoField.EPOCH_DAY));
|
}
|
|
// normalize fields
|
const prolepticMonth = fieldValues.remove(ChronoField.PROLEPTIC_MONTH);
|
if (prolepticMonth != null) {
|
if (resolverStyle !== ResolverStyle.LENIENT) {
|
ChronoField.PROLEPTIC_MONTH.checkValidValue(prolepticMonth);
|
}
|
this._updateResolveMap(fieldValues, ChronoField.MONTH_OF_YEAR, MathUtil.floorMod(prolepticMonth, 12) + 1);
|
this._updateResolveMap(fieldValues, ChronoField.YEAR, MathUtil.floorDiv(prolepticMonth, 12));
|
}
|
|
// eras
|
const yoeLong = fieldValues.remove(ChronoField.YEAR_OF_ERA);
|
if (yoeLong != null) {
|
if (resolverStyle !== ResolverStyle.LENIENT) {
|
ChronoField.YEAR_OF_ERA.checkValidValue(yoeLong);
|
}
|
const era = fieldValues.remove(ChronoField.ERA);
|
if (era == null) {
|
const year = fieldValues.get(ChronoField.YEAR);
|
if (resolverStyle === ResolverStyle.STRICT) {
|
// do not invent era if strict, but do cross-check with year
|
if (year != null) {
|
this._updateResolveMap(fieldValues, ChronoField.YEAR, (year > 0 ? yoeLong: MathUtil.safeSubtract(1, yoeLong)));
|
} else {
|
// reinstate the field removed earlier, no cross-check issues
|
fieldValues.put(ChronoField.YEAR_OF_ERA, yoeLong);
|
}
|
} else {
|
// invent era
|
this._updateResolveMap(fieldValues, ChronoField.YEAR, (year == null || year > 0 ? yoeLong: MathUtil.safeSubtract(1, yoeLong)));
|
}
|
} else if (era === 1) {
|
this._updateResolveMap(fieldValues, ChronoField.YEAR, yoeLong);
|
} else if (era === 0) {
|
this._updateResolveMap(fieldValues, ChronoField.YEAR, MathUtil.safeSubtract(1, yoeLong));
|
} else {
|
throw new DateTimeException(`Invalid value for era: ${era}`);
|
}
|
} else if (fieldValues.containsKey(ChronoField.ERA)) {
|
ChronoField.ERA.checkValidValue(fieldValues.get(ChronoField.ERA)); // always validated
|
}
|
|
// build date
|
if (fieldValues.containsKey(ChronoField.YEAR)) {
|
if (fieldValues.containsKey(ChronoField.MONTH_OF_YEAR)) {
|
if (fieldValues.containsKey(ChronoField.DAY_OF_MONTH)) {
|
const y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
const moy = fieldValues.remove(ChronoField.MONTH_OF_YEAR);
|
let dom = fieldValues.remove(ChronoField.DAY_OF_MONTH);
|
if (resolverStyle === ResolverStyle.LENIENT) {
|
const months = moy - 1;
|
const days = dom - 1;
|
return LocalDate.of(y, 1, 1).plusMonths(months).plusDays(days);
|
} else if (resolverStyle === ResolverStyle.SMART){
|
ChronoField.DAY_OF_MONTH.checkValidValue(dom);
|
if (moy === 4 || moy === 6 || moy === 9 || moy === 11) {
|
dom = Math.min(dom, 30);
|
} else if (moy === 2) {
|
dom = Math.min(dom, Month.FEBRUARY.length(Year.isLeap(y)));
|
}
|
return LocalDate.of(y, moy, dom);
|
} else {
|
return LocalDate.of(y, moy, dom);
|
}
|
}
|
/*
|
if (fieldValues.containsKey(ALIGNED_WEEK_OF_MONTH)) {
|
if (fieldValues.containsKey(ALIGNED_DAY_OF_WEEK_IN_MONTH)) {
|
int y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
long months = Jdk8Methods.safeSubtract(fieldValues.remove(ChronoField.MONTH_OF_YEAR), 1);
|
long weeks = Jdk8Methods.safeSubtract(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), 1);
|
long days = Jdk8Methods.safeSubtract(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_MONTH), 1);
|
return LocalDate.of(y, 1, 1).plusMonths(months).plusWeeks(weeks).plusDays(days);
|
}
|
int moy = ChronoField.MONTH_OF_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.MONTH_OF_YEAR));
|
int aw = ALIGNED_WEEK_OF_MONTH.checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_MONTH));
|
int ad = ALIGNED_DAY_OF_WEEK_IN_MONTH.checkValidIntValue(fieldValues.remove(ALIGNED_DAY_OF_WEEK_IN_MONTH));
|
LocalDate date = LocalDate.of(y, moy, 1).plusDays((aw - 1) * 7 + (ad - 1));
|
if (resolverStyle == ResolverStyle.STRICT && date.get(ChronoField.MONTH_OF_YEAR) != moy) {
|
throw new DateTimeException("Strict mode rejected date parsed to a different month");
|
}
|
return date;
|
}
|
if (fieldValues.containsKey(DAY_OF_WEEK)) {
|
int y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
if (resolverStyle == ResolverStyle.LENIENT) {
|
long months = Jdk8Methods.safeSubtract(fieldValues.remove(ChronoField.MONTH_OF_YEAR), 1);
|
long weeks = Jdk8Methods.safeSubtract(fieldValues.remove(ALIGNED_WEEK_OF_MONTH), 1);
|
long days = Jdk8Methods.safeSubtract(fieldValues.remove(DAY_OF_WEEK), 1);
|
return LocalDate.of(y, 1, 1).plusMonths(months).plusWeeks(weeks).plusDays(days);
|
}
|
int moy = ChronoField.MONTH_OF_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.MONTH_OF_YEAR));
|
int aw = ALIGNED_WEEK_OF_MONTH.checkValidIntValue(fieldValues.remove(ALIGNED_WEEK_OF_MONTH));
|
int dow = DAY_OF_WEEK.checkValidIntValue(fieldValues.remove(DAY_OF_WEEK));
|
LocalDate date = LocalDate.of(y, moy, 1).plusWeeks(aw - 1).with(nextOrSame(DayOfWeek.of(dow)));
|
if (resolverStyle == ResolverStyle.STRICT && date.get(ChronoField.MONTH_OF_YEAR) != moy) {
|
throw new DateTimeException("Strict mode rejected date parsed to a different month");
|
}
|
return date;
|
}
|
}
|
*/
|
}
|
if (fieldValues.containsKey(ChronoField.DAY_OF_YEAR)) {
|
const y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
if (resolverStyle === ResolverStyle.LENIENT) {
|
const days = MathUtil.safeSubtract(fieldValues.remove(ChronoField.DAY_OF_YEAR), 1);
|
return LocalDate.ofYearDay(y, 1).plusDays(days);
|
}
|
const doy = ChronoField.DAY_OF_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.DAY_OF_YEAR));
|
return LocalDate.ofYearDay(y, doy);
|
}
|
if (fieldValues.containsKey(ChronoField.ALIGNED_WEEK_OF_YEAR)) {
|
if (fieldValues.containsKey(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR)) {
|
const y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
if (resolverStyle === ResolverStyle.LENIENT) {
|
const weeks = MathUtil.safeSubtract(fieldValues.remove(ChronoField.ALIGNED_WEEK_OF_YEAR), 1);
|
const days = MathUtil.safeSubtract(fieldValues.remove(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR), 1);
|
return LocalDate.of(y, 1, 1).plusWeeks(weeks).plusDays(days);
|
}
|
const aw = ChronoField.ALIGNED_WEEK_OF_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.ALIGNED_WEEK_OF_YEAR));
|
const ad = ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR));
|
const date = LocalDate.of(y, 1, 1).plusDays((aw - 1) * 7 + (ad - 1));
|
if (resolverStyle === ResolverStyle.STRICT && date.get(ChronoField.YEAR) !== y) {
|
throw new DateTimeException('Strict mode rejected date parsed to a different year');
|
}
|
return date;
|
}
|
if (fieldValues.containsKey(ChronoField.DAY_OF_WEEK)) {
|
const y = ChronoField.YEAR.checkValidIntValue(fieldValues.remove(ChronoField.YEAR));
|
if (resolverStyle === ResolverStyle.LENIENT) {
|
const weeks = MathUtil.safeSubtract(fieldValues.remove(ChronoField.ALIGNED_WEEK_OF_YEAR), 1);
|
const days = MathUtil.safeSubtract(fieldValues.remove(ChronoField.DAY_OF_WEEK), 1);
|
return LocalDate.of(y, 1, 1).plusWeeks(weeks).plusDays(days);
|
}
|
const aw = ChronoField.ALIGNED_WEEK_OF_YEAR.checkValidIntValue(fieldValues.remove(ChronoField.ALIGNED_WEEK_OF_YEAR));
|
const dow = ChronoField.DAY_OF_WEEK.checkValidIntValue(fieldValues.remove(ChronoField.DAY_OF_WEEK));
|
const date = LocalDate.of(y, 1, 1).plusWeeks(aw - 1).with(TemporalAdjusters.nextOrSame(DayOfWeek.of(dow)));
|
if (resolverStyle === ResolverStyle.STRICT && date.get(ChronoField.YEAR) !== y) {
|
throw new DateTimeException('Strict mode rejected date parsed to a different month');
|
}
|
return date;
|
}
|
}
|
}
|
return null;
|
}
|
|
/**
|
* Obtains an ISO local date from another date-time object.
|
* <p>
|
* This is equivalent to {@link LocalDate#from(TemporalAccessor)}.
|
*
|
* @param temporal the date-time object to convert, not null
|
* @return the ISO local date, not null
|
* @throws DateTimeException if unable to create the date
|
*/
|
date(temporal) {
|
return LocalDate.from(temporal);
|
}
|
|
}
|
|
export function _init() {
|
IsoChronology.INSTANCE = new IsoChronology('IsoChronology');
|
}
|
