create-expo-cljs-app
Version:
Create a react native application with Expo and Shadow-CLJS!
1,126 lines (1,070 loc) • 74.6 kB
JavaScript
/**
* @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 {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 {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.
*/
const DAYS_PER_CYCLE = 146097;
/**
* The number of days from year zero to year 1970.
* There are five 400 year cycles from year zero to 2000.
* There are 7 leap years from 1970 to 2000.
*/
const DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5) - (30 * 365 + 7);
/**
* A date without a time-zone in the ISO-8601 calendar system,
* such as 2007-12-03.
*
* LocalDate is an immutable date-time object that represents a date,
* often viewed as year-month-day. Other date fields, such as day-of-year,
* day-of-week and week-of-year, can also be accessed.
* For example, the value "2nd October 2007" can be stored in a LocalDate.
*
* This class does not store or represent a time or time-zone.
* Instead, it is a description of the date, as used for birthdays.
* It cannot represent an instant on the time-line without additional information
* such as an offset or time-zone.
*
* The ISO-8601 calendar system is the modern civil calendar system used today
* in most of the world. It is equivalent to the proleptic Gregorian calendar
* system, in which today's rules for leap years are applied for all time.
* For most applications written today, the ISO-8601 rules are entirely suitable.
* However, any application that makes use of historical dates, and requires them
* to be accurate will find the ISO-8601 approach unsuitable.
*
* ### Static properties of Class {@link LocalDate}
*
* LocalDate.MIN = LocalDate.of(Year.MIN_VALUE, 1, 1);
*
* The minimum supported {@link LocalDate}
* This could be used by an application as a "far past" date.
*
* LocalDate.MAX = LocalDate.of(Year.MAX_VALUE, 12, 31);
*
* The maximum supported {@link LocalDate}
* This could be used by an application as a "far future" date.
*
* LocalDate.EPOCH_0
*
* The date at epoch day 0, that is 1970-01-01.
*/
export class LocalDate extends ChronoLocalDate{
/**
* Obtains the current date from the system clock in the default time-zone or
* if specified, the current date from the specified clock or
* if argument is a ZoneId this will query a clock with the specified ZoneId.
*
* This will query the specified clock to obtain the current date - today.
* Using this method allows the use of an alternate clock for testing.
*
* @param {Clock|ZoneId} [clockOrZone=Clock.systemDefaultZone()] - the clock or zone to use,
* if null, the system clock and default time-zone is used.
* @return {LocalDate} the current date, not null
*/
static now(clockOrZone) {
let clock;
if(clockOrZone == null){
clock = Clock.systemDefaultZone();
} else if(clockOrZone instanceof ZoneId){
clock = Clock.system(clockOrZone);
} else {
clock = clockOrZone;
}
return LocalDate.ofInstant(clock.instant(), clock.zone());
}
/**
* obtain a LocalDate from an Instant in the specified time-zone or, if null
* in the system default time-zone
*
* @param {!Instant} instant
* @param {ZoneId} [zone=ZoneId.systemDefault()], defaults to ZoneId.systemDefault()
* @returns {LocalDate} the current date, not null
*/
static ofInstant(instant, zone=ZoneId.systemDefault()){
requireNonNull(instant, 'instant');
const offset = zone.rules().offset(instant);
const epochSec = instant.epochSecond() + offset.totalSeconds();
const epochDay = MathUtil.floorDiv(epochSec, LocalTime.SECONDS_PER_DAY);
return LocalDate.ofEpochDay(epochDay);
}
/**
* Obtains an instance of {@link LocalDate} from a year, month and day.
*
* This returns a {@link LocalDate} with the specified year, month and day-of-month.
* The day must be valid for the year and month, otherwise an exception will be thrown.
*
* @param {!number} year - the year to represent, from {@link Year.MIN_VALUE} to {@link Year.MAX_VALUE}
* @param {!(Month|Number)} month - the month-of-year to represent, from 1 (January) to 12 (December)
* @param {!number} dayOfMonth - the day-of-month to represent, from 1 to 31
* @return {LocalDate} the local date, not null
* @throws {DateTimeException} if the value of any field is out of range,
* or if the day-of-month is invalid for the month-year
*/
static of(year, month, dayOfMonth) {
return new LocalDate(year, month, dayOfMonth);
}
/**
* Obtains an instance of {@link LocalDate} from a year and day-of-year.
*
* This returns a {@link LocalDate} with the specified year and day-of-year.
* The day-of-year must be valid for the year, otherwise an exception will be thrown.
*
* @param {!number} year - the year to represent, from {@link Year.MIN_VALUE} to {@link Year.MAX_VALUE}
* @param {!number} dayOfYear - the day-of-year to represent, from 1 to 366
* @return {LocalDate} the local date, not null
* @throws {DateTimeException} if the value of any field is out of range,
* or if the day-of-year is invalid for the year
*/
static ofYearDay(year, dayOfYear) {
ChronoField.YEAR.checkValidValue(year);
//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);
}
let moy = Month.of(Math.floor((dayOfYear - 1) / 31 + 1));
const monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;
if (dayOfYear > monthEnd) {
moy = moy.plus(1);
}
const dom = dayOfYear - moy.firstDayOfYear(leap) + 1;
return new LocalDate(year, moy.value(), dom);
}
/**
* Obtains an instance of LocalDate from the epoch day count.
*
* This returns a LocalDate with the specified epoch-day.
* The {@link ChronoField.EPOCH_DAY} is a simple incrementing count
* of days where day 0 is 1970-01-01. Negative numbers represent earlier days.
*
* @param {number} [epochDay=0] - the Epoch Day to convert, based on the epoch 1970-01-01
* @return {LocalDate} the local date, not null
* @throws {AssertionError} if the epoch days exceeds the supported date range
*/
static ofEpochDay(epochDay=0) {
let adjust, adjustCycles, doyEst, yearEst, zeroDay;
zeroDay = epochDay + DAYS_0000_TO_1970;
zeroDay -= 60;
adjust = 0;
if (zeroDay < 0) {
adjustCycles = MathUtil.intDiv(zeroDay + 1, DAYS_PER_CYCLE) - 1;
adjust = adjustCycles * 400;
zeroDay += -adjustCycles * DAYS_PER_CYCLE;
}
yearEst = MathUtil.intDiv(400 * zeroDay + 591, DAYS_PER_CYCLE);
doyEst = zeroDay - (365 * yearEst + MathUtil.intDiv(yearEst, 4) - MathUtil.intDiv(yearEst, 100) + MathUtil.intDiv(yearEst, 400));
if (doyEst < 0) {
yearEst--;
doyEst = zeroDay - (365 * yearEst + MathUtil.intDiv(yearEst, 4) - MathUtil.intDiv(yearEst, 100) + MathUtil.intDiv(yearEst, 400));
}
yearEst += adjust;
const marchDoy0 = doyEst;
const marchMonth0 = MathUtil.intDiv(marchDoy0 * 5 + 2, 153);
const month = (marchMonth0 + 2) % 12 + 1;
const dom = marchDoy0 - MathUtil.intDiv(marchMonth0 * 306 + 5, 10) + 1;
yearEst += MathUtil.intDiv(marchMonth0, 10);
const year = yearEst;
return new LocalDate(year, month, dom);
}
/**
* Obtains an instance of {@link LocalDate} from a temporal object.
*
* A {@link TemporalAccessor} represents some form of date and time information.
* This factory converts the arbitrary temporal object to an instance of {@link LocalDate}.
*
* The conversion uses the {@link TemporalQueries.localDate} query, which relies
* on extracting the {@link ChronoField.EPOCH_DAY} field.
*
* This method matches the signature of the functional interface {@link TemporalQuery}
* allowing it to be used as a query via method reference, {@link LocalDate::from}.
*
* @param {!TemporalAccessor} temporal - the temporal object to convert, not null
* @return {LocalDate} the local date, not null
* @throws {DateTimeException} if unable to convert to a {@link LocalDate}
*/
static from(temporal) {
requireNonNull(temporal, 'temporal');
const date = temporal.query(TemporalQueries.localDate());
if (date == null) {
throw new DateTimeException(
`Unable to obtain LocalDate from TemporalAccessor: ${temporal}, type ${temporal.constructor != null ? temporal.constructor.name : ''}`);
}
return date;
}
/**
* Obtains an instance of {@link LocalDate} from a text string using a specific formatter.
*
* The text is parsed using the formatter, returning a date.
*
* @param {!string} text - the text to parse, not null
* @param {DateTimeFormatter} [formatter=DateTimeFormatter.ISO_LOCAL_DATE] - the formatter to use, default is
* {@link DateTimeFormatter.ISO_LOCAL_DATE}
* @return {LocalDate} the parsed local date, not null
* @throws {DateTimeParseException} if the text cannot be parsed
*/
static parse(text, formatter = DateTimeFormatter.ISO_LOCAL_DATE){
assert(formatter != null, 'formatter', NullPointerException);
return formatter.parse(text, LocalDate.FROM);
}
/**
* Resolves the date, resolving days past the end of month.
*
* @param {!number} year - the year to represent, validated from {@link Year.MIN_VALUE} to {@link Year.MAX_VALUE}
* @param {!number} month - the month-of-year to represent, validated from 1 to 12
* @param {!number} day - the day-of-month to represent, validated from 1 to 31
* @return {LocalDate} resolved date, not null
*/
static _resolvePreviousValid(year, month, day) {
switch (month) {
case 2:
day = Math.min(day, IsoChronology.isLeapYear(year) ? 29 : 28);
break;
case 4:
case 6:
case 9:
case 11:
day = Math.min(day, 30);
break;
}
return LocalDate.of(year, month, day);
}
/**
* Do not call the constructor directly, use the of*() factories instead like {@link LocalDate.of}
*
* @param {!number} year
* @param {!(Month|number)} month
* @param {!number} dayOfMonth
* @private
*/
constructor(year, month, dayOfMonth){
super();
if (month instanceof Month) {
month = month.value();
}
this._year = MathUtil.safeToInt(year);
this._month = MathUtil.safeToInt(month);
this._day = MathUtil.safeToInt(dayOfMonth);
LocalDate._validate(this._year, this._month, this._day);
}
/**
*
* @param {!number} year
* @param {!number} month
* @param {!number} dayOfMonth
* @throws {DateTimeException} if date values are invalid
* @private
*/
static _validate(year, month, dayOfMonth) {
let dom;
ChronoField.YEAR.checkValidValue(year);
ChronoField.MONTH_OF_YEAR.checkValidValue(month);
ChronoField.DAY_OF_MONTH.checkValidValue(dayOfMonth);
if (dayOfMonth > 28) {
dom = 31;
switch (month) {
case 2:
dom = IsoChronology.isLeapYear(year) ? 29 : 28;
break;
case 4:
case 6:
case 9:
case 11:
dom = 30;
}
if (dayOfMonth > dom) {
if (dayOfMonth === 29) {
assert(false, 'Invalid date \'February 29\' as \'' + year + '\' is not a leap year', DateTimeException);
} else {
assert(false, 'Invalid date \'' + year + '\' \'' + month + '\' \'' + dayOfMonth + '\'', DateTimeException);
}
}
}
}
/**
* Checks if the specified field is supported.
*
* This checks if this date can be queried for the specified field.
* If false, then calling the {@link LocalDate.range} range and
* {@link LocalDate.get} get methods will throw an exception.
*
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link LocalDate.isSupported} supported fields will return valid
* values based on this date-time.
* The supported fields are:
*
* * {@link ChronoField.DAY_OF_WEEK}
* * {@link ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH}
* * {@link ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR}
* * {@link ChronoField.DAY_OF_MONTH}
* * {@link ChronoField.DAY_OF_YEAR}
* * {@link ChronoField.EPOCH_DAY}
* * {@link ChronoField.ALIGNED_WEEK_OF_MONTH}
* * {@link ChronoField.ALIGNED_WEEK_OF_YEAR}
* * {@link ChronoField.MONTH_OF_YEAR}
* * {@link ChronoField.EPOCH_MONTH}
* * {@link ChronoField.YEAR_OF_ERA}
* * {@link ChronoField.YEAR}
* * {@link ChronoField.ERA}
*
* All other {@link ChronoField} instances will return false.
*
* If the field is not a {@link ChronoField}, then the result of this method
* is obtained by invoking {@link TemporalField.isSupportedBy}
* passing this as the argument.
* Whether the field is supported is determined by the field.
*
* @param {TemporalField} field the field to check, null returns false
* @return {boolean} true if the field is supported on this date, false if not
*/
isSupported(field) {
return super.isSupported(field);
}
/**
* Gets the range of valid values for the specified field.
*
* The range object expresses the minimum and maximum valid values for a field.
* This date is used to enhance the accuracy of the returned range.
* If it is not possible to return the range, because the field is not supported
* or for some other reason, an exception is thrown.
*
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link LocalDate.isSupported} supported fields will return
* appropriate range instances.
* All other {@link ChronoField} instances will throw a {@link DateTimeException}.
*
* If the field is not a {@link ChronoField}, then the result of this method
* is obtained by invoking {@link TemporalField.rangeRefinedBy}
* passing this as the argument.
* Whether the range can be obtained is determined by the field.
*
* @param {TemporalField} field the field to query the range for, not null
* @return {ValueRange} the range of valid values for the field, not null
* @throws {DateTimeException} if the range for the field cannot be obtained
*/
range(field) {
if (field instanceof ChronoField) {
if (field.isDateBased()) {
switch (field) {
case ChronoField.DAY_OF_MONTH: return ValueRange.of(1, this.lengthOfMonth());
case ChronoField.DAY_OF_YEAR: return ValueRange.of(1, this.lengthOfYear());
case ChronoField.ALIGNED_WEEK_OF_MONTH: return ValueRange.of(1, this.month() === Month.FEBRUARY && this.isLeapYear() === false ? 4 : 5);
case ChronoField.YEAR_OF_ERA:
return (this._year <= 0 ? ValueRange.of(1, Year.MAX_VALUE + 1) : ValueRange.of(1, Year.MAX_VALUE));
}
return field.range();
}
throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
}
return field.rangeRefinedBy(this);
}
/**
* Gets the value of the specified field from this date as an `int`.
*
* This queries this date for the value for the specified field.
* The returned value will always be within the valid range of values for the field.
* If it is not possible to return the value, because the field is not supported
* or for some other reason, an exception is thrown.
*
* If the field is a {@link ChronoField} then the query is implemented here.
* The {@link LocalDate.isSupported} supported fields will return valid
* values based on this date, except {@link ChronoField.EPOCH_DAY} and {@link ChronoField.EPOCH_MONTH}
* which are too large to fit in an `int` and throw a {@link DateTimeException}.
* All other {@link ChronoField} instances will throw a {@link DateTimeException}.
*
* If the field is not a {@link ChronoField}, then the result of this method
* is obtained by invoking {@link TemporalField.getFrom}
* passing this as the argument. Whether the value can be obtained,
* and what the value represents, is determined by the field.
*
* @param {!TemporalField} field the field to get, not null
* @return the value for the field
* @throws {DateTimeException} if a value for the field cannot be obtained
* @throws {ArithmeticException} if numeric overflow occurs
*/
get(field) {
return this.getLong(field);
}
/**
* see {LocalDate.get}, get and getLong are identical in javascript, because we are only limited by
* {@link MathUtil.MIN_SAFE_INTEGER}/ {@link MathUtil.MAX_SAFE_INTEGER}
*
* @param {!TemporalField} field
* @returns {*}
*/
getLong(field) {
assert(field != null, '', NullPointerException);
if (field instanceof ChronoField) {
return this._get0(field);
}
return field.getFrom(this);
}
/**
* TODO tests are missing for the ALIGNED_* ChronoFields
*
* @param {!TemporalField} field
* @returns {*}
* @private
*/
_get0(field) {
switch (field) {
case ChronoField.DAY_OF_WEEK: return this.dayOfWeek().value();
case ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH: return MathUtil.intMod((this._day - 1), 7) + 1;
case ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR: return MathUtil.intMod((this.dayOfYear() - 1), 7) + 1;
case ChronoField.DAY_OF_MONTH: return this._day;
case ChronoField.DAY_OF_YEAR: return this.dayOfYear();
case ChronoField.EPOCH_DAY: return this.toEpochDay();
case ChronoField.ALIGNED_WEEK_OF_MONTH: return MathUtil.intDiv((this._day - 1), 7) + 1;
case ChronoField.ALIGNED_WEEK_OF_YEAR: return MathUtil.intDiv((this.dayOfYear() - 1), 7) + 1;
case ChronoField.MONTH_OF_YEAR: return this._month;
case ChronoField.PROLEPTIC_MONTH: return this._prolepticMonth();
case ChronoField.YEAR_OF_ERA: return (this._year >= 1 ? this._year : 1 - this._year);
case ChronoField.YEAR: return this._year;
case ChronoField.ERA: return (this._year >= 1 ? 1 : 0);
}
throw new UnsupportedTemporalTypeException('Unsupported field: ' + field);
}
/**
*
* @return {number}
* @private
*/
_prolepticMonth() {
return (this._year * 12) + (this._month - 1);
}
/**
* Gets the chronology of this date, which is the ISO calendar system.
*
* The {@link Chronology} represents the calendar system in use.
* The ISO-8601 calendar system is the modern civil calendar system used today
* in most of the world. It is equivalent to the proleptic Gregorian calendar
* system, in which today's rules for leap years are applied for all time.
*
* @return {Chronology} the ISO chronology, not null
*/
chronology() {
return IsoChronology.INSTANCE;
}
/**
*
* @return {number} gets the year
*/
year() {
return this._year;
}
/**
*
* @return {number} gets the month value
*/
monthValue() {
return this._month;
}
/**
*
* @returns {Month} month
*/
month() {
return Month.of(this._month);
}
/**
*
* @return {number} gets the day of month
*/
dayOfMonth() {
return this._day;
}
/**
* Gets the day-of-year field.
*
* This method returns the primitive int value for the day-of-year.
*
* @return {number} the day-of-year, from 1 to 365, or 366 in a leap year
*/
dayOfYear() {
return this.month().firstDayOfYear(this.isLeapYear()) + this._day - 1;
}
/**
* Gets the day-of-week field, which is an enum {@link DayOfWeek}.
*
* This method returns the enum {@link DayOfWeek} for the day-of-week.
* This avoids confusion as to what `int` values mean.
* If you need access to the primitive `int` value then the enum
* provides the {@link DayOfWeek.value} int value.
*
* Additional information can be obtained from the {@link DayOfWeek}.
* This includes textual names of the values.
*
* @return {DayOfWeek} the day-of-week, not null
*/
dayOfWeek() {
const dow0 = MathUtil.floorMod(this.toEpochDay() + 3, 7);
return DayOfWeek.of(dow0 + 1);
}
/**
* 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.
*
* @return {boolean} true if the year is leap, false otherwise
*/
isLeapYear() {
return IsoChronology.isLeapYear(this._year);
}
/**
* Returns the length of the month represented by this date.
*
* This returns the length of the month in days.
* For example, a date in January would return 31.
*
* @return {number} the length of the month in days
*/
lengthOfMonth() {
switch (this._month) {
case 2:
return (this.isLeapYear() ? 29 : 28);
case 4:
case 6:
case 9:
case 11:
return 30;
default:
return 31;
}
}
/**
* Returns the length of the year represented by this date.
*
* This returns the length of the year in days, either 365 or 366.
*
* @return {number} 366 if the year is leap, 365 otherwise
*/
lengthOfYear() {
return (this.isLeapYear() ? 366 : 365);
}
/**
* function overloading for the {@link LocalDate.with} method.
*
* calling "with" with one (or less) argument, assumes that the argument is an TemporalAdjuster
* and {@link LocalDate.withTemporalAdjuster} is called.
*
* Otherwise a TemporalField and newValue argument is expected and
* {@link LocalDate.withFieldAndValue} is called.
*
* @param {!(TemporalAdjuster|TemporalField)} fieldOrAdjuster
* @param {number} newValue - required if first argument is a TemporalField
* @return {LocalDate} the new LocalDate with the newValue set.
*/
with(fieldOrAdjuster, newValue){
if(arguments.length < 2){
return this.withTemporalAdjuster(fieldOrAdjuster);
} else {
return this.withFieldAndValue(fieldOrAdjuster, newValue);
}
}
/**
* Returns an adjusted copy of this date.
*
* This returns a new {@link LocalDate}, based on this one, with the date adjusted.
* The adjustment takes place using the specified adjuster strategy object.
* Read the documentation of the adjuster to understand what adjustment will be made.
*
* 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".
* Key date-time classes also implement the {@link TemporalAdjuster} interface,
* such as {@link Month} and {@link MonthDay}.
* The adjuster is responsible for handling special cases, such as the varying
* lengths of month and leap years.
*
* For example this code returns a date on the last day of July:
* <pre>
* import static org.threeten.bp.Month.*;
* import static org.threeten.bp.temporal.Adjusters.*;
*
* result = localDate.with(JULY).with(lastDayOfMonth());
* </pre>
*
* The result of this method is obtained by invoking the
* {@link TemporalAdjuster.adjustInto} method on the
* specified adjuster passing `this` as the argument.
*
* @param {!TemporalAdjuster} adjuster - the adjuster to use, not null
* @return {LocalDate} a {@link LocalDate} based on `this` with the adjustment made, not null
* @throws {DateTimeException} if the adjustment cannot be made
* @throws {ArithmeticException} if numeric overflow occurs
*/
withTemporalAdjuster(adjuster) {
requireNonNull(adjuster, 'adjuster');
// optimizations
if (adjuster instanceof LocalDate) {
return adjuster;
}
assert(typeof adjuster.adjustInto === 'function', 'adjuster', IllegalArgumentException);
return adjuster.adjustInto(this);
}
/**
* Returns a copy of this date with the specified field set to a new value.
*
* This returns a new {@link LocalDate}, based on this one, with the value
* for the specified field changed.
* This can be used to change any supported field, such as the year, month or day-of-month.
* If it is not possible to set the value, because the field is not supported or for
* some other reason, an exception is thrown.
*
* In some cases, changing the specified field can cause the resulting date to become invalid,
* such as changing the month from 31st January to February would make the day-of-month invalid.
* In cases like this, the field is responsible for resolving the date. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
*
* If the field is a {@link ChronoField} then the adjustment is implemented here.
* The supported fields behave as follows:
*
* * {@link DAY_OF_WEEK} -
* Returns a {@link LocalDate} with the specified day-of-week.
* The date is adjusted up to 6 days forward or backward within the boundary
* of a Monday to Sunday week.
* * {@link ALIGNED_DAY_OF_WEEK_IN_MONTH} -
* Returns a {@link LocalDate} with the specified aligned-day-of-week.
* The date is adjusted to the specified month-based aligned-day-of-week.
* Aligned weeks are counted such that the first week of a given month starts
* on the first day of that month.
* This may cause the date to be moved up to 6 days into the following month.
* * {@link ALIGNED_DAY_OF_WEEK_IN_YEAR} -
* Returns a {@link LocalDate} with the specified aligned-day-of-week.
* The date is adjusted to the specified year-based aligned-day-of-week.
* Aligned weeks are counted such that the first week of a given year starts
* on the first day of that year.
* This may cause the date to be moved up to 6 days into the following year.
* * {@link DAY_OF_MONTH} -
* Returns a {@link LocalDate} with the specified day-of-month.
* The month and year will be unchanged. If the day-of-month is invalid for the
* year and month, then a {@link DateTimeException} is thrown.
* * {@link DAY_OF_YEAR} -
* Returns a {@link LocalDate} with the specified day-of-year.
* The year will be unchanged. If the day-of-year is invalid for the
* year, then a {@link DateTimeException} is thrown.
* * {@link EPOCH_DAY} -
* Returns a {@link LocalDate} with the specified epoch-day.
* This completely replaces the date and is equivalent to {@link ofEpochDay}.
* * {@link ALIGNED_WEEK_OF_MONTH} -
* Returns a {@link LocalDate} with the specified aligned-week-of-month.
* Aligned weeks are counted such that the first week of a given month starts
* on the first day of that month.
* This adjustment moves the date in whole week chunks to match the specified week.
* The result will have the same day-of-week as this date.
* This may cause the date to be moved into the following month.
* * {@link ALIGNED_WEEK_OF_YEAR} -
* Returns a {@link LocalDate} with the specified aligned-week-of-year.
* Aligned weeks are counted such that the first week of a given year starts
* on the first day of that year.
* This adjustment moves the date in whole week chunks to match the specified week.
* The result will have the same day-of-week as this date.
* This may cause the date to be moved into the following year.
* * {@link MONTH_OF_YEAR} -
* Returns a {@link LocalDate} with the specified month-of-year.
* The year will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* * {@link PROLEPTIC_MONTH} -
* Returns a {@link LocalDate} with the specified proleptic-month.
* The day-of-month will be unchanged, unless it would be invalid for the new month
* and year. In that case, the day-of-month is adjusted to the maximum valid value
* for the new month and year.
* * {@link YEAR_OF_ERA} -
* Returns a {@link LocalDate} with the specified year-of-era.
* The era and month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* * {@link YEAR} -
* Returns a {@link LocalDate} with the specified year.
* The month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* * {@link ERA} -
* Returns a {@link LocalDate} with the specified era.
* The year-of-era and month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
*
* In all cases, if the new value is outside the valid range of values for the field
* then a {@link DateTimeException} will be thrown.
*
* All other {@link ChronoField} instances will throw a {@link DateTimeException}.
*
* If the field is not a {@link ChronoField}, then the result of this method
* is obtained by invoking {@link TemporalField.adjustInto}
* passing `this` as the argument. In this case, the field determines
* whether and how to adjust the instant.
*
* @param {TemporalField} field - the field to set in the result, not null
* @param {number} newValue - the new value of the field in the result
* @return {LocalDate} a {@link LocalDate} based on `this` with the specified field set, not null
* @throws {DateTimeException} if the field cannot be set
* @throws {ArithmeticException} if numeric overflow occurs
*/
withFieldAndValue(field, newValue) {
assert(field != null, 'field', NullPointerException);
if (field instanceof ChronoField) {
const f = field;
f.checkValidValue(newValue);
switch (f) {
case ChronoField.DAY_OF_WEEK: return this.plusDays(newValue - this.dayOfWeek().value());
case ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH: return this.plusDays(newValue - this.getLong(ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH));
case ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR: return this.plusDays(newValue - this.getLong(ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR));
case ChronoField.DAY_OF_MONTH: return this.withDayOfMonth(newValue);
case ChronoField.DAY_OF_YEAR: return this.withDayOfYear(newValue);
case ChronoField.EPOCH_DAY: return LocalDate.ofEpochDay(newValue);
case ChronoField.ALIGNED_WEEK_OF_MONTH: return this.plusWeeks(newValue - this.getLong(ChronoField.ALIGNED_WEEK_OF_MONTH));
case ChronoField.ALIGNED_WEEK_OF_YEAR: return this.plusWeeks(newValue - this.getLong(ChronoField.ALIGNED_WEEK_OF_YEAR));
case ChronoField.MONTH_OF_YEAR: return this.withMonth(newValue);
case ChronoField.PROLEPTIC_MONTH: return this.plusMonths(newValue - this.getLong(ChronoField.PROLEPTIC_MONTH));
case ChronoField.YEAR_OF_ERA: return this.withYear((this._year >= 1 ? newValue : 1 - newValue));
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);
}
return field.adjustInto(this, newValue);
}
/**
* Returns a copy of this date with the year altered.
* If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
*
* @param {!number} year the year to set in the result, from {@link Year.MIN_VALUE} to {@link Year.MAX_VALUE}
* @return {LocalDate} a {@link LocalDate} based on this date with the requested year, not null
* @throws {DateTimeException} if the year value is invalid
*/
withYear(year) {
if (this._year === year) {
return this;
}
ChronoField.YEAR.checkValidValue(year);
return LocalDate._resolvePreviousValid(year, this._month, this._day);
}
/**
* Returns a copy of this date with the month-of-year altered.
* If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
*
* @param {!(Month|number)} month - the month-of-year to set in the result, from 1 (January) to 12 (December)
* @return {LocalDate} a {@link LocalDate} based on this date with the requested month, not null
* @throws {DateTimeException} if the month-of-year value is invalid
*/
withMonth(month) {
const m = (month instanceof Month) ? month.value() : month;
if (this._month === m) {
return this;
}
ChronoField.MONTH_OF_YEAR.checkValidValue(m);
return LocalDate._resolvePreviousValid(this._year, m, this._day);
}
/**
* Returns a copy of this {@link LocalDate} with the day-of-month altered.
*
* If the resulting date is invalid, an exception is thrown.
*
* @param {!number} dayOfMonth - the day-of-month to set in the result, from 1 to 28-31
* @return {LocalDate} based on this date with the requested day, not null
* @throws {DateTimeException} if the day-of-month value is invalid,
* or if the day-of-month is invalid for the month-year
*/
withDayOfMonth(dayOfMonth) {
if (this._day === dayOfMonth) {
return this;
}
return LocalDate.of(this._year, this._month, dayOfMonth);
}
/**
* Returns a copy of this date with the day-of-year altered.
* If the resulting date is invalid, an exception is thrown.
*
* @param dayOfYear the day-of-year to set in the result, from 1 to 365-366
* @return {LocalDate} a {@link LocalDate} based on this date with the requested day, not null
* @throws {DateTimeException} if the day-of-year value is invalid
* @throws {DateTimeException} if the day-of-year is invalid for the year
*/
withDayOfYear(dayOfYear) {
if (this.dayOfYear() === dayOfYear) {
return this;
}
return LocalDate.ofYearDay(this._year, dayOfYear);
}
/**
* function overloading for plus
*
* called with 1 (or less) arguments, p1 is expected to be a TemporalAmount and {@link LocalDate.plus1}
* is called.
*
* Otherwise {@link LocalDate.plus2} is called.
*
* @param {!(TemporalAmount|number)} p1
* @param {TemporalUnit} p2 - required if called with 2 arguments
* @return {LocalDate}
*/
plus(p1, p2){
if(arguments.length < 2){
return this.plus1(p1);
} else {
return this.plus2(p1, p2);
}
}
/**
* 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.plus2}.
*
* @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
*/
plus1(amount) {
requireNonNull(amount, 'amount');
return amount.addTo(this);
}
/**
* 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.
* This can be used to add any period that is defined by a unit, for example to add years, months or days.
* The unit is responsible for the details of the calculation, including the resolution
* of any edge cases in the calculation.
*
* @param {!number} amountToAdd - the amount of the unit to add to the result, may be negative
* @param {!TemporalUnit} unit - the unit of the period to add, not null
* @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
*/
plus2(amountToAdd, unit) {
requireNonNull(amountToAdd, 'amountToAdd');
requireNonNull(unit, 'unit');
if (unit instanceof ChronoUnit) {
switch (unit) {
case ChronoUnit.DAYS: return this.plusDays(amountToAdd);
case ChronoUnit.WEEKS: return this.plusWeeks(amountToAdd);
case ChronoUnit.MONTHS: return this.plusMonths(amountToAdd);
case ChronoUnit.YEARS: return this.plusYears(amountToAdd);
case ChronoUnit.DECADES: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 10));
case ChronoUnit.CENTURIES: return this.plusYears(MathUtil.safeMultiply(amountToAdd, 100));
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);
}
return unit.addTo(this, amountToAdd);
}
/**
* Returns a copy of this {@link LocalDate} with the specified period in years added.
*
* This method adds the specified amount to the years field in three steps:
*
* 1. Add the input years to the year field
* 2. Check if the resulting date would be invalid
* 3. Adjust the day-of-month to the last valid day if necessary
*
* For example, 2008-02-29 (leap year) plus one year would result in the
* invalid date 2009-02-29 (standard year). Instead of returning an invalid
* result, the last valid day of the month, 2009-02-28, is selected instead.
*
* @param {!number} yearsToAdd - the years to add, may be negative
* @return {LocalDate} a {@link LocalDate} based on this date with the years added, not null
* @throws {DateTimeException} if the result exceeds the supported date range
*/
plusYears(yearsToAdd) {
if (yearsToAdd === 0) {
return this;
}
const newYear = ChronoField.YEAR.checkValidIntValue(this._year + yearsToAdd); // safe overflow
return LocalDate._resolvePreviousValid(newYear, this._month, this._day);
}
/**
* Returns a copy of this {@link LocalDate} with the specified period in months added.
*
* This method adds the specified amount to the months field in three steps:
*
* 1. Add the input months to the month-of-year field
* 2. Check if the resulting date would be invalid
* 3. Adjust the day-of-month to the last valid day if necessary
*
* For example, 2007-03-31 plus one month would result in the invalid date
* 2007-04-31. Instead of returning an invalid result, the last valid day
* of the month, 2007-04-30, is selected instead.
*
* @param {number} monthsToAdd - the months to add, may be negative
* @return {LocalDate} a {@link LocalDate} based on this date with the months added, not null
* @throws {DateTimeException} if the result exceeds the supported date range
*/
plusMonths(monthsToAdd) {
if (monthsToAdd === 0) {
return this;
}
const monthCount = this._year * 12 + (this._month - 1);
const calcMonths = monthCount + monthsToAdd; // safe overflow
const newYear = ChronoField.YEAR.checkValidIntValue(MathUtil.floorDiv(calcMonths, 12));
const newMonth = MathUtil.floorMod(calcMonths, 12) + 1;
return LocalDate._resolvePreviousValid(newYear, newMonth, this._day);
}
/**
* Returns a copy of this {@link LocalDate} with the specified period in weeks added.
*
* This method adds the specified amount in weeks to the days field incrementing
* the month and year fields as necessary to ensure the result remains valid.
* The result is only invalid if the maximum/minimum year is exceeded.
*
* For example, 2008-12-31 plus one week would result in 2009-01-07.
*
* @param {!number} weeksToAdd - the weeks to add, may be negative
* @return {LocalDate} a {@link LocalDate} based on this date with the weeks added, not null
* @throws {DateTimeException} if the result exceeds the supported date range
*/
plusWeeks(weeksToAdd) {
return this.plusDays(MathUtil.safeMultiply(weeksToAdd, 7));
}
/**
* Returns a copy of this LocalDate with the specified number of days added.
*
* This method adds the specified amount to the days field incrementing the
* month and year fields as necessary to ensure the result remains valid.
* The result is only invalid if the maximum/minimum year is exceeded.
*
* For example, 2008-12-31 plus one day would result in 2009-01-01.
*
* @param {number} daysToAdd - the days to add, may be negative
* @return {LocalDate} a LocalDate based on this date with the days added, not null
* @throws AssertionError if the result exceeds the supported date range
*/
plusDays(daysToAdd) {
if (daysToAdd === 0) {
return this;
}
const mjDay = MathUtil.safeAdd(this.toEpochDay(), daysToAdd);
return LocalDate.ofEpochDay(mjDay);
}
/**
* function overloading for minus
*
* called with 1 (or less) arguments, p1 is expected to be a TemporalAmount and {@link LocalDate.minus1}
* is called.
*
* Otherwise {@link LocalDate.minus2} is called.
*
* @param {!(TemporalAmount|number)} p1
* @param {TemporalUnit} p2 - required if called with 2 arguments
* @return {LocalDate}
*/
minus(p1, p2){
if(arguments.length < 2){
return this.minus1(p1);
} else {
return this.minus2(p1, p2);
}
}
/**
* 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
*/
minus1(amount) {
requireNonNull(amount, 'amount');
return amount.subtractFrom(this);
}
/**
* 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.
* This can be used to subtract any period that is defined by a unit, for example to subtract years, months or days.
* The unit is responsible for the details of the calculation, including the resolution
* of any edge cases in the calculation.
*
* @param {!number} amountToSubtract - the amount of the unit to subtract from the result, may be negative
* @param {!TemporalUnit} unit the unit of the period to subtract, not null
* @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
*/
minus2(amountToSubtract, unit) {
requireNonNull(amountToSubtract, 'amountToSubtract');
requireNonNull(unit, 'unit');
return this.plus2(-1 * amountToSubtract, unit);
}
/**
* Returns a copy of this {@link LocalDate} with the specified period in years subtracted.
*
* This method subtracts the specified amount from the years field in three steps:
*
* 1. Subtract the input years to the year field
* 2. Check if the resulting date would be invalid
* 3. Adjust the day-of-month to the last valid day if necessary
*
* For example, 2008-02-29 (leap year) minus one year would result in the
* invalid date 2007-02-29 (standard year). Instead of returning an invalid
* result, the last valid day of the month, 2007-02-28, is selected instead.
*
* @param {!number} yearsToSubtract - the years to subtract, may be negative
* @return {LocalDate} a {@link LocalDate} based on this date with the years subtracted, not null
* @throws {DateTimeException} if the result exceeds the supported date range
*/
minusYears(yearsToSubtract) {
return this.plusYears(yearsToSubtract * -1);
}
/**
* Returns a copy of this {@link LocalDate} with the specified period in months subtracted.
*
* This method subtracts the specified amount from the months field in three steps:
*
* 1. Subtract the input months to the month-of-year field
* 2. Check if the resulting date would be invalid
* 3. Adjust the day-of-month to the last valid day if necessary
*
* For example, 2007-03-31 minus one month would result in the invalid date
* 2007-02-31. Instead of returning an invalid result, the last valid day
* of the month, 2007-02-28, is selected instead.
*
* @param {!number} monthsToSubtract - the months to subtract, may be negative
* @return {LocalDate} a {@link LocalDate} based on this date with the months